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