projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
ALSA: hda - Fix error path in the sanity check in azx_pcm_open()
[deliverable/linux.git] / sound / pci / hda / patch_via.c
CommitLineData
c577b8a1
JC		 1/*
2 * Universal Interface for Intel High Definition Audio Codec
3 *
d949cac1 4 * HD audio interface patch for VIA VT1702/VT1708/VT1709 codec
c577b8a1 5 *
76d9b0dd
HW		 6 * Copyright (c) 2006-2008 Lydia Wang <lydiawang@viatech.com>
7 * Takashi Iwai <tiwai@suse.de>
c577b8a1
JC		 8 *
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.
13 *
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.
18 *
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
22 */
23
24/* * * * * * * * * * * * * * Release History * * * * * * * * * * * * * * * * */
25/* */
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 */
f7278fd0
JC		 30/* 2007-09-12 Lydia Wang Add EAPD enable during driver initialization */
31/* 2007-09-17 Lydia Wang Add VT1708B codec support */
76d9b0dd 32/* 2007-11-14 Lydia Wang Add VT1708A codec HP and CD pin connect config */
fb4cb772 33/* 2008-02-03 Lydia Wang Fix Rear channels and Back channels inverse issue */
d949cac1 34/* 2008-03-06 Lydia Wang Add VT1702 codec and VT1708S codec support */
69e52a80 35/* 2008-04-09 Lydia Wang Add mute front speaker when HP plugin */
0aa62aef 36/* 2008-04-09 Lydia Wang Add Independent HP feature */
98aa34c0 37/* 2008-05-28 Lydia Wang Add second S/PDIF Out support for VT1702 */
d7426329 38/* 2008-09-15 Logan Li Add VT1708S Mic Boost workaround/backdoor */
c577b8a1
JC		 39/* */
40/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
41
42
c577b8a1
JC		 43#include <linux/init.h>
44#include <linux/delay.h>
45#include <linux/slab.h>
c577b8a1 46#include <sound/core.h>
0aa62aef 47#include <sound/asoundef.h>
c577b8a1
JC		 48#include "hda_codec.h"
49#include "hda_local.h"
c577b8a1
JC		 50
51/* amp values */
52#define AMP_VAL_IDX_SHIFT 19
53#define AMP_VAL_IDX_MASK (0x0f<<19)
54
c577b8a1
JC		 55/* Pin Widget NID */
56#define VT1708_HP_NID 0x13
57#define VT1708_DIGOUT_NID 0x14
58#define VT1708_DIGIN_NID 0x16
f7278fd0 59#define VT1708_DIGIN_PIN 0x26
d949cac1
HW		 60#define VT1708_HP_PIN_NID 0x20
61#define VT1708_CD_PIN_NID 0x24
c577b8a1
JC		 62
63#define VT1709_HP_DAC_NID 0x28
64#define VT1709_DIGOUT_NID 0x13
65#define VT1709_DIGIN_NID 0x17
f7278fd0
JC		 66#define VT1709_DIGIN_PIN 0x25
67
68#define VT1708B_HP_NID 0x25
69#define VT1708B_DIGOUT_NID 0x12
70#define VT1708B_DIGIN_NID 0x15
71#define VT1708B_DIGIN_PIN 0x21
c577b8a1 72
d949cac1
HW		 73#define VT1708S_HP_NID 0x25
74#define VT1708S_DIGOUT_NID 0x12
75
76#define VT1702_HP_NID 0x17
77#define VT1702_DIGOUT_NID 0x11
78
c577b8a1
JC		 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)
f7278fd0
JC		 82#define IS_VT1708B_8CH_VENDORID(x) ((x) >= 0x1106e720 && (x) <= 0x1106e723)
83#define IS_VT1708B_4CH_VENDORID(x) ((x) >= 0x1106e724 && (x) <= 0x1106e727)
d949cac1
HW		 84#define IS_VT1708S_VENDORID(x) ((x) >= 0x11060397 && (x) <= 0x11067397)
85#define IS_VT1702_VENDORID(x) ((x) >= 0x11060398 && (x) <= 0x11067398)
c577b8a1 86
d7426329
HW		 87enum VIA_HDA_CODEC {
88 UNKNOWN = -1,
89 VT1708,
90 VT1709_10CH,
91 VT1709_6CH,
92 VT1708B_8CH,
93 VT1708B_4CH,
94 VT1708S,
95 VT1702,
96 CODEC_TYPES,
97};
98
99static enum VIA_HDA_CODEC get_codec_type(u32 vendor_id)
100{
101 u16 ven_id = vendor_id >> 16;
102 u16 dev_id = vendor_id & 0xffff;
103 enum VIA_HDA_CODEC codec_type;
104
105 /* get codec type */
106 if (ven_id != 0x1106)
107 codec_type = UNKNOWN;
108 else if (dev_id >= 0x1708 && dev_id <= 0x170b)
109 codec_type = VT1708;
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)
123 codec_type = VT1702;
124 else
125 codec_type = UNKNOWN;
126 return codec_type;
127};
128
69e52a80
HW		 129#define VIA_HP_EVENT 0x01
130#define VIA_GPIO_EVENT 0x02
131
c577b8a1
JC		 132enum {
133 VIA_CTL_WIDGET_VOL,
134 VIA_CTL_WIDGET_MUTE,
135};
136
137enum {
eb14a46c 138 AUTO_SEQ_FRONT = 0,
c577b8a1
JC		 139 AUTO_SEQ_SURROUND,
140 AUTO_SEQ_CENLFE,
141 AUTO_SEQ_SIDE
142};
143
d7426329
HW		 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. */
146static int mic_boost_tlv(struct snd_kcontrol *kcontrol, int op_flag,
147 unsigned int size, unsigned int __user *_tlv)
148{
149 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
150 hda_nid_t nid = get_amp_nid(kcontrol);
151
152 if (get_codec_type(codec->vendor_id) == VT1708S
153 && (nid == 0x1a || nid == 0x1e)) {
154 if (size < 4 * sizeof(unsigned int))
155 return -ENOMEM;
156 if (put_user(1, _tlv)) /* SNDRV_CTL_TLVT_DB_SCALE */
157 return -EFAULT;
158 if (put_user(2 * sizeof(unsigned int), _tlv + 1))
159 return -EFAULT;
160 if (put_user(0, _tlv + 2)) /* offset = 0 */
161 return -EFAULT;
162 if (put_user(1000, _tlv + 3)) /* step size = 10 dB */
163 return -EFAULT;
164 }
165 return 0;
166}
167
168static int mic_boost_volume_info(struct snd_kcontrol *kcontrol,
169 struct snd_ctl_elem_info *uinfo)
170{
171 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
172 hda_nid_t nid = get_amp_nid(kcontrol);
173
174 if (get_codec_type(codec->vendor_id) == VT1708S
175 && (nid == 0x1a || nid == 0x1e)) {
176 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
177 uinfo->count = 2;
178 uinfo->value.integer.min = 0;
179 uinfo->value.integer.max = 3;
180 }
181 return 0;
182}
183
c577b8a1
JC		 184static struct snd_kcontrol_new vt1708_control_templates[] = {
185 HDA_CODEC_VOLUME(NULL, 0, 0, 0),
186 HDA_CODEC_MUTE(NULL, 0, 0, 0),
187};
188
189
190struct via_spec {
191 /* codec parameterization */
192 struct snd_kcontrol_new *mixers[3];
193 unsigned int num_mixers;
194
69e52a80
HW		 195 struct hda_verb *init_verbs[5];
196 unsigned int num_iverbs;
c577b8a1
JC		 197
198 char *stream_name_analog;
199 struct hda_pcm_stream *stream_analog_playback;
200 struct hda_pcm_stream *stream_analog_capture;
201
202 char *stream_name_digital;
203 struct hda_pcm_stream *stream_digital_playback;
204 struct hda_pcm_stream *stream_digital_capture;
205
206 /* playback */
207 struct hda_multi_out multiout;
9da29271 208 hda_nid_t slave_dig_outs[2];
c577b8a1
JC		 209
210 /* capture */
211 unsigned int num_adc_nids;
212 hda_nid_t *adc_nids;
213 hda_nid_t dig_in_nid;
214
215 /* capture source */
216 const struct hda_input_mux *input_mux;
217 unsigned int cur_mux[3];
218
219 /* PCM information */
98aa34c0 220 struct hda_pcm pcm_rec[3];
c577b8a1
JC		 221
222 /* dynamic controls, init_verbs and input_mux */
223 struct auto_pin_cfg autocfg;
603c4019 224 struct snd_array kctls;
0aa62aef 225 struct hda_input_mux private_imux[2];
41923e44 226 hda_nid_t private_dac_nids[AUTO_CFG_MAX_OUTS];
cb53c626 227
0aa62aef
HW		 228 /* HP mode source */
229 const struct hda_input_mux *hp_mux;
230 unsigned int hp_independent_mode;
231
cb53c626
TI		 232#ifdef CONFIG_SND_HDA_POWER_SAVE
233 struct hda_loopback_check loopback;
234#endif
c577b8a1
JC		 235};
236
237static hda_nid_t vt1708_adc_nids[2] = {
238 /* ADC1-2 */
239 0x15, 0x27
240};
241
242static hda_nid_t vt1709_adc_nids[3] = {
243 /* ADC1-2 */
244 0x14, 0x15, 0x16
245};
246
f7278fd0
JC		 247static hda_nid_t vt1708B_adc_nids[2] = {
248 /* ADC1-2 */
249 0x13, 0x14
250};
251
d949cac1
HW		 252static hda_nid_t vt1708S_adc_nids[2] = {
253 /* ADC1-2 */
254 0x13, 0x14
255};
256
257static hda_nid_t vt1702_adc_nids[3] = {
258 /* ADC1-2 */
259 0x12, 0x20, 0x1F
260};
261
c577b8a1
JC		 262/* add dynamic controls */
263static int via_add_control(struct via_spec *spec, int type, const char *name,
264 unsigned long val)
265{
266 struct snd_kcontrol_new *knew;
267
603c4019
TI		 268 snd_array_init(&spec->kctls, sizeof(*knew), 32);
269 knew = snd_array_new(&spec->kctls);
270 if (!knew)
271 return -ENOMEM;
c577b8a1
JC		 272 *knew = vt1708_control_templates[type];
273 knew->name = kstrdup(name, GFP_KERNEL);
c577b8a1
JC		 274 if (!knew->name)
275 return -ENOMEM;
276 knew->private_value = val;
c577b8a1
JC		 277 return 0;
278}
279
603c4019
TI		 280static void via_free_kctls(struct hda_codec *codec)
281{
282 struct via_spec *spec = codec->spec;
283
284 if (spec->kctls.list) {
285 struct snd_kcontrol_new *kctl = spec->kctls.list;
286 int i;
287 for (i = 0; i < spec->kctls.used; i++)
288 kfree(kctl[i].name);
289 }
290 snd_array_free(&spec->kctls);
291}
292
c577b8a1
JC		 293/* create input playback/capture controls for the given pin */
294static int via_new_analog_input(struct via_spec *spec, hda_nid_t pin,
295 const char *ctlname, int idx, int mix_nid)
296{
297 char name[32];
298 int err;
299
300 sprintf(name, "%s Playback Volume", ctlname);
301 err = via_add_control(spec, VIA_CTL_WIDGET_VOL, name,
302 HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT));
303 if (err < 0)
304 return err;
305 sprintf(name, "%s Playback Switch", ctlname);
306 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, name,
307 HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT));
308 if (err < 0)
309 return err;
310 return 0;
311}
312
313static void via_auto_set_output_and_unmute(struct hda_codec *codec,
314 hda_nid_t nid, int pin_type,
315 int dac_idx)
316{
317 /* set as output */
318 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
319 pin_type);
320 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE,
321 AMP_OUT_UNMUTE);
322}
323
324
325static void via_auto_init_multi_out(struct hda_codec *codec)
326{
327 struct via_spec *spec = codec->spec;
328 int i;
329
330 for (i = 0; i <= AUTO_SEQ_SIDE; i++) {
331 hda_nid_t nid = spec->autocfg.line_out_pins[i];
332 if (nid)
333 via_auto_set_output_and_unmute(codec, nid, PIN_OUT, i);
334 }
335}
336
337static void via_auto_init_hp_out(struct hda_codec *codec)
338{
339 struct via_spec *spec = codec->spec;
340 hda_nid_t pin;
341
342 pin = spec->autocfg.hp_pins[0];
343 if (pin) /* connect to front */
344 via_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
345}
346
347static void via_auto_init_analog_input(struct hda_codec *codec)
348{
349 struct via_spec *spec = codec->spec;
350 int i;
351
352 for (i = 0; i < AUTO_PIN_LAST; i++) {
353 hda_nid_t nid = spec->autocfg.input_pins[i];
354
355 snd_hda_codec_write(codec, nid, 0,
356 AC_VERB_SET_PIN_WIDGET_CONTROL,
357 (i <= AUTO_PIN_FRONT_MIC ?
358 PIN_VREF50 : PIN_IN));
359
360 }
361}
362/*
363 * input MUX handling
364 */
365static int via_mux_enum_info(struct snd_kcontrol *kcontrol,
366 struct snd_ctl_elem_info *uinfo)
367{
368 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
369 struct via_spec *spec = codec->spec;
370 return snd_hda_input_mux_info(spec->input_mux, uinfo);
371}
372
373static int via_mux_enum_get(struct snd_kcontrol *kcontrol,
374 struct snd_ctl_elem_value *ucontrol)
375{
376 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
377 struct via_spec *spec = codec->spec;
378 unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
379
380 ucontrol->value.enumerated.item[0] = spec->cur_mux[adc_idx];
381 return 0;
382}
383
384static int via_mux_enum_put(struct snd_kcontrol *kcontrol,
385 struct snd_ctl_elem_value *ucontrol)
386{
387 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
388 struct via_spec *spec = codec->spec;
389 unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
390 unsigned int vendor_id = codec->vendor_id;
391
392 /* AIW0 lydia 060801 add for correct sw0 input select */
393 if (IS_VT1708_VENDORID(vendor_id) && (adc_idx == 0))
394 return snd_hda_input_mux_put(codec, spec->input_mux, ucontrol,
395 0x18, &spec->cur_mux[adc_idx]);
396 else if ((IS_VT1709_10CH_VENDORID(vendor_id) ||
eb14a46c 397 IS_VT1709_6CH_VENDORID(vendor_id)) && (adc_idx == 0))
c577b8a1
JC		 398 return snd_hda_input_mux_put(codec, spec->input_mux, ucontrol,
399 0x19, &spec->cur_mux[adc_idx]);
f7278fd0 400 else if ((IS_VT1708B_8CH_VENDORID(vendor_id) ||
eb14a46c 401 IS_VT1708B_4CH_VENDORID(vendor_id)) && (adc_idx == 0))
f7278fd0
JC		 402 return snd_hda_input_mux_put(codec, spec->input_mux, ucontrol,
403 0x17, &spec->cur_mux[adc_idx]);
d949cac1
HW		 404 else if (IS_VT1702_VENDORID(vendor_id) && (adc_idx == 0))
405 return snd_hda_input_mux_put(codec, spec->input_mux, ucontrol,
406 0x13, &spec->cur_mux[adc_idx]);
c577b8a1
JC		 407 else
408 return snd_hda_input_mux_put(codec, spec->input_mux, ucontrol,
409 spec->adc_nids[adc_idx],
410 &spec->cur_mux[adc_idx]);
411}
412
0aa62aef
HW		 413static int via_independent_hp_info(struct snd_kcontrol *kcontrol,
414 struct snd_ctl_elem_info *uinfo)
415{
416 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
417 struct via_spec *spec = codec->spec;
418 return snd_hda_input_mux_info(spec->hp_mux, uinfo);
419}
420
421static int via_independent_hp_get(struct snd_kcontrol *kcontrol,
422 struct snd_ctl_elem_value *ucontrol)
423{
424 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
425 struct via_spec *spec = codec->spec;
426 hda_nid_t nid = spec->autocfg.hp_pins[0];
427 unsigned int pinsel = snd_hda_codec_read(codec, nid, 0,
428 AC_VERB_GET_CONNECT_SEL,
429 0x00);
430
431 ucontrol->value.enumerated.item[0] = pinsel;
432
433 return 0;
434}
435
436static int via_independent_hp_put(struct snd_kcontrol *kcontrol,
437 struct snd_ctl_elem_value *ucontrol)
438{
439 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
440 struct via_spec *spec = codec->spec;
441 hda_nid_t nid = spec->autocfg.hp_pins[0];
442 unsigned int pinsel = ucontrol->value.enumerated.item[0];
443 unsigned int con_nid = snd_hda_codec_read(codec, nid, 0,
444 AC_VERB_GET_CONNECT_LIST, 0) & 0xff;
445
446 if (con_nid == spec->multiout.hp_nid) {
447 if (pinsel == 0) {
448 if (!spec->hp_independent_mode) {
449 if (spec->multiout.num_dacs > 1)
450 spec->multiout.num_dacs -= 1;
451 spec->hp_independent_mode = 1;
452 }
453 } else if (pinsel == 1) {
454 if (spec->hp_independent_mode) {
455 if (spec->multiout.num_dacs > 1)
456 spec->multiout.num_dacs += 1;
457 spec->hp_independent_mode = 0;
458 }
459 }
460 } else {
461 if (pinsel == 0) {
462 if (spec->hp_independent_mode) {
463 if (spec->multiout.num_dacs > 1)
464 spec->multiout.num_dacs += 1;
465 spec->hp_independent_mode = 0;
466 }
467 } else if (pinsel == 1) {
468 if (!spec->hp_independent_mode) {
469 if (spec->multiout.num_dacs > 1)
470 spec->multiout.num_dacs -= 1;
471 spec->hp_independent_mode = 1;
472 }
473 }
474 }
475 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CONNECT_SEL,
476 pinsel);
477
478 if (spec->multiout.hp_nid &&
479 spec->multiout.hp_nid != spec->multiout.dac_nids[HDA_FRONT])
480 snd_hda_codec_setup_stream(codec,
481 spec->multiout.hp_nid,
482 0, 0, 0);
483
484 return 0;
485}
486
487static struct snd_kcontrol_new via_hp_mixer[] = {
488 {
489 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
490 .name = "Independent HP",
491 .count = 1,
492 .info = via_independent_hp_info,
493 .get = via_independent_hp_get,
494 .put = via_independent_hp_put,
495 },
496 { } /* end */
497};
498
c577b8a1
JC		 499/* capture mixer elements */
500static struct snd_kcontrol_new vt1708_capture_mixer[] = {
501 HDA_CODEC_VOLUME("Capture Volume", 0x15, 0x0, HDA_INPUT),
502 HDA_CODEC_MUTE("Capture Switch", 0x15, 0x0, HDA_INPUT),
503 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x27, 0x0, HDA_INPUT),
504 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x27, 0x0, HDA_INPUT),
505 {
506 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
507 /* The multiple "Capture Source" controls confuse alsamixer
508 * So call somewhat different..
c577b8a1
JC		 509 */
510 /* .name = "Capture Source", */
511 .name = "Input Source",
512 .count = 1,
513 .info = via_mux_enum_info,
514 .get = via_mux_enum_get,
515 .put = via_mux_enum_put,
516 },
517 { } /* end */
518};
519/*
520 * generic initialization of ADC, input mixers and output mixers
521 */
522static struct hda_verb vt1708_volume_init_verbs[] = {
523 /*
524 * Unmute ADC0-1 and set the default input to mic-in
525 */
526 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
527 {0x27, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
528
529
f7278fd0 530 /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
c577b8a1
JC		 531 * mixer widget
532 */
533 /* Amp Indices: CD = 1, Mic1 = 2, Line = 3, Mic2 = 4 */
f7278fd0
JC		 534 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
535 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
536 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
537 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
538 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
c577b8a1
JC		 539
540 /*
541 * Set up output mixers (0x19 - 0x1b)
542 */
543 /* set vol=0 to output mixers */
544 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
545 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
546 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
547
548 /* Setup default input to PW4 */
549 {0x20, AC_VERB_SET_CONNECT_SEL, 0x1},
c577b8a1
JC		 550 /* PW9 Output enable */
551 {0x25, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
f7278fd0 552 { }
c577b8a1
JC		 553};
554
555static int via_playback_pcm_open(struct hda_pcm_stream *hinfo,
556 struct hda_codec *codec,
557 struct snd_pcm_substream *substream)
558{
559 struct via_spec *spec = codec->spec;
9a08160b
TI		 560 return snd_hda_multi_out_analog_open(codec, &spec->multiout, substream,
561 hinfo);
c577b8a1
JC		 562}
563
564static int via_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
565 struct hda_codec *codec,
566 unsigned int stream_tag,
567 unsigned int format,
568 struct snd_pcm_substream *substream)
569{
570 struct via_spec *spec = codec->spec;
571 return snd_hda_multi_out_analog_prepare(codec, &spec->multiout,
572 stream_tag, format, substream);
573}
574
575static int via_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
576 struct hda_codec *codec,
577 struct snd_pcm_substream *substream)
578{
579 struct via_spec *spec = codec->spec;
580 return snd_hda_multi_out_analog_cleanup(codec, &spec->multiout);
581}
582
0aa62aef
HW		 583
584static void playback_multi_pcm_prep_0(struct hda_codec *codec,
585 unsigned int stream_tag,
586 unsigned int format,
587 struct snd_pcm_substream *substream)
588{
589 struct via_spec *spec = codec->spec;
590 struct hda_multi_out *mout = &spec->multiout;
591 hda_nid_t *nids = mout->dac_nids;
592 int chs = substream->runtime->channels;
593 int i;
594
595 mutex_lock(&codec->spdif_mutex);
596 if (mout->dig_out_nid && mout->dig_out_used != HDA_DIG_EXCLUSIVE) {
597 if (chs == 2 &&
598 snd_hda_is_supported_format(codec, mout->dig_out_nid,
599 format) &&
600 !(codec->spdif_status & IEC958_AES0_NONAUDIO)) {
601 mout->dig_out_used = HDA_DIG_ANALOG_DUP;
602 /* turn off SPDIF once; otherwise the IEC958 bits won't
603 * be updated */
604 if (codec->spdif_ctls & AC_DIG1_ENABLE)
605 snd_hda_codec_write(codec, mout->dig_out_nid, 0,
606 AC_VERB_SET_DIGI_CONVERT_1,
607 codec->spdif_ctls &
608 ~AC_DIG1_ENABLE & 0xff);
609 snd_hda_codec_setup_stream(codec, mout->dig_out_nid,
610 stream_tag, 0, format);
611 /* turn on again (if needed) */
612 if (codec->spdif_ctls & AC_DIG1_ENABLE)
613 snd_hda_codec_write(codec, mout->dig_out_nid, 0,
614 AC_VERB_SET_DIGI_CONVERT_1,
615 codec->spdif_ctls & 0xff);
616 } else {
617 mout->dig_out_used = 0;
618 snd_hda_codec_setup_stream(codec, mout->dig_out_nid,
619 0, 0, 0);
620 }
621 }
622 mutex_unlock(&codec->spdif_mutex);
623
624 /* front */
625 snd_hda_codec_setup_stream(codec, nids[HDA_FRONT], stream_tag,
626 0, format);
627
628 if (mout->hp_nid && mout->hp_nid != nids[HDA_FRONT] &&
629 !spec->hp_independent_mode)
630 /* headphone out will just decode front left/right (stereo) */
631 snd_hda_codec_setup_stream(codec, mout->hp_nid, stream_tag,
632 0, format);
633
634 /* extra outputs copied from front */
635 for (i = 0; i < ARRAY_SIZE(mout->extra_out_nid); i++)
636 if (mout->extra_out_nid[i])
637 snd_hda_codec_setup_stream(codec,
638 mout->extra_out_nid[i],
639 stream_tag, 0, format);
640
641 /* surrounds */
642 for (i = 1; i < mout->num_dacs; i++) {
643 if (chs >= (i + 1) * 2) /* independent out */
644 snd_hda_codec_setup_stream(codec, nids[i], stream_tag,
645 i * 2, format);
646 else /* copy front */
647 snd_hda_codec_setup_stream(codec, nids[i], stream_tag,
648 0, format);
649 }
650}
651
652static int via_playback_multi_pcm_prepare(struct hda_pcm_stream *hinfo,
653 struct hda_codec *codec,
654 unsigned int stream_tag,
655 unsigned int format,
656 struct snd_pcm_substream *substream)
657{
658 struct via_spec *spec = codec->spec;
659 struct hda_multi_out *mout = &spec->multiout;
660 hda_nid_t *nids = mout->dac_nids;
661
662 if (substream->number == 0)
663 playback_multi_pcm_prep_0(codec, stream_tag, format,
664 substream);
665 else {
666 if (mout->hp_nid && mout->hp_nid != nids[HDA_FRONT] &&
667 spec->hp_independent_mode)
668 snd_hda_codec_setup_stream(codec, mout->hp_nid,
669 stream_tag, 0, format);
670 }
671
672 return 0;
673}
674
675static int via_playback_multi_pcm_cleanup(struct hda_pcm_stream *hinfo,
676 struct hda_codec *codec,
677 struct snd_pcm_substream *substream)
678{
679 struct via_spec *spec = codec->spec;
680 struct hda_multi_out *mout = &spec->multiout;
681 hda_nid_t *nids = mout->dac_nids;
682 int i;
683
684 if (substream->number == 0) {
685 for (i = 0; i < mout->num_dacs; i++)
686 snd_hda_codec_setup_stream(codec, nids[i], 0, 0, 0);
687
688 if (mout->hp_nid && !spec->hp_independent_mode)
689 snd_hda_codec_setup_stream(codec, mout->hp_nid,
690 0, 0, 0);
691
692 for (i = 0; i < ARRAY_SIZE(mout->extra_out_nid); i++)
693 if (mout->extra_out_nid[i])
694 snd_hda_codec_setup_stream(codec,
695 mout->extra_out_nid[i],
696 0, 0, 0);
697 mutex_lock(&codec->spdif_mutex);
698 if (mout->dig_out_nid &&
699 mout->dig_out_used == HDA_DIG_ANALOG_DUP) {
700 snd_hda_codec_setup_stream(codec, mout->dig_out_nid,
701 0, 0, 0);
702 mout->dig_out_used = 0;
703 }
704 mutex_unlock(&codec->spdif_mutex);
705 } else {
706 if (mout->hp_nid && mout->hp_nid != nids[HDA_FRONT] &&
707 spec->hp_independent_mode)
708 snd_hda_codec_setup_stream(codec, mout->hp_nid,
709 0, 0, 0);
710 }
711
712 return 0;
713}
714
c577b8a1
JC		 715/*
716 * Digital out
717 */
718static int via_dig_playback_pcm_open(struct hda_pcm_stream *hinfo,
719 struct hda_codec *codec,
720 struct snd_pcm_substream *substream)
721{
722 struct via_spec *spec = codec->spec;
723 return snd_hda_multi_out_dig_open(codec, &spec->multiout);
724}
725
726static int via_dig_playback_pcm_close(struct hda_pcm_stream *hinfo,
727 struct hda_codec *codec,
728 struct snd_pcm_substream *substream)
729{
730 struct via_spec *spec = codec->spec;
731 return snd_hda_multi_out_dig_close(codec, &spec->multiout);
732}
733
5691ec7f 734static int via_dig_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
98aa34c0
HW		 735 struct hda_codec *codec,
736 unsigned int stream_tag,
737 unsigned int format,
738 struct snd_pcm_substream *substream)
739{
740 struct via_spec *spec = codec->spec;
9da29271
TI		 741 return snd_hda_multi_out_dig_prepare(codec, &spec->multiout,
742 stream_tag, format, substream);
743}
98aa34c0 744
9da29271
TI		 745static int via_dig_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
746 struct hda_codec *codec,
747 struct snd_pcm_substream *substream)
748{
749 struct via_spec *spec = codec->spec;
750 snd_hda_multi_out_dig_cleanup(codec, &spec->multiout);
98aa34c0
HW		 751 return 0;
752}
753
c577b8a1
JC		 754/*
755 * Analog capture
756 */
757static int via_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
758 struct hda_codec *codec,
759 unsigned int stream_tag,
760 unsigned int format,
761 struct snd_pcm_substream *substream)
762{
763 struct via_spec *spec = codec->spec;
764
765 snd_hda_codec_setup_stream(codec, spec->adc_nids[substream->number],
766 stream_tag, 0, format);
767 return 0;
768}
769
770static int via_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
771 struct hda_codec *codec,
772 struct snd_pcm_substream *substream)
773{
774 struct via_spec *spec = codec->spec;
888afa15 775 snd_hda_codec_cleanup_stream(codec, spec->adc_nids[substream->number]);
c577b8a1
JC		 776 return 0;
777}
778
779static struct hda_pcm_stream vt1708_pcm_analog_playback = {
0aa62aef 780 .substreams = 2,
c577b8a1
JC		 781 .channels_min = 2,
782 .channels_max = 8,
783 .nid = 0x10, /* NID to query formats and rates */
784 .ops = {
785 .open = via_playback_pcm_open,
0aa62aef
HW		 786 .prepare = via_playback_multi_pcm_prepare,
787 .cleanup = via_playback_multi_pcm_cleanup
c577b8a1
JC		 788 },
789};
790
bc9b5623
TI		 791static struct hda_pcm_stream vt1708_pcm_analog_s16_playback = {
792 .substreams = 1,
793 .channels_min = 2,
794 .channels_max = 8,
795 .nid = 0x10, /* NID to query formats and rates */
796 /* We got noisy outputs on the right channel on VT1708 when
797 * 24bit samples are used. Until any workaround is found,
798 * disable the 24bit format, so far.
799 */
800 .formats = SNDRV_PCM_FMTBIT_S16_LE,
801 .ops = {
802 .open = via_playback_pcm_open,
803 .prepare = via_playback_pcm_prepare,
804 .cleanup = via_playback_pcm_cleanup
805 },
806};
807
c577b8a1
JC		 808static struct hda_pcm_stream vt1708_pcm_analog_capture = {
809 .substreams = 2,
810 .channels_min = 2,
811 .channels_max = 2,
812 .nid = 0x15, /* NID to query formats and rates */
813 .ops = {
814 .prepare = via_capture_pcm_prepare,
815 .cleanup = via_capture_pcm_cleanup
816 },
817};
818
819static struct hda_pcm_stream vt1708_pcm_digital_playback = {
820 .substreams = 1,
821 .channels_min = 2,
822 .channels_max = 2,
823 /* NID is set in via_build_pcms */
824 .ops = {
825 .open = via_dig_playback_pcm_open,
6b97eb45 826 .close = via_dig_playback_pcm_close,
9da29271
TI		 827 .prepare = via_dig_playback_pcm_prepare,
828 .cleanup = via_dig_playback_pcm_cleanup
c577b8a1
JC		 829 },
830};
831
832static struct hda_pcm_stream vt1708_pcm_digital_capture = {
833 .substreams = 1,
834 .channels_min = 2,
835 .channels_max = 2,
836};
837
838static int via_build_controls(struct hda_codec *codec)
839{
840 struct via_spec *spec = codec->spec;
841 int err;
842 int i;
843
844 for (i = 0; i < spec->num_mixers; i++) {
845 err = snd_hda_add_new_ctls(codec, spec->mixers[i]);
846 if (err < 0)
847 return err;
848 }
849
850 if (spec->multiout.dig_out_nid) {
851 err = snd_hda_create_spdif_out_ctls(codec,
852 spec->multiout.dig_out_nid);
853 if (err < 0)
854 return err;
9a08160b
TI		 855 err = snd_hda_create_spdif_share_sw(codec,
856 &spec->multiout);
857 if (err < 0)
858 return err;
859 spec->multiout.share_spdif = 1;
c577b8a1
JC		 860 }
861 if (spec->dig_in_nid) {
862 err = snd_hda_create_spdif_in_ctls(codec, spec->dig_in_nid);
863 if (err < 0)
864 return err;
865 }
603c4019 866 via_free_kctls(codec); /* no longer needed */
c577b8a1
JC		 867 return 0;
868}
869
870static int via_build_pcms(struct hda_codec *codec)
871{
872 struct via_spec *spec = codec->spec;
873 struct hda_pcm *info = spec->pcm_rec;
874
875 codec->num_pcms = 1;
876 codec->pcm_info = info;
877
878 info->name = spec->stream_name_analog;
879 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *(spec->stream_analog_playback);
880 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dac_nids[0];
881 info->stream[SNDRV_PCM_STREAM_CAPTURE] = *(spec->stream_analog_capture);
882 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adc_nids[0];
883
884 info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max =
885 spec->multiout.max_channels;
886
887 if (spec->multiout.dig_out_nid || spec->dig_in_nid) {
888 codec->num_pcms++;
889 info++;
890 info->name = spec->stream_name_digital;
7ba72ba1 891 info->pcm_type = HDA_PCM_TYPE_SPDIF;
c577b8a1
JC		 892 if (spec->multiout.dig_out_nid) {
893 info->stream[SNDRV_PCM_STREAM_PLAYBACK] =
894 *(spec->stream_digital_playback);
895 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid =
896 spec->multiout.dig_out_nid;
897 }
898 if (spec->dig_in_nid) {
899 info->stream[SNDRV_PCM_STREAM_CAPTURE] =
900 *(spec->stream_digital_capture);
901 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid =
902 spec->dig_in_nid;
903 }
904 }
905
906 return 0;
907}
908
909static void via_free(struct hda_codec *codec)
910{
911 struct via_spec *spec = codec->spec;
c577b8a1
JC		 912
913 if (!spec)
914 return;
915
603c4019 916 via_free_kctls(codec);
c577b8a1
JC		 917 kfree(codec->spec);
918}
919
69e52a80
HW		 920/* mute internal speaker if HP is plugged */
921static void via_hp_automute(struct hda_codec *codec)
922{
923 unsigned int present;
924 struct via_spec *spec = codec->spec;
925
926 present = snd_hda_codec_read(codec, spec->autocfg.hp_pins[0], 0,
927 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
928 snd_hda_codec_amp_stereo(codec, spec->autocfg.line_out_pins[0],
929 HDA_OUTPUT, 0, HDA_AMP_MUTE,
930 present ? HDA_AMP_MUTE : 0);
931}
932
933static void via_gpio_control(struct hda_codec *codec)
934{
935 unsigned int gpio_data;
936 unsigned int vol_counter;
937 unsigned int vol;
938 unsigned int master_vol;
939
940 struct via_spec *spec = codec->spec;
941
942 gpio_data = snd_hda_codec_read(codec, codec->afg, 0,
943 AC_VERB_GET_GPIO_DATA, 0) & 0x03;
944
945 vol_counter = (snd_hda_codec_read(codec, codec->afg, 0,
946 0xF84, 0) & 0x3F0000) >> 16;
947
948 vol = vol_counter & 0x1F;
949 master_vol = snd_hda_codec_read(codec, 0x1A, 0,
950 AC_VERB_GET_AMP_GAIN_MUTE,
951 AC_AMP_GET_INPUT);
952
953 if (gpio_data == 0x02) {
954 /* unmute line out */
955 snd_hda_codec_amp_stereo(codec, spec->autocfg.line_out_pins[0],
956 HDA_OUTPUT, 0, HDA_AMP_MUTE, 0);
957
958 if (vol_counter & 0x20) {
959 /* decrease volume */
960 if (vol > master_vol)
961 vol = master_vol;
962 snd_hda_codec_amp_stereo(codec, 0x1A, HDA_INPUT,
963 0, HDA_AMP_VOLMASK,
964 master_vol-vol);
965 } else {
966 /* increase volume */
967 snd_hda_codec_amp_stereo(codec, 0x1A, HDA_INPUT, 0,
968 HDA_AMP_VOLMASK,
969 ((master_vol+vol) > 0x2A) ? 0x2A :
970 (master_vol+vol));
971 }
972 } else if (!(gpio_data & 0x02)) {
973 /* mute line out */
974 snd_hda_codec_amp_stereo(codec,
975 spec->autocfg.line_out_pins[0],
976 HDA_OUTPUT, 0, HDA_AMP_MUTE,
977 HDA_AMP_MUTE);
978 }
979}
980
981/* unsolicited event for jack sensing */
982static void via_unsol_event(struct hda_codec *codec,
983 unsigned int res)
984{
985 res >>= 26;
986 if (res == VIA_HP_EVENT)
987 via_hp_automute(codec);
988 else if (res == VIA_GPIO_EVENT)
989 via_gpio_control(codec);
990}
991
c577b8a1
JC		 992static int via_init(struct hda_codec *codec)
993{
994 struct via_spec *spec = codec->spec;
69e52a80
HW		 995 int i;
996 for (i = 0; i < spec->num_iverbs; i++)
997 snd_hda_sequence_write(codec, spec->init_verbs[i]);
998
f7278fd0
JC		 999 /* Lydia Add for EAPD enable */
1000 if (!spec->dig_in_nid) { /* No Digital In connection */
1001 if (IS_VT1708_VENDORID(codec->vendor_id)) {
1002 snd_hda_codec_write(codec, VT1708_DIGIN_PIN, 0,
1003 AC_VERB_SET_PIN_WIDGET_CONTROL,
12b74c80 1004 PIN_OUT);
f7278fd0
JC		 1005 snd_hda_codec_write(codec, VT1708_DIGIN_PIN, 0,
1006 AC_VERB_SET_EAPD_BTLENABLE, 0x02);
1007 } else if (IS_VT1709_10CH_VENDORID(codec->vendor_id) ||
1008 IS_VT1709_6CH_VENDORID(codec->vendor_id)) {
1009 snd_hda_codec_write(codec, VT1709_DIGIN_PIN, 0,
1010 AC_VERB_SET_PIN_WIDGET_CONTROL,
12b74c80 1011 PIN_OUT);
f7278fd0
JC		 1012 snd_hda_codec_write(codec, VT1709_DIGIN_PIN, 0,
1013 AC_VERB_SET_EAPD_BTLENABLE, 0x02);
1014 } else if (IS_VT1708B_8CH_VENDORID(codec->vendor_id) ||
1015 IS_VT1708B_4CH_VENDORID(codec->vendor_id)) {
1016 snd_hda_codec_write(codec, VT1708B_DIGIN_PIN, 0,
1017 AC_VERB_SET_PIN_WIDGET_CONTROL,
12b74c80 1018 PIN_OUT);
f7278fd0
JC		 1019 snd_hda_codec_write(codec, VT1708B_DIGIN_PIN, 0,
1020 AC_VERB_SET_EAPD_BTLENABLE, 0x02);
1021 }
12b74c80
TI		 1022 } else /* enable SPDIF-input pin */
1023 snd_hda_codec_write(codec, spec->autocfg.dig_in_pin, 0,
1024 AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN);
f7278fd0 1025
9da29271
TI		 1026 /* assign slave outs */
1027 if (spec->slave_dig_outs[0])
1028 codec->slave_dig_outs = spec->slave_dig_outs;
5691ec7f 1029
c577b8a1
JC		 1030 return 0;
1031}
1032
cb53c626
TI		 1033#ifdef CONFIG_SND_HDA_POWER_SAVE
1034static int via_check_power_status(struct hda_codec *codec, hda_nid_t nid)
1035{
1036 struct via_spec *spec = codec->spec;
1037 return snd_hda_check_amp_list_power(codec, &spec->loopback, nid);
1038}
1039#endif
1040
c577b8a1
JC		 1041/*
1042 */
1043static struct hda_codec_ops via_patch_ops = {
1044 .build_controls = via_build_controls,
1045 .build_pcms = via_build_pcms,
1046 .init = via_init,
1047 .free = via_free,
cb53c626
TI		 1048#ifdef CONFIG_SND_HDA_POWER_SAVE
1049 .check_power_status = via_check_power_status,
1050#endif
c577b8a1
JC		 1051};
1052
1053/* fill in the dac_nids table from the parsed pin configuration */
1054static int vt1708_auto_fill_dac_nids(struct via_spec *spec,
1055 const struct auto_pin_cfg *cfg)
1056{
1057 int i;
1058 hda_nid_t nid;
1059
1060 spec->multiout.num_dacs = cfg->line_outs;
1061
1062 spec->multiout.dac_nids = spec->private_dac_nids;
1063
1064 for(i = 0; i < 4; i++) {
1065 nid = cfg->line_out_pins[i];
1066 if (nid) {
1067 /* config dac list */
1068 switch (i) {
1069 case AUTO_SEQ_FRONT:
1070 spec->multiout.dac_nids[i] = 0x10;
1071 break;
1072 case AUTO_SEQ_CENLFE:
1073 spec->multiout.dac_nids[i] = 0x12;
1074 break;
1075 case AUTO_SEQ_SURROUND:
fb4cb772 1076 spec->multiout.dac_nids[i] = 0x11;
c577b8a1
JC		 1077 break;
1078 case AUTO_SEQ_SIDE:
fb4cb772 1079 spec->multiout.dac_nids[i] = 0x13;
c577b8a1
JC		 1080 break;
1081 }
1082 }
1083 }
1084
1085 return 0;
1086}
1087
1088/* add playback controls from the parsed DAC table */
1089static int vt1708_auto_create_multi_out_ctls(struct via_spec *spec,
1090 const struct auto_pin_cfg *cfg)
1091{
1092 char name[32];
1093 static const char *chname[4] = { "Front", "Surround", "C/LFE", "Side" };
1094 hda_nid_t nid, nid_vol = 0;
1095 int i, err;
1096
1097 for (i = 0; i <= AUTO_SEQ_SIDE; i++) {
1098 nid = cfg->line_out_pins[i];
1099
1100 if (!nid)
1101 continue;
1102
1103 if (i != AUTO_SEQ_FRONT)
fb4cb772 1104 nid_vol = 0x18 + i;
c577b8a1
JC		 1105
1106 if (i == AUTO_SEQ_CENLFE) {
1107 /* Center/LFE */
1108 err = via_add_control(spec, VIA_CTL_WIDGET_VOL,
f7278fd0
JC		 1109 "Center Playback Volume",
1110 HDA_COMPOSE_AMP_VAL(nid_vol, 1, 0,
1111 HDA_OUTPUT));
c577b8a1
JC		 1112 if (err < 0)
1113 return err;
1114 err = via_add_control(spec, VIA_CTL_WIDGET_VOL,
1115 "LFE Playback Volume",
f7278fd0
JC		 1116 HDA_COMPOSE_AMP_VAL(nid_vol, 2, 0,
1117 HDA_OUTPUT));
c577b8a1
JC		 1118 if (err < 0)
1119 return err;
1120 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE,
1121 "Center Playback Switch",
f7278fd0
JC		 1122 HDA_COMPOSE_AMP_VAL(nid_vol, 1, 0,
1123 HDA_OUTPUT));
c577b8a1
JC		 1124 if (err < 0)
1125 return err;
1126 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE,
1127 "LFE Playback Switch",
f7278fd0
JC		 1128 HDA_COMPOSE_AMP_VAL(nid_vol, 2, 0,
1129 HDA_OUTPUT));
c577b8a1
JC		 1130 if (err < 0)
1131 return err;
1132 } else if (i == AUTO_SEQ_FRONT){
1133 /* add control to mixer index 0 */
1134 err = via_add_control(spec, VIA_CTL_WIDGET_VOL,
1135 "Master Front Playback Volume",
f7278fd0
JC		 1136 HDA_COMPOSE_AMP_VAL(0x17, 3, 0,
1137 HDA_INPUT));
c577b8a1
JC		 1138 if (err < 0)
1139 return err;
1140 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE,
1141 "Master Front Playback Switch",
f7278fd0
JC		 1142 HDA_COMPOSE_AMP_VAL(0x17, 3, 0,
1143 HDA_INPUT));
c577b8a1
JC		 1144 if (err < 0)
1145 return err;
1146
1147 /* add control to PW3 */
1148 sprintf(name, "%s Playback Volume", chname[i]);
1149 err = via_add_control(spec, VIA_CTL_WIDGET_VOL, name,
f7278fd0
JC		 1150 HDA_COMPOSE_AMP_VAL(nid, 3, 0,
1151 HDA_OUTPUT));
c577b8a1
JC		 1152 if (err < 0)
1153 return err;
1154 sprintf(name, "%s Playback Switch", chname[i]);
1155 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, name,
f7278fd0
JC		 1156 HDA_COMPOSE_AMP_VAL(nid, 3, 0,
1157 HDA_OUTPUT));
c577b8a1
JC		 1158 if (err < 0)
1159 return err;
1160 } else {
1161 sprintf(name, "%s Playback Volume", chname[i]);
1162 err = via_add_control(spec, VIA_CTL_WIDGET_VOL, name,
f7278fd0
JC		 1163 HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0,
1164 HDA_OUTPUT));
c577b8a1
JC		 1165 if (err < 0)
1166 return err;
1167 sprintf(name, "%s Playback Switch", chname[i]);
1168 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, name,
f7278fd0
JC		 1169 HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0,
1170 HDA_OUTPUT));
c577b8a1
JC		 1171 if (err < 0)
1172 return err;
1173 }
1174 }
1175
1176 return 0;
1177}
1178
0aa62aef
HW		 1179static void create_hp_imux(struct via_spec *spec)
1180{
1181 int i;
1182 struct hda_input_mux *imux = &spec->private_imux[1];
1183 static const char *texts[] = { "OFF", "ON", NULL};
1184
1185 /* for hp mode select */
1186 i = 0;
1187 while (texts[i] != NULL) {
1188 imux->items[imux->num_items].label = texts[i];
1189 imux->items[imux->num_items].index = i;
1190 imux->num_items++;
1191 i++;
1192 }
1193
1194 spec->hp_mux = &spec->private_imux[1];
1195}
1196
c577b8a1
JC		 1197static int vt1708_auto_create_hp_ctls(struct via_spec *spec, hda_nid_t pin)
1198{
1199 int err;
1200
1201 if (!pin)
1202 return 0;
1203
1204 spec->multiout.hp_nid = VT1708_HP_NID; /* AOW3 */
1205
1206 err = via_add_control(spec, VIA_CTL_WIDGET_VOL,
1207 "Headphone Playback Volume",
1208 HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
1209 if (err < 0)
1210 return err;
1211 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE,
1212 "Headphone Playback Switch",
1213 HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
1214 if (err < 0)
1215 return err;
1216
0aa62aef
HW		 1217 create_hp_imux(spec);
1218
c577b8a1
JC		 1219 return 0;
1220}
1221
1222/* create playback/capture controls for input pins */
1223static int vt1708_auto_create_analog_input_ctls(struct via_spec *spec,
1224 const struct auto_pin_cfg *cfg)
1225{
1226 static char *labels[] = {
1227 "Mic", "Front Mic", "Line", "Front Line", "CD", "Aux", NULL
1228 };
0aa62aef 1229 struct hda_input_mux *imux = &spec->private_imux[0];
c577b8a1
JC		 1230 int i, err, idx = 0;
1231
1232 /* for internal loopback recording select */
1233 imux->items[imux->num_items].label = "Stereo Mixer";
1234 imux->items[imux->num_items].index = idx;
1235 imux->num_items++;
1236
1237 for (i = 0; i < AUTO_PIN_LAST; i++) {
1238 if (!cfg->input_pins[i])
1239 continue;
1240
1241 switch (cfg->input_pins[i]) {
1242 case 0x1d: /* Mic */
1243 idx = 2;
1244 break;
1245
1246 case 0x1e: /* Line In */
1247 idx = 3;
1248 break;
1249
1250 case 0x21: /* Front Mic */
1251 idx = 4;
1252 break;
1253
1254 case 0x24: /* CD */
1255 idx = 1;
1256 break;
1257 }
1258 err = via_new_analog_input(spec, cfg->input_pins[i], labels[i],
1259 idx, 0x17);
1260 if (err < 0)
1261 return err;
1262 imux->items[imux->num_items].label = labels[i];
1263 imux->items[imux->num_items].index = idx;
1264 imux->num_items++;
1265 }
1266 return 0;
1267}
1268
cb53c626
TI		 1269#ifdef CONFIG_SND_HDA_POWER_SAVE
1270static struct hda_amp_list vt1708_loopbacks[] = {
1271 { 0x17, HDA_INPUT, 1 },
1272 { 0x17, HDA_INPUT, 2 },
1273 { 0x17, HDA_INPUT, 3 },
1274 { 0x17, HDA_INPUT, 4 },
1275 { } /* end */
1276};
1277#endif
1278
76d9b0dd
HW		 1279static void vt1708_set_pinconfig_connect(struct hda_codec *codec, hda_nid_t nid)
1280{
1281 unsigned int def_conf;
1282 unsigned char seqassoc;
1283
2f334f92 1284 def_conf = snd_hda_codec_get_pincfg(codec, nid);
76d9b0dd
HW		 1285 seqassoc = (unsigned char) get_defcfg_association(def_conf);
1286 seqassoc = (seqassoc << 4) | get_defcfg_sequence(def_conf);
1287 if (get_defcfg_connect(def_conf) == AC_JACK_PORT_NONE) {
1288 if (seqassoc == 0xff) {
1289 def_conf = def_conf & (~(AC_JACK_PORT_BOTH << 30));
2f334f92 1290 snd_hda_codec_set_pincfg(codec, nid, def_conf);
76d9b0dd
HW		 1291 }
1292 }
1293
1294 return;
1295}
1296
c577b8a1
JC		 1297static int vt1708_parse_auto_config(struct hda_codec *codec)
1298{
1299 struct via_spec *spec = codec->spec;
1300 int err;
1301
76d9b0dd
HW		 1302 /* Add HP and CD pin config connect bit re-config action */
1303 vt1708_set_pinconfig_connect(codec, VT1708_HP_PIN_NID);
1304 vt1708_set_pinconfig_connect(codec, VT1708_CD_PIN_NID);
1305
c577b8a1
JC		 1306 err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, NULL);
1307 if (err < 0)
1308 return err;
1309 err = vt1708_auto_fill_dac_nids(spec, &spec->autocfg);
1310 if (err < 0)
1311 return err;
1312 if (!spec->autocfg.line_outs && !spec->autocfg.hp_pins[0])
1313 return 0; /* can't find valid BIOS pin config */
1314
1315 err = vt1708_auto_create_multi_out_ctls(spec, &spec->autocfg);
1316 if (err < 0)
1317 return err;
1318 err = vt1708_auto_create_hp_ctls(spec, spec->autocfg.hp_pins[0]);
1319 if (err < 0)
1320 return err;
1321 err = vt1708_auto_create_analog_input_ctls(spec, &spec->autocfg);
1322 if (err < 0)
1323 return err;
1324
1325 spec->multiout.max_channels = spec->multiout.num_dacs * 2;
1326
0852d7a6 1327 if (spec->autocfg.dig_outs)
c577b8a1
JC		 1328 spec->multiout.dig_out_nid = VT1708_DIGOUT_NID;
1329 if (spec->autocfg.dig_in_pin)
1330 spec->dig_in_nid = VT1708_DIGIN_NID;
1331
603c4019
TI		 1332 if (spec->kctls.list)
1333 spec->mixers[spec->num_mixers++] = spec->kctls.list;
c577b8a1 1334
69e52a80 1335 spec->init_verbs[spec->num_iverbs++] = vt1708_volume_init_verbs;
c577b8a1 1336
0aa62aef
HW		 1337 spec->input_mux = &spec->private_imux[0];
1338
f8fdd495
HW		 1339 if (spec->hp_mux)
1340 spec->mixers[spec->num_mixers++] = via_hp_mixer;
c577b8a1
JC		 1341
1342 return 1;
1343}
1344
1345/* init callback for auto-configuration model -- overriding the default init */
1346static int via_auto_init(struct hda_codec *codec)
1347{
1348 via_init(codec);
1349 via_auto_init_multi_out(codec);
1350 via_auto_init_hp_out(codec);
1351 via_auto_init_analog_input(codec);
1352 return 0;
1353}
1354
1355static int patch_vt1708(struct hda_codec *codec)
1356{
1357 struct via_spec *spec;
1358 int err;
1359
1360 /* create a codec specific record */
eb14a46c 1361 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
c577b8a1
JC		 1362 if (spec == NULL)
1363 return -ENOMEM;
1364
1365 codec->spec = spec;
1366
1367 /* automatic parse from the BIOS config */
1368 err = vt1708_parse_auto_config(codec);
1369 if (err < 0) {
1370 via_free(codec);
1371 return err;
1372 } else if (!err) {
1373 printk(KERN_INFO "hda_codec: Cannot set up configuration "
1374 "from BIOS. Using genenic mode...\n");
1375 }
1376
1377
1378 spec->stream_name_analog = "VT1708 Analog";
1379 spec->stream_analog_playback = &vt1708_pcm_analog_playback;
bc9b5623
TI		 1380 /* disable 32bit format on VT1708 */
1381 if (codec->vendor_id == 0x11061708)
1382 spec->stream_analog_playback = &vt1708_pcm_analog_s16_playback;
c577b8a1
JC		 1383 spec->stream_analog_capture = &vt1708_pcm_analog_capture;
1384
1385 spec->stream_name_digital = "VT1708 Digital";
1386 spec->stream_digital_playback = &vt1708_pcm_digital_playback;
1387 spec->stream_digital_capture = &vt1708_pcm_digital_capture;
1388
1389
1390 if (!spec->adc_nids && spec->input_mux) {
1391 spec->adc_nids = vt1708_adc_nids;
1392 spec->num_adc_nids = ARRAY_SIZE(vt1708_adc_nids);
1393 spec->mixers[spec->num_mixers] = vt1708_capture_mixer;
1394 spec->num_mixers++;
1395 }
1396
1397 codec->patch_ops = via_patch_ops;
1398
1399 codec->patch_ops.init = via_auto_init;
cb53c626
TI		 1400#ifdef CONFIG_SND_HDA_POWER_SAVE
1401 spec->loopback.amplist = vt1708_loopbacks;
1402#endif
c577b8a1
JC		 1403
1404 return 0;
1405}
1406
1407/* capture mixer elements */
1408static struct snd_kcontrol_new vt1709_capture_mixer[] = {
1409 HDA_CODEC_VOLUME("Capture Volume", 0x14, 0x0, HDA_INPUT),
1410 HDA_CODEC_MUTE("Capture Switch", 0x14, 0x0, HDA_INPUT),
1411 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x15, 0x0, HDA_INPUT),
1412 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x15, 0x0, HDA_INPUT),
1413 HDA_CODEC_VOLUME_IDX("Capture Volume", 2, 0x16, 0x0, HDA_INPUT),
1414 HDA_CODEC_MUTE_IDX("Capture Switch", 2, 0x16, 0x0, HDA_INPUT),
1415 {
1416 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1417 /* The multiple "Capture Source" controls confuse alsamixer
1418 * So call somewhat different..
c577b8a1
JC		 1419 */
1420 /* .name = "Capture Source", */
1421 .name = "Input Source",
1422 .count = 1,
1423 .info = via_mux_enum_info,
1424 .get = via_mux_enum_get,
1425 .put = via_mux_enum_put,
1426 },
1427 { } /* end */
1428};
1429
69e52a80
HW		 1430static struct hda_verb vt1709_uniwill_init_verbs[] = {
1431 {0x20, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_HP_EVENT},
1432 { }
1433};
1434
c577b8a1
JC		 1435/*
1436 * generic initialization of ADC, input mixers and output mixers
1437 */
1438static struct hda_verb vt1709_10ch_volume_init_verbs[] = {
1439 /*
1440 * Unmute ADC0-2 and set the default input to mic-in
1441 */
1442 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
1443 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
1444 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
1445
1446
f7278fd0 1447 /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
c577b8a1
JC		 1448 * mixer widget
1449 */
1450 /* Amp Indices: AOW0=0, CD = 1, Mic1 = 2, Line = 3, Mic2 = 4 */
f7278fd0
JC		 1451 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
1452 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
1453 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
1454 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
1455 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
c577b8a1
JC		 1456
1457 /*
1458 * Set up output selector (0x1a, 0x1b, 0x29)
1459 */
1460 /* set vol=0 to output mixers */
1461 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
1462 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
1463 {0x29, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
1464
1465 /*
1466 * Unmute PW3 and PW4
1467 */
1468 {0x1f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
1469 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
1470
1471 /* Set input of PW4 as AOW4 */
1472 {0x20, AC_VERB_SET_CONNECT_SEL, 0x1},
c577b8a1
JC		 1473 /* PW9 Output enable */
1474 {0x24, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
1475 { }
1476};
1477
1478static struct hda_pcm_stream vt1709_10ch_pcm_analog_playback = {
1479 .substreams = 1,
1480 .channels_min = 2,
1481 .channels_max = 10,
1482 .nid = 0x10, /* NID to query formats and rates */
1483 .ops = {
1484 .open = via_playback_pcm_open,
1485 .prepare = via_playback_pcm_prepare,
1486 .cleanup = via_playback_pcm_cleanup
1487 },
1488};
1489
1490static struct hda_pcm_stream vt1709_6ch_pcm_analog_playback = {
1491 .substreams = 1,
1492 .channels_min = 2,
1493 .channels_max = 6,
1494 .nid = 0x10, /* NID to query formats and rates */
1495 .ops = {
1496 .open = via_playback_pcm_open,
1497 .prepare = via_playback_pcm_prepare,
1498 .cleanup = via_playback_pcm_cleanup
1499 },
1500};
1501
1502static struct hda_pcm_stream vt1709_pcm_analog_capture = {
1503 .substreams = 2,
1504 .channels_min = 2,
1505 .channels_max = 2,
1506 .nid = 0x14, /* NID to query formats and rates */
1507 .ops = {
1508 .prepare = via_capture_pcm_prepare,
1509 .cleanup = via_capture_pcm_cleanup
1510 },
1511};
1512
1513static struct hda_pcm_stream vt1709_pcm_digital_playback = {
1514 .substreams = 1,
1515 .channels_min = 2,
1516 .channels_max = 2,
1517 /* NID is set in via_build_pcms */
1518 .ops = {
1519 .open = via_dig_playback_pcm_open,
1520 .close = via_dig_playback_pcm_close
1521 },
1522};
1523
1524static struct hda_pcm_stream vt1709_pcm_digital_capture = {
1525 .substreams = 1,
1526 .channels_min = 2,
1527 .channels_max = 2,
1528};
1529
1530static int vt1709_auto_fill_dac_nids(struct via_spec *spec,
1531 const struct auto_pin_cfg *cfg)
1532{
1533 int i;
1534 hda_nid_t nid;
1535
1536 if (cfg->line_outs == 4) /* 10 channels */
1537 spec->multiout.num_dacs = cfg->line_outs+1; /* AOW0~AOW4 */
1538 else if (cfg->line_outs == 3) /* 6 channels */
1539 spec->multiout.num_dacs = cfg->line_outs; /* AOW0~AOW2 */
1540
1541 spec->multiout.dac_nids = spec->private_dac_nids;
1542
1543 if (cfg->line_outs == 4) { /* 10 channels */
1544 for (i = 0; i < cfg->line_outs; i++) {
1545 nid = cfg->line_out_pins[i];
1546 if (nid) {
1547 /* config dac list */
1548 switch (i) {
1549 case AUTO_SEQ_FRONT:
1550 /* AOW0 */
1551 spec->multiout.dac_nids[i] = 0x10;
1552 break;
1553 case AUTO_SEQ_CENLFE:
1554 /* AOW2 */
1555 spec->multiout.dac_nids[i] = 0x12;
1556 break;
1557 case AUTO_SEQ_SURROUND:
1558 /* AOW3 */
fb4cb772 1559 spec->multiout.dac_nids[i] = 0x11;
c577b8a1
JC		 1560 break;
1561 case AUTO_SEQ_SIDE:
1562 /* AOW1 */
fb4cb772 1563 spec->multiout.dac_nids[i] = 0x27;
c577b8a1
JC		 1564 break;
1565 default:
1566 break;
1567 }
1568 }
1569 }
1570 spec->multiout.dac_nids[cfg->line_outs] = 0x28; /* AOW4 */
1571
1572 } else if (cfg->line_outs == 3) { /* 6 channels */
1573 for(i = 0; i < cfg->line_outs; i++) {
1574 nid = cfg->line_out_pins[i];
1575 if (nid) {
1576 /* config dac list */
1577 switch(i) {
1578 case AUTO_SEQ_FRONT:
1579 /* AOW0 */
1580 spec->multiout.dac_nids[i] = 0x10;
1581 break;
1582 case AUTO_SEQ_CENLFE:
1583 /* AOW2 */
1584 spec->multiout.dac_nids[i] = 0x12;
1585 break;
1586 case AUTO_SEQ_SURROUND:
1587 /* AOW1 */
1588 spec->multiout.dac_nids[i] = 0x11;
1589 break;
1590 default:
1591 break;
1592 }
1593 }
1594 }
1595 }
1596
1597 return 0;
1598}
1599
1600/* add playback controls from the parsed DAC table */
1601static int vt1709_auto_create_multi_out_ctls(struct via_spec *spec,
1602 const struct auto_pin_cfg *cfg)
1603{
1604 char name[32];
1605 static const char *chname[4] = { "Front", "Surround", "C/LFE", "Side" };
1606 hda_nid_t nid = 0;
1607 int i, err;
1608
1609 for (i = 0; i <= AUTO_SEQ_SIDE; i++) {
1610 nid = cfg->line_out_pins[i];
1611
1612 if (!nid)
1613 continue;
1614
1615 if (i == AUTO_SEQ_CENLFE) {
1616 /* Center/LFE */
1617 err = via_add_control(spec, VIA_CTL_WIDGET_VOL,
1618 "Center Playback Volume",
f7278fd0
JC		 1619 HDA_COMPOSE_AMP_VAL(0x1b, 1, 0,
1620 HDA_OUTPUT));
c577b8a1
JC		 1621 if (err < 0)
1622 return err;
1623 err = via_add_control(spec, VIA_CTL_WIDGET_VOL,
1624 "LFE Playback Volume",
f7278fd0
JC		 1625 HDA_COMPOSE_AMP_VAL(0x1b, 2, 0,
1626 HDA_OUTPUT));
c577b8a1
JC		 1627 if (err < 0)
1628 return err;
1629 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE,
1630 "Center Playback Switch",
f7278fd0
JC		 1631 HDA_COMPOSE_AMP_VAL(0x1b, 1, 0,
1632 HDA_OUTPUT));
c577b8a1
JC		 1633 if (err < 0)
1634 return err;
1635 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE,
1636 "LFE Playback Switch",
f7278fd0
JC		 1637 HDA_COMPOSE_AMP_VAL(0x1b, 2, 0,
1638 HDA_OUTPUT));
c577b8a1
JC		 1639 if (err < 0)
1640 return err;
1641 } else if (i == AUTO_SEQ_FRONT){
1642 /* add control to mixer index 0 */
1643 err = via_add_control(spec, VIA_CTL_WIDGET_VOL,
1644 "Master Front Playback Volume",
f7278fd0
JC		 1645 HDA_COMPOSE_AMP_VAL(0x18, 3, 0,
1646 HDA_INPUT));
c577b8a1
JC		 1647 if (err < 0)
1648 return err;
1649 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE,
1650 "Master Front Playback Switch",
f7278fd0
JC		 1651 HDA_COMPOSE_AMP_VAL(0x18, 3, 0,
1652 HDA_INPUT));
c577b8a1
JC		 1653 if (err < 0)
1654 return err;
1655
1656 /* add control to PW3 */
1657 sprintf(name, "%s Playback Volume", chname[i]);
1658 err = via_add_control(spec, VIA_CTL_WIDGET_VOL, name,
f7278fd0
JC		 1659 HDA_COMPOSE_AMP_VAL(nid, 3, 0,
1660 HDA_OUTPUT));
c577b8a1
JC		 1661 if (err < 0)
1662 return err;
1663 sprintf(name, "%s Playback Switch", chname[i]);
1664 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, name,
f7278fd0
JC		 1665 HDA_COMPOSE_AMP_VAL(nid, 3, 0,
1666 HDA_OUTPUT));
c577b8a1
JC		 1667 if (err < 0)
1668 return err;
1669 } else if (i == AUTO_SEQ_SURROUND) {
1670 sprintf(name, "%s Playback Volume", chname[i]);
1671 err = via_add_control(spec, VIA_CTL_WIDGET_VOL, name,
fb4cb772 1672 HDA_COMPOSE_AMP_VAL(0x1a, 3, 0,
f7278fd0 1673 HDA_OUTPUT));
c577b8a1
JC		 1674 if (err < 0)
1675 return err;
1676 sprintf(name, "%s Playback Switch", chname[i]);
1677 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, name,
fb4cb772 1678 HDA_COMPOSE_AMP_VAL(0x1a, 3, 0,
f7278fd0 1679 HDA_OUTPUT));
c577b8a1
JC		 1680 if (err < 0)
1681 return err;
1682 } else if (i == AUTO_SEQ_SIDE) {
1683 sprintf(name, "%s Playback Volume", chname[i]);
1684 err = via_add_control(spec, VIA_CTL_WIDGET_VOL, name,
fb4cb772 1685 HDA_COMPOSE_AMP_VAL(0x29, 3, 0,
f7278fd0 1686 HDA_OUTPUT));
c577b8a1
JC		 1687 if (err < 0)
1688 return err;
1689 sprintf(name, "%s Playback Switch", chname[i]);
1690 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, name,
fb4cb772 1691 HDA_COMPOSE_AMP_VAL(0x29, 3, 0,
f7278fd0 1692 HDA_OUTPUT));
c577b8a1
JC		 1693 if (err < 0)
1694 return err;
1695 }
1696 }
1697
1698 return 0;
1699}
1700
1701static int vt1709_auto_create_hp_ctls(struct via_spec *spec, hda_nid_t pin)
1702{
1703 int err;
1704
1705 if (!pin)
1706 return 0;
1707
1708 if (spec->multiout.num_dacs == 5) /* 10 channels */
1709 spec->multiout.hp_nid = VT1709_HP_DAC_NID;
1710 else if (spec->multiout.num_dacs == 3) /* 6 channels */
1711 spec->multiout.hp_nid = 0;
1712
1713 err = via_add_control(spec, VIA_CTL_WIDGET_VOL,
1714 "Headphone Playback Volume",
1715 HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
1716 if (err < 0)
1717 return err;
1718 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE,
1719 "Headphone Playback Switch",
1720 HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
1721 if (err < 0)
1722 return err;
1723
1724 return 0;
1725}
1726
1727/* create playback/capture controls for input pins */
1728static int vt1709_auto_create_analog_input_ctls(struct via_spec *spec,
1729 const struct auto_pin_cfg *cfg)
1730{
1731 static char *labels[] = {
1732 "Mic", "Front Mic", "Line", "Front Line", "CD", "Aux", NULL
1733 };
0aa62aef 1734 struct hda_input_mux *imux = &spec->private_imux[0];
c577b8a1
JC		 1735 int i, err, idx = 0;
1736
1737 /* for internal loopback recording select */
1738 imux->items[imux->num_items].label = "Stereo Mixer";
1739 imux->items[imux->num_items].index = idx;
1740 imux->num_items++;
1741
1742 for (i = 0; i < AUTO_PIN_LAST; i++) {
1743 if (!cfg->input_pins[i])
1744 continue;
1745
1746 switch (cfg->input_pins[i]) {
1747 case 0x1d: /* Mic */
1748 idx = 2;
1749 break;
1750
1751 case 0x1e: /* Line In */
1752 idx = 3;
1753 break;
1754
1755 case 0x21: /* Front Mic */
1756 idx = 4;
1757 break;
1758
1759 case 0x23: /* CD */
1760 idx = 1;
1761 break;
1762 }
1763 err = via_new_analog_input(spec, cfg->input_pins[i], labels[i],
1764 idx, 0x18);
1765 if (err < 0)
1766 return err;
1767 imux->items[imux->num_items].label = labels[i];
1768 imux->items[imux->num_items].index = idx;
1769 imux->num_items++;
1770 }
1771 return 0;
1772}
1773
1774static int vt1709_parse_auto_config(struct hda_codec *codec)
1775{
1776 struct via_spec *spec = codec->spec;
1777 int err;
1778
1779 err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, NULL);
1780 if (err < 0)
1781 return err;
1782 err = vt1709_auto_fill_dac_nids(spec, &spec->autocfg);
1783 if (err < 0)
1784 return err;
1785 if (!spec->autocfg.line_outs && !spec->autocfg.hp_pins[0])
1786 return 0; /* can't find valid BIOS pin config */
1787
1788 err = vt1709_auto_create_multi_out_ctls(spec, &spec->autocfg);
1789 if (err < 0)
1790 return err;
1791 err = vt1709_auto_create_hp_ctls(spec, spec->autocfg.hp_pins[0]);
1792 if (err < 0)
1793 return err;
1794 err = vt1709_auto_create_analog_input_ctls(spec, &spec->autocfg);
1795 if (err < 0)
1796 return err;
1797
1798 spec->multiout.max_channels = spec->multiout.num_dacs * 2;
1799
0852d7a6 1800 if (spec->autocfg.dig_outs)
c577b8a1
JC		 1801 spec->multiout.dig_out_nid = VT1709_DIGOUT_NID;
1802 if (spec->autocfg.dig_in_pin)
1803 spec->dig_in_nid = VT1709_DIGIN_NID;
1804
603c4019
TI		 1805 if (spec->kctls.list)
1806 spec->mixers[spec->num_mixers++] = spec->kctls.list;
c577b8a1 1807
0aa62aef 1808 spec->input_mux = &spec->private_imux[0];
c577b8a1 1809
f8fdd495
HW		 1810 if (spec->hp_mux)
1811 spec->mixers[spec->num_mixers++] = via_hp_mixer;
1812
c577b8a1
JC		 1813 return 1;
1814}
1815
cb53c626
TI		 1816#ifdef CONFIG_SND_HDA_POWER_SAVE
1817static struct hda_amp_list vt1709_loopbacks[] = {
1818 { 0x18, HDA_INPUT, 1 },
1819 { 0x18, HDA_INPUT, 2 },
1820 { 0x18, HDA_INPUT, 3 },
1821 { 0x18, HDA_INPUT, 4 },
1822 { } /* end */
1823};
1824#endif
1825
c577b8a1
JC		 1826static int patch_vt1709_10ch(struct hda_codec *codec)
1827{
1828 struct via_spec *spec;
1829 int err;
1830
1831 /* create a codec specific record */
eb14a46c 1832 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
c577b8a1
JC		 1833 if (spec == NULL)
1834 return -ENOMEM;
1835
1836 codec->spec = spec;
1837
1838 err = vt1709_parse_auto_config(codec);
1839 if (err < 0) {
1840 via_free(codec);
1841 return err;
1842 } else if (!err) {
1843 printk(KERN_INFO "hda_codec: Cannot set up configuration. "
1844 "Using genenic mode...\n");
1845 }
1846
69e52a80
HW		 1847 spec->init_verbs[spec->num_iverbs++] = vt1709_10ch_volume_init_verbs;
1848 spec->init_verbs[spec->num_iverbs++] = vt1709_uniwill_init_verbs;
c577b8a1
JC		 1849
1850 spec->stream_name_analog = "VT1709 Analog";
1851 spec->stream_analog_playback = &vt1709_10ch_pcm_analog_playback;
1852 spec->stream_analog_capture = &vt1709_pcm_analog_capture;
1853
1854 spec->stream_name_digital = "VT1709 Digital";
1855 spec->stream_digital_playback = &vt1709_pcm_digital_playback;
1856 spec->stream_digital_capture = &vt1709_pcm_digital_capture;
1857
1858
1859 if (!spec->adc_nids && spec->input_mux) {
1860 spec->adc_nids = vt1709_adc_nids;
1861 spec->num_adc_nids = ARRAY_SIZE(vt1709_adc_nids);
1862 spec->mixers[spec->num_mixers] = vt1709_capture_mixer;
1863 spec->num_mixers++;
1864 }
1865
1866 codec->patch_ops = via_patch_ops;
1867
1868 codec->patch_ops.init = via_auto_init;
69e52a80 1869 codec->patch_ops.unsol_event = via_unsol_event;
cb53c626
TI		 1870#ifdef CONFIG_SND_HDA_POWER_SAVE
1871 spec->loopback.amplist = vt1709_loopbacks;
1872#endif
c577b8a1
JC		 1873
1874 return 0;
1875}
1876/*
1877 * generic initialization of ADC, input mixers and output mixers
1878 */
1879static struct hda_verb vt1709_6ch_volume_init_verbs[] = {
1880 /*
1881 * Unmute ADC0-2 and set the default input to mic-in
1882 */
1883 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
1884 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
1885 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
1886
1887
1888 /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
1889 * mixer widget
1890 */
1891 /* Amp Indices: AOW0=0, CD = 1, Mic1 = 2, Line = 3, Mic2 = 4 */
1892 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
1893 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
1894 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
1895 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
1896 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
1897
1898 /*
1899 * Set up output selector (0x1a, 0x1b, 0x29)
1900 */
1901 /* set vol=0 to output mixers */
1902 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
1903 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
1904 {0x29, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
1905
1906 /*
1907 * Unmute PW3 and PW4
1908 */
1909 {0x1f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
1910 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
1911
1912 /* Set input of PW4 as MW0 */
1913 {0x20, AC_VERB_SET_CONNECT_SEL, 0},
c577b8a1
JC		 1914 /* PW9 Output enable */
1915 {0x24, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
1916 { }
1917};
1918
1919static int patch_vt1709_6ch(struct hda_codec *codec)
1920{
1921 struct via_spec *spec;
1922 int err;
1923
1924 /* create a codec specific record */
eb14a46c 1925 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
c577b8a1
JC		 1926 if (spec == NULL)
1927 return -ENOMEM;
1928
1929 codec->spec = spec;
1930
1931 err = vt1709_parse_auto_config(codec);
1932 if (err < 0) {
1933 via_free(codec);
1934 return err;
1935 } else if (!err) {
1936 printk(KERN_INFO "hda_codec: Cannot set up configuration. "
1937 "Using genenic mode...\n");
1938 }
1939
69e52a80
HW		 1940 spec->init_verbs[spec->num_iverbs++] = vt1709_6ch_volume_init_verbs;
1941 spec->init_verbs[spec->num_iverbs++] = vt1709_uniwill_init_verbs;
c577b8a1
JC		 1942
1943 spec->stream_name_analog = "VT1709 Analog";
1944 spec->stream_analog_playback = &vt1709_6ch_pcm_analog_playback;
1945 spec->stream_analog_capture = &vt1709_pcm_analog_capture;
1946
1947 spec->stream_name_digital = "VT1709 Digital";
1948 spec->stream_digital_playback = &vt1709_pcm_digital_playback;
1949 spec->stream_digital_capture = &vt1709_pcm_digital_capture;
1950
1951
1952 if (!spec->adc_nids && spec->input_mux) {
1953 spec->adc_nids = vt1709_adc_nids;
1954 spec->num_adc_nids = ARRAY_SIZE(vt1709_adc_nids);
1955 spec->mixers[spec->num_mixers] = vt1709_capture_mixer;
1956 spec->num_mixers++;
1957 }
1958
1959 codec->patch_ops = via_patch_ops;
1960
1961 codec->patch_ops.init = via_auto_init;
69e52a80 1962 codec->patch_ops.unsol_event = via_unsol_event;
cb53c626
TI		 1963#ifdef CONFIG_SND_HDA_POWER_SAVE
1964 spec->loopback.amplist = vt1709_loopbacks;
1965#endif
f7278fd0
JC		 1966 return 0;
1967}
1968
1969/* capture mixer elements */
1970static struct snd_kcontrol_new vt1708B_capture_mixer[] = {
1971 HDA_CODEC_VOLUME("Capture Volume", 0x13, 0x0, HDA_INPUT),
1972 HDA_CODEC_MUTE("Capture Switch", 0x13, 0x0, HDA_INPUT),
1973 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x14, 0x0, HDA_INPUT),
1974 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x14, 0x0, HDA_INPUT),
1975 {
1976 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1977 /* The multiple "Capture Source" controls confuse alsamixer
1978 * So call somewhat different..
f7278fd0
JC		 1979 */
1980 /* .name = "Capture Source", */
1981 .name = "Input Source",
1982 .count = 1,
1983 .info = via_mux_enum_info,
1984 .get = via_mux_enum_get,
1985 .put = via_mux_enum_put,
1986 },
1987 { } /* end */
1988};
1989/*
1990 * generic initialization of ADC, input mixers and output mixers
1991 */
1992static struct hda_verb vt1708B_8ch_volume_init_verbs[] = {
1993 /*
1994 * Unmute ADC0-1 and set the default input to mic-in
1995 */
1996 {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
1997 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
1998
1999
2000 /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
2001 * mixer widget
2002 */
2003 /* Amp Indices: CD = 1, Mic1 = 2, Line = 3, Mic2 = 4 */
2004 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2005 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
2006 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
2007 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
2008 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
2009
2010 /*
2011 * Set up output mixers
2012 */
2013 /* set vol=0 to output mixers */
2014 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2015 {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2016 {0x27, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2017
2018 /* Setup default input to PW4 */
2019 {0x1d, AC_VERB_SET_CONNECT_SEL, 0x1},
2020 /* PW9 Output enable */
2021 {0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
2022 /* PW10 Input enable */
2023 {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
2024 { }
2025};
2026
2027static struct hda_verb vt1708B_4ch_volume_init_verbs[] = {
2028 /*
2029 * Unmute ADC0-1 and set the default input to mic-in
2030 */
2031 {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2032 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2033
2034
2035 /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
2036 * mixer widget
2037 */
2038 /* Amp Indices: CD = 1, Mic1 = 2, Line = 3, Mic2 = 4 */
2039 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2040 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
2041 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
2042 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
2043 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
2044
2045 /*
2046 * Set up output mixers
2047 */
2048 /* set vol=0 to output mixers */
2049 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2050 {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2051 {0x27, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2052
2053 /* Setup default input of PW4 to MW0 */
2054 {0x1d, AC_VERB_SET_CONNECT_SEL, 0x0},
2055 /* PW9 Output enable */
2056 {0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
2057 /* PW10 Input enable */
2058 {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
2059 { }
2060};
2061
69e52a80
HW		 2062static struct hda_verb vt1708B_uniwill_init_verbs[] = {
2063 {0x1D, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_HP_EVENT},
2064 { }
2065};
2066
f7278fd0 2067static struct hda_pcm_stream vt1708B_8ch_pcm_analog_playback = {
0aa62aef 2068 .substreams = 2,
f7278fd0
JC		 2069 .channels_min = 2,
2070 .channels_max = 8,
2071 .nid = 0x10, /* NID to query formats and rates */
2072 .ops = {
2073 .open = via_playback_pcm_open,
0aa62aef
HW		 2074 .prepare = via_playback_multi_pcm_prepare,
2075 .cleanup = via_playback_multi_pcm_cleanup
f7278fd0
JC		 2076 },
2077};
2078
2079static struct hda_pcm_stream vt1708B_4ch_pcm_analog_playback = {
0aa62aef 2080 .substreams = 2,
f7278fd0
JC		 2081 .channels_min = 2,
2082 .channels_max = 4,
2083 .nid = 0x10, /* NID to query formats and rates */
2084 .ops = {
2085 .open = via_playback_pcm_open,
0aa62aef
HW		 2086 .prepare = via_playback_multi_pcm_prepare,
2087 .cleanup = via_playback_multi_pcm_cleanup
f7278fd0
JC		 2088 },
2089};
2090
2091static struct hda_pcm_stream vt1708B_pcm_analog_capture = {
2092 .substreams = 2,
2093 .channels_min = 2,
2094 .channels_max = 2,
2095 .nid = 0x13, /* NID to query formats and rates */
2096 .ops = {
2097 .prepare = via_capture_pcm_prepare,
2098 .cleanup = via_capture_pcm_cleanup
2099 },
2100};
2101
2102static struct hda_pcm_stream vt1708B_pcm_digital_playback = {
2103 .substreams = 1,
2104 .channels_min = 2,
2105 .channels_max = 2,
2106 /* NID is set in via_build_pcms */
2107 .ops = {
2108 .open = via_dig_playback_pcm_open,
2109 .close = via_dig_playback_pcm_close,
9da29271
TI		 2110 .prepare = via_dig_playback_pcm_prepare,
2111 .cleanup = via_dig_playback_pcm_cleanup
f7278fd0
JC		 2112 },
2113};
2114
2115static struct hda_pcm_stream vt1708B_pcm_digital_capture = {
2116 .substreams = 1,
2117 .channels_min = 2,
2118 .channels_max = 2,
2119};
2120
2121/* fill in the dac_nids table from the parsed pin configuration */
2122static int vt1708B_auto_fill_dac_nids(struct via_spec *spec,
2123 const struct auto_pin_cfg *cfg)
2124{
2125 int i;
2126 hda_nid_t nid;
2127
2128 spec->multiout.num_dacs = cfg->line_outs;
2129
2130 spec->multiout.dac_nids = spec->private_dac_nids;
2131
2132 for (i = 0; i < 4; i++) {
2133 nid = cfg->line_out_pins[i];
2134 if (nid) {
2135 /* config dac list */
2136 switch (i) {
2137 case AUTO_SEQ_FRONT:
2138 spec->multiout.dac_nids[i] = 0x10;
2139 break;
2140 case AUTO_SEQ_CENLFE:
2141 spec->multiout.dac_nids[i] = 0x24;
2142 break;
2143 case AUTO_SEQ_SURROUND:
fb4cb772 2144 spec->multiout.dac_nids[i] = 0x11;
f7278fd0
JC		 2145 break;
2146 case AUTO_SEQ_SIDE:
fb4cb772 2147 spec->multiout.dac_nids[i] = 0x25;
f7278fd0
JC		 2148 break;
2149 }
2150 }
2151 }
2152
2153 return 0;
2154}
2155
2156/* add playback controls from the parsed DAC table */
2157static int vt1708B_auto_create_multi_out_ctls(struct via_spec *spec,
2158 const struct auto_pin_cfg *cfg)
2159{
2160 char name[32];
2161 static const char *chname[4] = { "Front", "Surround", "C/LFE", "Side" };
fb4cb772 2162 hda_nid_t nid_vols[] = {0x16, 0x18, 0x26, 0x27};
f7278fd0
JC		 2163 hda_nid_t nid, nid_vol = 0;
2164 int i, err;
2165
2166 for (i = 0; i <= AUTO_SEQ_SIDE; i++) {
2167 nid = cfg->line_out_pins[i];
2168
2169 if (!nid)
2170 continue;
2171
2172 nid_vol = nid_vols[i];
2173
2174 if (i == AUTO_SEQ_CENLFE) {
2175 /* Center/LFE */
2176 err = via_add_control(spec, VIA_CTL_WIDGET_VOL,
2177 "Center Playback Volume",
2178 HDA_COMPOSE_AMP_VAL(nid_vol, 1, 0,
2179 HDA_OUTPUT));
2180 if (err < 0)
2181 return err;
2182 err = via_add_control(spec, VIA_CTL_WIDGET_VOL,
2183 "LFE Playback Volume",
2184 HDA_COMPOSE_AMP_VAL(nid_vol, 2, 0,
2185 HDA_OUTPUT));
2186 if (err < 0)
2187 return err;
2188 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE,
2189 "Center Playback Switch",
2190 HDA_COMPOSE_AMP_VAL(nid_vol, 1, 0,
2191 HDA_OUTPUT));
2192 if (err < 0)
2193 return err;
2194 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE,
2195 "LFE Playback Switch",
2196 HDA_COMPOSE_AMP_VAL(nid_vol, 2, 0,
2197 HDA_OUTPUT));
2198 if (err < 0)
2199 return err;
2200 } else if (i == AUTO_SEQ_FRONT) {
2201 /* add control to mixer index 0 */
2202 err = via_add_control(spec, VIA_CTL_WIDGET_VOL,
2203 "Master Front Playback Volume",
2204 HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0,
2205 HDA_INPUT));
2206 if (err < 0)
2207 return err;
2208 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE,
2209 "Master Front Playback Switch",
2210 HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0,
2211 HDA_INPUT));
2212 if (err < 0)
2213 return err;
2214
2215 /* add control to PW3 */
2216 sprintf(name, "%s Playback Volume", chname[i]);
2217 err = via_add_control(spec, VIA_CTL_WIDGET_VOL, name,
2218 HDA_COMPOSE_AMP_VAL(nid, 3, 0,
2219 HDA_OUTPUT));
2220 if (err < 0)
2221 return err;
2222 sprintf(name, "%s Playback Switch", chname[i]);
2223 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, name,
2224 HDA_COMPOSE_AMP_VAL(nid, 3, 0,
2225 HDA_OUTPUT));
2226 if (err < 0)
2227 return err;
2228 } else {
2229 sprintf(name, "%s Playback Volume", chname[i]);
2230 err = via_add_control(spec, VIA_CTL_WIDGET_VOL, name,
2231 HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0,
2232 HDA_OUTPUT));
2233 if (err < 0)
2234 return err;
2235 sprintf(name, "%s Playback Switch", chname[i]);
2236 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, name,
2237 HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0,
2238 HDA_OUTPUT));
2239 if (err < 0)
2240 return err;
2241 }
2242 }
2243
2244 return 0;
2245}
2246
2247static int vt1708B_auto_create_hp_ctls(struct via_spec *spec, hda_nid_t pin)
2248{
2249 int err;
2250
2251 if (!pin)
2252 return 0;
2253
2254 spec->multiout.hp_nid = VT1708B_HP_NID; /* AOW3 */
2255
2256 err = via_add_control(spec, VIA_CTL_WIDGET_VOL,
2257 "Headphone Playback Volume",
2258 HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
2259 if (err < 0)
2260 return err;
2261 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE,
2262 "Headphone Playback Switch",
2263 HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
2264 if (err < 0)
2265 return err;
2266
0aa62aef
HW		 2267 create_hp_imux(spec);
2268
f7278fd0
JC		 2269 return 0;
2270}
2271
2272/* create playback/capture controls for input pins */
2273static int vt1708B_auto_create_analog_input_ctls(struct via_spec *spec,
2274 const struct auto_pin_cfg *cfg)
2275{
2276 static char *labels[] = {
2277 "Mic", "Front Mic", "Line", "Front Line", "CD", "Aux", NULL
2278 };
0aa62aef 2279 struct hda_input_mux *imux = &spec->private_imux[0];
f7278fd0
JC		 2280 int i, err, idx = 0;
2281
2282 /* for internal loopback recording select */
2283 imux->items[imux->num_items].label = "Stereo Mixer";
2284 imux->items[imux->num_items].index = idx;
2285 imux->num_items++;
2286
2287 for (i = 0; i < AUTO_PIN_LAST; i++) {
2288 if (!cfg->input_pins[i])
2289 continue;
2290
2291 switch (cfg->input_pins[i]) {
2292 case 0x1a: /* Mic */
2293 idx = 2;
2294 break;
2295
2296 case 0x1b: /* Line In */
2297 idx = 3;
2298 break;
2299
2300 case 0x1e: /* Front Mic */
2301 idx = 4;
2302 break;
2303
2304 case 0x1f: /* CD */
2305 idx = 1;
2306 break;
2307 }
2308 err = via_new_analog_input(spec, cfg->input_pins[i], labels[i],
2309 idx, 0x16);
2310 if (err < 0)
2311 return err;
2312 imux->items[imux->num_items].label = labels[i];
2313 imux->items[imux->num_items].index = idx;
2314 imux->num_items++;
2315 }
2316 return 0;
2317}
2318
2319static int vt1708B_parse_auto_config(struct hda_codec *codec)
2320{
2321 struct via_spec *spec = codec->spec;
2322 int err;
2323
2324 err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, NULL);
2325 if (err < 0)
2326 return err;
2327 err = vt1708B_auto_fill_dac_nids(spec, &spec->autocfg);
2328 if (err < 0)
2329 return err;
2330 if (!spec->autocfg.line_outs && !spec->autocfg.hp_pins[0])
2331 return 0; /* can't find valid BIOS pin config */
2332
2333 err = vt1708B_auto_create_multi_out_ctls(spec, &spec->autocfg);
2334 if (err < 0)
2335 return err;
2336 err = vt1708B_auto_create_hp_ctls(spec, spec->autocfg.hp_pins[0]);
2337 if (err < 0)
2338 return err;
2339 err = vt1708B_auto_create_analog_input_ctls(spec, &spec->autocfg);
2340 if (err < 0)
2341 return err;
2342
2343 spec->multiout.max_channels = spec->multiout.num_dacs * 2;
2344
0852d7a6 2345 if (spec->autocfg.dig_outs)
f7278fd0
JC		 2346 spec->multiout.dig_out_nid = VT1708B_DIGOUT_NID;
2347 if (spec->autocfg.dig_in_pin)
2348 spec->dig_in_nid = VT1708B_DIGIN_NID;
2349
603c4019
TI		 2350 if (spec->kctls.list)
2351 spec->mixers[spec->num_mixers++] = spec->kctls.list;
f7278fd0 2352
0aa62aef
HW		 2353 spec->input_mux = &spec->private_imux[0];
2354
f8fdd495
HW		 2355 if (spec->hp_mux)
2356 spec->mixers[spec->num_mixers++] = via_hp_mixer;
f7278fd0
JC		 2357
2358 return 1;
2359}
2360
2361#ifdef CONFIG_SND_HDA_POWER_SAVE
2362static struct hda_amp_list vt1708B_loopbacks[] = {
2363 { 0x16, HDA_INPUT, 1 },
2364 { 0x16, HDA_INPUT, 2 },
2365 { 0x16, HDA_INPUT, 3 },
2366 { 0x16, HDA_INPUT, 4 },
2367 { } /* end */
2368};
2369#endif
2370
2371static int patch_vt1708B_8ch(struct hda_codec *codec)
2372{
2373 struct via_spec *spec;
2374 int err;
2375
2376 /* create a codec specific record */
eb14a46c 2377 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
f7278fd0
JC		 2378 if (spec == NULL)
2379 return -ENOMEM;
2380
2381 codec->spec = spec;
2382
2383 /* automatic parse from the BIOS config */
2384 err = vt1708B_parse_auto_config(codec);
2385 if (err < 0) {
2386 via_free(codec);
2387 return err;
2388 } else if (!err) {
2389 printk(KERN_INFO "hda_codec: Cannot set up configuration "
2390 "from BIOS. Using genenic mode...\n");
2391 }
2392
69e52a80
HW		 2393 spec->init_verbs[spec->num_iverbs++] = vt1708B_8ch_volume_init_verbs;
2394 spec->init_verbs[spec->num_iverbs++] = vt1708B_uniwill_init_verbs;
f7278fd0
JC		 2395
2396 spec->stream_name_analog = "VT1708B Analog";
2397 spec->stream_analog_playback = &vt1708B_8ch_pcm_analog_playback;
2398 spec->stream_analog_capture = &vt1708B_pcm_analog_capture;
2399
2400 spec->stream_name_digital = "VT1708B Digital";
2401 spec->stream_digital_playback = &vt1708B_pcm_digital_playback;
2402 spec->stream_digital_capture = &vt1708B_pcm_digital_capture;
2403
2404 if (!spec->adc_nids && spec->input_mux) {
2405 spec->adc_nids = vt1708B_adc_nids;
2406 spec->num_adc_nids = ARRAY_SIZE(vt1708B_adc_nids);
2407 spec->mixers[spec->num_mixers] = vt1708B_capture_mixer;
2408 spec->num_mixers++;
2409 }
2410
2411 codec->patch_ops = via_patch_ops;
2412
2413 codec->patch_ops.init = via_auto_init;
69e52a80 2414 codec->patch_ops.unsol_event = via_unsol_event;
f7278fd0
JC		 2415#ifdef CONFIG_SND_HDA_POWER_SAVE
2416 spec->loopback.amplist = vt1708B_loopbacks;
2417#endif
2418
2419 return 0;
2420}
2421
2422static int patch_vt1708B_4ch(struct hda_codec *codec)
2423{
2424 struct via_spec *spec;
2425 int err;
2426
2427 /* create a codec specific record */
eb14a46c 2428 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
f7278fd0
JC		 2429 if (spec == NULL)
2430 return -ENOMEM;
2431
2432 codec->spec = spec;
2433
2434 /* automatic parse from the BIOS config */
2435 err = vt1708B_parse_auto_config(codec);
2436 if (err < 0) {
2437 via_free(codec);
2438 return err;
2439 } else if (!err) {
2440 printk(KERN_INFO "hda_codec: Cannot set up configuration "
2441 "from BIOS. Using genenic mode...\n");
2442 }
2443
69e52a80
HW		 2444 spec->init_verbs[spec->num_iverbs++] = vt1708B_4ch_volume_init_verbs;
2445 spec->init_verbs[spec->num_iverbs++] = vt1708B_uniwill_init_verbs;
f7278fd0
JC		 2446
2447 spec->stream_name_analog = "VT1708B Analog";
2448 spec->stream_analog_playback = &vt1708B_4ch_pcm_analog_playback;
2449 spec->stream_analog_capture = &vt1708B_pcm_analog_capture;
2450
2451 spec->stream_name_digital = "VT1708B Digital";
2452 spec->stream_digital_playback = &vt1708B_pcm_digital_playback;
2453 spec->stream_digital_capture = &vt1708B_pcm_digital_capture;
2454
2455 if (!spec->adc_nids && spec->input_mux) {
2456 spec->adc_nids = vt1708B_adc_nids;
2457 spec->num_adc_nids = ARRAY_SIZE(vt1708B_adc_nids);
2458 spec->mixers[spec->num_mixers] = vt1708B_capture_mixer;
2459 spec->num_mixers++;
2460 }
2461
2462 codec->patch_ops = via_patch_ops;
2463
2464 codec->patch_ops.init = via_auto_init;
69e52a80 2465 codec->patch_ops.unsol_event = via_unsol_event;
f7278fd0
JC		 2466#ifdef CONFIG_SND_HDA_POWER_SAVE
2467 spec->loopback.amplist = vt1708B_loopbacks;
2468#endif
c577b8a1
JC		 2469
2470 return 0;
2471}
2472
d949cac1
HW		 2473/* Patch for VT1708S */
2474
d7426329
HW		 2475/* VT1708S software backdoor based override for buggy hardware micboost
2476 * setting */
2477#define MIC_BOOST_VOLUME(xname, nid) { \
2478 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
2479 .name = xname, \
2480 .index = 0, \
2481 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | \
2482 SNDRV_CTL_ELEM_ACCESS_TLV_READ | \
2483 SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK, \
2484 .info = mic_boost_volume_info, \
2485 .get = snd_hda_mixer_amp_volume_get, \
2486 .put = snd_hda_mixer_amp_volume_put, \
2487 .tlv = { .c = mic_boost_tlv }, \
2488 .private_value = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT) }
2489
d949cac1
HW		 2490/* capture mixer elements */
2491static struct snd_kcontrol_new vt1708S_capture_mixer[] = {
2492 HDA_CODEC_VOLUME("Capture Volume", 0x13, 0x0, HDA_INPUT),
2493 HDA_CODEC_MUTE("Capture Switch", 0x13, 0x0, HDA_INPUT),
2494 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x14, 0x0, HDA_INPUT),
2495 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x14, 0x0, HDA_INPUT),
d7426329
HW		 2496 MIC_BOOST_VOLUME("Mic Boost Capture Volume", 0x1A),
2497 MIC_BOOST_VOLUME("Front Mic Boost Capture Volume", 0x1E),
d949cac1
HW		 2498 {
2499 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2500 /* The multiple "Capture Source" controls confuse alsamixer
2501 * So call somewhat different..
2502 */
2503 /* .name = "Capture Source", */
2504 .name = "Input Source",
2505 .count = 1,
2506 .info = via_mux_enum_info,
2507 .get = via_mux_enum_get,
2508 .put = via_mux_enum_put,
2509 },
2510 { } /* end */
2511};
2512
2513static struct hda_verb vt1708S_volume_init_verbs[] = {
2514 /* Unmute ADC0-1 and set the default input to mic-in */
2515 {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2516 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2517
2518 /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the
2519 * analog-loopback mixer widget */
2520 /* Amp Indices: CD = 1, Mic1 = 2, Line = 3, Mic2 = 4 */
2521 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2522 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
2523 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
2524 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
2525 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
2526
2527 /* Setup default input of PW4 to MW0 */
2528 {0x1d, AC_VERB_SET_CONNECT_SEL, 0x0},
5691ec7f 2529 /* PW9, PW10 Output enable */
d949cac1 2530 {0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
5691ec7f 2531 {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
d7426329
HW		 2532 /* Enable Mic Boost Volume backdoor */
2533 {0x1, 0xf98, 0x1},
d949cac1
HW		 2534 { }
2535};
2536
69e52a80
HW		 2537static struct hda_verb vt1708S_uniwill_init_verbs[] = {
2538 {0x1D, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_HP_EVENT},
2539 { }
2540};
2541
d949cac1
HW		 2542static struct hda_pcm_stream vt1708S_pcm_analog_playback = {
2543 .substreams = 2,
2544 .channels_min = 2,
2545 .channels_max = 8,
2546 .nid = 0x10, /* NID to query formats and rates */
2547 .ops = {
2548 .open = via_playback_pcm_open,
2549 .prepare = via_playback_pcm_prepare,
2550 .cleanup = via_playback_pcm_cleanup
2551 },
2552};
2553
2554static struct hda_pcm_stream vt1708S_pcm_analog_capture = {
2555 .substreams = 2,
2556 .channels_min = 2,
2557 .channels_max = 2,
2558 .nid = 0x13, /* NID to query formats and rates */
2559 .ops = {
2560 .prepare = via_capture_pcm_prepare,
2561 .cleanup = via_capture_pcm_cleanup
2562 },
2563};
2564
2565static struct hda_pcm_stream vt1708S_pcm_digital_playback = {
9da29271 2566 .substreams = 1,
d949cac1
HW		 2567 .channels_min = 2,
2568 .channels_max = 2,
2569 /* NID is set in via_build_pcms */
2570 .ops = {
2571 .open = via_dig_playback_pcm_open,
2572 .close = via_dig_playback_pcm_close,
9da29271
TI		 2573 .prepare = via_dig_playback_pcm_prepare,
2574 .cleanup = via_dig_playback_pcm_cleanup
d949cac1
HW		 2575 },
2576};
2577
2578/* fill in the dac_nids table from the parsed pin configuration */
2579static int vt1708S_auto_fill_dac_nids(struct via_spec *spec,
2580 const struct auto_pin_cfg *cfg)
2581{
2582 int i;
2583 hda_nid_t nid;
2584
2585 spec->multiout.num_dacs = cfg->line_outs;
2586
2587 spec->multiout.dac_nids = spec->private_dac_nids;
2588
2589 for (i = 0; i < 4; i++) {
2590 nid = cfg->line_out_pins[i];
2591 if (nid) {
2592 /* config dac list */
2593 switch (i) {
2594 case AUTO_SEQ_FRONT:
2595 spec->multiout.dac_nids[i] = 0x10;
2596 break;
2597 case AUTO_SEQ_CENLFE:
2598 spec->multiout.dac_nids[i] = 0x24;
2599 break;
2600 case AUTO_SEQ_SURROUND:
2601 spec->multiout.dac_nids[i] = 0x11;
2602 break;
2603 case AUTO_SEQ_SIDE:
2604 spec->multiout.dac_nids[i] = 0x25;
2605 break;
2606 }
2607 }
2608 }
2609
2610 return 0;
2611}
2612
2613/* add playback controls from the parsed DAC table */
2614static int vt1708S_auto_create_multi_out_ctls(struct via_spec *spec,
2615 const struct auto_pin_cfg *cfg)
2616{
2617 char name[32];
2618 static const char *chname[4] = { "Front", "Surround", "C/LFE", "Side" };
2619 hda_nid_t nid_vols[] = {0x10, 0x11, 0x24, 0x25};
2620 hda_nid_t nid_mutes[] = {0x1C, 0x18, 0x26, 0x27};
2621 hda_nid_t nid, nid_vol, nid_mute;
2622 int i, err;
2623
2624 for (i = 0; i <= AUTO_SEQ_SIDE; i++) {
2625 nid = cfg->line_out_pins[i];
2626
2627 if (!nid)
2628 continue;
2629
2630 nid_vol = nid_vols[i];
2631 nid_mute = nid_mutes[i];
2632
2633 if (i == AUTO_SEQ_CENLFE) {
2634 /* Center/LFE */
2635 err = via_add_control(spec, VIA_CTL_WIDGET_VOL,
2636 "Center Playback Volume",
2637 HDA_COMPOSE_AMP_VAL(nid_vol, 1, 0,
2638 HDA_OUTPUT));
2639 if (err < 0)
2640 return err;
2641 err = via_add_control(spec, VIA_CTL_WIDGET_VOL,
2642 "LFE Playback Volume",
2643 HDA_COMPOSE_AMP_VAL(nid_vol, 2, 0,
2644 HDA_OUTPUT));
2645 if (err < 0)
2646 return err;
2647 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE,
2648 "Center Playback Switch",
2649 HDA_COMPOSE_AMP_VAL(nid_mute,
2650 1, 0,
2651 HDA_OUTPUT));
2652 if (err < 0)
2653 return err;
2654 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE,
2655 "LFE Playback Switch",
2656 HDA_COMPOSE_AMP_VAL(nid_mute,
2657 2, 0,
2658 HDA_OUTPUT));
2659 if (err < 0)
2660 return err;
2661 } else if (i == AUTO_SEQ_FRONT) {
2662 /* add control to mixer index 0 */
2663 err = via_add_control(spec, VIA_CTL_WIDGET_VOL,
2664 "Master Front Playback Volume",
2665 HDA_COMPOSE_AMP_VAL(0x16, 3, 0,
2666 HDA_INPUT));
2667 if (err < 0)
2668 return err;
2669 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE,
2670 "Master Front Playback Switch",
2671 HDA_COMPOSE_AMP_VAL(0x16, 3, 0,
2672 HDA_INPUT));
2673 if (err < 0)
2674 return err;
2675
2676 /* Front */
2677 sprintf(name, "%s Playback Volume", chname[i]);
2678 err = via_add_control(spec, VIA_CTL_WIDGET_VOL, name,
2679 HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0,
2680 HDA_OUTPUT));
2681 if (err < 0)
2682 return err;
2683 sprintf(name, "%s Playback Switch", chname[i]);
2684 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, name,
2685 HDA_COMPOSE_AMP_VAL(nid_mute,
2686 3, 0,
2687 HDA_OUTPUT));
2688 if (err < 0)
2689 return err;
2690 } else {
2691 sprintf(name, "%s Playback Volume", chname[i]);
2692 err = via_add_control(spec, VIA_CTL_WIDGET_VOL, name,
2693 HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0,
2694 HDA_OUTPUT));
2695 if (err < 0)
2696 return err;
2697 sprintf(name, "%s Playback Switch", chname[i]);
2698 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, name,
2699 HDA_COMPOSE_AMP_VAL(nid_mute,
2700 3, 0,
2701 HDA_OUTPUT));
2702 if (err < 0)
2703 return err;
2704 }
2705 }
2706
2707 return 0;
2708}
2709
2710static int vt1708S_auto_create_hp_ctls(struct via_spec *spec, hda_nid_t pin)
2711{
2712 int err;
2713
2714 if (!pin)
2715 return 0;
2716
2717 spec->multiout.hp_nid = VT1708S_HP_NID; /* AOW3 */
2718
2719 err = via_add_control(spec, VIA_CTL_WIDGET_VOL,
2720 "Headphone Playback Volume",
2721 HDA_COMPOSE_AMP_VAL(0x25, 3, 0, HDA_OUTPUT));
2722 if (err < 0)
2723 return err;
2724
2725 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE,
2726 "Headphone Playback Switch",
2727 HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
2728 if (err < 0)
2729 return err;
2730
0aa62aef
HW		 2731 create_hp_imux(spec);
2732
d949cac1
HW		 2733 return 0;
2734}
2735
2736/* create playback/capture controls for input pins */
2737static int vt1708S_auto_create_analog_input_ctls(struct via_spec *spec,
2738 const struct auto_pin_cfg *cfg)
2739{
2740 static char *labels[] = {
2741 "Mic", "Front Mic", "Line", "Front Line", "CD", "Aux", NULL
2742 };
0aa62aef 2743 struct hda_input_mux *imux = &spec->private_imux[0];
d949cac1
HW		 2744 int i, err, idx = 0;
2745
2746 /* for internal loopback recording select */
2747 imux->items[imux->num_items].label = "Stereo Mixer";
2748 imux->items[imux->num_items].index = 5;
2749 imux->num_items++;
2750
2751 for (i = 0; i < AUTO_PIN_LAST; i++) {
2752 if (!cfg->input_pins[i])
2753 continue;
2754
2755 switch (cfg->input_pins[i]) {
2756 case 0x1a: /* Mic */
2757 idx = 2;
2758 break;
2759
2760 case 0x1b: /* Line In */
2761 idx = 3;
2762 break;
2763
2764 case 0x1e: /* Front Mic */
2765 idx = 4;
2766 break;
2767
2768 case 0x1f: /* CD */
2769 idx = 1;
2770 break;
2771 }
2772 err = via_new_analog_input(spec, cfg->input_pins[i], labels[i],
2773 idx, 0x16);
2774 if (err < 0)
2775 return err;
2776 imux->items[imux->num_items].label = labels[i];
2777 imux->items[imux->num_items].index = idx-1;
2778 imux->num_items++;
2779 }
2780 return 0;
2781}
2782
9da29271
TI		 2783/* fill out digital output widgets; one for master and one for slave outputs */
2784static void fill_dig_outs(struct hda_codec *codec)
2785{
2786 struct via_spec *spec = codec->spec;
2787 int i;
2788
2789 for (i = 0; i < spec->autocfg.dig_outs; i++) {
2790 hda_nid_t nid;
2791 int conn;
2792
2793 nid = spec->autocfg.dig_out_pins[i];
2794 if (!nid)
2795 continue;
2796 conn = snd_hda_get_connections(codec, nid, &nid, 1);
2797 if (conn < 1)
2798 continue;
2799 if (!spec->multiout.dig_out_nid)
2800 spec->multiout.dig_out_nid = nid;
2801 else {
2802 spec->slave_dig_outs[0] = nid;
2803 break; /* at most two dig outs */
2804 }
2805 }
2806}
2807
d949cac1
HW		 2808static int vt1708S_parse_auto_config(struct hda_codec *codec)
2809{
2810 struct via_spec *spec = codec->spec;
2811 int err;
d949cac1 2812
9da29271 2813 err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, NULL);
d949cac1
HW		 2814 if (err < 0)
2815 return err;
2816 err = vt1708S_auto_fill_dac_nids(spec, &spec->autocfg);
2817 if (err < 0)
2818 return err;
2819 if (!spec->autocfg.line_outs && !spec->autocfg.hp_pins[0])
2820 return 0; /* can't find valid BIOS pin config */
2821
2822 err = vt1708S_auto_create_multi_out_ctls(spec, &spec->autocfg);
2823 if (err < 0)
2824 return err;
2825 err = vt1708S_auto_create_hp_ctls(spec, spec->autocfg.hp_pins[0]);
2826 if (err < 0)
2827 return err;
2828 err = vt1708S_auto_create_analog_input_ctls(spec, &spec->autocfg);
2829 if (err < 0)
2830 return err;
2831
2832 spec->multiout.max_channels = spec->multiout.num_dacs * 2;
2833
9da29271 2834 fill_dig_outs(codec);
98aa34c0 2835
603c4019
TI		 2836 if (spec->kctls.list)
2837 spec->mixers[spec->num_mixers++] = spec->kctls.list;
d949cac1 2838
0aa62aef
HW		 2839 spec->input_mux = &spec->private_imux[0];
2840
f8fdd495
HW		 2841 if (spec->hp_mux)
2842 spec->mixers[spec->num_mixers++] = via_hp_mixer;
d949cac1
HW		 2843
2844 return 1;
2845}
2846
2847#ifdef CONFIG_SND_HDA_POWER_SAVE
2848static struct hda_amp_list vt1708S_loopbacks[] = {
2849 { 0x16, HDA_INPUT, 1 },
2850 { 0x16, HDA_INPUT, 2 },
2851 { 0x16, HDA_INPUT, 3 },
2852 { 0x16, HDA_INPUT, 4 },
2853 { } /* end */
2854};
2855#endif
2856
2857static int patch_vt1708S(struct hda_codec *codec)
2858{
2859 struct via_spec *spec;
2860 int err;
2861
2862 /* create a codec specific record */
2863 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
2864 if (spec == NULL)
2865 return -ENOMEM;
2866
2867 codec->spec = spec;
2868
2869 /* automatic parse from the BIOS config */
2870 err = vt1708S_parse_auto_config(codec);
2871 if (err < 0) {
2872 via_free(codec);
2873 return err;
2874 } else if (!err) {
2875 printk(KERN_INFO "hda_codec: Cannot set up configuration "
2876 "from BIOS. Using genenic mode...\n");
2877 }
2878
69e52a80
HW		 2879 spec->init_verbs[spec->num_iverbs++] = vt1708S_volume_init_verbs;
2880 spec->init_verbs[spec->num_iverbs++] = vt1708S_uniwill_init_verbs;
d949cac1
HW		 2881
2882 spec->stream_name_analog = "VT1708S Analog";
2883 spec->stream_analog_playback = &vt1708S_pcm_analog_playback;
2884 spec->stream_analog_capture = &vt1708S_pcm_analog_capture;
2885
2886 spec->stream_name_digital = "VT1708S Digital";
2887 spec->stream_digital_playback = &vt1708S_pcm_digital_playback;
2888
2889 if (!spec->adc_nids && spec->input_mux) {
2890 spec->adc_nids = vt1708S_adc_nids;
2891 spec->num_adc_nids = ARRAY_SIZE(vt1708S_adc_nids);
2892 spec->mixers[spec->num_mixers] = vt1708S_capture_mixer;
2893 spec->num_mixers++;
2894 }
2895
2896 codec->patch_ops = via_patch_ops;
2897
2898 codec->patch_ops.init = via_auto_init;
69e52a80 2899 codec->patch_ops.unsol_event = via_unsol_event;
d949cac1
HW		 2900#ifdef CONFIG_SND_HDA_POWER_SAVE
2901 spec->loopback.amplist = vt1708S_loopbacks;
2902#endif
2903
2904 return 0;
2905}
2906
2907/* Patch for VT1702 */
2908
2909/* capture mixer elements */
2910static struct snd_kcontrol_new vt1702_capture_mixer[] = {
2911 HDA_CODEC_VOLUME("Capture Volume", 0x12, 0x0, HDA_INPUT),
2912 HDA_CODEC_MUTE("Capture Switch", 0x12, 0x0, HDA_INPUT),
2913 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x20, 0x0, HDA_INPUT),
2914 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x20, 0x0, HDA_INPUT),
2915 HDA_CODEC_VOLUME("Digital Mic Capture Volume", 0x1F, 0x0, HDA_INPUT),
2916 HDA_CODEC_MUTE("Digital Mic Capture Switch", 0x1F, 0x0, HDA_INPUT),
2917 HDA_CODEC_VOLUME("Digital Mic Boost Capture Volume", 0x1E, 0x0,
2918 HDA_INPUT),
2919 {
2920 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2921 /* The multiple "Capture Source" controls confuse alsamixer
2922 * So call somewhat different..
2923 */
2924 /* .name = "Capture Source", */
2925 .name = "Input Source",
2926 .count = 1,
2927 .info = via_mux_enum_info,
2928 .get = via_mux_enum_get,
2929 .put = via_mux_enum_put,
2930 },
2931 { } /* end */
2932};
2933
2934static struct hda_verb vt1702_volume_init_verbs[] = {
2935 /*
2936 * Unmute ADC0-1 and set the default input to mic-in
2937 */
2938 {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2939 {0x1F, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2940 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2941
2942
2943 /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
2944 * mixer widget
2945 */
2946 /* Amp Indices: Mic1 = 1, Line = 1, Mic2 = 3 */
2947 {0x1A, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2948 {0x1A, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
2949 {0x1A, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
2950 {0x1A, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
2951 {0x1A, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
2952
2953 /* Setup default input of PW4 to MW0 */
2954 {0x17, AC_VERB_SET_CONNECT_SEL, 0x1},
2955 /* PW6 PW7 Output enable */
2956 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
2957 {0x1C, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
2958 { }
2959};
2960
69e52a80
HW		 2961static struct hda_verb vt1702_uniwill_init_verbs[] = {
2962 {0x01, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_GPIO_EVENT},
2963 {0x17, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_HP_EVENT},
2964 { }
2965};
2966
d949cac1 2967static struct hda_pcm_stream vt1702_pcm_analog_playback = {
0aa62aef 2968 .substreams = 2,
d949cac1
HW		 2969 .channels_min = 2,
2970 .channels_max = 2,
2971 .nid = 0x10, /* NID to query formats and rates */
2972 .ops = {
2973 .open = via_playback_pcm_open,
0aa62aef
HW		 2974 .prepare = via_playback_multi_pcm_prepare,
2975 .cleanup = via_playback_multi_pcm_cleanup
d949cac1
HW		 2976 },
2977};
2978
2979static struct hda_pcm_stream vt1702_pcm_analog_capture = {
2980 .substreams = 3,
2981 .channels_min = 2,
2982 .channels_max = 2,
2983 .nid = 0x12, /* NID to query formats and rates */
2984 .ops = {
2985 .prepare = via_capture_pcm_prepare,
2986 .cleanup = via_capture_pcm_cleanup
2987 },
2988};
2989
2990static struct hda_pcm_stream vt1702_pcm_digital_playback = {
5691ec7f 2991 .substreams = 2,
d949cac1
HW		 2992 .channels_min = 2,
2993 .channels_max = 2,
2994 /* NID is set in via_build_pcms */
2995 .ops = {
2996 .open = via_dig_playback_pcm_open,
2997 .close = via_dig_playback_pcm_close,
9da29271
TI		 2998 .prepare = via_dig_playback_pcm_prepare,
2999 .cleanup = via_dig_playback_pcm_cleanup
d949cac1
HW		 3000 },
3001};
3002
3003/* fill in the dac_nids table from the parsed pin configuration */
3004static int vt1702_auto_fill_dac_nids(struct via_spec *spec,
3005 const struct auto_pin_cfg *cfg)
3006{
3007 spec->multiout.num_dacs = 1;
3008 spec->multiout.dac_nids = spec->private_dac_nids;
3009
3010 if (cfg->line_out_pins[0]) {
3011 /* config dac list */
3012 spec->multiout.dac_nids[0] = 0x10;
3013 }
3014
3015 return 0;
3016}
3017
3018/* add playback controls from the parsed DAC table */
3019static int vt1702_auto_create_line_out_ctls(struct via_spec *spec,
3020 const struct auto_pin_cfg *cfg)
3021{
3022 int err;
3023
3024 if (!cfg->line_out_pins[0])
3025 return -1;
3026
3027 /* add control to mixer index 0 */
3028 err = via_add_control(spec, VIA_CTL_WIDGET_VOL,
3029 "Master Front Playback Volume",
3030 HDA_COMPOSE_AMP_VAL(0x1A, 3, 0, HDA_INPUT));
3031 if (err < 0)
3032 return err;
3033 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE,
3034 "Master Front Playback Switch",
3035 HDA_COMPOSE_AMP_VAL(0x1A, 3, 0, HDA_INPUT));
3036 if (err < 0)
3037 return err;
3038
3039 /* Front */
3040 err = via_add_control(spec, VIA_CTL_WIDGET_VOL,
3041 "Front Playback Volume",
3042 HDA_COMPOSE_AMP_VAL(0x10, 3, 0, HDA_OUTPUT));
3043 if (err < 0)
3044 return err;
3045 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE,
3046 "Front Playback Switch",
3047 HDA_COMPOSE_AMP_VAL(0x16, 3, 0, HDA_OUTPUT));
3048 if (err < 0)
3049 return err;
3050
3051 return 0;
3052}
3053
3054static int vt1702_auto_create_hp_ctls(struct via_spec *spec, hda_nid_t pin)
3055{
3056 int err;
3057
3058 if (!pin)
3059 return 0;
3060
3061 spec->multiout.hp_nid = 0x1D;
3062
3063 err = via_add_control(spec, VIA_CTL_WIDGET_VOL,
3064 "Headphone Playback Volume",
3065 HDA_COMPOSE_AMP_VAL(0x1D, 3, 0, HDA_OUTPUT));
3066 if (err < 0)
3067 return err;
3068
3069 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE,
3070 "Headphone Playback Switch",
3071 HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
3072 if (err < 0)
3073 return err;
3074
0aa62aef
HW		 3075 create_hp_imux(spec);
3076
d949cac1
HW		 3077 return 0;
3078}
3079
3080/* create playback/capture controls for input pins */
3081static int vt1702_auto_create_analog_input_ctls(struct via_spec *spec,
3082 const struct auto_pin_cfg *cfg)
3083{
3084 static char *labels[] = {
3085 "Mic", "Front Mic", "Line", "Front Line", "CD", "Aux", NULL
3086 };
0aa62aef 3087 struct hda_input_mux *imux = &spec->private_imux[0];
d949cac1
HW		 3088 int i, err, idx = 0;
3089
3090 /* for internal loopback recording select */
3091 imux->items[imux->num_items].label = "Stereo Mixer";
3092 imux->items[imux->num_items].index = 3;
3093 imux->num_items++;
3094
3095 for (i = 0; i < AUTO_PIN_LAST; i++) {
3096 if (!cfg->input_pins[i])
3097 continue;
3098
3099 switch (cfg->input_pins[i]) {
3100 case 0x14: /* Mic */
3101 idx = 1;
3102 break;
3103
3104 case 0x15: /* Line In */
3105 idx = 2;
3106 break;
3107
3108 case 0x18: /* Front Mic */
3109 idx = 3;
3110 break;
3111 }
3112 err = via_new_analog_input(spec, cfg->input_pins[i],
3113 labels[i], idx, 0x1A);
3114 if (err < 0)
3115 return err;
3116 imux->items[imux->num_items].label = labels[i];
3117 imux->items[imux->num_items].index = idx-1;
3118 imux->num_items++;
3119 }
3120 return 0;
3121}
3122
3123static int vt1702_parse_auto_config(struct hda_codec *codec)
3124{
3125 struct via_spec *spec = codec->spec;
3126 int err;
d949cac1 3127
9da29271 3128 err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, NULL);
d949cac1
HW		 3129 if (err < 0)
3130 return err;
3131 err = vt1702_auto_fill_dac_nids(spec, &spec->autocfg);
3132 if (err < 0)
3133 return err;
3134 if (!spec->autocfg.line_outs && !spec->autocfg.hp_pins[0])
3135 return 0; /* can't find valid BIOS pin config */
3136
3137 err = vt1702_auto_create_line_out_ctls(spec, &spec->autocfg);
3138 if (err < 0)
3139 return err;
3140 err = vt1702_auto_create_hp_ctls(spec, spec->autocfg.hp_pins[0]);
3141 if (err < 0)
3142 return err;
3143 err = vt1702_auto_create_analog_input_ctls(spec, &spec->autocfg);
3144 if (err < 0)
3145 return err;
3146
3147 spec->multiout.max_channels = spec->multiout.num_dacs * 2;
3148
9da29271 3149 fill_dig_outs(codec);
98aa34c0 3150
603c4019
TI		 3151 if (spec->kctls.list)
3152 spec->mixers[spec->num_mixers++] = spec->kctls.list;
d949cac1 3153
0aa62aef
HW		 3154 spec->input_mux = &spec->private_imux[0];
3155
f8fdd495
HW		 3156 if (spec->hp_mux)
3157 spec->mixers[spec->num_mixers++] = via_hp_mixer;
d949cac1
HW		 3158
3159 return 1;
3160}
3161
3162#ifdef CONFIG_SND_HDA_POWER_SAVE
3163static struct hda_amp_list vt1702_loopbacks[] = {
3164 { 0x1A, HDA_INPUT, 1 },
3165 { 0x1A, HDA_INPUT, 2 },
3166 { 0x1A, HDA_INPUT, 3 },
3167 { 0x1A, HDA_INPUT, 4 },
3168 { } /* end */
3169};
3170#endif
3171
3172static int patch_vt1702(struct hda_codec *codec)
3173{
3174 struct via_spec *spec;
3175 int err;
3176 unsigned int response;
3177 unsigned char control;
3178
3179 /* create a codec specific record */
3180 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
3181 if (spec == NULL)
3182 return -ENOMEM;
3183
3184 codec->spec = spec;
3185
3186 /* automatic parse from the BIOS config */
3187 err = vt1702_parse_auto_config(codec);
3188 if (err < 0) {
3189 via_free(codec);
3190 return err;
3191 } else if (!err) {
3192 printk(KERN_INFO "hda_codec: Cannot set up configuration "
3193 "from BIOS. Using genenic mode...\n");
3194 }
3195
69e52a80
HW		 3196 spec->init_verbs[spec->num_iverbs++] = vt1702_volume_init_verbs;
3197 spec->init_verbs[spec->num_iverbs++] = vt1702_uniwill_init_verbs;
d949cac1
HW		 3198
3199 spec->stream_name_analog = "VT1702 Analog";
3200 spec->stream_analog_playback = &vt1702_pcm_analog_playback;
3201 spec->stream_analog_capture = &vt1702_pcm_analog_capture;
3202
3203 spec->stream_name_digital = "VT1702 Digital";
3204 spec->stream_digital_playback = &vt1702_pcm_digital_playback;
3205
3206 if (!spec->adc_nids && spec->input_mux) {
3207 spec->adc_nids = vt1702_adc_nids;
3208 spec->num_adc_nids = ARRAY_SIZE(vt1702_adc_nids);
3209 spec->mixers[spec->num_mixers] = vt1702_capture_mixer;
3210 spec->num_mixers++;
3211 }
3212
3213 codec->patch_ops = via_patch_ops;
3214
3215 codec->patch_ops.init = via_auto_init;
69e52a80 3216 codec->patch_ops.unsol_event = via_unsol_event;
d949cac1
HW		 3217#ifdef CONFIG_SND_HDA_POWER_SAVE
3218 spec->loopback.amplist = vt1702_loopbacks;
3219#endif
3220
3221 /* Open backdoor */
3222 response = snd_hda_codec_read(codec, codec->afg, 0, 0xF8C, 0);
3223 control = (unsigned char)(response & 0xff);
3224 control |= 0x3;
3225 snd_hda_codec_write(codec, codec->afg, 0, 0xF88, control);
3226
3227 /* Enable GPIO 0&1 for volume&mute control */
3228 /* Enable GPIO 2 for DMIC-DATA */
3229 response = snd_hda_codec_read(codec, codec->afg, 0, 0xF84, 0);
3230 control = (unsigned char)((response >> 16) & 0x3f);
3231 snd_hda_codec_write(codec, codec->afg, 0, 0xF82, control);
3232
3233 return 0;
3234}
3235
c577b8a1
JC		 3236/*
3237 * patch entries
3238 */
1289e9e8 3239static struct hda_codec_preset snd_hda_preset_via[] = {
3218c178
TI		 3240 { .id = 0x11061708, .name = "VT1708", .patch = patch_vt1708},
3241 { .id = 0x11061709, .name = "VT1708", .patch = patch_vt1708},
3242 { .id = 0x1106170a, .name = "VT1708", .patch = patch_vt1708},
3243 { .id = 0x1106170b, .name = "VT1708", .patch = patch_vt1708},
3244 { .id = 0x1106e710, .name = "VT1709 10-Ch",
f7278fd0 3245 .patch = patch_vt1709_10ch},
3218c178 3246 { .id = 0x1106e711, .name = "VT1709 10-Ch",
f7278fd0 3247 .patch = patch_vt1709_10ch},
3218c178 3248 { .id = 0x1106e712, .name = "VT1709 10-Ch",
f7278fd0 3249 .patch = patch_vt1709_10ch},
3218c178 3250 { .id = 0x1106e713, .name = "VT1709 10-Ch",
f7278fd0 3251 .patch = patch_vt1709_10ch},
3218c178 3252 { .id = 0x1106e714, .name = "VT1709 6-Ch",
f7278fd0 3253 .patch = patch_vt1709_6ch},
3218c178 3254 { .id = 0x1106e715, .name = "VT1709 6-Ch",
f7278fd0 3255 .patch = patch_vt1709_6ch},
3218c178 3256 { .id = 0x1106e716, .name = "VT1709 6-Ch",
f7278fd0 3257 .patch = patch_vt1709_6ch},
3218c178 3258 { .id = 0x1106e717, .name = "VT1709 6-Ch",
f7278fd0 3259 .patch = patch_vt1709_6ch},
3218c178 3260 { .id = 0x1106e720, .name = "VT1708B 8-Ch",
f7278fd0 3261 .patch = patch_vt1708B_8ch},
3218c178 3262 { .id = 0x1106e721, .name = "VT1708B 8-Ch",
f7278fd0 3263 .patch = patch_vt1708B_8ch},
3218c178 3264 { .id = 0x1106e722, .name = "VT1708B 8-Ch",
f7278fd0 3265 .patch = patch_vt1708B_8ch},
3218c178 3266 { .id = 0x1106e723, .name = "VT1708B 8-Ch",
f7278fd0 3267 .patch = patch_vt1708B_8ch},
3218c178 3268 { .id = 0x1106e724, .name = "VT1708B 4-Ch",
f7278fd0 3269 .patch = patch_vt1708B_4ch},
3218c178 3270 { .id = 0x1106e725, .name = "VT1708B 4-Ch",
f7278fd0 3271 .patch = patch_vt1708B_4ch},
3218c178 3272 { .id = 0x1106e726, .name = "VT1708B 4-Ch",
f7278fd0 3273 .patch = patch_vt1708B_4ch},
3218c178 3274 { .id = 0x1106e727, .name = "VT1708B 4-Ch",
f7278fd0 3275 .patch = patch_vt1708B_4ch},
3218c178 3276 { .id = 0x11060397, .name = "VT1708S",
d949cac1 3277 .patch = patch_vt1708S},
3218c178 3278 { .id = 0x11061397, .name = "VT1708S",
d949cac1 3279 .patch = patch_vt1708S},
3218c178 3280 { .id = 0x11062397, .name = "VT1708S",
d949cac1 3281 .patch = patch_vt1708S},
3218c178 3282 { .id = 0x11063397, .name = "VT1708S",
d949cac1 3283 .patch = patch_vt1708S},
3218c178 3284 { .id = 0x11064397, .name = "VT1708S",
d949cac1 3285 .patch = patch_vt1708S},
3218c178 3286 { .id = 0x11065397, .name = "VT1708S",
d949cac1 3287 .patch = patch_vt1708S},
3218c178 3288 { .id = 0x11066397, .name = "VT1708S",
d949cac1 3289 .patch = patch_vt1708S},
3218c178 3290 { .id = 0x11067397, .name = "VT1708S",
d949cac1 3291 .patch = patch_vt1708S},
3218c178 3292 { .id = 0x11060398, .name = "VT1702",
d949cac1 3293 .patch = patch_vt1702},
3218c178 3294 { .id = 0x11061398, .name = "VT1702",
d949cac1 3295 .patch = patch_vt1702},
3218c178 3296 { .id = 0x11062398, .name = "VT1702",
d949cac1 3297 .patch = patch_vt1702},
3218c178 3298 { .id = 0x11063398, .name = "VT1702",
d949cac1 3299 .patch = patch_vt1702},
3218c178 3300 { .id = 0x11064398, .name = "VT1702",
d949cac1 3301 .patch = patch_vt1702},
3218c178 3302 { .id = 0x11065398, .name = "VT1702",
d949cac1 3303 .patch = patch_vt1702},
3218c178 3304 { .id = 0x11066398, .name = "VT1702",
d949cac1 3305 .patch = patch_vt1702},
3218c178 3306 { .id = 0x11067398, .name = "VT1702",
d949cac1 3307 .patch = patch_vt1702},
c577b8a1
JC		 3308 {} /* terminator */
3309};
1289e9e8
TI		 3310
3311MODULE_ALIAS("snd-hda-codec-id:1106*");
3312
3313static struct hda_codec_preset_list via_list = {
3314 .preset = snd_hda_preset_via,
3315 .owner = THIS_MODULE,
3316};
3317
3318MODULE_LICENSE("GPL");
3319MODULE_DESCRIPTION("VIA HD-audio codec");
3320
3321static int __init patch_via_init(void)
3322{
3323 return snd_hda_add_codec_preset(&via_list);
3324}
3325
3326static void __exit patch_via_exit(void)
3327{
3328 snd_hda_delete_codec_preset(&via_list);
3329}
3330
3331module_init(patch_via_init)
3332module_exit(patch_via_exit)
Linux kernel - Deliverables
This page took 0.41842 seconds and 5 git commands to generate.