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