?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
ALSA: hda - Create HP-vol control properly for VIA codecs
[linux-2.6/kvm.git] / sound / pci / hda / patch_via.c
blob8d46a0f937a9911d6e56d52dc5392a3b3a187993
1 /*
2 * Universal Interface for Intel High Definition Audio Codec
3 *
4 * HD audio interface patch for VIA VT17xx/VT18xx/VT20xx codec
5 *
6 * (C) 2006-2009 VIA Technology, Inc.
7 * (C) 2006-2008 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 /* 2009-02-16 Logan Li Add support for VT1718S */
40 /* 2009-03-13 Logan Li Add support for VT1716S */
41 /* 2009-04-14 Lydai Wang Add support for VT1828S and VT2020 */
42 /* 2009-07-08 Lydia Wang Add support for VT2002P */
43 /* 2009-07-21 Lydia Wang Add support for VT1812 */
44 /* 2009-09-19 Lydia Wang Add support for VT1818S */
45 /* */
46 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
47
48
49 #include <linux/init.h>
50 #include <linux/delay.h>
51 #include <linux/slab.h>
52 #include <sound/core.h>
53 #include <sound/asoundef.h>
54 #include "hda_codec.h"
55 #include "hda_local.h"
56
57 /* Pin Widget NID */
58 #define VT1708_HP_PIN_NID 0x20
59 #define VT1708_CD_PIN_NID 0x24
60
61 enum VIA_HDA_CODEC {
62 UNKNOWN = -1,
63 VT1708,
64 VT1709_10CH,
65 VT1709_6CH,
66 VT1708B_8CH,
67 VT1708B_4CH,
68 VT1708S,
69 VT1708BCE,
70 VT1702,
71 VT1718S,
72 VT1716S,
73 VT2002P,
74 VT1812,
75 VT1802,
76 CODEC_TYPES,
77 };
78
79 #define VT2002P_COMPATIBLE(spec) \
80 ((spec)->codec_type == VT2002P ||\
81 (spec)->codec_type == VT1812 ||\
82 (spec)->codec_type == VT1802)
83
84 #define MAX_NID_PATH_DEPTH 5
85
86 /* output-path: DAC -> ... -> pin
87 * idx[] contains the source index number of the next widget;
88 * e.g. idx[0] is the index of the DAC selected by path[1] widget
89 * multi[] indicates whether it's a selector widget with multi-connectors
90 * (i.e. the connection selection is mandatory)
91 * vol_ctl and mute_ctl contains the NIDs for the assigned mixers
92 */
93 struct nid_path {
94 int depth;
95 hda_nid_t path[MAX_NID_PATH_DEPTH];
96 unsigned char idx[MAX_NID_PATH_DEPTH];
97 unsigned char multi[MAX_NID_PATH_DEPTH];
98 unsigned int vol_ctl;
99 unsigned int mute_ctl;
100 };
101
102 /* input-path */
103 struct via_input {
104 hda_nid_t pin; /* input-pin or aa-mix */
105 int adc_idx; /* ADC index to be used */
106 int mux_idx; /* MUX index (if any) */
107 const char *label; /* input-source label */
108 };
109
110 #define VIA_MAX_ADCS 3
111
112 struct via_spec {
113 /* codec parameterization */
114 const struct snd_kcontrol_new *mixers[6];
115 unsigned int num_mixers;
116
117 const struct hda_verb *init_verbs[5];
118 unsigned int num_iverbs;
119
120 char stream_name_analog[32];
121 char stream_name_hp[32];
122 const struct hda_pcm_stream *stream_analog_playback;
123 const struct hda_pcm_stream *stream_analog_capture;
124
125 char stream_name_digital[32];
126 const struct hda_pcm_stream *stream_digital_playback;
127 const struct hda_pcm_stream *stream_digital_capture;
128
129 /* playback */
130 struct hda_multi_out multiout;
131 hda_nid_t slave_dig_outs[2];
132 hda_nid_t hp_dac_nid;
133 bool hp_indep_shared; /* indep HP-DAC is shared with side ch */
134 int num_active_streams;
135 int dac_mixer_idx;
136
137 struct nid_path out_path[HDA_SIDE + 1];
138 struct nid_path hp_path;
139 struct nid_path hp_dep_path;
140 struct nid_path speaker_path;
141
142 /* capture */
143 unsigned int num_adc_nids;
144 hda_nid_t adc_nids[VIA_MAX_ADCS];
145 hda_nid_t mux_nids[VIA_MAX_ADCS];
146 hda_nid_t aa_mix_nid;
147 hda_nid_t dig_in_nid;
148
149 /* capture source */
150 bool dyn_adc_switch;
151 int num_inputs;
152 struct via_input inputs[AUTO_CFG_MAX_INS + 1];
153 unsigned int cur_mux[VIA_MAX_ADCS];
154
155 /* dynamic ADC switching */
156 hda_nid_t cur_adc;
157 unsigned int cur_adc_stream_tag;
158 unsigned int cur_adc_format;
159
160 /* PCM information */
161 struct hda_pcm pcm_rec[3];
162
163 /* dynamic controls, init_verbs and input_mux */
164 struct auto_pin_cfg autocfg;
165 struct snd_array kctls;
166 hda_nid_t private_dac_nids[AUTO_CFG_MAX_OUTS];
167
168 /* HP mode source */
169 unsigned int hp_independent_mode;
170 unsigned int dmic_enabled;
171 unsigned int no_pin_power_ctl;
172 enum VIA_HDA_CODEC codec_type;
173
174 /* smart51 setup */
175 unsigned int smart51_nums;
176 hda_nid_t smart51_pins[2];
177 int smart51_idxs[2];
178 const char *smart51_labels[2];
179 unsigned int smart51_enabled;
180
181 /* work to check hp jack state */
182 struct hda_codec *codec;
183 struct delayed_work vt1708_hp_work;
184 int vt1708_jack_detect;
185 int vt1708_hp_present;
186
187 void (*set_widgets_power_state)(struct hda_codec *codec);
188
189 struct hda_loopback_check loopback;
190 int num_loopbacks;
191 struct hda_amp_list loopback_list[8];
192
193 /* bind capture-volume */
194 struct hda_bind_ctls *bind_cap_vol;
195 struct hda_bind_ctls *bind_cap_sw;
196 };
197
198 static enum VIA_HDA_CODEC get_codec_type(struct hda_codec *codec);
199 static struct via_spec * via_new_spec(struct hda_codec *codec)
200 {
201 struct via_spec *spec;
202
203 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
204 if (spec == NULL)
205 return NULL;
206
207 codec->spec = spec;
208 spec->codec = codec;
209 spec->codec_type = get_codec_type(codec);
210 /* VT1708BCE & VT1708S are almost same */
211 if (spec->codec_type == VT1708BCE)
212 spec->codec_type = VT1708S;
213 return spec;
214 }
215
216 static enum VIA_HDA_CODEC get_codec_type(struct hda_codec *codec)
217 {
218 u32 vendor_id = codec->vendor_id;
219 u16 ven_id = vendor_id >> 16;
220 u16 dev_id = vendor_id & 0xffff;
221 enum VIA_HDA_CODEC codec_type;
222
223 /* get codec type */
224 if (ven_id != 0x1106)
225 codec_type = UNKNOWN;
226 else if (dev_id >= 0x1708 && dev_id <= 0x170b)
227 codec_type = VT1708;
228 else if (dev_id >= 0xe710 && dev_id <= 0xe713)
229 codec_type = VT1709_10CH;
230 else if (dev_id >= 0xe714 && dev_id <= 0xe717)
231 codec_type = VT1709_6CH;
232 else if (dev_id >= 0xe720 && dev_id <= 0xe723) {
233 codec_type = VT1708B_8CH;
234 if (snd_hda_param_read(codec, 0x16, AC_PAR_CONNLIST_LEN) == 0x7)
235 codec_type = VT1708BCE;
236 } else if (dev_id >= 0xe724 && dev_id <= 0xe727)
237 codec_type = VT1708B_4CH;
238 else if ((dev_id & 0xfff) == 0x397
239 && (dev_id >> 12) < 8)
240 codec_type = VT1708S;
241 else if ((dev_id & 0xfff) == 0x398
242 && (dev_id >> 12) < 8)
243 codec_type = VT1702;
244 else if ((dev_id & 0xfff) == 0x428
245 && (dev_id >> 12) < 8)
246 codec_type = VT1718S;
247 else if (dev_id == 0x0433 || dev_id == 0xa721)
248 codec_type = VT1716S;
249 else if (dev_id == 0x0441 || dev_id == 0x4441)
250 codec_type = VT1718S;
251 else if (dev_id == 0x0438 || dev_id == 0x4438)
252 codec_type = VT2002P;
253 else if (dev_id == 0x0448)
254 codec_type = VT1812;
255 else if (dev_id == 0x0440)
256 codec_type = VT1708S;
257 else if ((dev_id & 0xfff) == 0x446)
258 codec_type = VT1802;
259 else
260 codec_type = UNKNOWN;
261 return codec_type;
262 };
263
264 #define VIA_JACK_EVENT 0x20
265 #define VIA_HP_EVENT 0x01
266 #define VIA_GPIO_EVENT 0x02
267 #define VIA_LINE_EVENT 0x03
268
269 enum {
270 VIA_CTL_WIDGET_VOL,
271 VIA_CTL_WIDGET_MUTE,
272 VIA_CTL_WIDGET_ANALOG_MUTE,
273 };
274
275 static void analog_low_current_mode(struct hda_codec *codec);
276 static bool is_aa_path_mute(struct hda_codec *codec);
277
278 static void vt1708_start_hp_work(struct via_spec *spec)
279 {
280 if (spec->codec_type != VT1708 || spec->autocfg.hp_pins[0] == 0)
281 return;
282 snd_hda_codec_write(spec->codec, 0x1, 0, 0xf81,
283 !spec->vt1708_jack_detect);
284 if (!delayed_work_pending(&spec->vt1708_hp_work))
285 schedule_delayed_work(&spec->vt1708_hp_work,
286 msecs_to_jiffies(100));
287 }
288
289 static void vt1708_stop_hp_work(struct via_spec *spec)
290 {
291 if (spec->codec_type != VT1708 || spec->autocfg.hp_pins[0] == 0)
292 return;
293 if (snd_hda_get_bool_hint(spec->codec, "analog_loopback_hp_detect") == 1
294 && !is_aa_path_mute(spec->codec))
295 return;
296 snd_hda_codec_write(spec->codec, 0x1, 0, 0xf81,
297 !spec->vt1708_jack_detect);
298 cancel_delayed_work_sync(&spec->vt1708_hp_work);
299 }
300
301 static void set_widgets_power_state(struct hda_codec *codec)
302 {
303 struct via_spec *spec = codec->spec;
304 if (spec->set_widgets_power_state)
305 spec->set_widgets_power_state(codec);
306 }
307
308 static int analog_input_switch_put(struct snd_kcontrol *kcontrol,
309 struct snd_ctl_elem_value *ucontrol)
310 {
311 int change = snd_hda_mixer_amp_switch_put(kcontrol, ucontrol);
312 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
313
314 set_widgets_power_state(codec);
315 analog_low_current_mode(snd_kcontrol_chip(kcontrol));
316 if (snd_hda_get_bool_hint(codec, "analog_loopback_hp_detect") == 1) {
317 if (is_aa_path_mute(codec))
318 vt1708_start_hp_work(codec->spec);
319 else
320 vt1708_stop_hp_work(codec->spec);
321 }
322 return change;
323 }
324
325 /* modify .put = snd_hda_mixer_amp_switch_put */
326 #define ANALOG_INPUT_MUTE \
327 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
328 .name = NULL, \
329 .index = 0, \
330 .info = snd_hda_mixer_amp_switch_info, \
331 .get = snd_hda_mixer_amp_switch_get, \
332 .put = analog_input_switch_put, \
333 .private_value = HDA_COMPOSE_AMP_VAL(0, 3, 0, 0) }
334
335 static const struct snd_kcontrol_new via_control_templates[] = {
336 HDA_CODEC_VOLUME(NULL, 0, 0, 0),
337 HDA_CODEC_MUTE(NULL, 0, 0, 0),
338 ANALOG_INPUT_MUTE,
339 };
340
341
342 /* add dynamic controls */
343 static struct snd_kcontrol_new *__via_clone_ctl(struct via_spec *spec,
344 const struct snd_kcontrol_new *tmpl,
345 const char *name)
346 {
347 struct snd_kcontrol_new *knew;
348
349 snd_array_init(&spec->kctls, sizeof(*knew), 32);
350 knew = snd_array_new(&spec->kctls);
351 if (!knew)
352 return NULL;
353 *knew = *tmpl;
354 if (!name)
355 name = tmpl->name;
356 if (name) {
357 knew->name = kstrdup(name, GFP_KERNEL);
358 if (!knew->name)
359 return NULL;
360 }
361 return knew;
362 }
363
364 static int __via_add_control(struct via_spec *spec, int type, const char *name,
365 int idx, unsigned long val)
366 {
367 struct snd_kcontrol_new *knew;
368
369 knew = __via_clone_ctl(spec, &via_control_templates[type], name);
370 if (!knew)
371 return -ENOMEM;
372 knew->index = idx;
373 if (get_amp_nid_(val))
374 knew->subdevice = HDA_SUBDEV_AMP_FLAG;
375 knew->private_value = val;
376 return 0;
377 }
378
379 #define via_add_control(spec, type, name, val) \
380 __via_add_control(spec, type, name, 0, val)
381
382 #define via_clone_control(spec, tmpl) __via_clone_ctl(spec, tmpl, NULL)
383
384 static void via_free_kctls(struct hda_codec *codec)
385 {
386 struct via_spec *spec = codec->spec;
387
388 if (spec->kctls.list) {
389 struct snd_kcontrol_new *kctl = spec->kctls.list;
390 int i;
391 for (i = 0; i < spec->kctls.used; i++)
392 kfree(kctl[i].name);
393 }
394 snd_array_free(&spec->kctls);
395 }
396
397 /* create input playback/capture controls for the given pin */
398 static int via_new_analog_input(struct via_spec *spec, const char *ctlname,
399 int type_idx, int idx, int mix_nid)
400 {
401 char name[32];
402 int err;
403
404 sprintf(name, "%s Playback Volume", ctlname);
405 err = __via_add_control(spec, VIA_CTL_WIDGET_VOL, name, type_idx,
406 HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT));
407 if (err < 0)
408 return err;
409 sprintf(name, "%s Playback Switch", ctlname);
410 err = __via_add_control(spec, VIA_CTL_WIDGET_ANALOG_MUTE, name, type_idx,
411 HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT));
412 if (err < 0)
413 return err;
414 return 0;
415 }
416
417 #define get_connection_index(codec, mux, nid) \
418 snd_hda_get_conn_index(codec, mux, nid, 0)
419
420 static bool check_amp_caps(struct hda_codec *codec, hda_nid_t nid, int dir,
421 unsigned int mask)
422 {
423 unsigned int caps;
424 if (!nid)
425 return false;
426 caps = get_wcaps(codec, nid);
427 if (dir == HDA_INPUT)
428 caps &= AC_WCAP_IN_AMP;
429 else
430 caps &= AC_WCAP_OUT_AMP;
431 if (!caps)
432 return false;
433 if (query_amp_caps(codec, nid, dir) & mask)
434 return true;
435 return false;
436 }
437
438 #define have_mute(codec, nid, dir) \
439 check_amp_caps(codec, nid, dir, AC_AMPCAP_MUTE)
440
441 /* enable/disable the output-route */
442 static void activate_output_path(struct hda_codec *codec, struct nid_path *path,
443 bool enable, bool force)
444 {
445 int i;
446 for (i = 0; i < path->depth; i++) {
447 hda_nid_t src, dst;
448 int idx = path->idx[i];
449 src = path->path[i];
450 if (i < path->depth - 1)
451 dst = path->path[i + 1];
452 else
453 dst = 0;
454 if (enable && path->multi[i])
455 snd_hda_codec_write(codec, dst, 0,
456 AC_VERB_SET_CONNECT_SEL, idx);
457 if (!force
458 && get_wcaps_type(get_wcaps(codec, src)) == AC_WID_AUD_OUT
459 && get_wcaps_type(get_wcaps(codec, dst)) == AC_WID_AUD_MIX)
460 continue;
461 if (have_mute(codec, dst, HDA_INPUT)) {
462 int val = enable ? AMP_IN_UNMUTE(idx) :
463 AMP_IN_MUTE(idx);
464 snd_hda_codec_write(codec, dst, 0,
465 AC_VERB_SET_AMP_GAIN_MUTE, val);
466 }
467 if (!force && (src == path->vol_ctl || src == path->mute_ctl))
468 continue;
469 if (have_mute(codec, src, HDA_OUTPUT)) {
470 int val = enable ? AMP_OUT_UNMUTE : AMP_OUT_MUTE;
471 snd_hda_codec_write(codec, src, 0,
472 AC_VERB_SET_AMP_GAIN_MUTE, val);
473 }
474 }
475 }
476
477 /* set the given pin as output */
478 static void init_output_pin(struct hda_codec *codec, hda_nid_t pin,
479 int pin_type)
480 {
481 if (!pin)
482 return;
483 snd_hda_codec_write(codec, pin, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
484 pin_type);
485 if (snd_hda_query_pin_caps(codec, pin) & AC_PINCAP_EAPD)
486 snd_hda_codec_write(codec, pin, 0,
487 AC_VERB_SET_EAPD_BTLENABLE, 0x02);
488 }
489
490 static void via_auto_init_output(struct hda_codec *codec,
491 struct nid_path *path, int pin_type,
492 bool force)
493 {
494 struct via_spec *spec = codec->spec;
495 unsigned int caps;
496 hda_nid_t pin, nid, pre_nid;
497 int i, idx, j, num;
498
499 if (!path->depth)
500 return;
501 pin = path->path[path->depth - 1];
502
503 init_output_pin(codec, pin, pin_type);
504 caps = query_amp_caps(codec, pin, HDA_OUTPUT);
505 if (caps & AC_AMPCAP_MUTE) {
506 unsigned int val;
507 val = (caps & AC_AMPCAP_OFFSET) >> AC_AMPCAP_OFFSET_SHIFT;
508 snd_hda_codec_write(codec, pin, 0, AC_VERB_SET_AMP_GAIN_MUTE,
509 AMP_OUT_MUTE | val);
510 }
511
512 activate_output_path(codec, path, true, force);
513
514 /* initialize the AA-path */
515 if (!spec->aa_mix_nid)
516 return;
517 for (i = path->depth - 1; i > 0; i--) {
518 nid = path->path[i];
519 pre_nid = path->path[i - 1];
520 idx = get_connection_index(codec, nid, spec->aa_mix_nid);
521 if (idx >= 0) {
522 if (have_mute(codec, nid, HDA_INPUT)) {
523 snd_hda_codec_write(codec, nid, 0,
524 AC_VERB_SET_AMP_GAIN_MUTE,
525 AMP_IN_UNMUTE(idx));
526 if (pre_nid == spec->multiout.dac_nids[0]) {
527 num = snd_hda_get_conn_list(codec, nid,
528 NULL);
529 for (j = 0; j < num; j++) {
530 if (j == idx)
531 continue;
532 snd_hda_codec_write(codec,
533 nid, 0,
534 AC_VERB_SET_AMP_GAIN_MUTE,
535 AMP_IN_MUTE(j));
536 }
537 }
538 }
539 break;
540 }
541 }
542 }
543
544 static void via_auto_init_multi_out(struct hda_codec *codec)
545 {
546 struct via_spec *spec = codec->spec;
547 int i;
548
549 for (i = 0; i < spec->autocfg.line_outs + spec->smart51_nums; i++)
550 via_auto_init_output(codec, &spec->out_path[i], PIN_OUT, true);
551 }
552
553 static void via_auto_init_hp_out(struct hda_codec *codec)
554 {
555 struct via_spec *spec = codec->spec;
556
557 if (!spec->hp_dac_nid) {
558 via_auto_init_output(codec, &spec->hp_dep_path, PIN_HP, true);
559 return;
560 }
561 if (spec->hp_independent_mode) {
562 activate_output_path(codec, &spec->hp_dep_path, false, false);
563 via_auto_init_output(codec, &spec->hp_path, PIN_HP, true);
564 } else {
565 activate_output_path(codec, &spec->hp_path, false, false);
566 via_auto_init_output(codec, &spec->hp_dep_path, PIN_HP, true);
567 }
568 }
569
570 static void via_auto_init_speaker_out(struct hda_codec *codec)
571 {
572 struct via_spec *spec = codec->spec;
573
574 if (spec->autocfg.speaker_outs)
575 via_auto_init_output(codec, &spec->speaker_path, PIN_OUT, true);
576 }
577
578 static bool is_smart51_pins(struct hda_codec *codec, hda_nid_t pin);
579
580 static void via_auto_init_analog_input(struct hda_codec *codec)
581 {
582 struct via_spec *spec = codec->spec;
583 const struct auto_pin_cfg *cfg = &spec->autocfg;
584 hda_nid_t conn[HDA_MAX_CONNECTIONS];
585 unsigned int ctl;
586 int i, num_conns;
587
588 /* init ADCs */
589 for (i = 0; i < spec->num_adc_nids; i++) {
590 snd_hda_codec_write(codec, spec->adc_nids[i], 0,
591 AC_VERB_SET_AMP_GAIN_MUTE,
592 AMP_IN_UNMUTE(0));
593 }
594
595 /* init pins */
596 for (i = 0; i < cfg->num_inputs; i++) {
597 hda_nid_t nid = cfg->inputs[i].pin;
598 if (spec->smart51_enabled && is_smart51_pins(codec, nid))
599 ctl = PIN_OUT;
600 else if (cfg->inputs[i].type == AUTO_PIN_MIC)
601 ctl = PIN_VREF50;
602 else
603 ctl = PIN_IN;
604 snd_hda_codec_write(codec, nid, 0,
605 AC_VERB_SET_PIN_WIDGET_CONTROL, ctl);
606 }
607
608 /* init input-src */
609 for (i = 0; i < spec->num_adc_nids; i++) {
610 int adc_idx = spec->inputs[spec->cur_mux[i]].adc_idx;
611 if (spec->mux_nids[adc_idx]) {
612 int mux_idx = spec->inputs[spec->cur_mux[i]].mux_idx;
613 snd_hda_codec_write(codec, spec->mux_nids[adc_idx], 0,
614 AC_VERB_SET_CONNECT_SEL,
615 mux_idx);
616 }
617 if (spec->dyn_adc_switch)
618 break; /* only one input-src */
619 }
620
621 /* init aa-mixer */
622 if (!spec->aa_mix_nid)
623 return;
624 num_conns = snd_hda_get_connections(codec, spec->aa_mix_nid, conn,
625 ARRAY_SIZE(conn));
626 for (i = 0; i < num_conns; i++) {
627 unsigned int caps = get_wcaps(codec, conn[i]);
628 if (get_wcaps_type(caps) == AC_WID_PIN)
629 snd_hda_codec_write(codec, spec->aa_mix_nid, 0,
630 AC_VERB_SET_AMP_GAIN_MUTE,
631 AMP_IN_MUTE(i));
632 }
633 }
634
635 static void set_pin_power_state(struct hda_codec *codec, hda_nid_t nid,
636 unsigned int *affected_parm)
637 {
638 unsigned parm;
639 unsigned def_conf = snd_hda_codec_get_pincfg(codec, nid);
640 unsigned no_presence = (def_conf & AC_DEFCFG_MISC)
641 >> AC_DEFCFG_MISC_SHIFT
642 & AC_DEFCFG_MISC_NO_PRESENCE; /* do not support pin sense */
643 struct via_spec *spec = codec->spec;
644 unsigned present = 0;
645
646 no_presence |= spec->no_pin_power_ctl;
647 if (!no_presence)
648 present = snd_hda_jack_detect(codec, nid);
649 if ((spec->smart51_enabled && is_smart51_pins(codec, nid))
650 || ((no_presence || present)
651 && get_defcfg_connect(def_conf) != AC_JACK_PORT_NONE)) {
652 *affected_parm = AC_PWRST_D0; /* if it's connected */
653 parm = AC_PWRST_D0;
654 } else
655 parm = AC_PWRST_D3;
656
657 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_POWER_STATE, parm);
658 }
659
660 static int via_pin_power_ctl_info(struct snd_kcontrol *kcontrol,
661 struct snd_ctl_elem_info *uinfo)
662 {
663 static const char * const texts[] = {
664 "Disabled", "Enabled"
665 };
666
667 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
668 uinfo->count = 1;
669 uinfo->value.enumerated.items = 2;
670 if (uinfo->value.enumerated.item >= uinfo->value.enumerated.items)
671 uinfo->value.enumerated.item = uinfo->value.enumerated.items - 1;
672 strcpy(uinfo->value.enumerated.name,
673 texts[uinfo->value.enumerated.item]);
674 return 0;
675 }
676
677 static int via_pin_power_ctl_get(struct snd_kcontrol *kcontrol,
678 struct snd_ctl_elem_value *ucontrol)
679 {
680 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
681 struct via_spec *spec = codec->spec;
682 ucontrol->value.enumerated.item[0] = !spec->no_pin_power_ctl;
683 return 0;
684 }
685
686 static int via_pin_power_ctl_put(struct snd_kcontrol *kcontrol,
687 struct snd_ctl_elem_value *ucontrol)
688 {
689 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
690 struct via_spec *spec = codec->spec;
691 unsigned int val = !ucontrol->value.enumerated.item[0];
692
693 if (val == spec->no_pin_power_ctl)
694 return 0;
695 spec->no_pin_power_ctl = val;
696 set_widgets_power_state(codec);
697 return 1;
698 }
699
700 static const struct snd_kcontrol_new via_pin_power_ctl_enum = {
701 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
702 .name = "Dynamic Power-Control",
703 .info = via_pin_power_ctl_info,
704 .get = via_pin_power_ctl_get,
705 .put = via_pin_power_ctl_put,
706 };
707
708
709 static int via_independent_hp_info(struct snd_kcontrol *kcontrol,
710 struct snd_ctl_elem_info *uinfo)
711 {
712 static const char * const texts[] = { "OFF", "ON" };
713
714 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
715 uinfo->count = 1;
716 uinfo->value.enumerated.items = 2;
717 if (uinfo->value.enumerated.item >= 2)
718 uinfo->value.enumerated.item = 1;
719 strcpy(uinfo->value.enumerated.name,
720 texts[uinfo->value.enumerated.item]);
721 return 0;
722 }
723
724 static int via_independent_hp_get(struct snd_kcontrol *kcontrol,
725 struct snd_ctl_elem_value *ucontrol)
726 {
727 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
728 struct via_spec *spec = codec->spec;
729
730 ucontrol->value.enumerated.item[0] = spec->hp_independent_mode;
731 return 0;
732 }
733
734 static int via_independent_hp_put(struct snd_kcontrol *kcontrol,
735 struct snd_ctl_elem_value *ucontrol)
736 {
737 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
738 struct via_spec *spec = codec->spec;
739 int cur;
740
741 /* no independent-hp status change during PCM playback is running */
742 if (spec->num_active_streams)
743 return -EBUSY;
744
745 cur = !!ucontrol->value.enumerated.item[0];
746 if (spec->hp_independent_mode == cur)
747 return 0;
748 spec->hp_independent_mode = cur;
749 if (cur) {
750 activate_output_path(codec, &spec->hp_dep_path, false, false);
751 activate_output_path(codec, &spec->hp_path, true, false);
752 if (spec->hp_indep_shared)
753 activate_output_path(codec, &spec->out_path[HDA_SIDE],
754 false, false);
755 } else {
756 activate_output_path(codec, &spec->hp_path, false, false);
757 activate_output_path(codec, &spec->hp_dep_path, true, false);
758 if (spec->hp_indep_shared)
759 activate_output_path(codec, &spec->out_path[HDA_SIDE],
760 true, false);
761 }
762
763 /* update jack power state */
764 set_widgets_power_state(codec);
765 return 1;
766 }
767
768 static const struct snd_kcontrol_new via_hp_mixer = {
769 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
770 .name = "Independent HP",
771 .info = via_independent_hp_info,
772 .get = via_independent_hp_get,
773 .put = via_independent_hp_put,
774 };
775
776 static int via_hp_build(struct hda_codec *codec)
777 {
778 struct via_spec *spec = codec->spec;
779 struct snd_kcontrol_new *knew;
780 hda_nid_t nid;
781
782 nid = spec->autocfg.hp_pins[0];
783 knew = via_clone_control(spec, &via_hp_mixer);
784 if (knew == NULL)
785 return -ENOMEM;
786
787 knew->subdevice = HDA_SUBDEV_NID_FLAG | nid;
788
789 return 0;
790 }
791
792 static void notify_aa_path_ctls(struct hda_codec *codec)
793 {
794 struct via_spec *spec = codec->spec;
795 int i;
796
797 for (i = 0; i < spec->smart51_nums; i++) {
798 struct snd_kcontrol *ctl;
799 struct snd_ctl_elem_id id;
800 memset(&id, 0, sizeof(id));
801 id.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
802 sprintf(id.name, "%s Playback Volume", spec->smart51_labels[i]);
803 ctl = snd_hda_find_mixer_ctl(codec, id.name);
804 if (ctl)
805 snd_ctl_notify(codec->bus->card,
806 SNDRV_CTL_EVENT_MASK_VALUE,
807 &ctl->id);
808 }
809 }
810
811 static void mute_aa_path(struct hda_codec *codec, int mute)
812 {
813 struct via_spec *spec = codec->spec;
814 int val = mute ? HDA_AMP_MUTE : HDA_AMP_UNMUTE;
815 int i;
816
817 /* check AA path's mute status */
818 for (i = 0; i < spec->smart51_nums; i++) {
819 if (spec->smart51_idxs[i] < 0)
820 continue;
821 snd_hda_codec_amp_stereo(codec, spec->aa_mix_nid,
822 HDA_INPUT, spec->smart51_idxs[i],
823 HDA_AMP_MUTE, val);
824 }
825 }
826
827 static bool is_smart51_pins(struct hda_codec *codec, hda_nid_t pin)
828 {
829 struct via_spec *spec = codec->spec;
830 int i;
831
832 for (i = 0; i < spec->smart51_nums; i++)
833 if (spec->smart51_pins[i] == pin)
834 return true;
835 return false;
836 }
837
838 static int via_smart51_get(struct snd_kcontrol *kcontrol,
839 struct snd_ctl_elem_value *ucontrol)
840 {
841 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
842 struct via_spec *spec = codec->spec;
843
844 *ucontrol->value.integer.value = spec->smart51_enabled;
845 return 0;
846 }
847
848 static int via_smart51_put(struct snd_kcontrol *kcontrol,
849 struct snd_ctl_elem_value *ucontrol)
850 {
851 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
852 struct via_spec *spec = codec->spec;
853 int out_in = *ucontrol->value.integer.value
854 ? AC_PINCTL_OUT_EN : AC_PINCTL_IN_EN;
855 int i;
856
857 for (i = 0; i < spec->smart51_nums; i++) {
858 hda_nid_t nid = spec->smart51_pins[i];
859 unsigned int parm;
860
861 parm = snd_hda_codec_read(codec, nid, 0,
862 AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
863 parm &= ~(AC_PINCTL_IN_EN | AC_PINCTL_OUT_EN);
864 parm |= out_in;
865 snd_hda_codec_write(codec, nid, 0,
866 AC_VERB_SET_PIN_WIDGET_CONTROL,
867 parm);
868 if (out_in == AC_PINCTL_OUT_EN) {
869 mute_aa_path(codec, 1);
870 notify_aa_path_ctls(codec);
871 }
872 }
873 spec->smart51_enabled = *ucontrol->value.integer.value;
874 set_widgets_power_state(codec);
875 return 1;
876 }
877
878 static const struct snd_kcontrol_new via_smart51_mixer = {
879 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
880 .name = "Smart 5.1",
881 .count = 1,
882 .info = snd_ctl_boolean_mono_info,
883 .get = via_smart51_get,
884 .put = via_smart51_put,
885 };
886
887 static int via_smart51_build(struct hda_codec *codec)
888 {
889 struct via_spec *spec = codec->spec;
890
891 if (!spec->smart51_nums)
892 return 0;
893 if (!via_clone_control(spec, &via_smart51_mixer))
894 return -ENOMEM;
895 return 0;
896 }
897
898 /* check AA path's mute status */
899 static bool is_aa_path_mute(struct hda_codec *codec)
900 {
901 struct via_spec *spec = codec->spec;
902 const struct hda_amp_list *p;
903 int i, ch, v;
904
905 for (i = 0; i < spec->num_loopbacks; i++) {
906 p = &spec->loopback_list[i];
907 for (ch = 0; ch < 2; ch++) {
908 v = snd_hda_codec_amp_read(codec, p->nid, ch, p->dir,
909 p->idx);
910 if (!(v & HDA_AMP_MUTE) && v > 0)
911 return false;
912 }
913 }
914 return true;
915 }
916
917 /* enter/exit analog low-current mode */
918 static void analog_low_current_mode(struct hda_codec *codec)
919 {
920 struct via_spec *spec = codec->spec;
921 bool enable;
922 unsigned int verb, parm;
923
924 enable = is_aa_path_mute(codec) && (spec->num_active_streams > 0);
925
926 /* decide low current mode's verb & parameter */
927 switch (spec->codec_type) {
928 case VT1708B_8CH:
929 case VT1708B_4CH:
930 verb = 0xf70;
931 parm = enable ? 0x02 : 0x00; /* 0x02: 2/3x, 0x00: 1x */
932 break;
933 case VT1708S:
934 case VT1718S:
935 case VT1716S:
936 verb = 0xf73;
937 parm = enable ? 0x51 : 0xe1; /* 0x51: 4/28x, 0xe1: 1x */
938 break;
939 case VT1702:
940 verb = 0xf73;
941 parm = enable ? 0x01 : 0x1d; /* 0x01: 4/40x, 0x1d: 1x */
942 break;
943 case VT2002P:
944 case VT1812:
945 case VT1802:
946 verb = 0xf93;
947 parm = enable ? 0x00 : 0xe0; /* 0x00: 4/40x, 0xe0: 1x */
948 break;
949 default:
950 return; /* other codecs are not supported */
951 }
952 /* send verb */
953 snd_hda_codec_write(codec, codec->afg, 0, verb, parm);
954 }
955
956 /*
957 * generic initialization of ADC, input mixers and output mixers
958 */
959 static const struct hda_verb vt1708_init_verbs[] = {
960 /* power down jack detect function */
961 {0x1, 0xf81, 0x1},
962 { }
963 };
964
965 static void set_stream_active(struct hda_codec *codec, bool active)
966 {
967 struct via_spec *spec = codec->spec;
968
969 if (active)
970 spec->num_active_streams++;
971 else
972 spec->num_active_streams--;
973 analog_low_current_mode(codec);
974 }
975
976 static int via_playback_multi_pcm_open(struct hda_pcm_stream *hinfo,
977 struct hda_codec *codec,
978 struct snd_pcm_substream *substream)
979 {
980 struct via_spec *spec = codec->spec;
981 const struct auto_pin_cfg *cfg = &spec->autocfg;
982 int err;
983
984 spec->multiout.hp_nid = 0;
985 spec->multiout.num_dacs = cfg->line_outs + spec->smart51_nums;
986 if (!spec->hp_independent_mode) {
987 if (!spec->hp_indep_shared)
988 spec->multiout.hp_nid = spec->hp_dac_nid;
989 } else {
990 if (spec->hp_indep_shared)
991 spec->multiout.num_dacs = cfg->line_outs - 1;
992 }
993 spec->multiout.max_channels = spec->multiout.num_dacs * 2;
994 set_stream_active(codec, true);
995 err = snd_hda_multi_out_analog_open(codec, &spec->multiout, substream,
996 hinfo);
997 if (err < 0) {
998 spec->multiout.hp_nid = 0;
999 set_stream_active(codec, false);
1000 return err;
1001 }
1002 return 0;
1003 }
1004
1005 static int via_playback_multi_pcm_close(struct hda_pcm_stream *hinfo,
1006 struct hda_codec *codec,
1007 struct snd_pcm_substream *substream)
1008 {
1009 struct via_spec *spec = codec->spec;
1010
1011 spec->multiout.hp_nid = 0;
1012 set_stream_active(codec, false);
1013 return 0;
1014 }
1015
1016 static int via_playback_hp_pcm_open(struct hda_pcm_stream *hinfo,
1017 struct hda_codec *codec,
1018 struct snd_pcm_substream *substream)
1019 {
1020 struct via_spec *spec = codec->spec;
1021
1022 if (snd_BUG_ON(!spec->hp_dac_nid))
1023 return -EINVAL;
1024 if (!spec->hp_independent_mode || spec->multiout.hp_nid)
1025 return -EBUSY;
1026 set_stream_active(codec, true);
1027 return 0;
1028 }
1029
1030 static int via_playback_hp_pcm_close(struct hda_pcm_stream *hinfo,
1031 struct hda_codec *codec,
1032 struct snd_pcm_substream *substream)
1033 {
1034 set_stream_active(codec, false);
1035 return 0;
1036 }
1037
1038 static int via_playback_multi_pcm_prepare(struct hda_pcm_stream *hinfo,
1039 struct hda_codec *codec,
1040 unsigned int stream_tag,
1041 unsigned int format,
1042 struct snd_pcm_substream *substream)
1043 {
1044 struct via_spec *spec = codec->spec;
1045
1046 snd_hda_multi_out_analog_prepare(codec, &spec->multiout, stream_tag,
1047 format, substream);
1048 vt1708_start_hp_work(spec);
1049 return 0;
1050 }
1051
1052 static int via_playback_hp_pcm_prepare(struct hda_pcm_stream *hinfo,
1053 struct hda_codec *codec,
1054 unsigned int stream_tag,
1055 unsigned int format,
1056 struct snd_pcm_substream *substream)
1057 {
1058 struct via_spec *spec = codec->spec;
1059
1060 snd_hda_codec_setup_stream(codec, spec->hp_dac_nid,
1061 stream_tag, 0, format);
1062 vt1708_start_hp_work(spec);
1063 return 0;
1064 }
1065
1066 static int via_playback_multi_pcm_cleanup(struct hda_pcm_stream *hinfo,
1067 struct hda_codec *codec,
1068 struct snd_pcm_substream *substream)
1069 {
1070 struct via_spec *spec = codec->spec;
1071
1072 snd_hda_multi_out_analog_cleanup(codec, &spec->multiout);
1073 vt1708_stop_hp_work(spec);
1074 return 0;
1075 }
1076
1077 static int via_playback_hp_pcm_cleanup(struct hda_pcm_stream *hinfo,
1078 struct hda_codec *codec,
1079 struct snd_pcm_substream *substream)
1080 {
1081 struct via_spec *spec = codec->spec;
1082
1083 snd_hda_codec_setup_stream(codec, spec->hp_dac_nid, 0, 0, 0);
1084 vt1708_stop_hp_work(spec);
1085 return 0;
1086 }
1087
1088 /*
1089 * Digital out
1090 */
1091 static int via_dig_playback_pcm_open(struct hda_pcm_stream *hinfo,
1092 struct hda_codec *codec,
1093 struct snd_pcm_substream *substream)
1094 {
1095 struct via_spec *spec = codec->spec;
1096 return snd_hda_multi_out_dig_open(codec, &spec->multiout);
1097 }
1098
1099 static int via_dig_playback_pcm_close(struct hda_pcm_stream *hinfo,
1100 struct hda_codec *codec,
1101 struct snd_pcm_substream *substream)
1102 {
1103 struct via_spec *spec = codec->spec;
1104 return snd_hda_multi_out_dig_close(codec, &spec->multiout);
1105 }
1106
1107 static int via_dig_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
1108 struct hda_codec *codec,
1109 unsigned int stream_tag,
1110 unsigned int format,
1111 struct snd_pcm_substream *substream)
1112 {
1113 struct via_spec *spec = codec->spec;
1114 return snd_hda_multi_out_dig_prepare(codec, &spec->multiout,
1115 stream_tag, format, substream);
1116 }
1117
1118 static int via_dig_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
1119 struct hda_codec *codec,
1120 struct snd_pcm_substream *substream)
1121 {
1122 struct via_spec *spec = codec->spec;
1123 snd_hda_multi_out_dig_cleanup(codec, &spec->multiout);
1124 return 0;
1125 }
1126
1127 /*
1128 * Analog capture
1129 */
1130 static int via_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
1131 struct hda_codec *codec,
1132 unsigned int stream_tag,
1133 unsigned int format,
1134 struct snd_pcm_substream *substream)
1135 {
1136 struct via_spec *spec = codec->spec;
1137
1138 snd_hda_codec_setup_stream(codec, spec->adc_nids[substream->number],
1139 stream_tag, 0, format);
1140 return 0;
1141 }
1142
1143 static int via_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
1144 struct hda_codec *codec,
1145 struct snd_pcm_substream *substream)
1146 {
1147 struct via_spec *spec = codec->spec;
1148 snd_hda_codec_cleanup_stream(codec, spec->adc_nids[substream->number]);
1149 return 0;
1150 }
1151
1152 /* analog capture with dynamic ADC switching */
1153 static int via_dyn_adc_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
1154 struct hda_codec *codec,
1155 unsigned int stream_tag,
1156 unsigned int format,
1157 struct snd_pcm_substream *substream)
1158 {
1159 struct via_spec *spec = codec->spec;
1160 int adc_idx = spec->inputs[spec->cur_mux[0]].adc_idx;
1161
1162 spec->cur_adc = spec->adc_nids[adc_idx];
1163 spec->cur_adc_stream_tag = stream_tag;
1164 spec->cur_adc_format = format;
1165 snd_hda_codec_setup_stream(codec, spec->cur_adc, stream_tag, 0, format);
1166 return 0;
1167 }
1168
1169 static int via_dyn_adc_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
1170 struct hda_codec *codec,
1171 struct snd_pcm_substream *substream)
1172 {
1173 struct via_spec *spec = codec->spec;
1174
1175 snd_hda_codec_cleanup_stream(codec, spec->cur_adc);
1176 spec->cur_adc = 0;
1177 return 0;
1178 }
1179
1180 /* re-setup the stream if running; called from input-src put */
1181 static bool via_dyn_adc_pcm_resetup(struct hda_codec *codec, int cur)
1182 {
1183 struct via_spec *spec = codec->spec;
1184 int adc_idx = spec->inputs[cur].adc_idx;
1185 hda_nid_t adc = spec->adc_nids[adc_idx];
1186
1187 if (spec->cur_adc && spec->cur_adc != adc) {
1188 /* stream is running, let's swap the current ADC */
1189 __snd_hda_codec_cleanup_stream(codec, spec->cur_adc, 1);
1190 spec->cur_adc = adc;
1191 snd_hda_codec_setup_stream(codec, adc,
1192 spec->cur_adc_stream_tag, 0,
1193 spec->cur_adc_format);
1194 return true;
1195 }
1196 return false;
1197 }
1198
1199 static const struct hda_pcm_stream via_pcm_analog_playback = {
1200 .substreams = 1,
1201 .channels_min = 2,
1202 .channels_max = 8,
1203 /* NID is set in via_build_pcms */
1204 .ops = {
1205 .open = via_playback_multi_pcm_open,
1206 .close = via_playback_multi_pcm_close,
1207 .prepare = via_playback_multi_pcm_prepare,
1208 .cleanup = via_playback_multi_pcm_cleanup
1209 },
1210 };
1211
1212 static const struct hda_pcm_stream via_pcm_hp_playback = {
1213 .substreams = 1,
1214 .channels_min = 2,
1215 .channels_max = 2,
1216 /* NID is set in via_build_pcms */
1217 .ops = {
1218 .open = via_playback_hp_pcm_open,
1219 .close = via_playback_hp_pcm_close,
1220 .prepare = via_playback_hp_pcm_prepare,
1221 .cleanup = via_playback_hp_pcm_cleanup
1222 },
1223 };
1224
1225 static const struct hda_pcm_stream vt1708_pcm_analog_s16_playback = {
1226 .substreams = 1,
1227 .channels_min = 2,
1228 .channels_max = 8,
1229 /* NID is set in via_build_pcms */
1230 /* We got noisy outputs on the right channel on VT1708 when
1231 * 24bit samples are used. Until any workaround is found,
1232 * disable the 24bit format, so far.
1233 */
1234 .formats = SNDRV_PCM_FMTBIT_S16_LE,
1235 .ops = {
1236 .open = via_playback_multi_pcm_open,
1237 .close = via_playback_multi_pcm_close,
1238 .prepare = via_playback_multi_pcm_prepare,
1239 .cleanup = via_playback_multi_pcm_cleanup
1240 },
1241 };
1242
1243 static const struct hda_pcm_stream via_pcm_analog_capture = {
1244 .substreams = 1, /* will be changed in via_build_pcms() */
1245 .channels_min = 2,
1246 .channels_max = 2,
1247 /* NID is set in via_build_pcms */
1248 .ops = {
1249 .prepare = via_capture_pcm_prepare,
1250 .cleanup = via_capture_pcm_cleanup
1251 },
1252 };
1253
1254 static const struct hda_pcm_stream via_pcm_dyn_adc_analog_capture = {
1255 .substreams = 1,
1256 .channels_min = 2,
1257 .channels_max = 2,
1258 /* NID is set in via_build_pcms */
1259 .ops = {
1260 .prepare = via_dyn_adc_capture_pcm_prepare,
1261 .cleanup = via_dyn_adc_capture_pcm_cleanup,
1262 },
1263 };
1264
1265 static const struct hda_pcm_stream via_pcm_digital_playback = {
1266 .substreams = 1,
1267 .channels_min = 2,
1268 .channels_max = 2,
1269 /* NID is set in via_build_pcms */
1270 .ops = {
1271 .open = via_dig_playback_pcm_open,
1272 .close = via_dig_playback_pcm_close,
1273 .prepare = via_dig_playback_pcm_prepare,
1274 .cleanup = via_dig_playback_pcm_cleanup
1275 },
1276 };
1277
1278 static const struct hda_pcm_stream via_pcm_digital_capture = {
1279 .substreams = 1,
1280 .channels_min = 2,
1281 .channels_max = 2,
1282 };
1283
1284 /*
1285 * slave controls for virtual master
1286 */
1287 static const char * const via_slave_vols[] = {
1288 "Front Playback Volume",
1289 "Surround Playback Volume",
1290 "Center Playback Volume",
1291 "LFE Playback Volume",
1292 "Side Playback Volume",
1293 "Headphone Playback Volume",
1294 "Speaker Playback Volume",
1295 NULL,
1296 };
1297
1298 static const char * const via_slave_sws[] = {
1299 "Front Playback Switch",
1300 "Surround Playback Switch",
1301 "Center Playback Switch",
1302 "LFE Playback Switch",
1303 "Side Playback Switch",
1304 "Headphone Playback Switch",
1305 "Speaker Playback Switch",
1306 NULL,
1307 };
1308
1309 static int via_build_controls(struct hda_codec *codec)
1310 {
1311 struct via_spec *spec = codec->spec;
1312 struct snd_kcontrol *kctl;
1313 int err, i;
1314
1315 if (spec->set_widgets_power_state)
1316 if (!via_clone_control(spec, &via_pin_power_ctl_enum))
1317 return -ENOMEM;
1318
1319 for (i = 0; i < spec->num_mixers; i++) {
1320 err = snd_hda_add_new_ctls(codec, spec->mixers[i]);
1321 if (err < 0)
1322 return err;
1323 }
1324
1325 if (spec->multiout.dig_out_nid) {
1326 err = snd_hda_create_spdif_out_ctls(codec,
1327 spec->multiout.dig_out_nid,
1328 spec->multiout.dig_out_nid);
1329 if (err < 0)
1330 return err;
1331 err = snd_hda_create_spdif_share_sw(codec,
1332 &spec->multiout);
1333 if (err < 0)
1334 return err;
1335 spec->multiout.share_spdif = 1;
1336 }
1337 if (spec->dig_in_nid) {
1338 err = snd_hda_create_spdif_in_ctls(codec, spec->dig_in_nid);
1339 if (err < 0)
1340 return err;
1341 }
1342
1343 /* if we have no master control, let's create it */
1344 if (!snd_hda_find_mixer_ctl(codec, "Master Playback Volume")) {
1345 unsigned int vmaster_tlv[4];
1346 snd_hda_set_vmaster_tlv(codec, spec->multiout.dac_nids[0],
1347 HDA_OUTPUT, vmaster_tlv);
1348 err = snd_hda_add_vmaster(codec, "Master Playback Volume",
1349 vmaster_tlv, via_slave_vols);
1350 if (err < 0)
1351 return err;
1352 }
1353 if (!snd_hda_find_mixer_ctl(codec, "Master Playback Switch")) {
1354 err = snd_hda_add_vmaster(codec, "Master Playback Switch",
1355 NULL, via_slave_sws);
1356 if (err < 0)
1357 return err;
1358 }
1359
1360 /* assign Capture Source enums to NID */
1361 kctl = snd_hda_find_mixer_ctl(codec, "Input Source");
1362 for (i = 0; kctl && i < kctl->count; i++) {
1363 err = snd_hda_add_nid(codec, kctl, i, spec->mux_nids[i]);
1364 if (err < 0)
1365 return err;
1366 }
1367
1368 /* init power states */
1369 set_widgets_power_state(codec);
1370 analog_low_current_mode(codec);
1371
1372 via_free_kctls(codec); /* no longer needed */
1373 return 0;
1374 }
1375
1376 static int via_build_pcms(struct hda_codec *codec)
1377 {
1378 struct via_spec *spec = codec->spec;
1379 struct hda_pcm *info = spec->pcm_rec;
1380
1381 codec->num_pcms = 1;
1382 codec->pcm_info = info;
1383
1384 snprintf(spec->stream_name_analog, sizeof(spec->stream_name_analog),
1385 "%s Analog", codec->chip_name);
1386 info->name = spec->stream_name_analog;
1387
1388 if (!spec->stream_analog_playback)
1389 spec->stream_analog_playback = &via_pcm_analog_playback;
1390 info->stream[SNDRV_PCM_STREAM_PLAYBACK] =
1391 *spec->stream_analog_playback;
1392 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid =
1393 spec->multiout.dac_nids[0];
1394 info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max =
1395 spec->multiout.max_channels;
1396
1397 if (!spec->stream_analog_capture) {
1398 if (spec->dyn_adc_switch)
1399 spec->stream_analog_capture =
1400 &via_pcm_dyn_adc_analog_capture;
1401 else
1402 spec->stream_analog_capture = &via_pcm_analog_capture;
1403 }
1404 info->stream[SNDRV_PCM_STREAM_CAPTURE] =
1405 *spec->stream_analog_capture;
1406 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adc_nids[0];
1407 if (!spec->dyn_adc_switch)
1408 info->stream[SNDRV_PCM_STREAM_CAPTURE].substreams =
1409 spec->num_adc_nids;
1410
1411 if (spec->multiout.dig_out_nid || spec->dig_in_nid) {
1412 codec->num_pcms++;
1413 info++;
1414 snprintf(spec->stream_name_digital,
1415 sizeof(spec->stream_name_digital),
1416 "%s Digital", codec->chip_name);
1417 info->name = spec->stream_name_digital;
1418 info->pcm_type = HDA_PCM_TYPE_SPDIF;
1419 if (spec->multiout.dig_out_nid) {
1420 if (!spec->stream_digital_playback)
1421 spec->stream_digital_playback =
1422 &via_pcm_digital_playback;
1423 info->stream[SNDRV_PCM_STREAM_PLAYBACK] =
1424 *spec->stream_digital_playback;
1425 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid =
1426 spec->multiout.dig_out_nid;
1427 }
1428 if (spec->dig_in_nid) {
1429 if (!spec->stream_digital_capture)
1430 spec->stream_digital_capture =
1431 &via_pcm_digital_capture;
1432 info->stream[SNDRV_PCM_STREAM_CAPTURE] =
1433 *spec->stream_digital_capture;
1434 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid =
1435 spec->dig_in_nid;
1436 }
1437 }
1438
1439 if (spec->hp_dac_nid) {
1440 codec->num_pcms++;
1441 info++;
1442 snprintf(spec->stream_name_hp, sizeof(spec->stream_name_hp),
1443 "%s HP", codec->chip_name);
1444 info->name = spec->stream_name_hp;
1445 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = via_pcm_hp_playback;
1446 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid =
1447 spec->hp_dac_nid;
1448 }
1449 return 0;
1450 }
1451
1452 static void via_free(struct hda_codec *codec)
1453 {
1454 struct via_spec *spec = codec->spec;
1455
1456 if (!spec)
1457 return;
1458
1459 via_free_kctls(codec);
1460 vt1708_stop_hp_work(spec);
1461 kfree(spec->bind_cap_vol);
1462 kfree(spec->bind_cap_sw);
1463 kfree(spec);
1464 }
1465
1466 /* mute/unmute outputs */
1467 static void toggle_output_mutes(struct hda_codec *codec, int num_pins,
1468 hda_nid_t *pins, bool mute)
1469 {
1470 int i;
1471 for (i = 0; i < num_pins; i++)
1472 snd_hda_codec_write(codec, pins[i], 0,
1473 AC_VERB_SET_PIN_WIDGET_CONTROL,
1474 mute ? 0 : PIN_OUT);
1475 }
1476
1477 /* mute internal speaker if line-out is plugged */
1478 static void via_line_automute(struct hda_codec *codec, int present)
1479 {
1480 struct via_spec *spec = codec->spec;
1481
1482 if (!spec->autocfg.speaker_outs)
1483 return;
1484 if (!present)
1485 present = snd_hda_jack_detect(codec,
1486 spec->autocfg.line_out_pins[0]);
1487 toggle_output_mutes(codec, spec->autocfg.speaker_outs,
1488 spec->autocfg.speaker_pins,
1489 present);
1490 }
1491
1492 /* mute internal speaker if HP is plugged */
1493 static void via_hp_automute(struct hda_codec *codec)
1494 {
1495 int present = 0;
1496 struct via_spec *spec = codec->spec;
1497
1498 if (!spec->hp_independent_mode && spec->autocfg.hp_pins[0]) {
1499 int nums;
1500 present = snd_hda_jack_detect(codec, spec->autocfg.hp_pins[0]);
1501 if (spec->smart51_enabled)
1502 nums = spec->autocfg.line_outs + spec->smart51_nums;
1503 else
1504 nums = spec->autocfg.line_outs;
1505 toggle_output_mutes(codec, nums,
1506 spec->autocfg.line_out_pins,
1507 present);
1508 }
1509 via_line_automute(codec, present);
1510 }
1511
1512 static void via_gpio_control(struct hda_codec *codec)
1513 {
1514 unsigned int gpio_data;
1515 unsigned int vol_counter;
1516 unsigned int vol;
1517 unsigned int master_vol;
1518
1519 struct via_spec *spec = codec->spec;
1520
1521 gpio_data = snd_hda_codec_read(codec, codec->afg, 0,
1522 AC_VERB_GET_GPIO_DATA, 0) & 0x03;
1523
1524 vol_counter = (snd_hda_codec_read(codec, codec->afg, 0,
1525 0xF84, 0) & 0x3F0000) >> 16;
1526
1527 vol = vol_counter & 0x1F;
1528 master_vol = snd_hda_codec_read(codec, 0x1A, 0,
1529 AC_VERB_GET_AMP_GAIN_MUTE,
1530 AC_AMP_GET_INPUT);
1531
1532 if (gpio_data == 0x02) {
1533 /* unmute line out */
1534 snd_hda_codec_write(codec, spec->autocfg.line_out_pins[0], 0,
1535 AC_VERB_SET_PIN_WIDGET_CONTROL,
1536 PIN_OUT);
1537 if (vol_counter & 0x20) {
1538 /* decrease volume */
1539 if (vol > master_vol)
1540 vol = master_vol;
1541 snd_hda_codec_amp_stereo(codec, 0x1A, HDA_INPUT,
1542 0, HDA_AMP_VOLMASK,
1543 master_vol-vol);
1544 } else {
1545 /* increase volume */
1546 snd_hda_codec_amp_stereo(codec, 0x1A, HDA_INPUT, 0,
1547 HDA_AMP_VOLMASK,
1548 ((master_vol+vol) > 0x2A) ? 0x2A :
1549 (master_vol+vol));
1550 }
1551 } else if (!(gpio_data & 0x02)) {
1552 /* mute line out */
1553 snd_hda_codec_write(codec, spec->autocfg.line_out_pins[0], 0,
1554 AC_VERB_SET_PIN_WIDGET_CONTROL,
1555 0);
1556 }
1557 }
1558
1559 /* unsolicited event for jack sensing */
1560 static void via_unsol_event(struct hda_codec *codec,
1561 unsigned int res)
1562 {
1563 res >>= 26;
1564
1565 if (res & VIA_JACK_EVENT)
1566 set_widgets_power_state(codec);
1567
1568 res &= ~VIA_JACK_EVENT;
1569
1570 if (res == VIA_HP_EVENT)
1571 via_hp_automute(codec);
1572 else if (res == VIA_GPIO_EVENT)
1573 via_gpio_control(codec);
1574 else if (res == VIA_LINE_EVENT)
1575 via_line_automute(codec, false);
1576 }
1577
1578 #ifdef SND_HDA_NEEDS_RESUME
1579 static int via_suspend(struct hda_codec *codec, pm_message_t state)
1580 {
1581 struct via_spec *spec = codec->spec;
1582 vt1708_stop_hp_work(spec);
1583 return 0;
1584 }
1585 #endif
1586
1587 #ifdef CONFIG_SND_HDA_POWER_SAVE
1588 static int via_check_power_status(struct hda_codec *codec, hda_nid_t nid)
1589 {
1590 struct via_spec *spec = codec->spec;
1591 return snd_hda_check_amp_list_power(codec, &spec->loopback, nid);
1592 }
1593 #endif
1594
1595 /*
1596 */
1597
1598 static int via_init(struct hda_codec *codec);
1599
1600 static const struct hda_codec_ops via_patch_ops = {
1601 .build_controls = via_build_controls,
1602 .build_pcms = via_build_pcms,
1603 .init = via_init,
1604 .free = via_free,
1605 .unsol_event = via_unsol_event,
1606 #ifdef SND_HDA_NEEDS_RESUME
1607 .suspend = via_suspend,
1608 #endif
1609 #ifdef CONFIG_SND_HDA_POWER_SAVE
1610 .check_power_status = via_check_power_status,
1611 #endif
1612 };
1613
1614 static bool is_empty_dac(struct hda_codec *codec, hda_nid_t dac)
1615 {
1616 struct via_spec *spec = codec->spec;
1617 int i;
1618
1619 for (i = 0; i < spec->multiout.num_dacs; i++) {
1620 if (spec->multiout.dac_nids[i] == dac)
1621 return false;
1622 }
1623 if (spec->hp_dac_nid == dac)
1624 return false;
1625 return true;
1626 }
1627
1628 static bool __parse_output_path(struct hda_codec *codec, hda_nid_t nid,
1629 hda_nid_t target_dac, struct nid_path *path,
1630 int depth, int wid_type)
1631 {
1632 hda_nid_t conn[8];
1633 int i, nums;
1634
1635 nums = snd_hda_get_connections(codec, nid, conn, ARRAY_SIZE(conn));
1636 for (i = 0; i < nums; i++) {
1637 if (get_wcaps_type(get_wcaps(codec, conn[i])) != AC_WID_AUD_OUT)
1638 continue;
1639 if (conn[i] == target_dac || is_empty_dac(codec, conn[i]))
1640 goto found;
1641 }
1642 if (depth >= MAX_NID_PATH_DEPTH)
1643 return false;
1644 for (i = 0; i < nums; i++) {
1645 unsigned int type;
1646 type = get_wcaps_type(get_wcaps(codec, conn[i]));
1647 if (type == AC_WID_AUD_OUT ||
1648 (wid_type != -1 && type != wid_type))
1649 continue;
1650 if (__parse_output_path(codec, conn[i], target_dac,
1651 path, depth + 1, AC_WID_AUD_SEL))
1652 goto found;
1653 }
1654 return false;
1655
1656 found:
1657 path->path[path->depth] = conn[i];
1658 path->idx[path->depth] = i;
1659 if (nums > 1 && get_wcaps_type(get_wcaps(codec, nid)) != AC_WID_AUD_MIX)
1660 path->multi[path->depth] = 1;
1661 path->depth++;
1662 return true;
1663 }
1664
1665 static bool parse_output_path(struct hda_codec *codec, hda_nid_t nid,
1666 hda_nid_t target_dac, struct nid_path *path)
1667 {
1668 if (__parse_output_path(codec, nid, target_dac, path, 1, -1)) {
1669 path->path[path->depth] = nid;
1670 path->depth++;
1671 return true;
1672 }
1673 return false;
1674 }
1675
1676 static int via_auto_fill_dac_nids(struct hda_codec *codec)
1677 {
1678 struct via_spec *spec = codec->spec;
1679 const struct auto_pin_cfg *cfg = &spec->autocfg;
1680 int i;
1681 hda_nid_t nid;
1682
1683 spec->multiout.dac_nids = spec->private_dac_nids;
1684 spec->multiout.num_dacs = cfg->line_outs;
1685 for (i = 0; i < cfg->line_outs; i++) {
1686 nid = cfg->line_out_pins[i];
1687 if (!nid)
1688 continue;
1689 if (parse_output_path(codec, nid, 0, &spec->out_path[i]))
1690 spec->private_dac_nids[i] = spec->out_path[i].path[0];
1691 }
1692 return 0;
1693 }
1694
1695 static int create_ch_ctls(struct hda_codec *codec, const char *pfx,
1696 int chs, bool check_dac, struct nid_path *path)
1697 {
1698 struct via_spec *spec = codec->spec;
1699 char name[32];
1700 hda_nid_t dac, pin, sel, nid;
1701 int err;
1702
1703 dac = check_dac ? path->path[0] : 0;
1704 pin = path->path[path->depth - 1];
1705 sel = path->depth > 1 ? path->path[1] : 0;
1706
1707 if (dac && check_amp_caps(codec, dac, HDA_OUTPUT, AC_AMPCAP_NUM_STEPS))
1708 nid = dac;
1709 else if (check_amp_caps(codec, pin, HDA_OUTPUT, AC_AMPCAP_NUM_STEPS))
1710 nid = pin;
1711 else if (check_amp_caps(codec, sel, HDA_OUTPUT, AC_AMPCAP_NUM_STEPS))
1712 nid = sel;
1713 else
1714 nid = 0;
1715 if (nid) {
1716 sprintf(name, "%s Playback Volume", pfx);
1717 err = via_add_control(spec, VIA_CTL_WIDGET_VOL, name,
1718 HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_OUTPUT));
1719 if (err < 0)
1720 return err;
1721 path->vol_ctl = nid;
1722 }
1723
1724 if (dac && check_amp_caps(codec, dac, HDA_OUTPUT, AC_AMPCAP_MUTE))
1725 nid = dac;
1726 else if (check_amp_caps(codec, pin, HDA_OUTPUT, AC_AMPCAP_MUTE))
1727 nid = pin;
1728 else if (check_amp_caps(codec, sel, HDA_OUTPUT, AC_AMPCAP_MUTE))
1729 nid = sel;
1730 else
1731 nid = 0;
1732 if (nid) {
1733 sprintf(name, "%s Playback Switch", pfx);
1734 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, name,
1735 HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_OUTPUT));
1736 if (err < 0)
1737 return err;
1738 path->mute_ctl = nid;
1739 }
1740 return 0;
1741 }
1742
1743 static void mangle_smart51(struct hda_codec *codec)
1744 {
1745 struct via_spec *spec = codec->spec;
1746 struct auto_pin_cfg *cfg = &spec->autocfg;
1747 struct auto_pin_cfg_item *ins = cfg->inputs;
1748 int i, j, nums, attr;
1749 int pins[AUTO_CFG_MAX_INS];
1750
1751 for (attr = INPUT_PIN_ATTR_REAR; attr >= INPUT_PIN_ATTR_NORMAL; attr--) {
1752 nums = 0;
1753 for (i = 0; i < cfg->num_inputs; i++) {
1754 unsigned int def;
1755 if (ins[i].type > AUTO_PIN_LINE_IN)
1756 continue;
1757 def = snd_hda_codec_get_pincfg(codec, ins[i].pin);
1758 if (snd_hda_get_input_pin_attr(def) != attr)
1759 continue;
1760 for (j = 0; j < nums; j++)
1761 if (ins[pins[j]].type < ins[i].type) {
1762 memmove(pins + j + 1, pins + j,
1763 (nums - j - 1) * sizeof(int));
1764 break;
1765 }
1766 pins[j] = i;
1767 nums++;
1768 }
1769 if (cfg->line_outs + nums < 3)
1770 continue;
1771 for (i = 0; i < nums; i++) {
1772 hda_nid_t pin = ins[pins[i]].pin;
1773 spec->smart51_pins[spec->smart51_nums++] = pin;
1774 cfg->line_out_pins[cfg->line_outs++] = pin;
1775 if (cfg->line_outs == 3)
1776 break;
1777 }
1778 return;
1779 }
1780 }
1781
1782 /* add playback controls from the parsed DAC table */
1783 static int via_auto_create_multi_out_ctls(struct hda_codec *codec)
1784 {
1785 struct via_spec *spec = codec->spec;
1786 struct auto_pin_cfg *cfg = &spec->autocfg;
1787 static const char * const chname[4] = {
1788 "Front", "Surround", "C/LFE", "Side"
1789 };
1790 int i, idx, err;
1791 int old_line_outs;
1792
1793 /* check smart51 */
1794 old_line_outs = cfg->line_outs;
1795 if (cfg->line_outs == 1)
1796 mangle_smart51(codec);
1797
1798 err = via_auto_fill_dac_nids(codec);
1799 if (err < 0)
1800 return err;
1801
1802 for (i = 0; i < cfg->line_outs; i++) {
1803 hda_nid_t pin, dac;
1804 pin = cfg->line_out_pins[i];
1805 dac = spec->multiout.dac_nids[i];
1806 if (!pin || !dac)
1807 continue;
1808 if (i == HDA_CLFE) {
1809 err = create_ch_ctls(codec, "Center", 1, true,
1810 &spec->out_path[i]);
1811 if (err < 0)
1812 return err;
1813 err = create_ch_ctls(codec, "LFE", 2, true,
1814 &spec->out_path[i]);
1815 if (err < 0)
1816 return err;
1817 } else {
1818 const char *pfx = chname[i];
1819 if (cfg->line_out_type == AUTO_PIN_SPEAKER_OUT &&
1820 cfg->line_outs == 1)
1821 pfx = "Speaker";
1822 err = create_ch_ctls(codec, pfx, 3, true,
1823 &spec->out_path[i]);
1824 if (err < 0)
1825 return err;
1826 }
1827 }
1828
1829 idx = get_connection_index(codec, spec->aa_mix_nid,
1830 spec->multiout.dac_nids[0]);
1831 if (idx < 0 && spec->dac_mixer_idx)
1832 idx = spec->dac_mixer_idx;
1833 if (idx >= 0) {
1834 /* add control to mixer */
1835 err = via_add_control(spec, VIA_CTL_WIDGET_VOL,
1836 "PCM Playback Volume",
1837 HDA_COMPOSE_AMP_VAL(spec->aa_mix_nid, 3,
1838 idx, HDA_INPUT));
1839 if (err < 0)
1840 return err;
1841 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE,
1842 "PCM Playback Switch",
1843 HDA_COMPOSE_AMP_VAL(spec->aa_mix_nid, 3,
1844 idx, HDA_INPUT));
1845 if (err < 0)
1846 return err;
1847 }
1848
1849 cfg->line_outs = old_line_outs;
1850
1851 return 0;
1852 }
1853
1854 static int via_auto_create_hp_ctls(struct hda_codec *codec, hda_nid_t pin)
1855 {
1856 struct via_spec *spec = codec->spec;
1857 struct nid_path *path;
1858 bool check_dac;
1859 int err;
1860
1861 if (!pin)
1862 return 0;
1863
1864 if (parse_output_path(codec, pin, 0, &spec->hp_path))
1865 spec->hp_dac_nid = spec->hp_path.path[0];
1866 else if (spec->multiout.dac_nids[HDA_SIDE] &&
1867 parse_output_path(codec, pin,
1868 spec->multiout.dac_nids[HDA_SIDE],
1869 &spec->hp_path)) {
1870 spec->hp_dac_nid = spec->hp_path.path[0];
1871 spec->hp_indep_shared = true;
1872 }
1873
1874 if (!parse_output_path(codec, pin, spec->multiout.dac_nids[HDA_FRONT],
1875 &spec->hp_dep_path) &&
1876 !spec->hp_dac_nid)
1877 return 0;
1878
1879 if (spec->hp_dac_nid && !spec->hp_indep_shared) {
1880 path = &spec->hp_path;
1881 check_dac = true;
1882 } else {
1883 path = &spec->hp_dep_path;
1884 check_dac = false;
1885 }
1886 err = create_ch_ctls(codec, "Headphone", 3, check_dac, path);
1887 if (err < 0)
1888 return err;
1889 if (spec->hp_dac_nid) {
1890 spec->hp_dep_path.vol_ctl = spec->hp_path.vol_ctl;
1891 spec->hp_dep_path.mute_ctl = spec->hp_path.mute_ctl;
1892 }
1893
1894 return 0;
1895 }
1896
1897 static int via_auto_create_speaker_ctls(struct hda_codec *codec)
1898 {
1899 struct via_spec *spec = codec->spec;
1900 hda_nid_t pin, dac;
1901
1902 pin = spec->autocfg.speaker_pins[0];
1903 if (!spec->autocfg.speaker_outs || !pin)
1904 return 0;
1905
1906 if (parse_output_path(codec, pin, 0, &spec->speaker_path)) {
1907 dac = spec->speaker_path.path[0];
1908 spec->multiout.extra_out_nid[0] = dac;
1909 return create_ch_ctls(codec, "Speaker", 3, true,
1910 &spec->speaker_path);
1911 }
1912 if (parse_output_path(codec, pin, spec->multiout.dac_nids[HDA_FRONT],
1913 &spec->speaker_path))
1914 return create_ch_ctls(codec, "Speaker", 3, false,
1915 &spec->speaker_path);
1916
1917 return 0;
1918 }
1919
1920 /* look for ADCs */
1921 static int via_fill_adcs(struct hda_codec *codec)
1922 {
1923 struct via_spec *spec = codec->spec;
1924 hda_nid_t nid = codec->start_nid;
1925 int i;
1926
1927 for (i = 0; i < codec->num_nodes; i++, nid++) {
1928 unsigned int wcaps = get_wcaps(codec, nid);
1929 if (get_wcaps_type(wcaps) != AC_WID_AUD_IN)
1930 continue;
1931 if (wcaps & AC_WCAP_DIGITAL)
1932 continue;
1933 if (!(wcaps & AC_WCAP_CONN_LIST))
1934 continue;
1935 if (spec->num_adc_nids >= ARRAY_SIZE(spec->adc_nids))
1936 return -ENOMEM;
1937 spec->adc_nids[spec->num_adc_nids++] = nid;
1938 }
1939 return 0;
1940 }
1941
1942 /* input-src control */
1943 static int via_mux_enum_info(struct snd_kcontrol *kcontrol,
1944 struct snd_ctl_elem_info *uinfo)
1945 {
1946 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1947 struct via_spec *spec = codec->spec;
1948
1949 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
1950 uinfo->count = 1;
1951 uinfo->value.enumerated.items = spec->num_inputs;
1952 if (uinfo->value.enumerated.item >= spec->num_inputs)
1953 uinfo->value.enumerated.item = spec->num_inputs - 1;
1954 strcpy(uinfo->value.enumerated.name,
1955 spec->inputs[uinfo->value.enumerated.item].label);
1956 return 0;
1957 }
1958
1959 static int via_mux_enum_get(struct snd_kcontrol *kcontrol,
1960 struct snd_ctl_elem_value *ucontrol)
1961 {
1962 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1963 struct via_spec *spec = codec->spec;
1964 unsigned int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
1965
1966 ucontrol->value.enumerated.item[0] = spec->cur_mux[idx];
1967 return 0;
1968 }
1969
1970 static int via_mux_enum_put(struct snd_kcontrol *kcontrol,
1971 struct snd_ctl_elem_value *ucontrol)
1972 {
1973 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1974 struct via_spec *spec = codec->spec;
1975 unsigned int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
1976 hda_nid_t mux;
1977 int cur;
1978
1979 cur = ucontrol->value.enumerated.item[0];
1980 if (cur < 0 || cur >= spec->num_inputs)
1981 return -EINVAL;
1982 if (spec->cur_mux[idx] == cur)
1983 return 0;
1984 spec->cur_mux[idx] = cur;
1985 if (spec->dyn_adc_switch) {
1986 int adc_idx = spec->inputs[cur].adc_idx;
1987 mux = spec->mux_nids[adc_idx];
1988 via_dyn_adc_pcm_resetup(codec, cur);
1989 } else {
1990 mux = spec->mux_nids[idx];
1991 if (snd_BUG_ON(!mux))
1992 return -EINVAL;
1993 }
1994
1995 if (mux) {
1996 /* switch to D0 beofre change index */
1997 if (snd_hda_codec_read(codec, mux, 0,
1998 AC_VERB_GET_POWER_STATE, 0x00) != AC_PWRST_D0)
1999 snd_hda_codec_write(codec, mux, 0,
2000 AC_VERB_SET_POWER_STATE, AC_PWRST_D0);
2001 snd_hda_codec_write(codec, mux, 0,
2002 AC_VERB_SET_CONNECT_SEL,
2003 spec->inputs[cur].mux_idx);
2004 }
2005
2006 /* update jack power state */
2007 set_widgets_power_state(codec);
2008 return 0;
2009 }
2010
2011 static const struct snd_kcontrol_new via_input_src_ctl = {
2012 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2013 /* The multiple "Capture Source" controls confuse alsamixer
2014 * So call somewhat different..
2015 */
2016 /* .name = "Capture Source", */
2017 .name = "Input Source",
2018 .info = via_mux_enum_info,
2019 .get = via_mux_enum_get,
2020 .put = via_mux_enum_put,
2021 };
2022
2023 static int create_input_src_ctls(struct hda_codec *codec, int count)
2024 {
2025 struct via_spec *spec = codec->spec;
2026 struct snd_kcontrol_new *knew;
2027
2028 if (spec->num_inputs <= 1 || !count)
2029 return 0; /* no need for single src */
2030
2031 knew = via_clone_control(spec, &via_input_src_ctl);
2032 if (!knew)
2033 return -ENOMEM;
2034 knew->count = count;
2035 return 0;
2036 }
2037
2038 /* add the powersave loopback-list entry */
2039 static void add_loopback_list(struct via_spec *spec, hda_nid_t mix, int idx)
2040 {
2041 struct hda_amp_list *list;
2042
2043 if (spec->num_loopbacks >= ARRAY_SIZE(spec->loopback_list) - 1)
2044 return;
2045 list = spec->loopback_list + spec->num_loopbacks;
2046 list->nid = mix;
2047 list->dir = HDA_INPUT;
2048 list->idx = idx;
2049 spec->num_loopbacks++;
2050 spec->loopback.amplist = spec->loopback_list;
2051 }
2052
2053 static bool is_reachable_nid(struct hda_codec *codec, hda_nid_t src,
2054 hda_nid_t dst)
2055 {
2056 return snd_hda_get_conn_index(codec, src, dst, 1) >= 0;
2057 }
2058
2059 /* add the input-route to the given pin */
2060 static bool add_input_route(struct hda_codec *codec, hda_nid_t pin)
2061 {
2062 struct via_spec *spec = codec->spec;
2063 int c, idx;
2064
2065 spec->inputs[spec->num_inputs].adc_idx = -1;
2066 spec->inputs[spec->num_inputs].pin = pin;
2067 for (c = 0; c < spec->num_adc_nids; c++) {
2068 if (spec->mux_nids[c]) {
2069 idx = get_connection_index(codec, spec->mux_nids[c],
2070 pin);
2071 if (idx < 0)
2072 continue;
2073 spec->inputs[spec->num_inputs].mux_idx = idx;
2074 } else {
2075 if (!is_reachable_nid(codec, spec->adc_nids[c], pin))
2076 continue;
2077 }
2078 spec->inputs[spec->num_inputs].adc_idx = c;
2079 /* Can primary ADC satisfy all inputs? */
2080 if (!spec->dyn_adc_switch &&
2081 spec->num_inputs > 0 && spec->inputs[0].adc_idx != c) {
2082 snd_printd(KERN_INFO
2083 "via: dynamic ADC switching enabled\n");
2084 spec->dyn_adc_switch = 1;
2085 }
2086 return true;
2087 }
2088 return false;
2089 }
2090
2091 static int get_mux_nids(struct hda_codec *codec);
2092
2093 /* parse input-routes; fill ADCs, MUXs and input-src entries */
2094 static int parse_analog_inputs(struct hda_codec *codec)
2095 {
2096 struct via_spec *spec = codec->spec;
2097 const struct auto_pin_cfg *cfg = &spec->autocfg;
2098 int i, err;
2099
2100 err = via_fill_adcs(codec);
2101 if (err < 0)
2102 return err;
2103 err = get_mux_nids(codec);
2104 if (err < 0)
2105 return err;
2106
2107 /* fill all input-routes */
2108 for (i = 0; i < cfg->num_inputs; i++) {
2109 if (add_input_route(codec, cfg->inputs[i].pin))
2110 spec->inputs[spec->num_inputs++].label =
2111 hda_get_autocfg_input_label(codec, cfg, i);
2112 }
2113
2114 /* check for internal loopback recording */
2115 if (spec->aa_mix_nid &&
2116 add_input_route(codec, spec->aa_mix_nid))
2117 spec->inputs[spec->num_inputs++].label = "Stereo Mixer";
2118
2119 return 0;
2120 }
2121
2122 /* create analog-loopback volume/switch controls */
2123 static int create_loopback_ctls(struct hda_codec *codec)
2124 {
2125 struct via_spec *spec = codec->spec;
2126 const struct auto_pin_cfg *cfg = &spec->autocfg;
2127 const char *prev_label = NULL;
2128 int type_idx = 0;
2129 int i, j, err, idx;
2130
2131 if (!spec->aa_mix_nid)
2132 return 0;
2133
2134 for (i = 0; i < cfg->num_inputs; i++) {
2135 hda_nid_t pin = cfg->inputs[i].pin;
2136 const char *label = hda_get_autocfg_input_label(codec, cfg, i);
2137
2138 if (prev_label && !strcmp(label, prev_label))
2139 type_idx++;
2140 else
2141 type_idx = 0;
2142 prev_label = label;
2143 idx = get_connection_index(codec, spec->aa_mix_nid, pin);
2144 if (idx >= 0) {
2145 err = via_new_analog_input(spec, label, type_idx,
2146 idx, spec->aa_mix_nid);
2147 if (err < 0)
2148 return err;
2149 add_loopback_list(spec, spec->aa_mix_nid, idx);
2150 }
2151
2152 /* remember the label for smart51 control */
2153 for (j = 0; j < spec->smart51_nums; j++) {
2154 if (spec->smart51_pins[j] == pin) {
2155 spec->smart51_idxs[j] = idx;
2156 spec->smart51_labels[j] = label;
2157 break;
2158 }
2159 }
2160 }
2161 return 0;
2162 }
2163
2164 /* create mic-boost controls (if present) */
2165 static int create_mic_boost_ctls(struct hda_codec *codec)
2166 {
2167 struct via_spec *spec = codec->spec;
2168 const struct auto_pin_cfg *cfg = &spec->autocfg;
2169 int i, err;
2170
2171 for (i = 0; i < cfg->num_inputs; i++) {
2172 hda_nid_t pin = cfg->inputs[i].pin;
2173 unsigned int caps;
2174 const char *label;
2175 char name[32];
2176
2177 if (cfg->inputs[i].type != AUTO_PIN_MIC)
2178 continue;
2179 caps = query_amp_caps(codec, pin, HDA_INPUT);
2180 if (caps == -1 || !(caps & AC_AMPCAP_NUM_STEPS))
2181 continue;
2182 label = hda_get_autocfg_input_label(codec, cfg, i);
2183 snprintf(name, sizeof(name), "%s Boost Volume", label);
2184 err = via_add_control(spec, VIA_CTL_WIDGET_VOL, name,
2185 HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_INPUT));
2186 if (err < 0)
2187 return err;
2188 }
2189 return 0;
2190 }
2191
2192 /* create capture and input-src controls for multiple streams */
2193 static int create_multi_adc_ctls(struct hda_codec *codec)
2194 {
2195 struct via_spec *spec = codec->spec;
2196 int i, err;
2197
2198 /* create capture mixer elements */
2199 for (i = 0; i < spec->num_adc_nids; i++) {
2200 hda_nid_t adc = spec->adc_nids[i];
2201 err = __via_add_control(spec, VIA_CTL_WIDGET_VOL,
2202 "Capture Volume", i,
2203 HDA_COMPOSE_AMP_VAL(adc, 3, 0,
2204 HDA_INPUT));
2205 if (err < 0)
2206 return err;
2207 err = __via_add_control(spec, VIA_CTL_WIDGET_MUTE,
2208 "Capture Switch", i,
2209 HDA_COMPOSE_AMP_VAL(adc, 3, 0,
2210 HDA_INPUT));
2211 if (err < 0)
2212 return err;
2213 }
2214
2215 /* input-source control */
2216 for (i = 0; i < spec->num_adc_nids; i++)
2217 if (!spec->mux_nids[i])
2218 break;
2219 err = create_input_src_ctls(codec, i);
2220 if (err < 0)
2221 return err;
2222 return 0;
2223 }
2224
2225 /* bind capture volume/switch */
2226 static struct snd_kcontrol_new via_bind_cap_vol_ctl =
2227 HDA_BIND_VOL("Capture Volume", 0);
2228 static struct snd_kcontrol_new via_bind_cap_sw_ctl =
2229 HDA_BIND_SW("Capture Switch", 0);
2230
2231 static int init_bind_ctl(struct via_spec *spec, struct hda_bind_ctls **ctl_ret,
2232 struct hda_ctl_ops *ops)
2233 {
2234 struct hda_bind_ctls *ctl;
2235 int i;
2236
2237 ctl = kzalloc(sizeof(*ctl) + sizeof(long) * 4, GFP_KERNEL);
2238 if (!ctl)
2239 return -ENOMEM;
2240 ctl->ops = ops;
2241 for (i = 0; i < spec->num_adc_nids; i++)
2242 ctl->values[i] =
2243 HDA_COMPOSE_AMP_VAL(spec->adc_nids[i], 3, 0, HDA_INPUT);
2244 *ctl_ret = ctl;
2245 return 0;
2246 }
2247
2248 /* create capture and input-src controls for dynamic ADC-switch case */
2249 static int create_dyn_adc_ctls(struct hda_codec *codec)
2250 {
2251 struct via_spec *spec = codec->spec;
2252 struct snd_kcontrol_new *knew;
2253 int err;
2254
2255 /* set up the bind capture ctls */
2256 err = init_bind_ctl(spec, &spec->bind_cap_vol, &snd_hda_bind_vol);
2257 if (err < 0)
2258 return err;
2259 err = init_bind_ctl(spec, &spec->bind_cap_sw, &snd_hda_bind_sw);
2260 if (err < 0)
2261 return err;
2262
2263 /* create capture mixer elements */
2264 knew = via_clone_control(spec, &via_bind_cap_vol_ctl);
2265 if (!knew)
2266 return -ENOMEM;
2267 knew->private_value = (long)spec->bind_cap_vol;
2268
2269 knew = via_clone_control(spec, &via_bind_cap_sw_ctl);
2270 if (!knew)
2271 return -ENOMEM;
2272 knew->private_value = (long)spec->bind_cap_sw;
2273
2274 /* input-source control */
2275 err = create_input_src_ctls(codec, 1);
2276 if (err < 0)
2277 return err;
2278 return 0;
2279 }
2280
2281 /* parse and create capture-related stuff */
2282 static int via_auto_create_analog_input_ctls(struct hda_codec *codec)
2283 {
2284 struct via_spec *spec = codec->spec;
2285 int err;
2286
2287 err = parse_analog_inputs(codec);
2288 if (err < 0)
2289 return err;
2290 if (spec->dyn_adc_switch)
2291 err = create_dyn_adc_ctls(codec);
2292 else
2293 err = create_multi_adc_ctls(codec);
2294 if (err < 0)
2295 return err;
2296 err = create_loopback_ctls(codec);
2297 if (err < 0)
2298 return err;
2299 err = create_mic_boost_ctls(codec);
2300 if (err < 0)
2301 return err;
2302 return 0;
2303 }
2304
2305 static void vt1708_set_pinconfig_connect(struct hda_codec *codec, hda_nid_t nid)
2306 {
2307 unsigned int def_conf;
2308 unsigned char seqassoc;
2309
2310 def_conf = snd_hda_codec_get_pincfg(codec, nid);
2311 seqassoc = (unsigned char) get_defcfg_association(def_conf);
2312 seqassoc = (seqassoc << 4) | get_defcfg_sequence(def_conf);
2313 if (get_defcfg_connect(def_conf) == AC_JACK_PORT_NONE
2314 && (seqassoc == 0xf0 || seqassoc == 0xff)) {
2315 def_conf = def_conf & (~(AC_JACK_PORT_BOTH << 30));
2316 snd_hda_codec_set_pincfg(codec, nid, def_conf);
2317 }
2318
2319 return;
2320 }
2321
2322 static int vt1708_jack_detect_get(struct snd_kcontrol *kcontrol,
2323 struct snd_ctl_elem_value *ucontrol)
2324 {
2325 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2326 struct via_spec *spec = codec->spec;
2327
2328 if (spec->codec_type != VT1708)
2329 return 0;
2330 spec->vt1708_jack_detect =
2331 !((snd_hda_codec_read(codec, 0x1, 0, 0xf84, 0) >> 8) & 0x1);
2332 ucontrol->value.integer.value[0] = spec->vt1708_jack_detect;
2333 return 0;
2334 }
2335
2336 static int vt1708_jack_detect_put(struct snd_kcontrol *kcontrol,
2337 struct snd_ctl_elem_value *ucontrol)
2338 {
2339 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2340 struct via_spec *spec = codec->spec;
2341 int change;
2342
2343 if (spec->codec_type != VT1708)
2344 return 0;
2345 spec->vt1708_jack_detect = ucontrol->value.integer.value[0];
2346 change = (0x1 & (snd_hda_codec_read(codec, 0x1, 0, 0xf84, 0) >> 8))
2347 == !spec->vt1708_jack_detect;
2348 if (spec->vt1708_jack_detect) {
2349 mute_aa_path(codec, 1);
2350 notify_aa_path_ctls(codec);
2351 }
2352 return change;
2353 }
2354
2355 static const struct snd_kcontrol_new vt1708_jack_detect_ctl = {
2356 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2357 .name = "Jack Detect",
2358 .count = 1,
2359 .info = snd_ctl_boolean_mono_info,
2360 .get = vt1708_jack_detect_get,
2361 .put = vt1708_jack_detect_put,
2362 };
2363
2364 static void fill_dig_outs(struct hda_codec *codec);
2365 static void fill_dig_in(struct hda_codec *codec);
2366
2367 static int via_parse_auto_config(struct hda_codec *codec)
2368 {
2369 struct via_spec *spec = codec->spec;
2370 int err;
2371
2372 err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, NULL);
2373 if (err < 0)
2374 return err;
2375 if (!spec->autocfg.line_outs && !spec->autocfg.hp_pins[0])
2376 return -EINVAL;
2377
2378 err = via_auto_create_multi_out_ctls(codec);
2379 if (err < 0)
2380 return err;
2381 err = via_auto_create_hp_ctls(codec, spec->autocfg.hp_pins[0]);
2382 if (err < 0)
2383 return err;
2384 err = via_auto_create_speaker_ctls(codec);
2385 if (err < 0)
2386 return err;
2387 err = via_auto_create_analog_input_ctls(codec);
2388 if (err < 0)
2389 return err;
2390
2391 spec->multiout.max_channels = spec->multiout.num_dacs * 2;
2392
2393 fill_dig_outs(codec);
2394 fill_dig_in(codec);
2395
2396 if (spec->kctls.list)
2397 spec->mixers[spec->num_mixers++] = spec->kctls.list;
2398
2399
2400 if (spec->hp_dac_nid && spec->hp_dep_path.depth) {
2401 err = via_hp_build(codec);
2402 if (err < 0)
2403 return err;
2404 }
2405
2406 err = via_smart51_build(codec);
2407 if (err < 0)
2408 return err;
2409
2410 /* assign slave outs */
2411 if (spec->slave_dig_outs[0])
2412 codec->slave_dig_outs = spec->slave_dig_outs;
2413
2414 return 1;
2415 }
2416
2417 static void via_auto_init_dig_outs(struct hda_codec *codec)
2418 {
2419 struct via_spec *spec = codec->spec;
2420 if (spec->multiout.dig_out_nid)
2421 init_output_pin(codec, spec->autocfg.dig_out_pins[0], PIN_OUT);
2422 if (spec->slave_dig_outs[0])
2423 init_output_pin(codec, spec->autocfg.dig_out_pins[1], PIN_OUT);
2424 }
2425
2426 static void via_auto_init_dig_in(struct hda_codec *codec)
2427 {
2428 struct via_spec *spec = codec->spec;
2429 if (!spec->dig_in_nid)
2430 return;
2431 snd_hda_codec_write(codec, spec->autocfg.dig_in_pin, 0,
2432 AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN);
2433 }
2434
2435 /* initialize the unsolicited events */
2436 static void via_auto_init_unsol_event(struct hda_codec *codec)
2437 {
2438 struct via_spec *spec = codec->spec;
2439 struct auto_pin_cfg *cfg = &spec->autocfg;
2440 unsigned int ev;
2441 int i;
2442
2443 if (cfg->hp_pins[0] && is_jack_detectable(codec, cfg->hp_pins[0]))
2444 snd_hda_codec_write(codec, cfg->hp_pins[0], 0,
2445 AC_VERB_SET_UNSOLICITED_ENABLE,
2446 AC_USRSP_EN | VIA_HP_EVENT | VIA_JACK_EVENT);
2447
2448 if (cfg->speaker_pins[0])
2449 ev = VIA_LINE_EVENT;
2450 else
2451 ev = 0;
2452 for (i = 0; i < cfg->line_outs; i++) {
2453 if (cfg->line_out_pins[i] &&
2454 is_jack_detectable(codec, cfg->line_out_pins[i]))
2455 snd_hda_codec_write(codec, cfg->line_out_pins[i], 0,
2456 AC_VERB_SET_UNSOLICITED_ENABLE,
2457 AC_USRSP_EN | ev | VIA_JACK_EVENT);
2458 }
2459
2460 for (i = 0; i < cfg->num_inputs; i++) {
2461 if (is_jack_detectable(codec, cfg->inputs[i].pin))
2462 snd_hda_codec_write(codec, cfg->inputs[i].pin, 0,
2463 AC_VERB_SET_UNSOLICITED_ENABLE,
2464 AC_USRSP_EN | VIA_JACK_EVENT);
2465 }
2466 }
2467
2468 static int via_init(struct hda_codec *codec)
2469 {
2470 struct via_spec *spec = codec->spec;
2471 int i;
2472
2473 for (i = 0; i < spec->num_iverbs; i++)
2474 snd_hda_sequence_write(codec, spec->init_verbs[i]);
2475
2476 via_auto_init_multi_out(codec);
2477 via_auto_init_hp_out(codec);
2478 via_auto_init_speaker_out(codec);
2479 via_auto_init_analog_input(codec);
2480 via_auto_init_dig_outs(codec);
2481 via_auto_init_dig_in(codec);
2482
2483 via_auto_init_unsol_event(codec);
2484
2485 via_hp_automute(codec);
2486 via_line_automute(codec, false);
2487
2488 return 0;
2489 }
2490
2491 static void vt1708_update_hp_jack_state(struct work_struct *work)
2492 {
2493 struct via_spec *spec = container_of(work, struct via_spec,
2494 vt1708_hp_work.work);
2495 if (spec->codec_type != VT1708)
2496 return;
2497 /* if jack state toggled */
2498 if (spec->vt1708_hp_present
2499 != snd_hda_jack_detect(spec->codec, spec->autocfg.hp_pins[0])) {
2500 spec->vt1708_hp_present ^= 1;
2501 via_hp_automute(spec->codec);
2502 }
2503 vt1708_start_hp_work(spec);
2504 }
2505
2506 static int get_mux_nids(struct hda_codec *codec)
2507 {
2508 struct via_spec *spec = codec->spec;
2509 hda_nid_t nid, conn[8];
2510 unsigned int type;
2511 int i, n;
2512
2513 for (i = 0; i < spec->num_adc_nids; i++) {
2514 nid = spec->adc_nids[i];
2515 while (nid) {
2516 type = get_wcaps_type(get_wcaps(codec, nid));
2517 if (type == AC_WID_PIN)
2518 break;
2519 n = snd_hda_get_connections(codec, nid, conn,
2520 ARRAY_SIZE(conn));
2521 if (n <= 0)
2522 break;
2523 if (n > 1) {
2524 spec->mux_nids[i] = nid;
2525 break;
2526 }
2527 nid = conn[0];
2528 }
2529 }
2530 return 0;
2531 }
2532
2533 static int patch_vt1708(struct hda_codec *codec)
2534 {
2535 struct via_spec *spec;
2536 int err;
2537
2538 /* create a codec specific record */
2539 spec = via_new_spec(codec);
2540 if (spec == NULL)
2541 return -ENOMEM;
2542
2543 spec->aa_mix_nid = 0x17;
2544
2545 /* Add HP and CD pin config connect bit re-config action */
2546 vt1708_set_pinconfig_connect(codec, VT1708_HP_PIN_NID);
2547 vt1708_set_pinconfig_connect(codec, VT1708_CD_PIN_NID);
2548
2549 /* automatic parse from the BIOS config */
2550 err = via_parse_auto_config(codec);
2551 if (err < 0) {
2552 via_free(codec);
2553 return err;
2554 }
2555
2556 /* add jack detect on/off control */
2557 if (!via_clone_control(spec, &vt1708_jack_detect_ctl))
2558 return -ENOMEM;
2559
2560 /* disable 32bit format on VT1708 */
2561 if (codec->vendor_id == 0x11061708)
2562 spec->stream_analog_playback = &vt1708_pcm_analog_s16_playback;
2563
2564 spec->init_verbs[spec->num_iverbs++] = vt1708_init_verbs;
2565
2566 codec->patch_ops = via_patch_ops;
2567
2568 INIT_DELAYED_WORK(&spec->vt1708_hp_work, vt1708_update_hp_jack_state);
2569 return 0;
2570 }
2571
2572 static int patch_vt1709(struct hda_codec *codec)
2573 {
2574 struct via_spec *spec;
2575 int err;
2576
2577 /* create a codec specific record */
2578 spec = via_new_spec(codec);
2579 if (spec == NULL)
2580 return -ENOMEM;
2581
2582 spec->aa_mix_nid = 0x18;
2583
2584 err = via_parse_auto_config(codec);
2585 if (err < 0) {
2586 via_free(codec);
2587 return err;
2588 }
2589
2590 codec->patch_ops = via_patch_ops;
2591
2592 return 0;
2593 }
2594
2595 static void set_widgets_power_state_vt1708B(struct hda_codec *codec)
2596 {
2597 struct via_spec *spec = codec->spec;
2598 int imux_is_smixer;
2599 unsigned int parm;
2600 int is_8ch = 0;
2601 if ((spec->codec_type != VT1708B_4CH) &&
2602 (codec->vendor_id != 0x11064397))
2603 is_8ch = 1;
2604
2605 /* SW0 (17h) = stereo mixer */
2606 imux_is_smixer =
2607 (snd_hda_codec_read(codec, 0x17, 0, AC_VERB_GET_CONNECT_SEL, 0x00)
2608 == ((spec->codec_type == VT1708S) ? 5 : 0));
2609 /* inputs */
2610 /* PW 1/2/5 (1ah/1bh/1eh) */
2611 parm = AC_PWRST_D3;
2612 set_pin_power_state(codec, 0x1a, &parm);
2613 set_pin_power_state(codec, 0x1b, &parm);
2614 set_pin_power_state(codec, 0x1e, &parm);
2615 if (imux_is_smixer)
2616 parm = AC_PWRST_D0;
2617 /* SW0 (17h), AIW 0/1 (13h/14h) */
2618 snd_hda_codec_write(codec, 0x17, 0, AC_VERB_SET_POWER_STATE, parm);
2619 snd_hda_codec_write(codec, 0x13, 0, AC_VERB_SET_POWER_STATE, parm);
2620 snd_hda_codec_write(codec, 0x14, 0, AC_VERB_SET_POWER_STATE, parm);
2621
2622 /* outputs */
2623 /* PW0 (19h), SW1 (18h), AOW1 (11h) */
2624 parm = AC_PWRST_D3;
2625 set_pin_power_state(codec, 0x19, &parm);
2626 if (spec->smart51_enabled)
2627 set_pin_power_state(codec, 0x1b, &parm);
2628 snd_hda_codec_write(codec, 0x18, 0, AC_VERB_SET_POWER_STATE, parm);
2629 snd_hda_codec_write(codec, 0x11, 0, AC_VERB_SET_POWER_STATE, parm);
2630
2631 /* PW6 (22h), SW2 (26h), AOW2 (24h) */
2632 if (is_8ch) {
2633 parm = AC_PWRST_D3;
2634 set_pin_power_state(codec, 0x22, &parm);
2635 if (spec->smart51_enabled)
2636 set_pin_power_state(codec, 0x1a, &parm);
2637 snd_hda_codec_write(codec, 0x26, 0,
2638 AC_VERB_SET_POWER_STATE, parm);
2639 snd_hda_codec_write(codec, 0x24, 0,
2640 AC_VERB_SET_POWER_STATE, parm);
2641 } else if (codec->vendor_id == 0x11064397) {
2642 /* PW7(23h), SW2(27h), AOW2(25h) */
2643 parm = AC_PWRST_D3;
2644 set_pin_power_state(codec, 0x23, &parm);
2645 if (spec->smart51_enabled)
2646 set_pin_power_state(codec, 0x1a, &parm);
2647 snd_hda_codec_write(codec, 0x27, 0,
2648 AC_VERB_SET_POWER_STATE, parm);
2649 snd_hda_codec_write(codec, 0x25, 0,
2650 AC_VERB_SET_POWER_STATE, parm);
2651 }
2652
2653 /* PW 3/4/7 (1ch/1dh/23h) */
2654 parm = AC_PWRST_D3;
2655 /* force to D0 for internal Speaker */
2656 set_pin_power_state(codec, 0x1c, &parm);
2657 set_pin_power_state(codec, 0x1d, &parm);
2658 if (is_8ch)
2659 set_pin_power_state(codec, 0x23, &parm);
2660
2661 /* MW0 (16h), Sw3 (27h), AOW 0/3 (10h/25h) */
2662 snd_hda_codec_write(codec, 0x16, 0, AC_VERB_SET_POWER_STATE,
2663 imux_is_smixer ? AC_PWRST_D0 : parm);
2664 snd_hda_codec_write(codec, 0x10, 0, AC_VERB_SET_POWER_STATE, parm);
2665 if (is_8ch) {
2666 snd_hda_codec_write(codec, 0x25, 0,
2667 AC_VERB_SET_POWER_STATE, parm);
2668 snd_hda_codec_write(codec, 0x27, 0,
2669 AC_VERB_SET_POWER_STATE, parm);
2670 } else if (codec->vendor_id == 0x11064397 && spec->hp_independent_mode)
2671 snd_hda_codec_write(codec, 0x25, 0,
2672 AC_VERB_SET_POWER_STATE, parm);
2673 }
2674
2675 static int patch_vt1708S(struct hda_codec *codec);
2676 static int patch_vt1708B(struct hda_codec *codec)
2677 {
2678 struct via_spec *spec;
2679 int err;
2680
2681 if (get_codec_type(codec) == VT1708BCE)
2682 return patch_vt1708S(codec);
2683
2684 /* create a codec specific record */
2685 spec = via_new_spec(codec);
2686 if (spec == NULL)
2687 return -ENOMEM;
2688
2689 spec->aa_mix_nid = 0x16;
2690
2691 /* automatic parse from the BIOS config */
2692 err = via_parse_auto_config(codec);
2693 if (err < 0) {
2694 via_free(codec);
2695 return err;
2696 }
2697
2698 codec->patch_ops = via_patch_ops;
2699
2700 spec->set_widgets_power_state = set_widgets_power_state_vt1708B;
2701
2702 return 0;
2703 }
2704
2705 /* Patch for VT1708S */
2706 static const struct hda_verb vt1708S_init_verbs[] = {
2707 /* Enable Mic Boost Volume backdoor */
2708 {0x1, 0xf98, 0x1},
2709 /* don't bybass mixer */
2710 {0x1, 0xf88, 0xc0},
2711 { }
2712 };
2713
2714 /* fill out digital output widgets; one for master and one for slave outputs */
2715 static void fill_dig_outs(struct hda_codec *codec)
2716 {
2717 struct via_spec *spec = codec->spec;
2718 int i;
2719
2720 for (i = 0; i < spec->autocfg.dig_outs; i++) {
2721 hda_nid_t nid;
2722 int conn;
2723
2724 nid = spec->autocfg.dig_out_pins[i];
2725 if (!nid)
2726 continue;
2727 conn = snd_hda_get_connections(codec, nid, &nid, 1);
2728 if (conn < 1)
2729 continue;
2730 if (!spec->multiout.dig_out_nid)
2731 spec->multiout.dig_out_nid = nid;
2732 else {
2733 spec->slave_dig_outs[0] = nid;
2734 break; /* at most two dig outs */
2735 }
2736 }
2737 }
2738
2739 static void fill_dig_in(struct hda_codec *codec)
2740 {
2741 struct via_spec *spec = codec->spec;
2742 hda_nid_t dig_nid;
2743 int i, err;
2744
2745 if (!spec->autocfg.dig_in_pin)
2746 return;
2747
2748 dig_nid = codec->start_nid;
2749 for (i = 0; i < codec->num_nodes; i++, dig_nid++) {
2750 unsigned int wcaps = get_wcaps(codec, dig_nid);
2751 if (get_wcaps_type(wcaps) != AC_WID_AUD_IN)
2752 continue;
2753 if (!(wcaps & AC_WCAP_DIGITAL))
2754 continue;
2755 if (!(wcaps & AC_WCAP_CONN_LIST))
2756 continue;
2757 err = get_connection_index(codec, dig_nid,
2758 spec->autocfg.dig_in_pin);
2759 if (err >= 0) {
2760 spec->dig_in_nid = dig_nid;
2761 break;
2762 }
2763 }
2764 }
2765
2766 static void override_mic_boost(struct hda_codec *codec, hda_nid_t pin,
2767 int offset, int num_steps, int step_size)
2768 {
2769 snd_hda_override_amp_caps(codec, pin, HDA_INPUT,
2770 (offset << AC_AMPCAP_OFFSET_SHIFT) |
2771 (num_steps << AC_AMPCAP_NUM_STEPS_SHIFT) |
2772 (step_size << AC_AMPCAP_STEP_SIZE_SHIFT) |
2773 (0 << AC_AMPCAP_MUTE_SHIFT));
2774 }
2775
2776 static int patch_vt1708S(struct hda_codec *codec)
2777 {
2778 struct via_spec *spec;
2779 int err;
2780
2781 /* create a codec specific record */
2782 spec = via_new_spec(codec);
2783 if (spec == NULL)
2784 return -ENOMEM;
2785
2786 spec->aa_mix_nid = 0x16;
2787 override_mic_boost(codec, 0x1a, 0, 3, 40);
2788 override_mic_boost(codec, 0x1e, 0, 3, 40);
2789
2790 /* automatic parse from the BIOS config */
2791 err = via_parse_auto_config(codec);
2792 if (err < 0) {
2793 via_free(codec);
2794 return err;
2795 }
2796
2797 spec->init_verbs[spec->num_iverbs++] = vt1708S_init_verbs;
2798
2799 codec->patch_ops = via_patch_ops;
2800
2801 /* correct names for VT1708BCE */
2802 if (get_codec_type(codec) == VT1708BCE) {
2803 kfree(codec->chip_name);
2804 codec->chip_name = kstrdup("VT1708BCE", GFP_KERNEL);
2805 snprintf(codec->bus->card->mixername,
2806 sizeof(codec->bus->card->mixername),
2807 "%s %s", codec->vendor_name, codec->chip_name);
2808 }
2809 /* correct names for VT1705 */
2810 if (codec->vendor_id == 0x11064397) {
2811 kfree(codec->chip_name);
2812 codec->chip_name = kstrdup("VT1705", GFP_KERNEL);
2813 snprintf(codec->bus->card->mixername,
2814 sizeof(codec->bus->card->mixername),
2815 "%s %s", codec->vendor_name, codec->chip_name);
2816 }
2817 spec->set_widgets_power_state = set_widgets_power_state_vt1708B;
2818 return 0;
2819 }
2820
2821 /* Patch for VT1702 */
2822
2823 static const struct hda_verb vt1702_init_verbs[] = {
2824 /* mixer enable */
2825 {0x1, 0xF88, 0x3},
2826 /* GPIO 0~2 */
2827 {0x1, 0xF82, 0x3F},
2828 { }
2829 };
2830
2831 static void set_widgets_power_state_vt1702(struct hda_codec *codec)
2832 {
2833 int imux_is_smixer =
2834 snd_hda_codec_read(codec, 0x13, 0, AC_VERB_GET_CONNECT_SEL, 0x00) == 3;
2835 unsigned int parm;
2836 /* inputs */
2837 /* PW 1/2/5 (14h/15h/18h) */
2838 parm = AC_PWRST_D3;
2839 set_pin_power_state(codec, 0x14, &parm);
2840 set_pin_power_state(codec, 0x15, &parm);
2841 set_pin_power_state(codec, 0x18, &parm);
2842 if (imux_is_smixer)
2843 parm = AC_PWRST_D0; /* SW0 (13h) = stereo mixer (idx 3) */
2844 /* SW0 (13h), AIW 0/1/2 (12h/1fh/20h) */
2845 snd_hda_codec_write(codec, 0x13, 0, AC_VERB_SET_POWER_STATE, parm);
2846 snd_hda_codec_write(codec, 0x12, 0, AC_VERB_SET_POWER_STATE, parm);
2847 snd_hda_codec_write(codec, 0x1f, 0, AC_VERB_SET_POWER_STATE, parm);
2848 snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_POWER_STATE, parm);
2849
2850 /* outputs */
2851 /* PW 3/4 (16h/17h) */
2852 parm = AC_PWRST_D3;
2853 set_pin_power_state(codec, 0x17, &parm);
2854 set_pin_power_state(codec, 0x16, &parm);
2855 /* MW0 (1ah), AOW 0/1 (10h/1dh) */
2856 snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_POWER_STATE,
2857 imux_is_smixer ? AC_PWRST_D0 : parm);
2858 snd_hda_codec_write(codec, 0x10, 0, AC_VERB_SET_POWER_STATE, parm);
2859 snd_hda_codec_write(codec, 0x1d, 0, AC_VERB_SET_POWER_STATE, parm);
2860 }
2861
2862 static int patch_vt1702(struct hda_codec *codec)
2863 {
2864 struct via_spec *spec;
2865 int err;
2866
2867 /* create a codec specific record */
2868 spec = via_new_spec(codec);
2869 if (spec == NULL)
2870 return -ENOMEM;
2871
2872 spec->aa_mix_nid = 0x1a;
2873
2874 /* limit AA path volume to 0 dB */
2875 snd_hda_override_amp_caps(codec, 0x1A, HDA_INPUT,
2876 (0x17 << AC_AMPCAP_OFFSET_SHIFT) |
2877 (0x17 << AC_AMPCAP_NUM_STEPS_SHIFT) |
2878 (0x5 << AC_AMPCAP_STEP_SIZE_SHIFT) |
2879 (1 << AC_AMPCAP_MUTE_SHIFT));
2880
2881 /* automatic parse from the BIOS config */
2882 err = via_parse_auto_config(codec);
2883 if (err < 0) {
2884 via_free(codec);
2885 return err;
2886 }
2887
2888 spec->init_verbs[spec->num_iverbs++] = vt1702_init_verbs;
2889
2890 codec->patch_ops = via_patch_ops;
2891
2892 spec->set_widgets_power_state = set_widgets_power_state_vt1702;
2893 return 0;
2894 }
2895
2896 /* Patch for VT1718S */
2897
2898 static const struct hda_verb vt1718S_init_verbs[] = {
2899 /* Enable MW0 adjust Gain 5 */
2900 {0x1, 0xfb2, 0x10},
2901 /* Enable Boost Volume backdoor */
2902 {0x1, 0xf88, 0x8},
2903
2904 { }
2905 };
2906
2907 static void set_widgets_power_state_vt1718S(struct hda_codec *codec)
2908 {
2909 struct via_spec *spec = codec->spec;
2910 int imux_is_smixer;
2911 unsigned int parm;
2912 /* MUX6 (1eh) = stereo mixer */
2913 imux_is_smixer =
2914 snd_hda_codec_read(codec, 0x1e, 0, AC_VERB_GET_CONNECT_SEL, 0x00) == 5;
2915 /* inputs */
2916 /* PW 5/6/7 (29h/2ah/2bh) */
2917 parm = AC_PWRST_D3;
2918 set_pin_power_state(codec, 0x29, &parm);
2919 set_pin_power_state(codec, 0x2a, &parm);
2920 set_pin_power_state(codec, 0x2b, &parm);
2921 if (imux_is_smixer)
2922 parm = AC_PWRST_D0;
2923 /* MUX6/7 (1eh/1fh), AIW 0/1 (10h/11h) */
2924 snd_hda_codec_write(codec, 0x1e, 0, AC_VERB_SET_POWER_STATE, parm);
2925 snd_hda_codec_write(codec, 0x1f, 0, AC_VERB_SET_POWER_STATE, parm);
2926 snd_hda_codec_write(codec, 0x10, 0, AC_VERB_SET_POWER_STATE, parm);
2927 snd_hda_codec_write(codec, 0x11, 0, AC_VERB_SET_POWER_STATE, parm);
2928
2929 /* outputs */
2930 /* PW3 (27h), MW2 (1ah), AOW3 (bh) */
2931 parm = AC_PWRST_D3;
2932 set_pin_power_state(codec, 0x27, &parm);
2933 snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_POWER_STATE, parm);
2934 snd_hda_codec_write(codec, 0xb, 0, AC_VERB_SET_POWER_STATE, parm);
2935
2936 /* PW2 (26h), AOW2 (ah) */
2937 parm = AC_PWRST_D3;
2938 set_pin_power_state(codec, 0x26, &parm);
2939 if (spec->smart51_enabled)
2940 set_pin_power_state(codec, 0x2b, &parm);
2941 snd_hda_codec_write(codec, 0xa, 0, AC_VERB_SET_POWER_STATE, parm);
2942
2943 /* PW0 (24h), AOW0 (8h) */
2944 parm = AC_PWRST_D3;
2945 set_pin_power_state(codec, 0x24, &parm);
2946 if (!spec->hp_independent_mode) /* check for redirected HP */
2947 set_pin_power_state(codec, 0x28, &parm);
2948 snd_hda_codec_write(codec, 0x8, 0, AC_VERB_SET_POWER_STATE, parm);
2949 /* MW9 (21h), Mw2 (1ah), AOW0 (8h) */
2950 snd_hda_codec_write(codec, 0x21, 0, AC_VERB_SET_POWER_STATE,
2951 imux_is_smixer ? AC_PWRST_D0 : parm);
2952
2953 /* PW1 (25h), AOW1 (9h) */
2954 parm = AC_PWRST_D3;
2955 set_pin_power_state(codec, 0x25, &parm);
2956 if (spec->smart51_enabled)
2957 set_pin_power_state(codec, 0x2a, &parm);
2958 snd_hda_codec_write(codec, 0x9, 0, AC_VERB_SET_POWER_STATE, parm);
2959
2960 if (spec->hp_independent_mode) {
2961 /* PW4 (28h), MW3 (1bh), MUX1(34h), AOW4 (ch) */
2962 parm = AC_PWRST_D3;
2963 set_pin_power_state(codec, 0x28, &parm);
2964 snd_hda_codec_write(codec, 0x1b, 0,
2965 AC_VERB_SET_POWER_STATE, parm);
2966 snd_hda_codec_write(codec, 0x34, 0,
2967 AC_VERB_SET_POWER_STATE, parm);
2968 snd_hda_codec_write(codec, 0xc, 0,
2969 AC_VERB_SET_POWER_STATE, parm);
2970 }
2971 }
2972
2973 static int patch_vt1718S(struct hda_codec *codec)
2974 {
2975 struct via_spec *spec;
2976 int err;
2977
2978 /* create a codec specific record */
2979 spec = via_new_spec(codec);
2980 if (spec == NULL)
2981 return -ENOMEM;
2982
2983 spec->aa_mix_nid = 0x21;
2984 override_mic_boost(codec, 0x2b, 0, 3, 40);
2985 override_mic_boost(codec, 0x29, 0, 3, 40);
2986 spec->dac_mixer_idx = 5;
2987
2988 /* automatic parse from the BIOS config */
2989 err = via_parse_auto_config(codec);
2990 if (err < 0) {
2991 via_free(codec);
2992 return err;
2993 }
2994
2995 spec->init_verbs[spec->num_iverbs++] = vt1718S_init_verbs;
2996
2997 codec->patch_ops = via_patch_ops;
2998
2999 spec->set_widgets_power_state = set_widgets_power_state_vt1718S;
3000
3001 return 0;
3002 }
3003
3004 /* Patch for VT1716S */
3005
3006 static int vt1716s_dmic_info(struct snd_kcontrol *kcontrol,
3007 struct snd_ctl_elem_info *uinfo)
3008 {
3009 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
3010 uinfo->count = 1;
3011 uinfo->value.integer.min = 0;
3012 uinfo->value.integer.max = 1;
3013 return 0;
3014 }
3015
3016 static int vt1716s_dmic_get(struct snd_kcontrol *kcontrol,
3017 struct snd_ctl_elem_value *ucontrol)
3018 {
3019 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3020 int index = 0;
3021
3022 index = snd_hda_codec_read(codec, 0x26, 0,
3023 AC_VERB_GET_CONNECT_SEL, 0);
3024 if (index != -1)
3025 *ucontrol->value.integer.value = index;
3026
3027 return 0;
3028 }
3029
3030 static int vt1716s_dmic_put(struct snd_kcontrol *kcontrol,
3031 struct snd_ctl_elem_value *ucontrol)
3032 {
3033 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3034 struct via_spec *spec = codec->spec;
3035 int index = *ucontrol->value.integer.value;
3036
3037 snd_hda_codec_write(codec, 0x26, 0,
3038 AC_VERB_SET_CONNECT_SEL, index);
3039 spec->dmic_enabled = index;
3040 set_widgets_power_state(codec);
3041 return 1;
3042 }
3043
3044 static const struct snd_kcontrol_new vt1716s_dmic_mixer[] = {
3045 HDA_CODEC_VOLUME("Digital Mic Capture Volume", 0x22, 0x0, HDA_INPUT),
3046 {
3047 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3048 .name = "Digital Mic Capture Switch",
3049 .subdevice = HDA_SUBDEV_NID_FLAG | 0x26,
3050 .count = 1,
3051 .info = vt1716s_dmic_info,
3052 .get = vt1716s_dmic_get,
3053 .put = vt1716s_dmic_put,
3054 },
3055 {} /* end */
3056 };
3057
3058
3059 /* mono-out mixer elements */
3060 static const struct snd_kcontrol_new vt1716S_mono_out_mixer[] = {
3061 HDA_CODEC_MUTE("Mono Playback Switch", 0x2a, 0x0, HDA_OUTPUT),
3062 { } /* end */
3063 };
3064
3065 static const struct hda_verb vt1716S_init_verbs[] = {
3066 /* Enable Boost Volume backdoor */
3067 {0x1, 0xf8a, 0x80},
3068 /* don't bybass mixer */
3069 {0x1, 0xf88, 0xc0},
3070 /* Enable mono output */
3071 {0x1, 0xf90, 0x08},
3072 { }
3073 };
3074
3075 static void set_widgets_power_state_vt1716S(struct hda_codec *codec)
3076 {
3077 struct via_spec *spec = codec->spec;
3078 int imux_is_smixer;
3079 unsigned int parm;
3080 unsigned int mono_out, present;
3081 /* SW0 (17h) = stereo mixer */
3082 imux_is_smixer =
3083 (snd_hda_codec_read(codec, 0x17, 0,
3084 AC_VERB_GET_CONNECT_SEL, 0x00) == 5);
3085 /* inputs */
3086 /* PW 1/2/5 (1ah/1bh/1eh) */
3087 parm = AC_PWRST_D3;
3088 set_pin_power_state(codec, 0x1a, &parm);
3089 set_pin_power_state(codec, 0x1b, &parm);
3090 set_pin_power_state(codec, 0x1e, &parm);
3091 if (imux_is_smixer)
3092 parm = AC_PWRST_D0;
3093 /* SW0 (17h), AIW0(13h) */
3094 snd_hda_codec_write(codec, 0x17, 0, AC_VERB_SET_POWER_STATE, parm);
3095 snd_hda_codec_write(codec, 0x13, 0, AC_VERB_SET_POWER_STATE, parm);
3096
3097 parm = AC_PWRST_D3;
3098 set_pin_power_state(codec, 0x1e, &parm);
3099 /* PW11 (22h) */
3100 if (spec->dmic_enabled)
3101 set_pin_power_state(codec, 0x22, &parm);
3102 else
3103 snd_hda_codec_write(codec, 0x22, 0,
3104 AC_VERB_SET_POWER_STATE, AC_PWRST_D3);
3105
3106 /* SW2(26h), AIW1(14h) */
3107 snd_hda_codec_write(codec, 0x26, 0, AC_VERB_SET_POWER_STATE, parm);
3108 snd_hda_codec_write(codec, 0x14, 0, AC_VERB_SET_POWER_STATE, parm);
3109
3110 /* outputs */
3111 /* PW0 (19h), SW1 (18h), AOW1 (11h) */
3112 parm = AC_PWRST_D3;
3113 set_pin_power_state(codec, 0x19, &parm);
3114 /* Smart 5.1 PW2(1bh) */
3115 if (spec->smart51_enabled)
3116 set_pin_power_state(codec, 0x1b, &parm);
3117 snd_hda_codec_write(codec, 0x18, 0, AC_VERB_SET_POWER_STATE, parm);
3118 snd_hda_codec_write(codec, 0x11, 0, AC_VERB_SET_POWER_STATE, parm);
3119
3120 /* PW7 (23h), SW3 (27h), AOW3 (25h) */
3121 parm = AC_PWRST_D3;
3122 set_pin_power_state(codec, 0x23, &parm);
3123 /* Smart 5.1 PW1(1ah) */
3124 if (spec->smart51_enabled)
3125 set_pin_power_state(codec, 0x1a, &parm);
3126 snd_hda_codec_write(codec, 0x27, 0, AC_VERB_SET_POWER_STATE, parm);
3127
3128 /* Smart 5.1 PW5(1eh) */
3129 if (spec->smart51_enabled)
3130 set_pin_power_state(codec, 0x1e, &parm);
3131 snd_hda_codec_write(codec, 0x25, 0, AC_VERB_SET_POWER_STATE, parm);
3132
3133 /* Mono out */
3134 /* SW4(28h)->MW1(29h)-> PW12 (2ah)*/
3135 present = snd_hda_jack_detect(codec, 0x1c);
3136
3137 if (present)
3138 mono_out = 0;
3139 else {
3140 present = snd_hda_jack_detect(codec, 0x1d);
3141 if (!spec->hp_independent_mode && present)
3142 mono_out = 0;
3143 else
3144 mono_out = 1;
3145 }
3146 parm = mono_out ? AC_PWRST_D0 : AC_PWRST_D3;
3147 snd_hda_codec_write(codec, 0x28, 0, AC_VERB_SET_POWER_STATE, parm);
3148 snd_hda_codec_write(codec, 0x29, 0, AC_VERB_SET_POWER_STATE, parm);
3149 snd_hda_codec_write(codec, 0x2a, 0, AC_VERB_SET_POWER_STATE, parm);
3150
3151 /* PW 3/4 (1ch/1dh) */
3152 parm = AC_PWRST_D3;
3153 set_pin_power_state(codec, 0x1c, &parm);
3154 set_pin_power_state(codec, 0x1d, &parm);
3155 /* HP Independent Mode, power on AOW3 */
3156 if (spec->hp_independent_mode)
3157 snd_hda_codec_write(codec, 0x25, 0,
3158 AC_VERB_SET_POWER_STATE, parm);
3159
3160 /* force to D0 for internal Speaker */
3161 /* MW0 (16h), AOW0 (10h) */
3162 snd_hda_codec_write(codec, 0x16, 0, AC_VERB_SET_POWER_STATE,
3163 imux_is_smixer ? AC_PWRST_D0 : parm);
3164 snd_hda_codec_write(codec, 0x10, 0, AC_VERB_SET_POWER_STATE,
3165 mono_out ? AC_PWRST_D0 : parm);
3166 }
3167
3168 static int patch_vt1716S(struct hda_codec *codec)
3169 {
3170 struct via_spec *spec;
3171 int err;
3172
3173 /* create a codec specific record */
3174 spec = via_new_spec(codec);
3175 if (spec == NULL)
3176 return -ENOMEM;
3177
3178 spec->aa_mix_nid = 0x16;
3179 override_mic_boost(codec, 0x1a, 0, 3, 40);
3180 override_mic_boost(codec, 0x1e, 0, 3, 40);
3181
3182 /* automatic parse from the BIOS config */
3183 err = via_parse_auto_config(codec);
3184 if (err < 0) {
3185 via_free(codec);
3186 return err;
3187 }
3188
3189 spec->init_verbs[spec->num_iverbs++] = vt1716S_init_verbs;
3190
3191 spec->mixers[spec->num_mixers] = vt1716s_dmic_mixer;
3192 spec->num_mixers++;
3193
3194 spec->mixers[spec->num_mixers++] = vt1716S_mono_out_mixer;
3195
3196 codec->patch_ops = via_patch_ops;
3197
3198 spec->set_widgets_power_state = set_widgets_power_state_vt1716S;
3199 return 0;
3200 }
3201
3202 /* for vt2002P */
3203
3204 static const struct hda_verb vt2002P_init_verbs[] = {
3205 /* Class-D speaker related verbs */
3206 {0x1, 0xfe0, 0x4},
3207 {0x1, 0xfe9, 0x80},
3208 {0x1, 0xfe2, 0x22},
3209 /* Enable Boost Volume backdoor */
3210 {0x1, 0xfb9, 0x24},
3211 /* Enable AOW0 to MW9 */
3212 {0x1, 0xfb8, 0x88},
3213 { }
3214 };
3215
3216 static const struct hda_verb vt1802_init_verbs[] = {
3217 /* Enable Boost Volume backdoor */
3218 {0x1, 0xfb9, 0x24},
3219 /* Enable AOW0 to MW9 */
3220 {0x1, 0xfb8, 0x88},
3221 { }
3222 };
3223
3224 static void set_widgets_power_state_vt2002P(struct hda_codec *codec)
3225 {
3226 struct via_spec *spec = codec->spec;
3227 int imux_is_smixer;
3228 unsigned int parm;
3229 unsigned int present;
3230 /* MUX9 (1eh) = stereo mixer */
3231 imux_is_smixer =
3232 snd_hda_codec_read(codec, 0x1e, 0, AC_VERB_GET_CONNECT_SEL, 0x00) == 3;
3233 /* inputs */
3234 /* PW 5/6/7 (29h/2ah/2bh) */
3235 parm = AC_PWRST_D3;
3236 set_pin_power_state(codec, 0x29, &parm);
3237 set_pin_power_state(codec, 0x2a, &parm);
3238 set_pin_power_state(codec, 0x2b, &parm);
3239 parm = AC_PWRST_D0;
3240 /* MUX9/10 (1eh/1fh), AIW 0/1 (10h/11h) */
3241 snd_hda_codec_write(codec, 0x1e, 0, AC_VERB_SET_POWER_STATE, parm);
3242 snd_hda_codec_write(codec, 0x1f, 0, AC_VERB_SET_POWER_STATE, parm);
3243 snd_hda_codec_write(codec, 0x10, 0, AC_VERB_SET_POWER_STATE, parm);
3244 snd_hda_codec_write(codec, 0x11, 0, AC_VERB_SET_POWER_STATE, parm);
3245
3246 /* outputs */
3247 /* AOW0 (8h)*/
3248 snd_hda_codec_write(codec, 0x8, 0, AC_VERB_SET_POWER_STATE, parm);
3249
3250 if (spec->codec_type == VT1802) {
3251 /* PW4 (28h), MW4 (18h), MUX4(38h) */
3252 parm = AC_PWRST_D3;
3253 set_pin_power_state(codec, 0x28, &parm);
3254 snd_hda_codec_write(codec, 0x18, 0,
3255 AC_VERB_SET_POWER_STATE, parm);
3256 snd_hda_codec_write(codec, 0x38, 0,
3257 AC_VERB_SET_POWER_STATE, parm);
3258 } else {
3259 /* PW4 (26h), MW4 (1ch), MUX4(37h) */
3260 parm = AC_PWRST_D3;
3261 set_pin_power_state(codec, 0x26, &parm);
3262 snd_hda_codec_write(codec, 0x1c, 0,
3263 AC_VERB_SET_POWER_STATE, parm);
3264 snd_hda_codec_write(codec, 0x37, 0,
3265 AC_VERB_SET_POWER_STATE, parm);
3266 }
3267
3268 if (spec->codec_type == VT1802) {
3269 /* PW1 (25h), MW1 (15h), MUX1(35h), AOW1 (9h) */
3270 parm = AC_PWRST_D3;
3271 set_pin_power_state(codec, 0x25, &parm);
3272 snd_hda_codec_write(codec, 0x15, 0,
3273 AC_VERB_SET_POWER_STATE, parm);
3274 snd_hda_codec_write(codec, 0x35, 0,
3275 AC_VERB_SET_POWER_STATE, parm);
3276 } else {
3277 /* PW1 (25h), MW1 (19h), MUX1(35h), AOW1 (9h) */
3278 parm = AC_PWRST_D3;
3279 set_pin_power_state(codec, 0x25, &parm);
3280 snd_hda_codec_write(codec, 0x19, 0,
3281 AC_VERB_SET_POWER_STATE, parm);
3282 snd_hda_codec_write(codec, 0x35, 0,
3283 AC_VERB_SET_POWER_STATE, parm);
3284 }
3285
3286 if (spec->hp_independent_mode)
3287 snd_hda_codec_write(codec, 0x9, 0,
3288 AC_VERB_SET_POWER_STATE, AC_PWRST_D0);
3289
3290 /* Class-D */
3291 /* PW0 (24h), MW0(18h/14h), MUX0(34h) */
3292 present = snd_hda_jack_detect(codec, 0x25);
3293
3294 parm = AC_PWRST_D3;
3295 set_pin_power_state(codec, 0x24, &parm);
3296 parm = present ? AC_PWRST_D3 : AC_PWRST_D0;
3297 if (spec->codec_type == VT1802)
3298 snd_hda_codec_write(codec, 0x14, 0,
3299 AC_VERB_SET_POWER_STATE, parm);
3300 else
3301 snd_hda_codec_write(codec, 0x18, 0,
3302 AC_VERB_SET_POWER_STATE, parm);
3303 snd_hda_codec_write(codec, 0x34, 0, AC_VERB_SET_POWER_STATE, parm);
3304
3305 /* Mono Out */
3306 present = snd_hda_jack_detect(codec, 0x26);
3307
3308 parm = present ? AC_PWRST_D3 : AC_PWRST_D0;
3309 if (spec->codec_type == VT1802) {
3310 /* PW15 (33h), MW8(1ch), MUX8(3ch) */
3311 snd_hda_codec_write(codec, 0x33, 0,
3312 AC_VERB_SET_POWER_STATE, parm);
3313 snd_hda_codec_write(codec, 0x1c, 0,
3314 AC_VERB_SET_POWER_STATE, parm);
3315 snd_hda_codec_write(codec, 0x3c, 0,
3316 AC_VERB_SET_POWER_STATE, parm);
3317 } else {
3318 /* PW15 (31h), MW8(17h), MUX8(3bh) */
3319 snd_hda_codec_write(codec, 0x31, 0,
3320 AC_VERB_SET_POWER_STATE, parm);
3321 snd_hda_codec_write(codec, 0x17, 0,
3322 AC_VERB_SET_POWER_STATE, parm);
3323 snd_hda_codec_write(codec, 0x3b, 0,
3324 AC_VERB_SET_POWER_STATE, parm);
3325 }
3326 /* MW9 (21h) */
3327 if (imux_is_smixer || !is_aa_path_mute(codec))
3328 snd_hda_codec_write(codec, 0x21, 0,
3329 AC_VERB_SET_POWER_STATE, AC_PWRST_D0);
3330 else
3331 snd_hda_codec_write(codec, 0x21, 0,
3332 AC_VERB_SET_POWER_STATE, AC_PWRST_D3);
3333 }
3334
3335 /* patch for vt2002P */
3336 static int patch_vt2002P(struct hda_codec *codec)
3337 {
3338 struct via_spec *spec;
3339 int err;
3340
3341 /* create a codec specific record */
3342 spec = via_new_spec(codec);
3343 if (spec == NULL)
3344 return -ENOMEM;
3345
3346 spec->aa_mix_nid = 0x21;
3347 override_mic_boost(codec, 0x2b, 0, 3, 40);
3348 override_mic_boost(codec, 0x29, 0, 3, 40);
3349
3350 /* automatic parse from the BIOS config */
3351 err = via_parse_auto_config(codec);
3352 if (err < 0) {
3353 via_free(codec);
3354 return err;
3355 }
3356
3357 if (spec->codec_type == VT1802)
3358 spec->init_verbs[spec->num_iverbs++] = vt1802_init_verbs;
3359 else
3360 spec->init_verbs[spec->num_iverbs++] = vt2002P_init_verbs;
3361
3362 codec->patch_ops = via_patch_ops;
3363
3364 spec->set_widgets_power_state = set_widgets_power_state_vt2002P;
3365 return 0;
3366 }
3367
3368 /* for vt1812 */
3369
3370 static const struct hda_verb vt1812_init_verbs[] = {
3371 /* Enable Boost Volume backdoor */
3372 {0x1, 0xfb9, 0x24},
3373 /* Enable AOW0 to MW9 */
3374 {0x1, 0xfb8, 0xa8},
3375 { }
3376 };
3377
3378 static void set_widgets_power_state_vt1812(struct hda_codec *codec)
3379 {
3380 struct via_spec *spec = codec->spec;
3381 int imux_is_smixer =
3382 snd_hda_codec_read(codec, 0x13, 0, AC_VERB_GET_CONNECT_SEL, 0x00) == 3;
3383 unsigned int parm;
3384 unsigned int present;
3385 /* MUX10 (1eh) = stereo mixer */
3386 imux_is_smixer =
3387 snd_hda_codec_read(codec, 0x1e, 0, AC_VERB_GET_CONNECT_SEL, 0x00) == 5;
3388 /* inputs */
3389 /* PW 5/6/7 (29h/2ah/2bh) */
3390 parm = AC_PWRST_D3;
3391 set_pin_power_state(codec, 0x29, &parm);
3392 set_pin_power_state(codec, 0x2a, &parm);
3393 set_pin_power_state(codec, 0x2b, &parm);
3394 parm = AC_PWRST_D0;
3395 /* MUX10/11 (1eh/1fh), AIW 0/1 (10h/11h) */
3396 snd_hda_codec_write(codec, 0x1e, 0, AC_VERB_SET_POWER_STATE, parm);
3397 snd_hda_codec_write(codec, 0x1f, 0, AC_VERB_SET_POWER_STATE, parm);
3398 snd_hda_codec_write(codec, 0x10, 0, AC_VERB_SET_POWER_STATE, parm);
3399 snd_hda_codec_write(codec, 0x11, 0, AC_VERB_SET_POWER_STATE, parm);
3400
3401 /* outputs */
3402 /* AOW0 (8h)*/
3403 snd_hda_codec_write(codec, 0x8, 0,
3404 AC_VERB_SET_POWER_STATE, AC_PWRST_D0);
3405
3406 /* PW4 (28h), MW4 (18h), MUX4(38h) */
3407 parm = AC_PWRST_D3;
3408 set_pin_power_state(codec, 0x28, &parm);
3409 snd_hda_codec_write(codec, 0x18, 0, AC_VERB_SET_POWER_STATE, parm);
3410 snd_hda_codec_write(codec, 0x38, 0, AC_VERB_SET_POWER_STATE, parm);
3411
3412 /* PW1 (25h), MW1 (15h), MUX1(35h), AOW1 (9h) */
3413 parm = AC_PWRST_D3;
3414 set_pin_power_state(codec, 0x25, &parm);
3415 snd_hda_codec_write(codec, 0x15, 0, AC_VERB_SET_POWER_STATE, parm);
3416 snd_hda_codec_write(codec, 0x35, 0, AC_VERB_SET_POWER_STATE, parm);
3417 if (spec->hp_independent_mode)
3418 snd_hda_codec_write(codec, 0x9, 0,
3419 AC_VERB_SET_POWER_STATE, AC_PWRST_D0);
3420
3421 /* Internal Speaker */
3422 /* PW0 (24h), MW0(14h), MUX0(34h) */
3423 present = snd_hda_jack_detect(codec, 0x25);
3424
3425 parm = AC_PWRST_D3;
3426 set_pin_power_state(codec, 0x24, &parm);
3427 if (present) {
3428 snd_hda_codec_write(codec, 0x14, 0,
3429 AC_VERB_SET_POWER_STATE, AC_PWRST_D3);
3430 snd_hda_codec_write(codec, 0x34, 0,
3431 AC_VERB_SET_POWER_STATE, AC_PWRST_D3);
3432 } else {
3433 snd_hda_codec_write(codec, 0x14, 0,
3434 AC_VERB_SET_POWER_STATE, AC_PWRST_D0);
3435 snd_hda_codec_write(codec, 0x34, 0,
3436 AC_VERB_SET_POWER_STATE, AC_PWRST_D0);
3437 }
3438
3439
3440 /* Mono Out */
3441 /* PW13 (31h), MW13(1ch), MUX13(3ch), MW14(3eh) */
3442 present = snd_hda_jack_detect(codec, 0x28);
3443
3444 parm = AC_PWRST_D3;
3445 set_pin_power_state(codec, 0x31, &parm);
3446 if (present) {
3447 snd_hda_codec_write(codec, 0x1c, 0,
3448 AC_VERB_SET_POWER_STATE, AC_PWRST_D3);
3449 snd_hda_codec_write(codec, 0x3c, 0,
3450 AC_VERB_SET_POWER_STATE, AC_PWRST_D3);
3451 snd_hda_codec_write(codec, 0x3e, 0,
3452 AC_VERB_SET_POWER_STATE, AC_PWRST_D3);
3453 } else {
3454 snd_hda_codec_write(codec, 0x1c, 0,
3455 AC_VERB_SET_POWER_STATE, AC_PWRST_D0);
3456 snd_hda_codec_write(codec, 0x3c, 0,
3457 AC_VERB_SET_POWER_STATE, AC_PWRST_D0);
3458 snd_hda_codec_write(codec, 0x3e, 0,
3459 AC_VERB_SET_POWER_STATE, AC_PWRST_D0);
3460 }
3461
3462 /* PW15 (33h), MW15 (1dh), MUX15(3dh) */
3463 parm = AC_PWRST_D3;
3464 set_pin_power_state(codec, 0x33, &parm);
3465 snd_hda_codec_write(codec, 0x1d, 0, AC_VERB_SET_POWER_STATE, parm);
3466 snd_hda_codec_write(codec, 0x3d, 0, AC_VERB_SET_POWER_STATE, parm);
3467
3468 }
3469
3470 /* patch for vt1812 */
3471 static int patch_vt1812(struct hda_codec *codec)
3472 {
3473 struct via_spec *spec;
3474 int err;
3475
3476 /* create a codec specific record */
3477 spec = via_new_spec(codec);
3478 if (spec == NULL)
3479 return -ENOMEM;
3480
3481 spec->aa_mix_nid = 0x21;
3482 override_mic_boost(codec, 0x2b, 0, 3, 40);
3483 override_mic_boost(codec, 0x29, 0, 3, 40);
3484
3485 /* automatic parse from the BIOS config */
3486 err = via_parse_auto_config(codec);
3487 if (err < 0) {
3488 via_free(codec);
3489 return err;
3490 }
3491
3492 spec->init_verbs[spec->num_iverbs++] = vt1812_init_verbs;
3493
3494 codec->patch_ops = via_patch_ops;
3495
3496 spec->set_widgets_power_state = set_widgets_power_state_vt1812;
3497 return 0;
3498 }
3499
3500 /*
3501 * patch entries
3502 */
3503 static const struct hda_codec_preset snd_hda_preset_via[] = {
3504 { .id = 0x11061708, .name = "VT1708", .patch = patch_vt1708},
3505 { .id = 0x11061709, .name = "VT1708", .patch = patch_vt1708},
3506 { .id = 0x1106170a, .name = "VT1708", .patch = patch_vt1708},
3507 { .id = 0x1106170b, .name = "VT1708", .patch = patch_vt1708},
3508 { .id = 0x1106e710, .name = "VT1709 10-Ch",
3509 .patch = patch_vt1709},
3510 { .id = 0x1106e711, .name = "VT1709 10-Ch",
3511 .patch = patch_vt1709},
3512 { .id = 0x1106e712, .name = "VT1709 10-Ch",
3513 .patch = patch_vt1709},
3514 { .id = 0x1106e713, .name = "VT1709 10-Ch",
3515 .patch = patch_vt1709},
3516 { .id = 0x1106e714, .name = "VT1709 6-Ch",
3517 .patch = patch_vt1709},
3518 { .id = 0x1106e715, .name = "VT1709 6-Ch",
3519 .patch = patch_vt1709},
3520 { .id = 0x1106e716, .name = "VT1709 6-Ch",
3521 .patch = patch_vt1709},
3522 { .id = 0x1106e717, .name = "VT1709 6-Ch",
3523 .patch = patch_vt1709},
3524 { .id = 0x1106e720, .name = "VT1708B 8-Ch",
3525 .patch = patch_vt1708B},
3526 { .id = 0x1106e721, .name = "VT1708B 8-Ch",
3527 .patch = patch_vt1708B},
3528 { .id = 0x1106e722, .name = "VT1708B 8-Ch",
3529 .patch = patch_vt1708B},
3530 { .id = 0x1106e723, .name = "VT1708B 8-Ch",
3531 .patch = patch_vt1708B},
3532 { .id = 0x1106e724, .name = "VT1708B 4-Ch",
3533 .patch = patch_vt1708B},
3534 { .id = 0x1106e725, .name = "VT1708B 4-Ch",
3535 .patch = patch_vt1708B},
3536 { .id = 0x1106e726, .name = "VT1708B 4-Ch",
3537 .patch = patch_vt1708B},
3538 { .id = 0x1106e727, .name = "VT1708B 4-Ch",
3539 .patch = patch_vt1708B},
3540 { .id = 0x11060397, .name = "VT1708S",
3541 .patch = patch_vt1708S},
3542 { .id = 0x11061397, .name = "VT1708S",
3543 .patch = patch_vt1708S},
3544 { .id = 0x11062397, .name = "VT1708S",
3545 .patch = patch_vt1708S},
3546 { .id = 0x11063397, .name = "VT1708S",
3547 .patch = patch_vt1708S},
3548 { .id = 0x11064397, .name = "VT1705",
3549 .patch = patch_vt1708S},
3550 { .id = 0x11065397, .name = "VT1708S",
3551 .patch = patch_vt1708S},
3552 { .id = 0x11066397, .name = "VT1708S",
3553 .patch = patch_vt1708S},
3554 { .id = 0x11067397, .name = "VT1708S",
3555 .patch = patch_vt1708S},
3556 { .id = 0x11060398, .name = "VT1702",
3557 .patch = patch_vt1702},
3558 { .id = 0x11061398, .name = "VT1702",
3559 .patch = patch_vt1702},
3560 { .id = 0x11062398, .name = "VT1702",
3561 .patch = patch_vt1702},
3562 { .id = 0x11063398, .name = "VT1702",
3563 .patch = patch_vt1702},
3564 { .id = 0x11064398, .name = "VT1702",
3565 .patch = patch_vt1702},
3566 { .id = 0x11065398, .name = "VT1702",
3567 .patch = patch_vt1702},
3568 { .id = 0x11066398, .name = "VT1702",
3569 .patch = patch_vt1702},
3570 { .id = 0x11067398, .name = "VT1702",
3571 .patch = patch_vt1702},
3572 { .id = 0x11060428, .name = "VT1718S",
3573 .patch = patch_vt1718S},
3574 { .id = 0x11064428, .name = "VT1718S",
3575 .patch = patch_vt1718S},
3576 { .id = 0x11060441, .name = "VT2020",
3577 .patch = patch_vt1718S},
3578 { .id = 0x11064441, .name = "VT1828S",
3579 .patch = patch_vt1718S},
3580 { .id = 0x11060433, .name = "VT1716S",
3581 .patch = patch_vt1716S},
3582 { .id = 0x1106a721, .name = "VT1716S",
3583 .patch = patch_vt1716S},
3584 { .id = 0x11060438, .name = "VT2002P", .patch = patch_vt2002P},
3585 { .id = 0x11064438, .name = "VT2002P", .patch = patch_vt2002P},
3586 { .id = 0x11060448, .name = "VT1812", .patch = patch_vt1812},
3587 { .id = 0x11060440, .name = "VT1818S",
3588 .patch = patch_vt1708S},
3589 { .id = 0x11060446, .name = "VT1802",
3590 .patch = patch_vt2002P},
3591 { .id = 0x11068446, .name = "VT1802",
3592 .patch = patch_vt2002P},
3593 {} /* terminator */
3594 };
3595
3596 MODULE_ALIAS("snd-hda-codec-id:1106*");
3597
3598 static struct hda_codec_preset_list via_list = {
3599 .preset = snd_hda_preset_via,
3600 .owner = THIS_MODULE,
3601 };
3602
3603 MODULE_LICENSE("GPL");
3604 MODULE_DESCRIPTION("VIA HD-audio codec");
3605
3606 static int __init patch_via_init(void)
3607 {
3608 return snd_hda_add_codec_preset(&via_list);
3609 }
3610
3611 static void __exit patch_via_exit(void)
3612 {
3613 snd_hda_delete_codec_preset(&via_list);
3614 }
3615
3616 module_init(patch_via_init)
3617 module_exit(patch_via_exit)
kernel-based virtual machine