?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Committer: Michael Beasley <mike@snafu.setup>
[mikesnafu-overlay.git] / sound / pci / hda / patch_via.c
blob4e5dd4cf36f5f6404852e9ef70a0fc7110fc5730
1 /*
2 * Universal Interface for Intel High Definition Audio Codec
3 *
4 * HD audio interface patch for VIA VT1708 codec
5 *
6 * Copyright (c) 2006 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 /* */
33 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
34
35
36 #include <linux/init.h>
37 #include <linux/delay.h>
38 #include <linux/slab.h>
39 #include <sound/core.h>
40 #include "hda_codec.h"
41 #include "hda_local.h"
42
43
44 /* amp values */
45 #define AMP_VAL_IDX_SHIFT 19
46 #define AMP_VAL_IDX_MASK (0x0f<<19)
47
48 #define NUM_CONTROL_ALLOC 32
49 #define NUM_VERB_ALLOC 32
50
51 /* Pin Widget NID */
52 #define VT1708_HP_NID 0x13
53 #define VT1708_DIGOUT_NID 0x14
54 #define VT1708_DIGIN_NID 0x16
55 #define VT1708_DIGIN_PIN 0x26
56
57 #define VT1709_HP_DAC_NID 0x28
58 #define VT1709_DIGOUT_NID 0x13
59 #define VT1709_DIGIN_NID 0x17
60 #define VT1709_DIGIN_PIN 0x25
61
62 #define VT1708B_HP_NID 0x25
63 #define VT1708B_DIGOUT_NID 0x12
64 #define VT1708B_DIGIN_NID 0x15
65 #define VT1708B_DIGIN_PIN 0x21
66
67 #define IS_VT1708_VENDORID(x) ((x) >= 0x11061708 && (x) <= 0x1106170b)
68 #define IS_VT1709_10CH_VENDORID(x) ((x) >= 0x1106e710 && (x) <= 0x1106e713)
69 #define IS_VT1709_6CH_VENDORID(x) ((x) >= 0x1106e714 && (x) <= 0x1106e717)
70 #define IS_VT1708B_8CH_VENDORID(x) ((x) >= 0x1106e720 && (x) <= 0x1106e723)
71 #define IS_VT1708B_4CH_VENDORID(x) ((x) >= 0x1106e724 && (x) <= 0x1106e727)
72
73
74 enum {
75 VIA_CTL_WIDGET_VOL,
76 VIA_CTL_WIDGET_MUTE,
77 };
78
79 enum {
80 AUTO_SEQ_FRONT,
81 AUTO_SEQ_SURROUND,
82 AUTO_SEQ_CENLFE,
83 AUTO_SEQ_SIDE
84 };
85
86 static struct snd_kcontrol_new vt1708_control_templates[] = {
87 HDA_CODEC_VOLUME(NULL, 0, 0, 0),
88 HDA_CODEC_MUTE(NULL, 0, 0, 0),
89 };
90
91
92 struct via_spec {
93 /* codec parameterization */
94 struct snd_kcontrol_new *mixers[3];
95 unsigned int num_mixers;
96
97 struct hda_verb *init_verbs;
98
99 char *stream_name_analog;
100 struct hda_pcm_stream *stream_analog_playback;
101 struct hda_pcm_stream *stream_analog_capture;
102
103 char *stream_name_digital;
104 struct hda_pcm_stream *stream_digital_playback;
105 struct hda_pcm_stream *stream_digital_capture;
106
107 /* playback */
108 struct hda_multi_out multiout;
109
110 /* capture */
111 unsigned int num_adc_nids;
112 hda_nid_t *adc_nids;
113 hda_nid_t dig_in_nid;
114
115 /* capture source */
116 const struct hda_input_mux *input_mux;
117 unsigned int cur_mux[3];
118
119 /* PCM information */
120 struct hda_pcm pcm_rec[2];
121
122 /* dynamic controls, init_verbs and input_mux */
123 struct auto_pin_cfg autocfg;
124 unsigned int num_kctl_alloc, num_kctl_used;
125 struct snd_kcontrol_new *kctl_alloc;
126 struct hda_input_mux private_imux;
127 hda_nid_t private_dac_nids[AUTO_CFG_MAX_OUTS];
128
129 #ifdef CONFIG_SND_HDA_POWER_SAVE
130 struct hda_loopback_check loopback;
131 #endif
132 };
133
134 static hda_nid_t vt1708_adc_nids[2] = {
135 /* ADC1-2 */
136 0x15, 0x27
137 };
138
139 static hda_nid_t vt1709_adc_nids[3] = {
140 /* ADC1-2 */
141 0x14, 0x15, 0x16
142 };
143
144 static hda_nid_t vt1708B_adc_nids[2] = {
145 /* ADC1-2 */
146 0x13, 0x14
147 };
148
149 /* add dynamic controls */
150 static int via_add_control(struct via_spec *spec, int type, const char *name,
151 unsigned long val)
152 {
153 struct snd_kcontrol_new *knew;
154
155 if (spec->num_kctl_used >= spec->num_kctl_alloc) {
156 int num = spec->num_kctl_alloc + NUM_CONTROL_ALLOC;
157
158 /* array + terminator */
159 knew = kcalloc(num + 1, sizeof(*knew), GFP_KERNEL);
160 if (!knew)
161 return -ENOMEM;
162 if (spec->kctl_alloc) {
163 memcpy(knew, spec->kctl_alloc,
164 sizeof(*knew) * spec->num_kctl_alloc);
165 kfree(spec->kctl_alloc);
166 }
167 spec->kctl_alloc = knew;
168 spec->num_kctl_alloc = num;
169 }
170
171 knew = &spec->kctl_alloc[spec->num_kctl_used];
172 *knew = vt1708_control_templates[type];
173 knew->name = kstrdup(name, GFP_KERNEL);
174
175 if (!knew->name)
176 return -ENOMEM;
177 knew->private_value = val;
178 spec->num_kctl_used++;
179 return 0;
180 }
181
182 /* create input playback/capture controls for the given pin */
183 static int via_new_analog_input(struct via_spec *spec, hda_nid_t pin,
184 const char *ctlname, int idx, int mix_nid)
185 {
186 char name[32];
187 int err;
188
189 sprintf(name, "%s Playback Volume", ctlname);
190 err = via_add_control(spec, VIA_CTL_WIDGET_VOL, name,
191 HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT));
192 if (err < 0)
193 return err;
194 sprintf(name, "%s Playback Switch", ctlname);
195 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, name,
196 HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT));
197 if (err < 0)
198 return err;
199 return 0;
200 }
201
202 static void via_auto_set_output_and_unmute(struct hda_codec *codec,
203 hda_nid_t nid, int pin_type,
204 int dac_idx)
205 {
206 /* set as output */
207 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
208 pin_type);
209 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE,
210 AMP_OUT_UNMUTE);
211 }
212
213
214 static void via_auto_init_multi_out(struct hda_codec *codec)
215 {
216 struct via_spec *spec = codec->spec;
217 int i;
218
219 for (i = 0; i <= AUTO_SEQ_SIDE; i++) {
220 hda_nid_t nid = spec->autocfg.line_out_pins[i];
221 if (nid)
222 via_auto_set_output_and_unmute(codec, nid, PIN_OUT, i);
223 }
224 }
225
226 static void via_auto_init_hp_out(struct hda_codec *codec)
227 {
228 struct via_spec *spec = codec->spec;
229 hda_nid_t pin;
230
231 pin = spec->autocfg.hp_pins[0];
232 if (pin) /* connect to front */
233 via_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
234 }
235
236 static void via_auto_init_analog_input(struct hda_codec *codec)
237 {
238 struct via_spec *spec = codec->spec;
239 int i;
240
241 for (i = 0; i < AUTO_PIN_LAST; i++) {
242 hda_nid_t nid = spec->autocfg.input_pins[i];
243
244 snd_hda_codec_write(codec, nid, 0,
245 AC_VERB_SET_PIN_WIDGET_CONTROL,
246 (i <= AUTO_PIN_FRONT_MIC ?
247 PIN_VREF50 : PIN_IN));
248
249 }
250 }
251 /*
252 * input MUX handling
253 */
254 static int via_mux_enum_info(struct snd_kcontrol *kcontrol,
255 struct snd_ctl_elem_info *uinfo)
256 {
257 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
258 struct via_spec *spec = codec->spec;
259 return snd_hda_input_mux_info(spec->input_mux, uinfo);
260 }
261
262 static int via_mux_enum_get(struct snd_kcontrol *kcontrol,
263 struct snd_ctl_elem_value *ucontrol)
264 {
265 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
266 struct via_spec *spec = codec->spec;
267 unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
268
269 ucontrol->value.enumerated.item[0] = spec->cur_mux[adc_idx];
270 return 0;
271 }
272
273 static int via_mux_enum_put(struct snd_kcontrol *kcontrol,
274 struct snd_ctl_elem_value *ucontrol)
275 {
276 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
277 struct via_spec *spec = codec->spec;
278 unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
279 unsigned int vendor_id = codec->vendor_id;
280
281 /* AIW0 lydia 060801 add for correct sw0 input select */
282 if (IS_VT1708_VENDORID(vendor_id) && (adc_idx == 0))
283 return snd_hda_input_mux_put(codec, spec->input_mux, ucontrol,
284 0x18, &spec->cur_mux[adc_idx]);
285 else if ((IS_VT1709_10CH_VENDORID(vendor_id) ||
286 IS_VT1709_6CH_VENDORID(vendor_id)) && adc_idx == 0)
287 return snd_hda_input_mux_put(codec, spec->input_mux, ucontrol,
288 0x19, &spec->cur_mux[adc_idx]);
289 else if ((IS_VT1708B_8CH_VENDORID(vendor_id) ||
290 IS_VT1708B_4CH_VENDORID(vendor_id)) && adc_idx == 0)
291 return snd_hda_input_mux_put(codec, spec->input_mux, ucontrol,
292 0x17, &spec->cur_mux[adc_idx]);
293 else
294 return snd_hda_input_mux_put(codec, spec->input_mux, ucontrol,
295 spec->adc_nids[adc_idx],
296 &spec->cur_mux[adc_idx]);
297 }
298
299 /* capture mixer elements */
300 static struct snd_kcontrol_new vt1708_capture_mixer[] = {
301 HDA_CODEC_VOLUME("Capture Volume", 0x15, 0x0, HDA_INPUT),
302 HDA_CODEC_MUTE("Capture Switch", 0x15, 0x0, HDA_INPUT),
303 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x27, 0x0, HDA_INPUT),
304 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x27, 0x0, HDA_INPUT),
305 {
306 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
307 /* The multiple "Capture Source" controls confuse alsamixer
308 * So call somewhat different..
309 */
310 /* .name = "Capture Source", */
311 .name = "Input Source",
312 .count = 1,
313 .info = via_mux_enum_info,
314 .get = via_mux_enum_get,
315 .put = via_mux_enum_put,
316 },
317 { } /* end */
318 };
319 /*
320 * generic initialization of ADC, input mixers and output mixers
321 */
322 static struct hda_verb vt1708_volume_init_verbs[] = {
323 /*
324 * Unmute ADC0-1 and set the default input to mic-in
325 */
326 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
327 {0x27, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
328
329
330 /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
331 * mixer widget
332 */
333 /* Amp Indices: CD = 1, Mic1 = 2, Line = 3, Mic2 = 4 */
334 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
335 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
336 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
337 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
338 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
339
340 /*
341 * Set up output mixers (0x19 - 0x1b)
342 */
343 /* set vol=0 to output mixers */
344 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
345 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
346 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
347
348 /* Setup default input to PW4 */
349 {0x20, AC_VERB_SET_CONNECT_SEL, 0x1},
350 /* PW9 Output enable */
351 {0x25, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
352 { }
353 };
354
355 static int via_playback_pcm_open(struct hda_pcm_stream *hinfo,
356 struct hda_codec *codec,
357 struct snd_pcm_substream *substream)
358 {
359 struct via_spec *spec = codec->spec;
360 return snd_hda_multi_out_analog_open(codec, &spec->multiout, substream);
361 }
362
363 static int via_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
364 struct hda_codec *codec,
365 unsigned int stream_tag,
366 unsigned int format,
367 struct snd_pcm_substream *substream)
368 {
369 struct via_spec *spec = codec->spec;
370 return snd_hda_multi_out_analog_prepare(codec, &spec->multiout,
371 stream_tag, format, substream);
372 }
373
374 static int via_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
375 struct hda_codec *codec,
376 struct snd_pcm_substream *substream)
377 {
378 struct via_spec *spec = codec->spec;
379 return snd_hda_multi_out_analog_cleanup(codec, &spec->multiout);
380 }
381
382 /*
383 * Digital out
384 */
385 static int via_dig_playback_pcm_open(struct hda_pcm_stream *hinfo,
386 struct hda_codec *codec,
387 struct snd_pcm_substream *substream)
388 {
389 struct via_spec *spec = codec->spec;
390 return snd_hda_multi_out_dig_open(codec, &spec->multiout);
391 }
392
393 static int via_dig_playback_pcm_close(struct hda_pcm_stream *hinfo,
394 struct hda_codec *codec,
395 struct snd_pcm_substream *substream)
396 {
397 struct via_spec *spec = codec->spec;
398 return snd_hda_multi_out_dig_close(codec, &spec->multiout);
399 }
400
401 static int via_dig_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
402 struct hda_codec *codec,
403 unsigned int stream_tag,
404 unsigned int format,
405 struct snd_pcm_substream *substream)
406 {
407 struct via_spec *spec = codec->spec;
408 return snd_hda_multi_out_dig_prepare(codec, &spec->multiout,
409 stream_tag, format, substream);
410 }
411
412 /*
413 * Analog capture
414 */
415 static int via_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
416 struct hda_codec *codec,
417 unsigned int stream_tag,
418 unsigned int format,
419 struct snd_pcm_substream *substream)
420 {
421 struct via_spec *spec = codec->spec;
422
423 snd_hda_codec_setup_stream(codec, spec->adc_nids[substream->number],
424 stream_tag, 0, format);
425 return 0;
426 }
427
428 static int via_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
429 struct hda_codec *codec,
430 struct snd_pcm_substream *substream)
431 {
432 struct via_spec *spec = codec->spec;
433 snd_hda_codec_setup_stream(codec, spec->adc_nids[substream->number],
434 0, 0, 0);
435 return 0;
436 }
437
438 static struct hda_pcm_stream vt1708_pcm_analog_playback = {
439 .substreams = 1,
440 .channels_min = 2,
441 .channels_max = 8,
442 .nid = 0x10, /* NID to query formats and rates */
443 .ops = {
444 .open = via_playback_pcm_open,
445 .prepare = via_playback_pcm_prepare,
446 .cleanup = via_playback_pcm_cleanup
447 },
448 };
449
450 static struct hda_pcm_stream vt1708_pcm_analog_capture = {
451 .substreams = 2,
452 .channels_min = 2,
453 .channels_max = 2,
454 .nid = 0x15, /* NID to query formats and rates */
455 .ops = {
456 .prepare = via_capture_pcm_prepare,
457 .cleanup = via_capture_pcm_cleanup
458 },
459 };
460
461 static struct hda_pcm_stream vt1708_pcm_digital_playback = {
462 .substreams = 1,
463 .channels_min = 2,
464 .channels_max = 2,
465 /* NID is set in via_build_pcms */
466 .ops = {
467 .open = via_dig_playback_pcm_open,
468 .close = via_dig_playback_pcm_close,
469 .prepare = via_dig_playback_pcm_prepare
470 },
471 };
472
473 static struct hda_pcm_stream vt1708_pcm_digital_capture = {
474 .substreams = 1,
475 .channels_min = 2,
476 .channels_max = 2,
477 };
478
479 static int via_build_controls(struct hda_codec *codec)
480 {
481 struct via_spec *spec = codec->spec;
482 int err;
483 int i;
484
485 for (i = 0; i < spec->num_mixers; i++) {
486 err = snd_hda_add_new_ctls(codec, spec->mixers[i]);
487 if (err < 0)
488 return err;
489 }
490
491 if (spec->multiout.dig_out_nid) {
492 err = snd_hda_create_spdif_out_ctls(codec,
493 spec->multiout.dig_out_nid);
494 if (err < 0)
495 return err;
496 }
497 if (spec->dig_in_nid) {
498 err = snd_hda_create_spdif_in_ctls(codec, spec->dig_in_nid);
499 if (err < 0)
500 return err;
501 }
502 return 0;
503 }
504
505 static int via_build_pcms(struct hda_codec *codec)
506 {
507 struct via_spec *spec = codec->spec;
508 struct hda_pcm *info = spec->pcm_rec;
509
510 codec->num_pcms = 1;
511 codec->pcm_info = info;
512
513 info->name = spec->stream_name_analog;
514 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *(spec->stream_analog_playback);
515 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dac_nids[0];
516 info->stream[SNDRV_PCM_STREAM_CAPTURE] = *(spec->stream_analog_capture);
517 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adc_nids[0];
518
519 info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max =
520 spec->multiout.max_channels;
521
522 if (spec->multiout.dig_out_nid || spec->dig_in_nid) {
523 codec->num_pcms++;
524 info++;
525 info->name = spec->stream_name_digital;
526 if (spec->multiout.dig_out_nid) {
527 info->stream[SNDRV_PCM_STREAM_PLAYBACK] =
528 *(spec->stream_digital_playback);
529 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid =
530 spec->multiout.dig_out_nid;
531 }
532 if (spec->dig_in_nid) {
533 info->stream[SNDRV_PCM_STREAM_CAPTURE] =
534 *(spec->stream_digital_capture);
535 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid =
536 spec->dig_in_nid;
537 }
538 }
539
540 return 0;
541 }
542
543 static void via_free(struct hda_codec *codec)
544 {
545 struct via_spec *spec = codec->spec;
546 unsigned int i;
547
548 if (!spec)
549 return;
550
551 if (spec->kctl_alloc) {
552 for (i = 0; i < spec->num_kctl_used; i++)
553 kfree(spec->kctl_alloc[i].name);
554 kfree(spec->kctl_alloc);
555 }
556
557 kfree(codec->spec);
558 }
559
560 static int via_init(struct hda_codec *codec)
561 {
562 struct via_spec *spec = codec->spec;
563 snd_hda_sequence_write(codec, spec->init_verbs);
564 /* Lydia Add for EAPD enable */
565 if (!spec->dig_in_nid) { /* No Digital In connection */
566 if (IS_VT1708_VENDORID(codec->vendor_id)) {
567 snd_hda_codec_write(codec, VT1708_DIGIN_PIN, 0,
568 AC_VERB_SET_PIN_WIDGET_CONTROL,
569 PIN_OUT);
570 snd_hda_codec_write(codec, VT1708_DIGIN_PIN, 0,
571 AC_VERB_SET_EAPD_BTLENABLE, 0x02);
572 } else if (IS_VT1709_10CH_VENDORID(codec->vendor_id) ||
573 IS_VT1709_6CH_VENDORID(codec->vendor_id)) {
574 snd_hda_codec_write(codec, VT1709_DIGIN_PIN, 0,
575 AC_VERB_SET_PIN_WIDGET_CONTROL,
576 PIN_OUT);
577 snd_hda_codec_write(codec, VT1709_DIGIN_PIN, 0,
578 AC_VERB_SET_EAPD_BTLENABLE, 0x02);
579 } else if (IS_VT1708B_8CH_VENDORID(codec->vendor_id) ||
580 IS_VT1708B_4CH_VENDORID(codec->vendor_id)) {
581 snd_hda_codec_write(codec, VT1708B_DIGIN_PIN, 0,
582 AC_VERB_SET_PIN_WIDGET_CONTROL,
583 PIN_OUT);
584 snd_hda_codec_write(codec, VT1708B_DIGIN_PIN, 0,
585 AC_VERB_SET_EAPD_BTLENABLE, 0x02);
586 }
587 } else /* enable SPDIF-input pin */
588 snd_hda_codec_write(codec, spec->autocfg.dig_in_pin, 0,
589 AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN);
590
591 return 0;
592 }
593
594 #ifdef CONFIG_SND_HDA_POWER_SAVE
595 static int via_check_power_status(struct hda_codec *codec, hda_nid_t nid)
596 {
597 struct via_spec *spec = codec->spec;
598 return snd_hda_check_amp_list_power(codec, &spec->loopback, nid);
599 }
600 #endif
601
602 /*
603 */
604 static struct hda_codec_ops via_patch_ops = {
605 .build_controls = via_build_controls,
606 .build_pcms = via_build_pcms,
607 .init = via_init,
608 .free = via_free,
609 #ifdef CONFIG_SND_HDA_POWER_SAVE
610 .check_power_status = via_check_power_status,
611 #endif
612 };
613
614 /* fill in the dac_nids table from the parsed pin configuration */
615 static int vt1708_auto_fill_dac_nids(struct via_spec *spec,
616 const struct auto_pin_cfg *cfg)
617 {
618 int i;
619 hda_nid_t nid;
620
621 spec->multiout.num_dacs = cfg->line_outs;
622
623 spec->multiout.dac_nids = spec->private_dac_nids;
624
625 for(i = 0; i < 4; i++) {
626 nid = cfg->line_out_pins[i];
627 if (nid) {
628 /* config dac list */
629 switch (i) {
630 case AUTO_SEQ_FRONT:
631 spec->multiout.dac_nids[i] = 0x10;
632 break;
633 case AUTO_SEQ_CENLFE:
634 spec->multiout.dac_nids[i] = 0x12;
635 break;
636 case AUTO_SEQ_SURROUND:
637 spec->multiout.dac_nids[i] = 0x13;
638 break;
639 case AUTO_SEQ_SIDE:
640 spec->multiout.dac_nids[i] = 0x11;
641 break;
642 }
643 }
644 }
645
646 return 0;
647 }
648
649 /* add playback controls from the parsed DAC table */
650 static int vt1708_auto_create_multi_out_ctls(struct via_spec *spec,
651 const struct auto_pin_cfg *cfg)
652 {
653 char name[32];
654 static const char *chname[4] = { "Front", "Surround", "C/LFE", "Side" };
655 hda_nid_t nid, nid_vol = 0;
656 int i, err;
657
658 for (i = 0; i <= AUTO_SEQ_SIDE; i++) {
659 nid = cfg->line_out_pins[i];
660
661 if (!nid)
662 continue;
663
664 if (i != AUTO_SEQ_FRONT)
665 nid_vol = 0x1b - i + 1;
666
667 if (i == AUTO_SEQ_CENLFE) {
668 /* Center/LFE */
669 err = via_add_control(spec, VIA_CTL_WIDGET_VOL,
670 "Center Playback Volume",
671 HDA_COMPOSE_AMP_VAL(nid_vol, 1, 0,
672 HDA_OUTPUT));
673 if (err < 0)
674 return err;
675 err = via_add_control(spec, VIA_CTL_WIDGET_VOL,
676 "LFE Playback Volume",
677 HDA_COMPOSE_AMP_VAL(nid_vol, 2, 0,
678 HDA_OUTPUT));
679 if (err < 0)
680 return err;
681 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE,
682 "Center Playback Switch",
683 HDA_COMPOSE_AMP_VAL(nid_vol, 1, 0,
684 HDA_OUTPUT));
685 if (err < 0)
686 return err;
687 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE,
688 "LFE Playback Switch",
689 HDA_COMPOSE_AMP_VAL(nid_vol, 2, 0,
690 HDA_OUTPUT));
691 if (err < 0)
692 return err;
693 } else if (i == AUTO_SEQ_FRONT){
694 /* add control to mixer index 0 */
695 err = via_add_control(spec, VIA_CTL_WIDGET_VOL,
696 "Master Front Playback Volume",
697 HDA_COMPOSE_AMP_VAL(0x17, 3, 0,
698 HDA_INPUT));
699 if (err < 0)
700 return err;
701 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE,
702 "Master Front Playback Switch",
703 HDA_COMPOSE_AMP_VAL(0x17, 3, 0,
704 HDA_INPUT));
705 if (err < 0)
706 return err;
707
708 /* add control to PW3 */
709 sprintf(name, "%s Playback Volume", chname[i]);
710 err = via_add_control(spec, VIA_CTL_WIDGET_VOL, name,
711 HDA_COMPOSE_AMP_VAL(nid, 3, 0,
712 HDA_OUTPUT));
713 if (err < 0)
714 return err;
715 sprintf(name, "%s Playback Switch", chname[i]);
716 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, name,
717 HDA_COMPOSE_AMP_VAL(nid, 3, 0,
718 HDA_OUTPUT));
719 if (err < 0)
720 return err;
721 } else {
722 sprintf(name, "%s Playback Volume", chname[i]);
723 err = via_add_control(spec, VIA_CTL_WIDGET_VOL, name,
724 HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0,
725 HDA_OUTPUT));
726 if (err < 0)
727 return err;
728 sprintf(name, "%s Playback Switch", chname[i]);
729 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, name,
730 HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0,
731 HDA_OUTPUT));
732 if (err < 0)
733 return err;
734 }
735 }
736
737 return 0;
738 }
739
740 static int vt1708_auto_create_hp_ctls(struct via_spec *spec, hda_nid_t pin)
741 {
742 int err;
743
744 if (!pin)
745 return 0;
746
747 spec->multiout.hp_nid = VT1708_HP_NID; /* AOW3 */
748
749 err = via_add_control(spec, VIA_CTL_WIDGET_VOL,
750 "Headphone Playback Volume",
751 HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
752 if (err < 0)
753 return err;
754 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE,
755 "Headphone Playback Switch",
756 HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
757 if (err < 0)
758 return err;
759
760 return 0;
761 }
762
763 /* create playback/capture controls for input pins */
764 static int vt1708_auto_create_analog_input_ctls(struct via_spec *spec,
765 const struct auto_pin_cfg *cfg)
766 {
767 static char *labels[] = {
768 "Mic", "Front Mic", "Line", "Front Line", "CD", "Aux", NULL
769 };
770 struct hda_input_mux *imux = &spec->private_imux;
771 int i, err, idx = 0;
772
773 /* for internal loopback recording select */
774 imux->items[imux->num_items].label = "Stereo Mixer";
775 imux->items[imux->num_items].index = idx;
776 imux->num_items++;
777
778 for (i = 0; i < AUTO_PIN_LAST; i++) {
779 if (!cfg->input_pins[i])
780 continue;
781
782 switch (cfg->input_pins[i]) {
783 case 0x1d: /* Mic */
784 idx = 2;
785 break;
786
787 case 0x1e: /* Line In */
788 idx = 3;
789 break;
790
791 case 0x21: /* Front Mic */
792 idx = 4;
793 break;
794
795 case 0x24: /* CD */
796 idx = 1;
797 break;
798 }
799 err = via_new_analog_input(spec, cfg->input_pins[i], labels[i],
800 idx, 0x17);
801 if (err < 0)
802 return err;
803 imux->items[imux->num_items].label = labels[i];
804 imux->items[imux->num_items].index = idx;
805 imux->num_items++;
806 }
807 return 0;
808 }
809
810 #ifdef CONFIG_SND_HDA_POWER_SAVE
811 static struct hda_amp_list vt1708_loopbacks[] = {
812 { 0x17, HDA_INPUT, 1 },
813 { 0x17, HDA_INPUT, 2 },
814 { 0x17, HDA_INPUT, 3 },
815 { 0x17, HDA_INPUT, 4 },
816 { } /* end */
817 };
818 #endif
819
820 static int vt1708_parse_auto_config(struct hda_codec *codec)
821 {
822 struct via_spec *spec = codec->spec;
823 int err;
824
825 err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, NULL);
826 if (err < 0)
827 return err;
828 err = vt1708_auto_fill_dac_nids(spec, &spec->autocfg);
829 if (err < 0)
830 return err;
831 if (!spec->autocfg.line_outs && !spec->autocfg.hp_pins[0])
832 return 0; /* can't find valid BIOS pin config */
833
834 err = vt1708_auto_create_multi_out_ctls(spec, &spec->autocfg);
835 if (err < 0)
836 return err;
837 err = vt1708_auto_create_hp_ctls(spec, spec->autocfg.hp_pins[0]);
838 if (err < 0)
839 return err;
840 err = vt1708_auto_create_analog_input_ctls(spec, &spec->autocfg);
841 if (err < 0)
842 return err;
843
844 spec->multiout.max_channels = spec->multiout.num_dacs * 2;
845
846 if (spec->autocfg.dig_out_pin)
847 spec->multiout.dig_out_nid = VT1708_DIGOUT_NID;
848 if (spec->autocfg.dig_in_pin)
849 spec->dig_in_nid = VT1708_DIGIN_NID;
850
851 if (spec->kctl_alloc)
852 spec->mixers[spec->num_mixers++] = spec->kctl_alloc;
853
854 spec->init_verbs = vt1708_volume_init_verbs;
855
856 spec->input_mux = &spec->private_imux;
857
858 return 1;
859 }
860
861 /* init callback for auto-configuration model -- overriding the default init */
862 static int via_auto_init(struct hda_codec *codec)
863 {
864 via_init(codec);
865 via_auto_init_multi_out(codec);
866 via_auto_init_hp_out(codec);
867 via_auto_init_analog_input(codec);
868 return 0;
869 }
870
871 static int patch_vt1708(struct hda_codec *codec)
872 {
873 struct via_spec *spec;
874 int err;
875
876 /* create a codec specific record */
877 spec = kcalloc(1, sizeof(*spec), GFP_KERNEL);
878 if (spec == NULL)
879 return -ENOMEM;
880
881 codec->spec = spec;
882
883 /* automatic parse from the BIOS config */
884 err = vt1708_parse_auto_config(codec);
885 if (err < 0) {
886 via_free(codec);
887 return err;
888 } else if (!err) {
889 printk(KERN_INFO "hda_codec: Cannot set up configuration "
890 "from BIOS. Using genenic mode...\n");
891 }
892
893
894 spec->stream_name_analog = "VT1708 Analog";
895 spec->stream_analog_playback = &vt1708_pcm_analog_playback;
896 spec->stream_analog_capture = &vt1708_pcm_analog_capture;
897
898 spec->stream_name_digital = "VT1708 Digital";
899 spec->stream_digital_playback = &vt1708_pcm_digital_playback;
900 spec->stream_digital_capture = &vt1708_pcm_digital_capture;
901
902
903 if (!spec->adc_nids && spec->input_mux) {
904 spec->adc_nids = vt1708_adc_nids;
905 spec->num_adc_nids = ARRAY_SIZE(vt1708_adc_nids);
906 spec->mixers[spec->num_mixers] = vt1708_capture_mixer;
907 spec->num_mixers++;
908 }
909
910 codec->patch_ops = via_patch_ops;
911
912 codec->patch_ops.init = via_auto_init;
913 #ifdef CONFIG_SND_HDA_POWER_SAVE
914 spec->loopback.amplist = vt1708_loopbacks;
915 #endif
916
917 return 0;
918 }
919
920 /* capture mixer elements */
921 static struct snd_kcontrol_new vt1709_capture_mixer[] = {
922 HDA_CODEC_VOLUME("Capture Volume", 0x14, 0x0, HDA_INPUT),
923 HDA_CODEC_MUTE("Capture Switch", 0x14, 0x0, HDA_INPUT),
924 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x15, 0x0, HDA_INPUT),
925 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x15, 0x0, HDA_INPUT),
926 HDA_CODEC_VOLUME_IDX("Capture Volume", 2, 0x16, 0x0, HDA_INPUT),
927 HDA_CODEC_MUTE_IDX("Capture Switch", 2, 0x16, 0x0, HDA_INPUT),
928 {
929 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
930 /* The multiple "Capture Source" controls confuse alsamixer
931 * So call somewhat different..
932 */
933 /* .name = "Capture Source", */
934 .name = "Input Source",
935 .count = 1,
936 .info = via_mux_enum_info,
937 .get = via_mux_enum_get,
938 .put = via_mux_enum_put,
939 },
940 { } /* end */
941 };
942
943 /*
944 * generic initialization of ADC, input mixers and output mixers
945 */
946 static struct hda_verb vt1709_10ch_volume_init_verbs[] = {
947 /*
948 * Unmute ADC0-2 and set the default input to mic-in
949 */
950 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
951 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
952 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
953
954
955 /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
956 * mixer widget
957 */
958 /* Amp Indices: AOW0=0, CD = 1, Mic1 = 2, Line = 3, Mic2 = 4 */
959 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
960 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
961 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
962 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
963 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
964
965 /*
966 * Set up output selector (0x1a, 0x1b, 0x29)
967 */
968 /* set vol=0 to output mixers */
969 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
970 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
971 {0x29, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
972
973 /*
974 * Unmute PW3 and PW4
975 */
976 {0x1f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
977 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
978
979 /* Set input of PW4 as AOW4 */
980 {0x20, AC_VERB_SET_CONNECT_SEL, 0x1},
981 /* PW9 Output enable */
982 {0x24, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
983 { }
984 };
985
986 static struct hda_pcm_stream vt1709_10ch_pcm_analog_playback = {
987 .substreams = 1,
988 .channels_min = 2,
989 .channels_max = 10,
990 .nid = 0x10, /* NID to query formats and rates */
991 .ops = {
992 .open = via_playback_pcm_open,
993 .prepare = via_playback_pcm_prepare,
994 .cleanup = via_playback_pcm_cleanup
995 },
996 };
997
998 static struct hda_pcm_stream vt1709_6ch_pcm_analog_playback = {
999 .substreams = 1,
1000 .channels_min = 2,
1001 .channels_max = 6,
1002 .nid = 0x10, /* NID to query formats and rates */
1003 .ops = {
1004 .open = via_playback_pcm_open,
1005 .prepare = via_playback_pcm_prepare,
1006 .cleanup = via_playback_pcm_cleanup
1007 },
1008 };
1009
1010 static struct hda_pcm_stream vt1709_pcm_analog_capture = {
1011 .substreams = 2,
1012 .channels_min = 2,
1013 .channels_max = 2,
1014 .nid = 0x14, /* NID to query formats and rates */
1015 .ops = {
1016 .prepare = via_capture_pcm_prepare,
1017 .cleanup = via_capture_pcm_cleanup
1018 },
1019 };
1020
1021 static struct hda_pcm_stream vt1709_pcm_digital_playback = {
1022 .substreams = 1,
1023 .channels_min = 2,
1024 .channels_max = 2,
1025 /* NID is set in via_build_pcms */
1026 .ops = {
1027 .open = via_dig_playback_pcm_open,
1028 .close = via_dig_playback_pcm_close
1029 },
1030 };
1031
1032 static struct hda_pcm_stream vt1709_pcm_digital_capture = {
1033 .substreams = 1,
1034 .channels_min = 2,
1035 .channels_max = 2,
1036 };
1037
1038 static int vt1709_auto_fill_dac_nids(struct via_spec *spec,
1039 const struct auto_pin_cfg *cfg)
1040 {
1041 int i;
1042 hda_nid_t nid;
1043
1044 if (cfg->line_outs == 4) /* 10 channels */
1045 spec->multiout.num_dacs = cfg->line_outs+1; /* AOW0~AOW4 */
1046 else if (cfg->line_outs == 3) /* 6 channels */
1047 spec->multiout.num_dacs = cfg->line_outs; /* AOW0~AOW2 */
1048
1049 spec->multiout.dac_nids = spec->private_dac_nids;
1050
1051 if (cfg->line_outs == 4) { /* 10 channels */
1052 for (i = 0; i < cfg->line_outs; i++) {
1053 nid = cfg->line_out_pins[i];
1054 if (nid) {
1055 /* config dac list */
1056 switch (i) {
1057 case AUTO_SEQ_FRONT:
1058 /* AOW0 */
1059 spec->multiout.dac_nids[i] = 0x10;
1060 break;
1061 case AUTO_SEQ_CENLFE:
1062 /* AOW2 */
1063 spec->multiout.dac_nids[i] = 0x12;
1064 break;
1065 case AUTO_SEQ_SURROUND:
1066 /* AOW3 */
1067 spec->multiout.dac_nids[i] = 0x27;
1068 break;
1069 case AUTO_SEQ_SIDE:
1070 /* AOW1 */
1071 spec->multiout.dac_nids[i] = 0x11;
1072 break;
1073 default:
1074 break;
1075 }
1076 }
1077 }
1078 spec->multiout.dac_nids[cfg->line_outs] = 0x28; /* AOW4 */
1079
1080 } else if (cfg->line_outs == 3) { /* 6 channels */
1081 for(i = 0; i < cfg->line_outs; i++) {
1082 nid = cfg->line_out_pins[i];
1083 if (nid) {
1084 /* config dac list */
1085 switch(i) {
1086 case AUTO_SEQ_FRONT:
1087 /* AOW0 */
1088 spec->multiout.dac_nids[i] = 0x10;
1089 break;
1090 case AUTO_SEQ_CENLFE:
1091 /* AOW2 */
1092 spec->multiout.dac_nids[i] = 0x12;
1093 break;
1094 case AUTO_SEQ_SURROUND:
1095 /* AOW1 */
1096 spec->multiout.dac_nids[i] = 0x11;
1097 break;
1098 default:
1099 break;
1100 }
1101 }
1102 }
1103 }
1104
1105 return 0;
1106 }
1107
1108 /* add playback controls from the parsed DAC table */
1109 static int vt1709_auto_create_multi_out_ctls(struct via_spec *spec,
1110 const struct auto_pin_cfg *cfg)
1111 {
1112 char name[32];
1113 static const char *chname[4] = { "Front", "Surround", "C/LFE", "Side" };
1114 hda_nid_t nid = 0;
1115 int i, err;
1116
1117 for (i = 0; i <= AUTO_SEQ_SIDE; i++) {
1118 nid = cfg->line_out_pins[i];
1119
1120 if (!nid)
1121 continue;
1122
1123 if (i == AUTO_SEQ_CENLFE) {
1124 /* Center/LFE */
1125 err = via_add_control(spec, VIA_CTL_WIDGET_VOL,
1126 "Center Playback Volume",
1127 HDA_COMPOSE_AMP_VAL(0x1b, 1, 0,
1128 HDA_OUTPUT));
1129 if (err < 0)
1130 return err;
1131 err = via_add_control(spec, VIA_CTL_WIDGET_VOL,
1132 "LFE Playback Volume",
1133 HDA_COMPOSE_AMP_VAL(0x1b, 2, 0,
1134 HDA_OUTPUT));
1135 if (err < 0)
1136 return err;
1137 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE,
1138 "Center Playback Switch",
1139 HDA_COMPOSE_AMP_VAL(0x1b, 1, 0,
1140 HDA_OUTPUT));
1141 if (err < 0)
1142 return err;
1143 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE,
1144 "LFE Playback Switch",
1145 HDA_COMPOSE_AMP_VAL(0x1b, 2, 0,
1146 HDA_OUTPUT));
1147 if (err < 0)
1148 return err;
1149 } else if (i == AUTO_SEQ_FRONT){
1150 /* add control to mixer index 0 */
1151 err = via_add_control(spec, VIA_CTL_WIDGET_VOL,
1152 "Master Front Playback Volume",
1153 HDA_COMPOSE_AMP_VAL(0x18, 3, 0,
1154 HDA_INPUT));
1155 if (err < 0)
1156 return err;
1157 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE,
1158 "Master Front Playback Switch",
1159 HDA_COMPOSE_AMP_VAL(0x18, 3, 0,
1160 HDA_INPUT));
1161 if (err < 0)
1162 return err;
1163
1164 /* add control to PW3 */
1165 sprintf(name, "%s Playback Volume", chname[i]);
1166 err = via_add_control(spec, VIA_CTL_WIDGET_VOL, name,
1167 HDA_COMPOSE_AMP_VAL(nid, 3, 0,
1168 HDA_OUTPUT));
1169 if (err < 0)
1170 return err;
1171 sprintf(name, "%s Playback Switch", chname[i]);
1172 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, name,
1173 HDA_COMPOSE_AMP_VAL(nid, 3, 0,
1174 HDA_OUTPUT));
1175 if (err < 0)
1176 return err;
1177 } else if (i == AUTO_SEQ_SURROUND) {
1178 sprintf(name, "%s Playback Volume", chname[i]);
1179 err = via_add_control(spec, VIA_CTL_WIDGET_VOL, name,
1180 HDA_COMPOSE_AMP_VAL(0x29, 3, 0,
1181 HDA_OUTPUT));
1182 if (err < 0)
1183 return err;
1184 sprintf(name, "%s Playback Switch", chname[i]);
1185 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, name,
1186 HDA_COMPOSE_AMP_VAL(0x29, 3, 0,
1187 HDA_OUTPUT));
1188 if (err < 0)
1189 return err;
1190 } else if (i == AUTO_SEQ_SIDE) {
1191 sprintf(name, "%s Playback Volume", chname[i]);
1192 err = via_add_control(spec, VIA_CTL_WIDGET_VOL, name,
1193 HDA_COMPOSE_AMP_VAL(0x1a, 3, 0,
1194 HDA_OUTPUT));
1195 if (err < 0)
1196 return err;
1197 sprintf(name, "%s Playback Switch", chname[i]);
1198 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, name,
1199 HDA_COMPOSE_AMP_VAL(0x1a, 3, 0,
1200 HDA_OUTPUT));
1201 if (err < 0)
1202 return err;
1203 }
1204 }
1205
1206 return 0;
1207 }
1208
1209 static int vt1709_auto_create_hp_ctls(struct via_spec *spec, hda_nid_t pin)
1210 {
1211 int err;
1212
1213 if (!pin)
1214 return 0;
1215
1216 if (spec->multiout.num_dacs == 5) /* 10 channels */
1217 spec->multiout.hp_nid = VT1709_HP_DAC_NID;
1218 else if (spec->multiout.num_dacs == 3) /* 6 channels */
1219 spec->multiout.hp_nid = 0;
1220
1221 err = via_add_control(spec, VIA_CTL_WIDGET_VOL,
1222 "Headphone Playback Volume",
1223 HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
1224 if (err < 0)
1225 return err;
1226 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE,
1227 "Headphone Playback Switch",
1228 HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
1229 if (err < 0)
1230 return err;
1231
1232 return 0;
1233 }
1234
1235 /* create playback/capture controls for input pins */
1236 static int vt1709_auto_create_analog_input_ctls(struct via_spec *spec,
1237 const struct auto_pin_cfg *cfg)
1238 {
1239 static char *labels[] = {
1240 "Mic", "Front Mic", "Line", "Front Line", "CD", "Aux", NULL
1241 };
1242 struct hda_input_mux *imux = &spec->private_imux;
1243 int i, err, idx = 0;
1244
1245 /* for internal loopback recording select */
1246 imux->items[imux->num_items].label = "Stereo Mixer";
1247 imux->items[imux->num_items].index = idx;
1248 imux->num_items++;
1249
1250 for (i = 0; i < AUTO_PIN_LAST; i++) {
1251 if (!cfg->input_pins[i])
1252 continue;
1253
1254 switch (cfg->input_pins[i]) {
1255 case 0x1d: /* Mic */
1256 idx = 2;
1257 break;
1258
1259 case 0x1e: /* Line In */
1260 idx = 3;
1261 break;
1262
1263 case 0x21: /* Front Mic */
1264 idx = 4;
1265 break;
1266
1267 case 0x23: /* CD */
1268 idx = 1;
1269 break;
1270 }
1271 err = via_new_analog_input(spec, cfg->input_pins[i], labels[i],
1272 idx, 0x18);
1273 if (err < 0)
1274 return err;
1275 imux->items[imux->num_items].label = labels[i];
1276 imux->items[imux->num_items].index = idx;
1277 imux->num_items++;
1278 }
1279 return 0;
1280 }
1281
1282 static int vt1709_parse_auto_config(struct hda_codec *codec)
1283 {
1284 struct via_spec *spec = codec->spec;
1285 int err;
1286
1287 err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, NULL);
1288 if (err < 0)
1289 return err;
1290 err = vt1709_auto_fill_dac_nids(spec, &spec->autocfg);
1291 if (err < 0)
1292 return err;
1293 if (!spec->autocfg.line_outs && !spec->autocfg.hp_pins[0])
1294 return 0; /* can't find valid BIOS pin config */
1295
1296 err = vt1709_auto_create_multi_out_ctls(spec, &spec->autocfg);
1297 if (err < 0)
1298 return err;
1299 err = vt1709_auto_create_hp_ctls(spec, spec->autocfg.hp_pins[0]);
1300 if (err < 0)
1301 return err;
1302 err = vt1709_auto_create_analog_input_ctls(spec, &spec->autocfg);
1303 if (err < 0)
1304 return err;
1305
1306 spec->multiout.max_channels = spec->multiout.num_dacs * 2;
1307
1308 if (spec->autocfg.dig_out_pin)
1309 spec->multiout.dig_out_nid = VT1709_DIGOUT_NID;
1310 if (spec->autocfg.dig_in_pin)
1311 spec->dig_in_nid = VT1709_DIGIN_NID;
1312
1313 if (spec->kctl_alloc)
1314 spec->mixers[spec->num_mixers++] = spec->kctl_alloc;
1315
1316 spec->input_mux = &spec->private_imux;
1317
1318 return 1;
1319 }
1320
1321 #ifdef CONFIG_SND_HDA_POWER_SAVE
1322 static struct hda_amp_list vt1709_loopbacks[] = {
1323 { 0x18, HDA_INPUT, 1 },
1324 { 0x18, HDA_INPUT, 2 },
1325 { 0x18, HDA_INPUT, 3 },
1326 { 0x18, HDA_INPUT, 4 },
1327 { } /* end */
1328 };
1329 #endif
1330
1331 static int patch_vt1709_10ch(struct hda_codec *codec)
1332 {
1333 struct via_spec *spec;
1334 int err;
1335
1336 /* create a codec specific record */
1337 spec = kcalloc(1, sizeof(*spec), GFP_KERNEL);
1338 if (spec == NULL)
1339 return -ENOMEM;
1340
1341 codec->spec = spec;
1342
1343 err = vt1709_parse_auto_config(codec);
1344 if (err < 0) {
1345 via_free(codec);
1346 return err;
1347 } else if (!err) {
1348 printk(KERN_INFO "hda_codec: Cannot set up configuration. "
1349 "Using genenic mode...\n");
1350 }
1351
1352 spec->init_verbs = vt1709_10ch_volume_init_verbs;
1353
1354 spec->stream_name_analog = "VT1709 Analog";
1355 spec->stream_analog_playback = &vt1709_10ch_pcm_analog_playback;
1356 spec->stream_analog_capture = &vt1709_pcm_analog_capture;
1357
1358 spec->stream_name_digital = "VT1709 Digital";
1359 spec->stream_digital_playback = &vt1709_pcm_digital_playback;
1360 spec->stream_digital_capture = &vt1709_pcm_digital_capture;
1361
1362
1363 if (!spec->adc_nids && spec->input_mux) {
1364 spec->adc_nids = vt1709_adc_nids;
1365 spec->num_adc_nids = ARRAY_SIZE(vt1709_adc_nids);
1366 spec->mixers[spec->num_mixers] = vt1709_capture_mixer;
1367 spec->num_mixers++;
1368 }
1369
1370 codec->patch_ops = via_patch_ops;
1371
1372 codec->patch_ops.init = via_auto_init;
1373 #ifdef CONFIG_SND_HDA_POWER_SAVE
1374 spec->loopback.amplist = vt1709_loopbacks;
1375 #endif
1376
1377 return 0;
1378 }
1379 /*
1380 * generic initialization of ADC, input mixers and output mixers
1381 */
1382 static struct hda_verb vt1709_6ch_volume_init_verbs[] = {
1383 /*
1384 * Unmute ADC0-2 and set the default input to mic-in
1385 */
1386 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
1387 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
1388 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
1389
1390
1391 /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
1392 * mixer widget
1393 */
1394 /* Amp Indices: AOW0=0, CD = 1, Mic1 = 2, Line = 3, Mic2 = 4 */
1395 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
1396 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
1397 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
1398 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
1399 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
1400
1401 /*
1402 * Set up output selector (0x1a, 0x1b, 0x29)
1403 */
1404 /* set vol=0 to output mixers */
1405 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
1406 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
1407 {0x29, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
1408
1409 /*
1410 * Unmute PW3 and PW4
1411 */
1412 {0x1f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
1413 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
1414
1415 /* Set input of PW4 as MW0 */
1416 {0x20, AC_VERB_SET_CONNECT_SEL, 0},
1417 /* PW9 Output enable */
1418 {0x24, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
1419 { }
1420 };
1421
1422 static int patch_vt1709_6ch(struct hda_codec *codec)
1423 {
1424 struct via_spec *spec;
1425 int err;
1426
1427 /* create a codec specific record */
1428 spec = kcalloc(1, sizeof(*spec), GFP_KERNEL);
1429 if (spec == NULL)
1430 return -ENOMEM;
1431
1432 codec->spec = spec;
1433
1434 err = vt1709_parse_auto_config(codec);
1435 if (err < 0) {
1436 via_free(codec);
1437 return err;
1438 } else if (!err) {
1439 printk(KERN_INFO "hda_codec: Cannot set up configuration. "
1440 "Using genenic mode...\n");
1441 }
1442
1443 spec->init_verbs = vt1709_6ch_volume_init_verbs;
1444
1445 spec->stream_name_analog = "VT1709 Analog";
1446 spec->stream_analog_playback = &vt1709_6ch_pcm_analog_playback;
1447 spec->stream_analog_capture = &vt1709_pcm_analog_capture;
1448
1449 spec->stream_name_digital = "VT1709 Digital";
1450 spec->stream_digital_playback = &vt1709_pcm_digital_playback;
1451 spec->stream_digital_capture = &vt1709_pcm_digital_capture;
1452
1453
1454 if (!spec->adc_nids && spec->input_mux) {
1455 spec->adc_nids = vt1709_adc_nids;
1456 spec->num_adc_nids = ARRAY_SIZE(vt1709_adc_nids);
1457 spec->mixers[spec->num_mixers] = vt1709_capture_mixer;
1458 spec->num_mixers++;
1459 }
1460
1461 codec->patch_ops = via_patch_ops;
1462
1463 codec->patch_ops.init = via_auto_init;
1464 #ifdef CONFIG_SND_HDA_POWER_SAVE
1465 spec->loopback.amplist = vt1709_loopbacks;
1466 #endif
1467 return 0;
1468 }
1469
1470 /* capture mixer elements */
1471 static struct snd_kcontrol_new vt1708B_capture_mixer[] = {
1472 HDA_CODEC_VOLUME("Capture Volume", 0x13, 0x0, HDA_INPUT),
1473 HDA_CODEC_MUTE("Capture Switch", 0x13, 0x0, HDA_INPUT),
1474 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x14, 0x0, HDA_INPUT),
1475 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x14, 0x0, HDA_INPUT),
1476 {
1477 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1478 /* The multiple "Capture Source" controls confuse alsamixer
1479 * So call somewhat different..
1480 */
1481 /* .name = "Capture Source", */
1482 .name = "Input Source",
1483 .count = 1,
1484 .info = via_mux_enum_info,
1485 .get = via_mux_enum_get,
1486 .put = via_mux_enum_put,
1487 },
1488 { } /* end */
1489 };
1490 /*
1491 * generic initialization of ADC, input mixers and output mixers
1492 */
1493 static struct hda_verb vt1708B_8ch_volume_init_verbs[] = {
1494 /*
1495 * Unmute ADC0-1 and set the default input to mic-in
1496 */
1497 {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
1498 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
1499
1500
1501 /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
1502 * mixer widget
1503 */
1504 /* Amp Indices: CD = 1, Mic1 = 2, Line = 3, Mic2 = 4 */
1505 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
1506 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
1507 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
1508 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
1509 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
1510
1511 /*
1512 * Set up output mixers
1513 */
1514 /* set vol=0 to output mixers */
1515 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
1516 {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
1517 {0x27, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
1518
1519 /* Setup default input to PW4 */
1520 {0x1d, AC_VERB_SET_CONNECT_SEL, 0x1},
1521 /* PW9 Output enable */
1522 {0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
1523 /* PW10 Input enable */
1524 {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
1525 { }
1526 };
1527
1528 static struct hda_verb vt1708B_4ch_volume_init_verbs[] = {
1529 /*
1530 * Unmute ADC0-1 and set the default input to mic-in
1531 */
1532 {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
1533 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
1534
1535
1536 /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
1537 * mixer widget
1538 */
1539 /* Amp Indices: CD = 1, Mic1 = 2, Line = 3, Mic2 = 4 */
1540 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
1541 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
1542 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
1543 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
1544 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
1545
1546 /*
1547 * Set up output mixers
1548 */
1549 /* set vol=0 to output mixers */
1550 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
1551 {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
1552 {0x27, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
1553
1554 /* Setup default input of PW4 to MW0 */
1555 {0x1d, AC_VERB_SET_CONNECT_SEL, 0x0},
1556 /* PW9 Output enable */
1557 {0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
1558 /* PW10 Input enable */
1559 {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
1560 { }
1561 };
1562
1563 static struct hda_pcm_stream vt1708B_8ch_pcm_analog_playback = {
1564 .substreams = 1,
1565 .channels_min = 2,
1566 .channels_max = 8,
1567 .nid = 0x10, /* NID to query formats and rates */
1568 .ops = {
1569 .open = via_playback_pcm_open,
1570 .prepare = via_playback_pcm_prepare,
1571 .cleanup = via_playback_pcm_cleanup
1572 },
1573 };
1574
1575 static struct hda_pcm_stream vt1708B_4ch_pcm_analog_playback = {
1576 .substreams = 1,
1577 .channels_min = 2,
1578 .channels_max = 4,
1579 .nid = 0x10, /* NID to query formats and rates */
1580 .ops = {
1581 .open = via_playback_pcm_open,
1582 .prepare = via_playback_pcm_prepare,
1583 .cleanup = via_playback_pcm_cleanup
1584 },
1585 };
1586
1587 static struct hda_pcm_stream vt1708B_pcm_analog_capture = {
1588 .substreams = 2,
1589 .channels_min = 2,
1590 .channels_max = 2,
1591 .nid = 0x13, /* NID to query formats and rates */
1592 .ops = {
1593 .prepare = via_capture_pcm_prepare,
1594 .cleanup = via_capture_pcm_cleanup
1595 },
1596 };
1597
1598 static struct hda_pcm_stream vt1708B_pcm_digital_playback = {
1599 .substreams = 1,
1600 .channels_min = 2,
1601 .channels_max = 2,
1602 /* NID is set in via_build_pcms */
1603 .ops = {
1604 .open = via_dig_playback_pcm_open,
1605 .close = via_dig_playback_pcm_close,
1606 .prepare = via_dig_playback_pcm_prepare
1607 },
1608 };
1609
1610 static struct hda_pcm_stream vt1708B_pcm_digital_capture = {
1611 .substreams = 1,
1612 .channels_min = 2,
1613 .channels_max = 2,
1614 };
1615
1616 /* fill in the dac_nids table from the parsed pin configuration */
1617 static int vt1708B_auto_fill_dac_nids(struct via_spec *spec,
1618 const struct auto_pin_cfg *cfg)
1619 {
1620 int i;
1621 hda_nid_t nid;
1622
1623 spec->multiout.num_dacs = cfg->line_outs;
1624
1625 spec->multiout.dac_nids = spec->private_dac_nids;
1626
1627 for (i = 0; i < 4; i++) {
1628 nid = cfg->line_out_pins[i];
1629 if (nid) {
1630 /* config dac list */
1631 switch (i) {
1632 case AUTO_SEQ_FRONT:
1633 spec->multiout.dac_nids[i] = 0x10;
1634 break;
1635 case AUTO_SEQ_CENLFE:
1636 spec->multiout.dac_nids[i] = 0x24;
1637 break;
1638 case AUTO_SEQ_SURROUND:
1639 spec->multiout.dac_nids[i] = 0x25;
1640 break;
1641 case AUTO_SEQ_SIDE:
1642 spec->multiout.dac_nids[i] = 0x11;
1643 break;
1644 }
1645 }
1646 }
1647
1648 return 0;
1649 }
1650
1651 /* add playback controls from the parsed DAC table */
1652 static int vt1708B_auto_create_multi_out_ctls(struct via_spec *spec,
1653 const struct auto_pin_cfg *cfg)
1654 {
1655 char name[32];
1656 static const char *chname[4] = { "Front", "Surround", "C/LFE", "Side" };
1657 hda_nid_t nid_vols[] = {0x16, 0x27, 0x26, 0x18};
1658 hda_nid_t nid, nid_vol = 0;
1659 int i, err;
1660
1661 for (i = 0; i <= AUTO_SEQ_SIDE; i++) {
1662 nid = cfg->line_out_pins[i];
1663
1664 if (!nid)
1665 continue;
1666
1667 nid_vol = nid_vols[i];
1668
1669 if (i == AUTO_SEQ_CENLFE) {
1670 /* Center/LFE */
1671 err = via_add_control(spec, VIA_CTL_WIDGET_VOL,
1672 "Center Playback Volume",
1673 HDA_COMPOSE_AMP_VAL(nid_vol, 1, 0,
1674 HDA_OUTPUT));
1675 if (err < 0)
1676 return err;
1677 err = via_add_control(spec, VIA_CTL_WIDGET_VOL,
1678 "LFE Playback Volume",
1679 HDA_COMPOSE_AMP_VAL(nid_vol, 2, 0,
1680 HDA_OUTPUT));
1681 if (err < 0)
1682 return err;
1683 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE,
1684 "Center Playback Switch",
1685 HDA_COMPOSE_AMP_VAL(nid_vol, 1, 0,
1686 HDA_OUTPUT));
1687 if (err < 0)
1688 return err;
1689 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE,
1690 "LFE Playback Switch",
1691 HDA_COMPOSE_AMP_VAL(nid_vol, 2, 0,
1692 HDA_OUTPUT));
1693 if (err < 0)
1694 return err;
1695 } else if (i == AUTO_SEQ_FRONT) {
1696 /* add control to mixer index 0 */
1697 err = via_add_control(spec, VIA_CTL_WIDGET_VOL,
1698 "Master Front Playback Volume",
1699 HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0,
1700 HDA_INPUT));
1701 if (err < 0)
1702 return err;
1703 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE,
1704 "Master Front Playback Switch",
1705 HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0,
1706 HDA_INPUT));
1707 if (err < 0)
1708 return err;
1709
1710 /* add control to PW3 */
1711 sprintf(name, "%s Playback Volume", chname[i]);
1712 err = via_add_control(spec, VIA_CTL_WIDGET_VOL, name,
1713 HDA_COMPOSE_AMP_VAL(nid, 3, 0,
1714 HDA_OUTPUT));
1715 if (err < 0)
1716 return err;
1717 sprintf(name, "%s Playback Switch", chname[i]);
1718 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, name,
1719 HDA_COMPOSE_AMP_VAL(nid, 3, 0,
1720 HDA_OUTPUT));
1721 if (err < 0)
1722 return err;
1723 } else {
1724 sprintf(name, "%s Playback Volume", chname[i]);
1725 err = via_add_control(spec, VIA_CTL_WIDGET_VOL, name,
1726 HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0,
1727 HDA_OUTPUT));
1728 if (err < 0)
1729 return err;
1730 sprintf(name, "%s Playback Switch", chname[i]);
1731 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, name,
1732 HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0,
1733 HDA_OUTPUT));
1734 if (err < 0)
1735 return err;
1736 }
1737 }
1738
1739 return 0;
1740 }
1741
1742 static int vt1708B_auto_create_hp_ctls(struct via_spec *spec, hda_nid_t pin)
1743 {
1744 int err;
1745
1746 if (!pin)
1747 return 0;
1748
1749 spec->multiout.hp_nid = VT1708B_HP_NID; /* AOW3 */
1750
1751 err = via_add_control(spec, VIA_CTL_WIDGET_VOL,
1752 "Headphone Playback Volume",
1753 HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
1754 if (err < 0)
1755 return err;
1756 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE,
1757 "Headphone Playback Switch",
1758 HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
1759 if (err < 0)
1760 return err;
1761
1762 return 0;
1763 }
1764
1765 /* create playback/capture controls for input pins */
1766 static int vt1708B_auto_create_analog_input_ctls(struct via_spec *spec,
1767 const struct auto_pin_cfg *cfg)
1768 {
1769 static char *labels[] = {
1770 "Mic", "Front Mic", "Line", "Front Line", "CD", "Aux", NULL
1771 };
1772 struct hda_input_mux *imux = &spec->private_imux;
1773 int i, err, idx = 0;
1774
1775 /* for internal loopback recording select */
1776 imux->items[imux->num_items].label = "Stereo Mixer";
1777 imux->items[imux->num_items].index = idx;
1778 imux->num_items++;
1779
1780 for (i = 0; i < AUTO_PIN_LAST; i++) {
1781 if (!cfg->input_pins[i])
1782 continue;
1783
1784 switch (cfg->input_pins[i]) {
1785 case 0x1a: /* Mic */
1786 idx = 2;
1787 break;
1788
1789 case 0x1b: /* Line In */
1790 idx = 3;
1791 break;
1792
1793 case 0x1e: /* Front Mic */
1794 idx = 4;
1795 break;
1796
1797 case 0x1f: /* CD */
1798 idx = 1;
1799 break;
1800 }
1801 err = via_new_analog_input(spec, cfg->input_pins[i], labels[i],
1802 idx, 0x16);
1803 if (err < 0)
1804 return err;
1805 imux->items[imux->num_items].label = labels[i];
1806 imux->items[imux->num_items].index = idx;
1807 imux->num_items++;
1808 }
1809 return 0;
1810 }
1811
1812 static int vt1708B_parse_auto_config(struct hda_codec *codec)
1813 {
1814 struct via_spec *spec = codec->spec;
1815 int err;
1816
1817 err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, NULL);
1818 if (err < 0)
1819 return err;
1820 err = vt1708B_auto_fill_dac_nids(spec, &spec->autocfg);
1821 if (err < 0)
1822 return err;
1823 if (!spec->autocfg.line_outs && !spec->autocfg.hp_pins[0])
1824 return 0; /* can't find valid BIOS pin config */
1825
1826 err = vt1708B_auto_create_multi_out_ctls(spec, &spec->autocfg);
1827 if (err < 0)
1828 return err;
1829 err = vt1708B_auto_create_hp_ctls(spec, spec->autocfg.hp_pins[0]);
1830 if (err < 0)
1831 return err;
1832 err = vt1708B_auto_create_analog_input_ctls(spec, &spec->autocfg);
1833 if (err < 0)
1834 return err;
1835
1836 spec->multiout.max_channels = spec->multiout.num_dacs * 2;
1837
1838 if (spec->autocfg.dig_out_pin)
1839 spec->multiout.dig_out_nid = VT1708B_DIGOUT_NID;
1840 if (spec->autocfg.dig_in_pin)
1841 spec->dig_in_nid = VT1708B_DIGIN_NID;
1842
1843 if (spec->kctl_alloc)
1844 spec->mixers[spec->num_mixers++] = spec->kctl_alloc;
1845
1846 spec->input_mux = &spec->private_imux;
1847
1848 return 1;
1849 }
1850
1851 #ifdef CONFIG_SND_HDA_POWER_SAVE
1852 static struct hda_amp_list vt1708B_loopbacks[] = {
1853 { 0x16, HDA_INPUT, 1 },
1854 { 0x16, HDA_INPUT, 2 },
1855 { 0x16, HDA_INPUT, 3 },
1856 { 0x16, HDA_INPUT, 4 },
1857 { } /* end */
1858 };
1859 #endif
1860
1861 static int patch_vt1708B_8ch(struct hda_codec *codec)
1862 {
1863 struct via_spec *spec;
1864 int err;
1865
1866 /* create a codec specific record */
1867 spec = kcalloc(1, sizeof(*spec), GFP_KERNEL);
1868 if (spec == NULL)
1869 return -ENOMEM;
1870
1871 codec->spec = spec;
1872
1873 /* automatic parse from the BIOS config */
1874 err = vt1708B_parse_auto_config(codec);
1875 if (err < 0) {
1876 via_free(codec);
1877 return err;
1878 } else if (!err) {
1879 printk(KERN_INFO "hda_codec: Cannot set up configuration "
1880 "from BIOS. Using genenic mode...\n");
1881 }
1882
1883 spec->init_verbs = vt1708B_8ch_volume_init_verbs;
1884
1885 spec->stream_name_analog = "VT1708B Analog";
1886 spec->stream_analog_playback = &vt1708B_8ch_pcm_analog_playback;
1887 spec->stream_analog_capture = &vt1708B_pcm_analog_capture;
1888
1889 spec->stream_name_digital = "VT1708B Digital";
1890 spec->stream_digital_playback = &vt1708B_pcm_digital_playback;
1891 spec->stream_digital_capture = &vt1708B_pcm_digital_capture;
1892
1893 if (!spec->adc_nids && spec->input_mux) {
1894 spec->adc_nids = vt1708B_adc_nids;
1895 spec->num_adc_nids = ARRAY_SIZE(vt1708B_adc_nids);
1896 spec->mixers[spec->num_mixers] = vt1708B_capture_mixer;
1897 spec->num_mixers++;
1898 }
1899
1900 codec->patch_ops = via_patch_ops;
1901
1902 codec->patch_ops.init = via_auto_init;
1903 #ifdef CONFIG_SND_HDA_POWER_SAVE
1904 spec->loopback.amplist = vt1708B_loopbacks;
1905 #endif
1906
1907 return 0;
1908 }
1909
1910 static int patch_vt1708B_4ch(struct hda_codec *codec)
1911 {
1912 struct via_spec *spec;
1913 int err;
1914
1915 /* create a codec specific record */
1916 spec = kcalloc(1, sizeof(*spec), GFP_KERNEL);
1917 if (spec == NULL)
1918 return -ENOMEM;
1919
1920 codec->spec = spec;
1921
1922 /* automatic parse from the BIOS config */
1923 err = vt1708B_parse_auto_config(codec);
1924 if (err < 0) {
1925 via_free(codec);
1926 return err;
1927 } else if (!err) {
1928 printk(KERN_INFO "hda_codec: Cannot set up configuration "
1929 "from BIOS. Using genenic mode...\n");
1930 }
1931
1932 spec->init_verbs = vt1708B_4ch_volume_init_verbs;
1933
1934 spec->stream_name_analog = "VT1708B Analog";
1935 spec->stream_analog_playback = &vt1708B_4ch_pcm_analog_playback;
1936 spec->stream_analog_capture = &vt1708B_pcm_analog_capture;
1937
1938 spec->stream_name_digital = "VT1708B Digital";
1939 spec->stream_digital_playback = &vt1708B_pcm_digital_playback;
1940 spec->stream_digital_capture = &vt1708B_pcm_digital_capture;
1941
1942 if (!spec->adc_nids && spec->input_mux) {
1943 spec->adc_nids = vt1708B_adc_nids;
1944 spec->num_adc_nids = ARRAY_SIZE(vt1708B_adc_nids);
1945 spec->mixers[spec->num_mixers] = vt1708B_capture_mixer;
1946 spec->num_mixers++;
1947 }
1948
1949 codec->patch_ops = via_patch_ops;
1950
1951 codec->patch_ops.init = via_auto_init;
1952 #ifdef CONFIG_SND_HDA_POWER_SAVE
1953 spec->loopback.amplist = vt1708B_loopbacks;
1954 #endif
1955
1956 return 0;
1957 }
1958
1959 /*
1960 * patch entries
1961 */
1962 struct hda_codec_preset snd_hda_preset_via[] = {
1963 { .id = 0x11061708, .name = "VIA VT1708", .patch = patch_vt1708},
1964 { .id = 0x11061709, .name = "VIA VT1708", .patch = patch_vt1708},
1965 { .id = 0x1106170A, .name = "VIA VT1708", .patch = patch_vt1708},
1966 { .id = 0x1106170B, .name = "VIA VT1708", .patch = patch_vt1708},
1967 { .id = 0x1106E710, .name = "VIA VT1709 10-Ch",
1968 .patch = patch_vt1709_10ch},
1969 { .id = 0x1106E711, .name = "VIA VT1709 10-Ch",
1970 .patch = patch_vt1709_10ch},
1971 { .id = 0x1106E712, .name = "VIA VT1709 10-Ch",
1972 .patch = patch_vt1709_10ch},
1973 { .id = 0x1106E713, .name = "VIA VT1709 10-Ch",
1974 .patch = patch_vt1709_10ch},
1975 { .id = 0x1106E714, .name = "VIA VT1709 6-Ch",
1976 .patch = patch_vt1709_6ch},
1977 { .id = 0x1106E715, .name = "VIA VT1709 6-Ch",
1978 .patch = patch_vt1709_6ch},
1979 { .id = 0x1106E716, .name = "VIA VT1709 6-Ch",
1980 .patch = patch_vt1709_6ch},
1981 { .id = 0x1106E717, .name = "VIA VT1709 6-Ch",
1982 .patch = patch_vt1709_6ch},
1983 { .id = 0x1106E720, .name = "VIA VT1708B 8-Ch",
1984 .patch = patch_vt1708B_8ch},
1985 { .id = 0x1106E721, .name = "VIA VT1708B 8-Ch",
1986 .patch = patch_vt1708B_8ch},
1987 { .id = 0x1106E722, .name = "VIA VT1708B 8-Ch",
1988 .patch = patch_vt1708B_8ch},
1989 { .id = 0x1106E723, .name = "VIA VT1708B 8-Ch",
1990 .patch = patch_vt1708B_8ch},
1991 { .id = 0x1106E724, .name = "VIA VT1708B 4-Ch",
1992 .patch = patch_vt1708B_4ch},
1993 { .id = 0x1106E725, .name = "VIA VT1708B 4-Ch",
1994 .patch = patch_vt1708B_4ch},
1995 { .id = 0x1106E726, .name = "VIA VT1708B 4-Ch",
1996 .patch = patch_vt1708B_4ch},
1997 { .id = 0x1106E727, .name = "VIA VT1708B 4-Ch",
1998 .patch = patch_vt1708B_4ch},
1999 {} /* terminator */
2000 };
mah project overlay