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