1
2
3
4
5
6
7
8
9
10#include <linux/init.h>
11#include <linux/slab.h>
12#include <linux/export.h>
13#include <linux/sort.h>
14#include <linux/delay.h>
15#include <linux/ctype.h>
16#include <linux/string.h>
17#include <linux/bitops.h>
18#include <linux/module.h>
19#include <linux/leds.h>
20#include <sound/core.h>
21#include <sound/jack.h>
22#include <sound/tlv.h>
23#include <sound/hda_codec.h>
24#include "hda_local.h"
25#include "hda_auto_parser.h"
26#include "hda_jack.h"
27#include "hda_beep.h"
28#include "hda_generic.h"
29
30
31
32
33
34
35
36
37int snd_hda_gen_spec_init(struct hda_gen_spec *spec)
38{
39 snd_array_init(&spec->kctls, sizeof(struct snd_kcontrol_new), 32);
40 snd_array_init(&spec->paths, sizeof(struct nid_path), 8);
41 snd_array_init(&spec->loopback_list, sizeof(struct hda_amp_list), 8);
42 mutex_init(&spec->pcm_mutex);
43 return 0;
44}
45EXPORT_SYMBOL_GPL(snd_hda_gen_spec_init);
46
47
48
49
50
51
52
53
54
55
56
57
58struct snd_kcontrol_new *
59snd_hda_gen_add_kctl(struct hda_gen_spec *spec, const char *name,
60 const struct snd_kcontrol_new *temp)
61{
62 struct snd_kcontrol_new *knew = snd_array_new(&spec->kctls);
63 if (!knew)
64 return NULL;
65 *knew = *temp;
66 if (name)
67 knew->name = kstrdup(name, GFP_KERNEL);
68 else if (knew->name)
69 knew->name = kstrdup(knew->name, GFP_KERNEL);
70 if (!knew->name)
71 return NULL;
72 return knew;
73}
74EXPORT_SYMBOL_GPL(snd_hda_gen_add_kctl);
75
76static void free_kctls(struct hda_gen_spec *spec)
77{
78 if (spec->kctls.list) {
79 struct snd_kcontrol_new *kctl = spec->kctls.list;
80 int i;
81 for (i = 0; i < spec->kctls.used; i++)
82 kfree(kctl[i].name);
83 }
84 snd_array_free(&spec->kctls);
85}
86
87static void snd_hda_gen_spec_free(struct hda_gen_spec *spec)
88{
89 if (!spec)
90 return;
91 free_kctls(spec);
92 snd_array_free(&spec->paths);
93 snd_array_free(&spec->loopback_list);
94}
95
96
97
98
99static void parse_user_hints(struct hda_codec *codec)
100{
101 struct hda_gen_spec *spec = codec->spec;
102 int val;
103
104 val = snd_hda_get_bool_hint(codec, "jack_detect");
105 if (val >= 0)
106 codec->no_jack_detect = !val;
107 val = snd_hda_get_bool_hint(codec, "inv_jack_detect");
108 if (val >= 0)
109 codec->inv_jack_detect = !!val;
110 val = snd_hda_get_bool_hint(codec, "trigger_sense");
111 if (val >= 0)
112 codec->no_trigger_sense = !val;
113 val = snd_hda_get_bool_hint(codec, "inv_eapd");
114 if (val >= 0)
115 codec->inv_eapd = !!val;
116 val = snd_hda_get_bool_hint(codec, "pcm_format_first");
117 if (val >= 0)
118 codec->pcm_format_first = !!val;
119 val = snd_hda_get_bool_hint(codec, "sticky_stream");
120 if (val >= 0)
121 codec->no_sticky_stream = !val;
122 val = snd_hda_get_bool_hint(codec, "spdif_status_reset");
123 if (val >= 0)
124 codec->spdif_status_reset = !!val;
125 val = snd_hda_get_bool_hint(codec, "pin_amp_workaround");
126 if (val >= 0)
127 codec->pin_amp_workaround = !!val;
128 val = snd_hda_get_bool_hint(codec, "single_adc_amp");
129 if (val >= 0)
130 codec->single_adc_amp = !!val;
131 val = snd_hda_get_bool_hint(codec, "power_save_node");
132 if (val >= 0)
133 codec->power_save_node = !!val;
134
135 val = snd_hda_get_bool_hint(codec, "auto_mute");
136 if (val >= 0)
137 spec->suppress_auto_mute = !val;
138 val = snd_hda_get_bool_hint(codec, "auto_mic");
139 if (val >= 0)
140 spec->suppress_auto_mic = !val;
141 val = snd_hda_get_bool_hint(codec, "line_in_auto_switch");
142 if (val >= 0)
143 spec->line_in_auto_switch = !!val;
144 val = snd_hda_get_bool_hint(codec, "auto_mute_via_amp");
145 if (val >= 0)
146 spec->auto_mute_via_amp = !!val;
147 val = snd_hda_get_bool_hint(codec, "need_dac_fix");
148 if (val >= 0)
149 spec->need_dac_fix = !!val;
150 val = snd_hda_get_bool_hint(codec, "primary_hp");
151 if (val >= 0)
152 spec->no_primary_hp = !val;
153 val = snd_hda_get_bool_hint(codec, "multi_io");
154 if (val >= 0)
155 spec->no_multi_io = !val;
156 val = snd_hda_get_bool_hint(codec, "multi_cap_vol");
157 if (val >= 0)
158 spec->multi_cap_vol = !!val;
159 val = snd_hda_get_bool_hint(codec, "inv_dmic_split");
160 if (val >= 0)
161 spec->inv_dmic_split = !!val;
162 val = snd_hda_get_bool_hint(codec, "indep_hp");
163 if (val >= 0)
164 spec->indep_hp = !!val;
165 val = snd_hda_get_bool_hint(codec, "add_stereo_mix_input");
166 if (val >= 0)
167 spec->add_stereo_mix_input = !!val;
168
169 val = snd_hda_get_bool_hint(codec, "add_out_jack_modes");
170 if (val >= 0)
171 spec->add_jack_modes = !!val;
172 val = snd_hda_get_bool_hint(codec, "add_in_jack_modes");
173 if (val >= 0)
174 spec->add_jack_modes = !!val;
175 val = snd_hda_get_bool_hint(codec, "add_jack_modes");
176 if (val >= 0)
177 spec->add_jack_modes = !!val;
178 val = snd_hda_get_bool_hint(codec, "power_down_unused");
179 if (val >= 0)
180 spec->power_down_unused = !!val;
181 val = snd_hda_get_bool_hint(codec, "add_hp_mic");
182 if (val >= 0)
183 spec->hp_mic = !!val;
184 val = snd_hda_get_bool_hint(codec, "hp_mic_detect");
185 if (val >= 0)
186 spec->suppress_hp_mic_detect = !val;
187 val = snd_hda_get_bool_hint(codec, "vmaster");
188 if (val >= 0)
189 spec->suppress_vmaster = !val;
190
191 if (!snd_hda_get_int_hint(codec, "mixer_nid", &val))
192 spec->mixer_nid = val;
193}
194
195
196
197
198
199#define update_pin_ctl(codec, pin, val) \
200 snd_hda_codec_write_cache(codec, pin, 0, \
201 AC_VERB_SET_PIN_WIDGET_CONTROL, val)
202
203
204static inline void restore_pin_ctl(struct hda_codec *codec, hda_nid_t pin)
205{
206 update_pin_ctl(codec, pin, snd_hda_codec_get_pin_target(codec, pin));
207}
208
209
210static void set_pin_target(struct hda_codec *codec, hda_nid_t pin,
211 unsigned int val, bool do_write)
212{
213 if (!pin)
214 return;
215 val = snd_hda_correct_pin_ctl(codec, pin, val);
216 snd_hda_codec_set_pin_target(codec, pin, val);
217 if (do_write)
218 update_pin_ctl(codec, pin, val);
219}
220
221
222static void set_pin_targets(struct hda_codec *codec, int num_pins,
223 hda_nid_t *pins, unsigned int val)
224{
225 int i;
226 for (i = 0; i < num_pins; i++)
227 set_pin_target(codec, pins[i], val, false);
228}
229
230
231
232
233
234
235static int find_idx_in_nid_list(hda_nid_t nid, const hda_nid_t *list, int nums)
236{
237 int i;
238 for (i = 0; i < nums; i++)
239 if (list[i] == nid)
240 return i;
241 return -1;
242}
243
244
245static bool is_nid_contained(struct nid_path *path, hda_nid_t nid)
246{
247 return find_idx_in_nid_list(nid, path->path, path->depth) >= 0;
248}
249
250static struct nid_path *get_nid_path(struct hda_codec *codec,
251 hda_nid_t from_nid, hda_nid_t to_nid,
252 int anchor_nid)
253{
254 struct hda_gen_spec *spec = codec->spec;
255 struct nid_path *path;
256 int i;
257
258 snd_array_for_each(&spec->paths, i, path) {
259 if (path->depth <= 0)
260 continue;
261 if ((!from_nid || path->path[0] == from_nid) &&
262 (!to_nid || path->path[path->depth - 1] == to_nid)) {
263 if (!anchor_nid ||
264 (anchor_nid > 0 && is_nid_contained(path, anchor_nid)) ||
265 (anchor_nid < 0 && !is_nid_contained(path, anchor_nid)))
266 return path;
267 }
268 }
269 return NULL;
270}
271
272
273
274
275
276
277
278
279
280
281int snd_hda_get_path_idx(struct hda_codec *codec, struct nid_path *path)
282{
283 struct hda_gen_spec *spec = codec->spec;
284 struct nid_path *array = spec->paths.list;
285 ssize_t idx;
286
287 if (!spec->paths.used)
288 return 0;
289 idx = path - array;
290 if (idx < 0 || idx >= spec->paths.used)
291 return 0;
292 return idx + 1;
293}
294EXPORT_SYMBOL_GPL(snd_hda_get_path_idx);
295
296
297
298
299
300
301
302struct nid_path *snd_hda_get_path_from_idx(struct hda_codec *codec, int idx)
303{
304 struct hda_gen_spec *spec = codec->spec;
305
306 if (idx <= 0 || idx > spec->paths.used)
307 return NULL;
308 return snd_array_elem(&spec->paths, idx - 1);
309}
310EXPORT_SYMBOL_GPL(snd_hda_get_path_from_idx);
311
312
313static bool is_dac_already_used(struct hda_codec *codec, hda_nid_t nid)
314{
315 struct hda_gen_spec *spec = codec->spec;
316 const struct nid_path *path;
317 int i;
318
319 snd_array_for_each(&spec->paths, i, path) {
320 if (path->path[0] == nid)
321 return true;
322 }
323 return false;
324}
325
326
327static bool is_reachable_path(struct hda_codec *codec,
328 hda_nid_t from_nid, hda_nid_t to_nid)
329{
330 if (!from_nid || !to_nid)
331 return false;
332 return snd_hda_get_conn_index(codec, to_nid, from_nid, true) >= 0;
333}
334
335
336#define AMP_VAL_COMPARE_MASK (0xffff | (1U << 18) | (0x0f << 19))
337
338
339static bool is_ctl_used(struct hda_codec *codec, unsigned int val, int type)
340{
341 struct hda_gen_spec *spec = codec->spec;
342 const struct nid_path *path;
343 int i;
344
345 val &= AMP_VAL_COMPARE_MASK;
346 snd_array_for_each(&spec->paths, i, path) {
347 if ((path->ctls[type] & AMP_VAL_COMPARE_MASK) == val)
348 return true;
349 }
350 return false;
351}
352
353
354static bool is_ctl_associated(struct hda_codec *codec, hda_nid_t nid,
355 int dir, int idx, int type)
356{
357 unsigned int val = HDA_COMPOSE_AMP_VAL(nid, 3, idx, dir);
358 return is_ctl_used(codec, val, type);
359}
360
361static void print_nid_path(struct hda_codec *codec,
362 const char *pfx, struct nid_path *path)
363{
364 char buf[40];
365 char *pos = buf;
366 int i;
367
368 *pos = 0;
369 for (i = 0; i < path->depth; i++)
370 pos += scnprintf(pos, sizeof(buf) - (pos - buf), "%s%02x",
371 pos != buf ? ":" : "",
372 path->path[i]);
373
374 codec_dbg(codec, "%s path: depth=%d '%s'\n", pfx, path->depth, buf);
375}
376
377
378static bool __parse_nid_path(struct hda_codec *codec,
379 hda_nid_t from_nid, hda_nid_t to_nid,
380 int anchor_nid, struct nid_path *path,
381 int depth)
382{
383 const hda_nid_t *conn;
384 int i, nums;
385
386 if (to_nid == anchor_nid)
387 anchor_nid = 0;
388 else if (to_nid == (hda_nid_t)(-anchor_nid))
389 return false;
390
391 nums = snd_hda_get_conn_list(codec, to_nid, &conn);
392 for (i = 0; i < nums; i++) {
393 if (conn[i] != from_nid) {
394
395
396
397 if (from_nid ||
398 get_wcaps_type(get_wcaps(codec, conn[i])) != AC_WID_AUD_OUT ||
399 is_dac_already_used(codec, conn[i]))
400 continue;
401 }
402
403 if (anchor_nid <= 0)
404 goto found;
405 }
406 if (depth >= MAX_NID_PATH_DEPTH)
407 return false;
408 for (i = 0; i < nums; i++) {
409 unsigned int type;
410 type = get_wcaps_type(get_wcaps(codec, conn[i]));
411 if (type == AC_WID_AUD_OUT || type == AC_WID_AUD_IN ||
412 type == AC_WID_PIN)
413 continue;
414 if (__parse_nid_path(codec, from_nid, conn[i],
415 anchor_nid, path, depth + 1))
416 goto found;
417 }
418 return false;
419
420 found:
421 path->path[path->depth] = conn[i];
422 path->idx[path->depth + 1] = i;
423 if (nums > 1 && get_wcaps_type(get_wcaps(codec, to_nid)) != AC_WID_AUD_MIX)
424 path->multi[path->depth + 1] = 1;
425 path->depth++;
426 return true;
427}
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448static bool snd_hda_parse_nid_path(struct hda_codec *codec, hda_nid_t from_nid,
449 hda_nid_t to_nid, int anchor_nid,
450 struct nid_path *path)
451{
452 if (__parse_nid_path(codec, from_nid, to_nid, anchor_nid, path, 1)) {
453 path->path[path->depth] = to_nid;
454 path->depth++;
455 return true;
456 }
457 return false;
458}
459
460
461
462
463
464
465
466
467
468
469
470struct nid_path *
471snd_hda_add_new_path(struct hda_codec *codec, hda_nid_t from_nid,
472 hda_nid_t to_nid, int anchor_nid)
473{
474 struct hda_gen_spec *spec = codec->spec;
475 struct nid_path *path;
476
477 if (from_nid && to_nid && !is_reachable_path(codec, from_nid, to_nid))
478 return NULL;
479
480
481 path = get_nid_path(codec, from_nid, to_nid, anchor_nid);
482 if (path)
483 return path;
484
485 path = snd_array_new(&spec->paths);
486 if (!path)
487 return NULL;
488 memset(path, 0, sizeof(*path));
489 if (snd_hda_parse_nid_path(codec, from_nid, to_nid, anchor_nid, path))
490 return path;
491
492 spec->paths.used--;
493 return NULL;
494}
495EXPORT_SYMBOL_GPL(snd_hda_add_new_path);
496
497
498static void invalidate_nid_path(struct hda_codec *codec, int idx)
499{
500 struct nid_path *path = snd_hda_get_path_from_idx(codec, idx);
501 if (!path)
502 return;
503 memset(path, 0, sizeof(*path));
504}
505
506
507static hda_nid_t get_preferred_dac(struct hda_codec *codec, hda_nid_t pin)
508{
509 struct hda_gen_spec *spec = codec->spec;
510 const hda_nid_t *list = spec->preferred_dacs;
511
512 if (!list)
513 return 0;
514 for (; *list; list += 2)
515 if (*list == pin)
516 return list[1];
517 return 0;
518}
519
520
521static hda_nid_t look_for_dac(struct hda_codec *codec, hda_nid_t pin,
522 bool is_digital)
523{
524 struct hda_gen_spec *spec = codec->spec;
525 bool cap_digital;
526 int i;
527
528 for (i = 0; i < spec->num_all_dacs; i++) {
529 hda_nid_t nid = spec->all_dacs[i];
530 if (!nid || is_dac_already_used(codec, nid))
531 continue;
532 cap_digital = !!(get_wcaps(codec, nid) & AC_WCAP_DIGITAL);
533 if (is_digital != cap_digital)
534 continue;
535 if (is_reachable_path(codec, nid, pin))
536 return nid;
537 }
538 return 0;
539}
540
541
542static unsigned int amp_val_replace_channels(unsigned int val, unsigned int chs)
543{
544 val &= ~(0x3U << 16);
545 val |= chs << 16;
546 return val;
547}
548
549static bool same_amp_caps(struct hda_codec *codec, hda_nid_t nid1,
550 hda_nid_t nid2, int dir)
551{
552 if (!(get_wcaps(codec, nid1) & (1 << (dir + 1))))
553 return !(get_wcaps(codec, nid2) & (1 << (dir + 1)));
554 return (query_amp_caps(codec, nid1, dir) ==
555 query_amp_caps(codec, nid2, dir));
556}
557
558
559static hda_nid_t look_for_out_mute_nid(struct hda_codec *codec,
560 struct nid_path *path)
561{
562 int i;
563
564 for (i = path->depth - 1; i >= 0; i--) {
565 if (nid_has_mute(codec, path->path[i], HDA_OUTPUT))
566 return path->path[i];
567 if (i != path->depth - 1 && i != 0 &&
568 nid_has_mute(codec, path->path[i], HDA_INPUT))
569 return path->path[i];
570 }
571 return 0;
572}
573
574
575static hda_nid_t look_for_out_vol_nid(struct hda_codec *codec,
576 struct nid_path *path)
577{
578 struct hda_gen_spec *spec = codec->spec;
579 int i;
580
581 for (i = path->depth - 1; i >= 0; i--) {
582 hda_nid_t nid = path->path[i];
583 if ((spec->out_vol_mask >> nid) & 1)
584 continue;
585 if (nid_has_volume(codec, nid, HDA_OUTPUT))
586 return nid;
587 }
588 return 0;
589}
590
591
592
593
594
595
596static bool has_amp_in(struct hda_codec *codec, struct nid_path *path, int idx)
597{
598 hda_nid_t nid = path->path[idx];
599 unsigned int caps = get_wcaps(codec, nid);
600 unsigned int type = get_wcaps_type(caps);
601
602 if (!(caps & AC_WCAP_IN_AMP))
603 return false;
604 if (type == AC_WID_PIN && idx > 0)
605 return false;
606 return true;
607}
608
609
610static bool has_amp_out(struct hda_codec *codec, struct nid_path *path, int idx)
611{
612 hda_nid_t nid = path->path[idx];
613 unsigned int caps = get_wcaps(codec, nid);
614 unsigned int type = get_wcaps_type(caps);
615
616 if (!(caps & AC_WCAP_OUT_AMP))
617 return false;
618 if (type == AC_WID_PIN && !idx)
619 return false;
620 return true;
621}
622
623
624static bool is_active_nid(struct hda_codec *codec, hda_nid_t nid,
625 unsigned int dir, unsigned int idx)
626{
627 struct hda_gen_spec *spec = codec->spec;
628 int type = get_wcaps_type(get_wcaps(codec, nid));
629 const struct nid_path *path;
630 int i, n;
631
632 if (nid == codec->core.afg)
633 return true;
634
635 snd_array_for_each(&spec->paths, n, path) {
636 if (!path->active)
637 continue;
638 if (codec->power_save_node) {
639 if (!path->stream_enabled)
640 continue;
641
642 if (!(path->pin_enabled || path->pin_fixed) &&
643 type != AC_WID_AUD_OUT && type != AC_WID_AUD_IN)
644 continue;
645 }
646 for (i = 0; i < path->depth; i++) {
647 if (path->path[i] == nid) {
648 if (dir == HDA_OUTPUT || idx == -1 ||
649 path->idx[i] == idx)
650 return true;
651 break;
652 }
653 }
654 }
655 return false;
656}
657
658
659#define is_active_nid_for_any(codec, nid) \
660 is_active_nid(codec, nid, HDA_OUTPUT, -1)
661
662
663static int get_amp_val_to_activate(struct hda_codec *codec, hda_nid_t nid,
664 int dir, unsigned int caps, bool enable)
665{
666 unsigned int val = 0;
667
668 if (caps & AC_AMPCAP_NUM_STEPS) {
669
670 if (enable)
671 val = (caps & AC_AMPCAP_OFFSET) >> AC_AMPCAP_OFFSET_SHIFT;
672 }
673 if (caps & (AC_AMPCAP_MUTE | AC_AMPCAP_MIN_MUTE)) {
674 if (!enable)
675 val |= HDA_AMP_MUTE;
676 }
677 return val;
678}
679
680
681static bool is_stereo_amps(struct hda_codec *codec, hda_nid_t nid, int dir)
682{
683 unsigned int wcaps = get_wcaps(codec, nid);
684 hda_nid_t conn;
685
686 if (wcaps & AC_WCAP_STEREO)
687 return true;
688 if (dir != HDA_INPUT || get_wcaps_type(wcaps) != AC_WID_AUD_MIX)
689 return false;
690 if (snd_hda_get_num_conns(codec, nid) != 1)
691 return false;
692 if (snd_hda_get_connections(codec, nid, &conn, 1) < 0)
693 return false;
694 return !!(get_wcaps(codec, conn) & AC_WCAP_STEREO);
695}
696
697
698static void init_amp(struct hda_codec *codec, hda_nid_t nid, int dir, int idx)
699{
700 unsigned int caps = query_amp_caps(codec, nid, dir);
701 int val = get_amp_val_to_activate(codec, nid, dir, caps, false);
702
703 if (is_stereo_amps(codec, nid, dir))
704 snd_hda_codec_amp_init_stereo(codec, nid, dir, idx, 0xff, val);
705 else
706 snd_hda_codec_amp_init(codec, nid, 0, dir, idx, 0xff, val);
707}
708
709
710static int update_amp(struct hda_codec *codec, hda_nid_t nid, int dir, int idx,
711 unsigned int mask, unsigned int val)
712{
713 if (is_stereo_amps(codec, nid, dir))
714 return snd_hda_codec_amp_stereo(codec, nid, dir, idx,
715 mask, val);
716 else
717 return snd_hda_codec_amp_update(codec, nid, 0, dir, idx,
718 mask, val);
719}
720
721
722
723
724static unsigned int get_amp_mask_to_modify(struct hda_codec *codec,
725 hda_nid_t nid, int dir, int idx,
726 unsigned int caps)
727{
728 unsigned int mask = 0xff;
729
730 if (caps & (AC_AMPCAP_MUTE | AC_AMPCAP_MIN_MUTE)) {
731 if (is_ctl_associated(codec, nid, dir, idx, NID_PATH_MUTE_CTL))
732 mask &= ~0x80;
733 }
734 if (caps & AC_AMPCAP_NUM_STEPS) {
735 if (is_ctl_associated(codec, nid, dir, idx, NID_PATH_VOL_CTL) ||
736 is_ctl_associated(codec, nid, dir, idx, NID_PATH_BOOST_CTL))
737 mask &= ~0x7f;
738 }
739 return mask;
740}
741
742static void activate_amp(struct hda_codec *codec, hda_nid_t nid, int dir,
743 int idx, int idx_to_check, bool enable)
744{
745 unsigned int caps;
746 unsigned int mask, val;
747
748 caps = query_amp_caps(codec, nid, dir);
749 val = get_amp_val_to_activate(codec, nid, dir, caps, enable);
750 mask = get_amp_mask_to_modify(codec, nid, dir, idx_to_check, caps);
751 if (!mask)
752 return;
753
754 val &= mask;
755 update_amp(codec, nid, dir, idx, mask, val);
756}
757
758static void check_and_activate_amp(struct hda_codec *codec, hda_nid_t nid,
759 int dir, int idx, int idx_to_check,
760 bool enable)
761{
762
763 if (!enable && is_active_nid(codec, nid, dir, idx_to_check))
764 return;
765 activate_amp(codec, nid, dir, idx, idx_to_check, enable);
766}
767
768static void activate_amp_out(struct hda_codec *codec, struct nid_path *path,
769 int i, bool enable)
770{
771 hda_nid_t nid = path->path[i];
772 init_amp(codec, nid, HDA_OUTPUT, 0);
773 check_and_activate_amp(codec, nid, HDA_OUTPUT, 0, 0, enable);
774}
775
776static void activate_amp_in(struct hda_codec *codec, struct nid_path *path,
777 int i, bool enable, bool add_aamix)
778{
779 struct hda_gen_spec *spec = codec->spec;
780 const hda_nid_t *conn;
781 int n, nums, idx;
782 int type;
783 hda_nid_t nid = path->path[i];
784
785 nums = snd_hda_get_conn_list(codec, nid, &conn);
786 if (nums < 0)
787 return;
788 type = get_wcaps_type(get_wcaps(codec, nid));
789 if (type == AC_WID_PIN ||
790 (type == AC_WID_AUD_IN && codec->single_adc_amp)) {
791 nums = 1;
792 idx = 0;
793 } else
794 idx = path->idx[i];
795
796 for (n = 0; n < nums; n++)
797 init_amp(codec, nid, HDA_INPUT, n);
798
799
800
801
802 for (n = 0; n < nums; n++) {
803 if (n != idx) {
804 if (conn[n] != spec->mixer_merge_nid)
805 continue;
806
807 if (!add_aamix) {
808 activate_amp(codec, nid, HDA_INPUT, n, n, false);
809 continue;
810 }
811 }
812 check_and_activate_amp(codec, nid, HDA_INPUT, n, idx, enable);
813 }
814}
815
816
817static hda_nid_t path_power_update(struct hda_codec *codec,
818 struct nid_path *path,
819 bool allow_powerdown)
820{
821 hda_nid_t nid, changed = 0;
822 int i, state, power;
823
824 for (i = 0; i < path->depth; i++) {
825 nid = path->path[i];
826 if (!(get_wcaps(codec, nid) & AC_WCAP_POWER))
827 continue;
828 if (nid == codec->core.afg)
829 continue;
830 if (!allow_powerdown || is_active_nid_for_any(codec, nid))
831 state = AC_PWRST_D0;
832 else
833 state = AC_PWRST_D3;
834 power = snd_hda_codec_read(codec, nid, 0,
835 AC_VERB_GET_POWER_STATE, 0);
836 if (power != (state | (state << 4))) {
837 snd_hda_codec_write(codec, nid, 0,
838 AC_VERB_SET_POWER_STATE, state);
839 changed = nid;
840
841
842
843
844
845
846#if 0
847 if (state == AC_PWRST_D0)
848 snd_hdac_regmap_sync_node(&codec->core, nid);
849#endif
850 }
851 }
852 return changed;
853}
854
855
856static void sync_power_state_change(struct hda_codec *codec, hda_nid_t nid)
857{
858 if (nid) {
859 msleep(10);
860 snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_POWER_STATE, 0);
861 }
862}
863
864
865
866
867
868
869
870
871
872
873void snd_hda_activate_path(struct hda_codec *codec, struct nid_path *path,
874 bool enable, bool add_aamix)
875{
876 struct hda_gen_spec *spec = codec->spec;
877 int i;
878
879 path->active = enable;
880
881
882 if (enable && (spec->power_down_unused || codec->power_save_node))
883 path_power_update(codec, path, codec->power_save_node);
884
885 for (i = path->depth - 1; i >= 0; i--) {
886 hda_nid_t nid = path->path[i];
887
888 if (enable && path->multi[i])
889 snd_hda_codec_write_cache(codec, nid, 0,
890 AC_VERB_SET_CONNECT_SEL,
891 path->idx[i]);
892 if (has_amp_in(codec, path, i))
893 activate_amp_in(codec, path, i, enable, add_aamix);
894 if (has_amp_out(codec, path, i))
895 activate_amp_out(codec, path, i, enable);
896 }
897}
898EXPORT_SYMBOL_GPL(snd_hda_activate_path);
899
900
901static void path_power_down_sync(struct hda_codec *codec, struct nid_path *path)
902{
903 struct hda_gen_spec *spec = codec->spec;
904
905 if (!(spec->power_down_unused || codec->power_save_node) || path->active)
906 return;
907 sync_power_state_change(codec, path_power_update(codec, path, true));
908}
909
910
911static void set_pin_eapd(struct hda_codec *codec, hda_nid_t pin, bool enable)
912{
913 struct hda_gen_spec *spec = codec->spec;
914 if (spec->own_eapd_ctl ||
915 !(snd_hda_query_pin_caps(codec, pin) & AC_PINCAP_EAPD))
916 return;
917 if (spec->keep_eapd_on && !enable)
918 return;
919 if (codec->inv_eapd)
920 enable = !enable;
921 snd_hda_codec_write_cache(codec, pin, 0,
922 AC_VERB_SET_EAPD_BTLENABLE,
923 enable ? 0x02 : 0x00);
924}
925
926
927static void resume_path_from_idx(struct hda_codec *codec, int path_idx)
928{
929 struct nid_path *path = snd_hda_get_path_from_idx(codec, path_idx);
930 if (path)
931 snd_hda_activate_path(codec, path, path->active, false);
932}
933
934
935
936
937
938
939static int hda_gen_mixer_mute_put(struct snd_kcontrol *kcontrol,
940 struct snd_ctl_elem_value *ucontrol);
941static int hda_gen_bind_mute_get(struct snd_kcontrol *kcontrol,
942 struct snd_ctl_elem_value *ucontrol);
943static int hda_gen_bind_mute_put(struct snd_kcontrol *kcontrol,
944 struct snd_ctl_elem_value *ucontrol);
945
946enum {
947 HDA_CTL_WIDGET_VOL,
948 HDA_CTL_WIDGET_MUTE,
949 HDA_CTL_BIND_MUTE,
950};
951static const struct snd_kcontrol_new control_templates[] = {
952 HDA_CODEC_VOLUME(NULL, 0, 0, 0),
953
954 {
955 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
956 .subdevice = HDA_SUBDEV_AMP_FLAG,
957 .info = snd_hda_mixer_amp_switch_info,
958 .get = snd_hda_mixer_amp_switch_get,
959 .put = hda_gen_mixer_mute_put,
960 .private_value = HDA_COMPOSE_AMP_VAL(0, 3, 0, 0),
961 },
962 {
963 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
964 .info = snd_hda_mixer_amp_switch_info,
965 .get = hda_gen_bind_mute_get,
966 .put = hda_gen_bind_mute_put,
967 .private_value = HDA_COMPOSE_AMP_VAL(0, 3, 0, 0),
968 },
969};
970
971
972static struct snd_kcontrol_new *
973add_control(struct hda_gen_spec *spec, int type, const char *name,
974 int cidx, unsigned long val)
975{
976 struct snd_kcontrol_new *knew;
977
978 knew = snd_hda_gen_add_kctl(spec, name, &control_templates[type]);
979 if (!knew)
980 return NULL;
981 knew->index = cidx;
982 if (get_amp_nid_(val))
983 knew->subdevice = HDA_SUBDEV_AMP_FLAG;
984 if (knew->access == 0)
985 knew->access = SNDRV_CTL_ELEM_ACCESS_READWRITE;
986 knew->private_value = val;
987 return knew;
988}
989
990static int add_control_with_pfx(struct hda_gen_spec *spec, int type,
991 const char *pfx, const char *dir,
992 const char *sfx, int cidx, unsigned long val)
993{
994 char name[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];
995 snprintf(name, sizeof(name), "%s %s %s", pfx, dir, sfx);
996 if (!add_control(spec, type, name, cidx, val))
997 return -ENOMEM;
998 return 0;
999}
1000
1001#define add_pb_vol_ctrl(spec, type, pfx, val) \
1002 add_control_with_pfx(spec, type, pfx, "Playback", "Volume", 0, val)
1003#define add_pb_sw_ctrl(spec, type, pfx, val) \
1004 add_control_with_pfx(spec, type, pfx, "Playback", "Switch", 0, val)
1005#define __add_pb_vol_ctrl(spec, type, pfx, cidx, val) \
1006 add_control_with_pfx(spec, type, pfx, "Playback", "Volume", cidx, val)
1007#define __add_pb_sw_ctrl(spec, type, pfx, cidx, val) \
1008 add_control_with_pfx(spec, type, pfx, "Playback", "Switch", cidx, val)
1009
1010static int add_vol_ctl(struct hda_codec *codec, const char *pfx, int cidx,
1011 unsigned int chs, struct nid_path *path)
1012{
1013 unsigned int val;
1014 if (!path)
1015 return 0;
1016 val = path->ctls[NID_PATH_VOL_CTL];
1017 if (!val)
1018 return 0;
1019 val = amp_val_replace_channels(val, chs);
1020 return __add_pb_vol_ctrl(codec->spec, HDA_CTL_WIDGET_VOL, pfx, cidx, val);
1021}
1022
1023
1024static int get_default_ch_nums(struct hda_codec *codec, struct nid_path *path,
1025 int type)
1026{
1027 int chs = 1;
1028 if (path) {
1029 hda_nid_t nid = get_amp_nid_(path->ctls[type]);
1030 if (nid && (get_wcaps(codec, nid) & AC_WCAP_STEREO))
1031 chs = 3;
1032 }
1033 return chs;
1034}
1035
1036static int add_stereo_vol(struct hda_codec *codec, const char *pfx, int cidx,
1037 struct nid_path *path)
1038{
1039 int chs = get_default_ch_nums(codec, path, NID_PATH_VOL_CTL);
1040 return add_vol_ctl(codec, pfx, cidx, chs, path);
1041}
1042
1043
1044
1045
1046static int add_sw_ctl(struct hda_codec *codec, const char *pfx, int cidx,
1047 unsigned int chs, struct nid_path *path)
1048{
1049 unsigned int val;
1050 int type = HDA_CTL_WIDGET_MUTE;
1051
1052 if (!path)
1053 return 0;
1054 val = path->ctls[NID_PATH_MUTE_CTL];
1055 if (!val)
1056 return 0;
1057 val = amp_val_replace_channels(val, chs);
1058 if (get_amp_direction_(val) == HDA_INPUT) {
1059 hda_nid_t nid = get_amp_nid_(val);
1060 int nums = snd_hda_get_num_conns(codec, nid);
1061 if (nums > 1) {
1062 type = HDA_CTL_BIND_MUTE;
1063 val |= nums << 19;
1064 }
1065 }
1066 return __add_pb_sw_ctrl(codec->spec, type, pfx, cidx, val);
1067}
1068
1069static int add_stereo_sw(struct hda_codec *codec, const char *pfx,
1070 int cidx, struct nid_path *path)
1071{
1072 int chs = get_default_ch_nums(codec, path, NID_PATH_MUTE_CTL);
1073 return add_sw_ctl(codec, pfx, cidx, chs, path);
1074}
1075
1076
1077static void sync_auto_mute_bits(struct snd_kcontrol *kcontrol,
1078 struct snd_ctl_elem_value *ucontrol)
1079{
1080 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1081 struct hda_gen_spec *spec = codec->spec;
1082
1083 if (spec->auto_mute_via_amp) {
1084 hda_nid_t nid = get_amp_nid(kcontrol);
1085 bool enabled = !((spec->mute_bits >> nid) & 1);
1086 ucontrol->value.integer.value[0] &= enabled;
1087 ucontrol->value.integer.value[1] &= enabled;
1088 }
1089}
1090
1091static int hda_gen_mixer_mute_put(struct snd_kcontrol *kcontrol,
1092 struct snd_ctl_elem_value *ucontrol)
1093{
1094 sync_auto_mute_bits(kcontrol, ucontrol);
1095 return snd_hda_mixer_amp_switch_put(kcontrol, ucontrol);
1096}
1097
1098
1099
1100
1101#define AMP_VAL_IDX_SHIFT 19
1102#define AMP_VAL_IDX_MASK (0x0f<<19)
1103
1104static int hda_gen_bind_mute_get(struct snd_kcontrol *kcontrol,
1105 struct snd_ctl_elem_value *ucontrol)
1106{
1107 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1108 unsigned long pval;
1109 int err;
1110
1111 mutex_lock(&codec->control_mutex);
1112 pval = kcontrol->private_value;
1113 kcontrol->private_value = pval & ~AMP_VAL_IDX_MASK;
1114 err = snd_hda_mixer_amp_switch_get(kcontrol, ucontrol);
1115 kcontrol->private_value = pval;
1116 mutex_unlock(&codec->control_mutex);
1117 return err;
1118}
1119
1120static int hda_gen_bind_mute_put(struct snd_kcontrol *kcontrol,
1121 struct snd_ctl_elem_value *ucontrol)
1122{
1123 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1124 unsigned long pval;
1125 int i, indices, err = 0, change = 0;
1126
1127 sync_auto_mute_bits(kcontrol, ucontrol);
1128
1129 mutex_lock(&codec->control_mutex);
1130 pval = kcontrol->private_value;
1131 indices = (pval & AMP_VAL_IDX_MASK) >> AMP_VAL_IDX_SHIFT;
1132 for (i = 0; i < indices; i++) {
1133 kcontrol->private_value = (pval & ~AMP_VAL_IDX_MASK) |
1134 (i << AMP_VAL_IDX_SHIFT);
1135 err = snd_hda_mixer_amp_switch_put(kcontrol, ucontrol);
1136 if (err < 0)
1137 break;
1138 change |= err;
1139 }
1140 kcontrol->private_value = pval;
1141 mutex_unlock(&codec->control_mutex);
1142 return err < 0 ? err : change;
1143}
1144
1145
1146static bool path_has_mixer(struct hda_codec *codec, int path_idx, int ctl_type)
1147{
1148 struct nid_path *path = snd_hda_get_path_from_idx(codec, path_idx);
1149 return path && path->ctls[ctl_type];
1150}
1151
1152static const char * const channel_name[4] = {
1153 "Front", "Surround", "CLFE", "Side"
1154};
1155
1156
1157static const char *get_line_out_pfx(struct hda_codec *codec, int ch,
1158 int *index, int ctl_type)
1159{
1160 struct hda_gen_spec *spec = codec->spec;
1161 struct auto_pin_cfg *cfg = &spec->autocfg;
1162
1163 *index = 0;
1164 if (cfg->line_outs == 1 && !spec->multi_ios &&
1165 !codec->force_pin_prefix &&
1166 !cfg->hp_outs && !cfg->speaker_outs)
1167 return spec->vmaster_mute.hook ? "PCM" : "Master";
1168
1169
1170
1171
1172 if (spec->multiout.num_dacs == 1 && !spec->mixer_nid &&
1173 !codec->force_pin_prefix &&
1174 !spec->multiout.hp_out_nid[0] && !spec->multiout.extra_out_nid[0])
1175 return spec->vmaster_mute.hook ? "PCM" : "Master";
1176
1177
1178 if (ch >= cfg->line_outs)
1179 return channel_name[ch];
1180
1181 switch (cfg->line_out_type) {
1182 case AUTO_PIN_SPEAKER_OUT:
1183
1184
1185
1186 if (!ch && cfg->hp_outs &&
1187 !path_has_mixer(codec, spec->hp_paths[0], ctl_type))
1188 break;
1189 if (cfg->line_outs == 1)
1190 return "Speaker";
1191 if (cfg->line_outs == 2)
1192 return ch ? "Bass Speaker" : "Speaker";
1193 break;
1194 case AUTO_PIN_HP_OUT:
1195
1196
1197
1198 if (!ch && cfg->speaker_outs &&
1199 !path_has_mixer(codec, spec->speaker_paths[0], ctl_type))
1200 break;
1201
1202 if (ch && spec->multi_ios)
1203 break;
1204 *index = ch;
1205 return "Headphone";
1206 case AUTO_PIN_LINE_OUT:
1207
1208
1209
1210 if (!ch) {
1211 bool hp_lo_shared = false, spk_lo_shared = false;
1212
1213 if (cfg->speaker_outs)
1214 spk_lo_shared = !path_has_mixer(codec,
1215 spec->speaker_paths[0], ctl_type);
1216 if (cfg->hp_outs)
1217 hp_lo_shared = !path_has_mixer(codec, spec->hp_paths[0], ctl_type);
1218 if (hp_lo_shared && spk_lo_shared)
1219 return spec->vmaster_mute.hook ? "PCM" : "Master";
1220 if (hp_lo_shared)
1221 return "Headphone+LO";
1222 if (spk_lo_shared)
1223 return "Speaker+LO";
1224 }
1225 }
1226
1227
1228 if (cfg->line_outs == 1 && !spec->multi_ios)
1229 return "Line Out";
1230
1231 if (ch >= ARRAY_SIZE(channel_name)) {
1232 snd_BUG();
1233 return "PCM";
1234 }
1235
1236 return channel_name[ch];
1237}
1238
1239
1240
1241
1242
1243
1244enum {
1245
1246 BAD_NO_PRIMARY_DAC = 0x10000,
1247
1248 BAD_NO_DAC = 0x4000,
1249
1250 BAD_MULTI_IO = 0x120,
1251
1252 BAD_NO_EXTRA_DAC = 0x102,
1253
1254 BAD_NO_EXTRA_SURR_DAC = 0x101,
1255
1256 BAD_SHARED_SURROUND = 0x100,
1257
1258 BAD_NO_INDEP_HP = 0x10,
1259
1260 BAD_SHARED_CLFE = 0x10,
1261
1262 BAD_SHARED_EXTRA_SURROUND = 0x10,
1263
1264 BAD_SHARED_VOL = 0x10,
1265};
1266
1267
1268
1269
1270
1271
1272
1273
1274static int assign_out_path_ctls(struct hda_codec *codec, struct nid_path *path)
1275{
1276 struct hda_gen_spec *spec = codec->spec;
1277 hda_nid_t nid;
1278 unsigned int val;
1279 int badness = 0;
1280
1281 if (!path)
1282 return BAD_SHARED_VOL * 2;
1283
1284 if (path->ctls[NID_PATH_VOL_CTL] ||
1285 path->ctls[NID_PATH_MUTE_CTL])
1286 return 0;
1287
1288 nid = look_for_out_vol_nid(codec, path);
1289 if (nid) {
1290 val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
1291 if (spec->dac_min_mute)
1292 val |= HDA_AMP_VAL_MIN_MUTE;
1293 if (is_ctl_used(codec, val, NID_PATH_VOL_CTL))
1294 badness += BAD_SHARED_VOL;
1295 else
1296 path->ctls[NID_PATH_VOL_CTL] = val;
1297 } else
1298 badness += BAD_SHARED_VOL;
1299 nid = look_for_out_mute_nid(codec, path);
1300 if (nid) {
1301 unsigned int wid_type = get_wcaps_type(get_wcaps(codec, nid));
1302 if (wid_type == AC_WID_PIN || wid_type == AC_WID_AUD_OUT ||
1303 nid_has_mute(codec, nid, HDA_OUTPUT))
1304 val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
1305 else
1306 val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT);
1307 if (is_ctl_used(codec, val, NID_PATH_MUTE_CTL))
1308 badness += BAD_SHARED_VOL;
1309 else
1310 path->ctls[NID_PATH_MUTE_CTL] = val;
1311 } else
1312 badness += BAD_SHARED_VOL;
1313 return badness;
1314}
1315
1316const struct badness_table hda_main_out_badness = {
1317 .no_primary_dac = BAD_NO_PRIMARY_DAC,
1318 .no_dac = BAD_NO_DAC,
1319 .shared_primary = BAD_NO_PRIMARY_DAC,
1320 .shared_surr = BAD_SHARED_SURROUND,
1321 .shared_clfe = BAD_SHARED_CLFE,
1322 .shared_surr_main = BAD_SHARED_SURROUND,
1323};
1324EXPORT_SYMBOL_GPL(hda_main_out_badness);
1325
1326const struct badness_table hda_extra_out_badness = {
1327 .no_primary_dac = BAD_NO_DAC,
1328 .no_dac = BAD_NO_DAC,
1329 .shared_primary = BAD_NO_EXTRA_DAC,
1330 .shared_surr = BAD_SHARED_EXTRA_SURROUND,
1331 .shared_clfe = BAD_SHARED_EXTRA_SURROUND,
1332 .shared_surr_main = BAD_NO_EXTRA_SURR_DAC,
1333};
1334EXPORT_SYMBOL_GPL(hda_extra_out_badness);
1335
1336
1337static hda_nid_t get_primary_out(struct hda_codec *codec, int idx)
1338{
1339 struct hda_gen_spec *spec = codec->spec;
1340 struct auto_pin_cfg *cfg = &spec->autocfg;
1341
1342 if (cfg->line_outs > idx)
1343 return spec->private_dac_nids[idx];
1344 idx -= cfg->line_outs;
1345 if (spec->multi_ios > idx)
1346 return spec->multi_io[idx].dac;
1347 return 0;
1348}
1349
1350
1351static inline hda_nid_t try_dac(struct hda_codec *codec,
1352 hda_nid_t dac, hda_nid_t pin)
1353{
1354 return is_reachable_path(codec, dac, pin) ? dac : 0;
1355}
1356
1357
1358static int try_assign_dacs(struct hda_codec *codec, int num_outs,
1359 const hda_nid_t *pins, hda_nid_t *dacs,
1360 int *path_idx,
1361 const struct badness_table *bad)
1362{
1363 struct hda_gen_spec *spec = codec->spec;
1364 int i, j;
1365 int badness = 0;
1366 hda_nid_t dac;
1367
1368 if (!num_outs)
1369 return 0;
1370
1371 for (i = 0; i < num_outs; i++) {
1372 struct nid_path *path;
1373 hda_nid_t pin = pins[i];
1374
1375 if (!spec->obey_preferred_dacs) {
1376 path = snd_hda_get_path_from_idx(codec, path_idx[i]);
1377 if (path) {
1378 badness += assign_out_path_ctls(codec, path);
1379 continue;
1380 }
1381 }
1382
1383 dacs[i] = get_preferred_dac(codec, pin);
1384 if (dacs[i]) {
1385 if (is_dac_already_used(codec, dacs[i]))
1386 badness += bad->shared_primary;
1387 } else if (spec->obey_preferred_dacs) {
1388 badness += BAD_NO_PRIMARY_DAC;
1389 }
1390
1391 if (!dacs[i])
1392 dacs[i] = look_for_dac(codec, pin, false);
1393 if (!dacs[i] && !i) {
1394
1395 for (j = 1; j < num_outs; j++) {
1396 if (is_reachable_path(codec, dacs[j], pin)) {
1397 dacs[0] = dacs[j];
1398 dacs[j] = 0;
1399 invalidate_nid_path(codec, path_idx[j]);
1400 path_idx[j] = 0;
1401 break;
1402 }
1403 }
1404 }
1405 dac = dacs[i];
1406 if (!dac) {
1407 if (num_outs > 2)
1408 dac = try_dac(codec, get_primary_out(codec, i), pin);
1409 if (!dac)
1410 dac = try_dac(codec, dacs[0], pin);
1411 if (!dac)
1412 dac = try_dac(codec, get_primary_out(codec, i), pin);
1413 if (dac) {
1414 if (!i)
1415 badness += bad->shared_primary;
1416 else if (i == 1)
1417 badness += bad->shared_surr;
1418 else
1419 badness += bad->shared_clfe;
1420 } else if (is_reachable_path(codec, spec->private_dac_nids[0], pin)) {
1421 dac = spec->private_dac_nids[0];
1422 badness += bad->shared_surr_main;
1423 } else if (!i)
1424 badness += bad->no_primary_dac;
1425 else
1426 badness += bad->no_dac;
1427 }
1428 if (!dac)
1429 continue;
1430 path = snd_hda_add_new_path(codec, dac, pin, -spec->mixer_nid);
1431 if (!path && !i && spec->mixer_nid) {
1432
1433 path = snd_hda_add_new_path(codec, dac, pin, 0);
1434 }
1435 if (!path) {
1436 dacs[i] = 0;
1437 badness += bad->no_dac;
1438 } else {
1439
1440 path->active = true;
1441 path_idx[i] = snd_hda_get_path_idx(codec, path);
1442 badness += assign_out_path_ctls(codec, path);
1443 }
1444 }
1445
1446 return badness;
1447}
1448
1449
1450static hda_nid_t get_dac_if_single(struct hda_codec *codec, hda_nid_t pin)
1451{
1452 struct hda_gen_spec *spec = codec->spec;
1453 int i;
1454 hda_nid_t nid_found = 0;
1455
1456 for (i = 0; i < spec->num_all_dacs; i++) {
1457 hda_nid_t nid = spec->all_dacs[i];
1458 if (!nid || is_dac_already_used(codec, nid))
1459 continue;
1460 if (is_reachable_path(codec, nid, pin)) {
1461 if (nid_found)
1462 return 0;
1463 nid_found = nid;
1464 }
1465 }
1466 return nid_found;
1467}
1468
1469
1470static bool can_be_multiio_pin(struct hda_codec *codec,
1471 unsigned int location, hda_nid_t nid)
1472{
1473 unsigned int defcfg, caps;
1474
1475 defcfg = snd_hda_codec_get_pincfg(codec, nid);
1476 if (get_defcfg_connect(defcfg) != AC_JACK_PORT_COMPLEX)
1477 return false;
1478 if (location && get_defcfg_location(defcfg) != location)
1479 return false;
1480 caps = snd_hda_query_pin_caps(codec, nid);
1481 if (!(caps & AC_PINCAP_OUT))
1482 return false;
1483 return true;
1484}
1485
1486
1487static int count_multiio_pins(struct hda_codec *codec, hda_nid_t reference_pin)
1488{
1489 struct hda_gen_spec *spec = codec->spec;
1490 struct auto_pin_cfg *cfg = &spec->autocfg;
1491 unsigned int defcfg = snd_hda_codec_get_pincfg(codec, reference_pin);
1492 unsigned int location = get_defcfg_location(defcfg);
1493 int type, i;
1494 int num_pins = 0;
1495
1496 for (type = AUTO_PIN_LINE_IN; type >= AUTO_PIN_MIC; type--) {
1497 for (i = 0; i < cfg->num_inputs; i++) {
1498 if (cfg->inputs[i].type != type)
1499 continue;
1500 if (can_be_multiio_pin(codec, location,
1501 cfg->inputs[i].pin))
1502 num_pins++;
1503 }
1504 }
1505 return num_pins;
1506}
1507
1508
1509
1510
1511
1512
1513
1514
1515
1516static int fill_multi_ios(struct hda_codec *codec,
1517 hda_nid_t reference_pin,
1518 bool hardwired)
1519{
1520 struct hda_gen_spec *spec = codec->spec;
1521 struct auto_pin_cfg *cfg = &spec->autocfg;
1522 int type, i, j, num_pins, old_pins;
1523 unsigned int defcfg = snd_hda_codec_get_pincfg(codec, reference_pin);
1524 unsigned int location = get_defcfg_location(defcfg);
1525 int badness = 0;
1526 struct nid_path *path;
1527
1528 old_pins = spec->multi_ios;
1529 if (old_pins >= 2)
1530 goto end_fill;
1531
1532 num_pins = count_multiio_pins(codec, reference_pin);
1533 if (num_pins < 2)
1534 goto end_fill;
1535
1536 for (type = AUTO_PIN_LINE_IN; type >= AUTO_PIN_MIC; type--) {
1537 for (i = 0; i < cfg->num_inputs; i++) {
1538 hda_nid_t nid = cfg->inputs[i].pin;
1539 hda_nid_t dac = 0;
1540
1541 if (cfg->inputs[i].type != type)
1542 continue;
1543 if (!can_be_multiio_pin(codec, location, nid))
1544 continue;
1545 for (j = 0; j < spec->multi_ios; j++) {
1546 if (nid == spec->multi_io[j].pin)
1547 break;
1548 }
1549 if (j < spec->multi_ios)
1550 continue;
1551
1552 if (hardwired)
1553 dac = get_dac_if_single(codec, nid);
1554 else if (!dac)
1555 dac = look_for_dac(codec, nid, false);
1556 if (!dac) {
1557 badness++;
1558 continue;
1559 }
1560 path = snd_hda_add_new_path(codec, dac, nid,
1561 -spec->mixer_nid);
1562 if (!path) {
1563 badness++;
1564 continue;
1565 }
1566
1567 spec->multi_io[spec->multi_ios].pin = nid;
1568 spec->multi_io[spec->multi_ios].dac = dac;
1569 spec->out_paths[cfg->line_outs + spec->multi_ios] =
1570 snd_hda_get_path_idx(codec, path);
1571 spec->multi_ios++;
1572 if (spec->multi_ios >= 2)
1573 break;
1574 }
1575 }
1576 end_fill:
1577 if (badness)
1578 badness = BAD_MULTI_IO;
1579 if (old_pins == spec->multi_ios) {
1580 if (hardwired)
1581 return 1;
1582 else
1583 return badness;
1584 }
1585 if (!hardwired && spec->multi_ios < 2) {
1586
1587 spec->paths.used -= spec->multi_ios - old_pins;
1588 spec->multi_ios = old_pins;
1589 return badness;
1590 }
1591
1592
1593 for (i = old_pins; i < spec->multi_ios; i++) {
1594 path = snd_hda_get_path_from_idx(codec, spec->out_paths[cfg->line_outs + i]);
1595 badness += assign_out_path_ctls(codec, path);
1596 }
1597
1598 return badness;
1599}
1600
1601
1602static bool map_singles(struct hda_codec *codec, int outs,
1603 const hda_nid_t *pins, hda_nid_t *dacs, int *path_idx)
1604{
1605 struct hda_gen_spec *spec = codec->spec;
1606 int i;
1607 bool found = false;
1608 for (i = 0; i < outs; i++) {
1609 struct nid_path *path;
1610 hda_nid_t dac;
1611 if (dacs[i])
1612 continue;
1613 dac = get_dac_if_single(codec, pins[i]);
1614 if (!dac)
1615 continue;
1616 path = snd_hda_add_new_path(codec, dac, pins[i],
1617 -spec->mixer_nid);
1618 if (!path && !i && spec->mixer_nid)
1619 path = snd_hda_add_new_path(codec, dac, pins[i], 0);
1620 if (path) {
1621 dacs[i] = dac;
1622 found = true;
1623
1624 path->active = true;
1625 path_idx[i] = snd_hda_get_path_idx(codec, path);
1626 }
1627 }
1628 return found;
1629}
1630
1631static inline bool has_aamix_out_paths(struct hda_gen_spec *spec)
1632{
1633 return spec->aamix_out_paths[0] || spec->aamix_out_paths[1] ||
1634 spec->aamix_out_paths[2];
1635}
1636
1637
1638static int check_aamix_out_path(struct hda_codec *codec, int path_idx)
1639{
1640 struct hda_gen_spec *spec = codec->spec;
1641 struct nid_path *path;
1642 hda_nid_t path_dac, dac, pin;
1643
1644 path = snd_hda_get_path_from_idx(codec, path_idx);
1645 if (!path || !path->depth ||
1646 is_nid_contained(path, spec->mixer_nid))
1647 return 0;
1648 path_dac = path->path[0];
1649 dac = spec->private_dac_nids[0];
1650 pin = path->path[path->depth - 1];
1651 path = snd_hda_add_new_path(codec, dac, pin, spec->mixer_nid);
1652 if (!path) {
1653 if (dac != path_dac)
1654 dac = path_dac;
1655 else if (spec->multiout.hp_out_nid[0])
1656 dac = spec->multiout.hp_out_nid[0];
1657 else if (spec->multiout.extra_out_nid[0])
1658 dac = spec->multiout.extra_out_nid[0];
1659 else
1660 dac = 0;
1661 if (dac)
1662 path = snd_hda_add_new_path(codec, dac, pin,
1663 spec->mixer_nid);
1664 }
1665 if (!path)
1666 return 0;
1667
1668 path->active = false;
1669 path->pin_fixed = true;
1670 return snd_hda_get_path_idx(codec, path);
1671}
1672
1673
1674static bool indep_hp_possible(struct hda_codec *codec)
1675{
1676 struct hda_gen_spec *spec = codec->spec;
1677 struct auto_pin_cfg *cfg = &spec->autocfg;
1678 struct nid_path *path;
1679 int i, idx;
1680
1681 if (cfg->line_out_type == AUTO_PIN_HP_OUT)
1682 idx = spec->out_paths[0];
1683 else
1684 idx = spec->hp_paths[0];
1685 path = snd_hda_get_path_from_idx(codec, idx);
1686 if (!path)
1687 return false;
1688
1689
1690 if (!spec->mixer_nid || !is_nid_contained(path, spec->mixer_nid))
1691 return true;
1692
1693
1694 for (i = 0; i < cfg->line_outs; i++) {
1695 if (spec->out_paths[i] == idx)
1696 break;
1697 path = snd_hda_get_path_from_idx(codec, spec->out_paths[i]);
1698 if (path && is_nid_contained(path, spec->mixer_nid))
1699 return false;
1700 }
1701 for (i = 0; i < cfg->speaker_outs; i++) {
1702 path = snd_hda_get_path_from_idx(codec, spec->speaker_paths[i]);
1703 if (path && is_nid_contained(path, spec->mixer_nid))
1704 return false;
1705 }
1706
1707 return true;
1708}
1709
1710
1711
1712
1713static void refill_shared_dacs(struct hda_codec *codec, int num_outs,
1714 hda_nid_t *dacs, int *path_idx)
1715{
1716 struct nid_path *path;
1717 int i;
1718
1719 for (i = 0; i < num_outs; i++) {
1720 if (dacs[i])
1721 continue;
1722 path = snd_hda_get_path_from_idx(codec, path_idx[i]);
1723 if (!path)
1724 continue;
1725 dacs[i] = path->path[0];
1726 }
1727}
1728
1729
1730static int fill_and_eval_dacs(struct hda_codec *codec,
1731 bool fill_hardwired,
1732 bool fill_mio_first)
1733{
1734 struct hda_gen_spec *spec = codec->spec;
1735 struct auto_pin_cfg *cfg = &spec->autocfg;
1736 int i, err, badness;
1737
1738
1739 spec->multiout.num_dacs = cfg->line_outs;
1740 spec->multiout.dac_nids = spec->private_dac_nids;
1741 memset(spec->private_dac_nids, 0, sizeof(spec->private_dac_nids));
1742 memset(spec->multiout.hp_out_nid, 0, sizeof(spec->multiout.hp_out_nid));
1743 memset(spec->multiout.extra_out_nid, 0, sizeof(spec->multiout.extra_out_nid));
1744 spec->multi_ios = 0;
1745 snd_array_free(&spec->paths);
1746
1747
1748 memset(spec->out_paths, 0, sizeof(spec->out_paths));
1749 memset(spec->hp_paths, 0, sizeof(spec->hp_paths));
1750 memset(spec->speaker_paths, 0, sizeof(spec->speaker_paths));
1751 memset(spec->aamix_out_paths, 0, sizeof(spec->aamix_out_paths));
1752 memset(spec->digout_paths, 0, sizeof(spec->digout_paths));
1753 memset(spec->input_paths, 0, sizeof(spec->input_paths));
1754 memset(spec->loopback_paths, 0, sizeof(spec->loopback_paths));
1755 memset(&spec->digin_path, 0, sizeof(spec->digin_path));
1756
1757 badness = 0;
1758
1759
1760 if (fill_hardwired) {
1761 bool mapped;
1762 do {
1763 mapped = map_singles(codec, cfg->line_outs,
1764 cfg->line_out_pins,
1765 spec->private_dac_nids,
1766 spec->out_paths);
1767 mapped |= map_singles(codec, cfg->hp_outs,
1768 cfg->hp_pins,
1769 spec->multiout.hp_out_nid,
1770 spec->hp_paths);
1771 mapped |= map_singles(codec, cfg->speaker_outs,
1772 cfg->speaker_pins,
1773 spec->multiout.extra_out_nid,
1774 spec->speaker_paths);
1775 if (!spec->no_multi_io &&
1776 fill_mio_first && cfg->line_outs == 1 &&
1777 cfg->line_out_type != AUTO_PIN_SPEAKER_OUT) {
1778 err = fill_multi_ios(codec, cfg->line_out_pins[0], true);
1779 if (!err)
1780 mapped = true;
1781 }
1782 } while (mapped);
1783 }
1784
1785 badness += try_assign_dacs(codec, cfg->line_outs, cfg->line_out_pins,
1786 spec->private_dac_nids, spec->out_paths,
1787 spec->main_out_badness);
1788
1789 if (!spec->no_multi_io && fill_mio_first &&
1790 cfg->line_outs == 1 && cfg->line_out_type != AUTO_PIN_SPEAKER_OUT) {
1791
1792 err = fill_multi_ios(codec, cfg->line_out_pins[0], false);
1793 if (err < 0)
1794 return err;
1795
1796 }
1797
1798 if (cfg->line_out_type != AUTO_PIN_HP_OUT) {
1799 err = try_assign_dacs(codec, cfg->hp_outs, cfg->hp_pins,
1800 spec->multiout.hp_out_nid,
1801 spec->hp_paths,
1802 spec->extra_out_badness);
1803 if (err < 0)
1804 return err;
1805 badness += err;
1806 }
1807 if (cfg->line_out_type != AUTO_PIN_SPEAKER_OUT) {
1808 err = try_assign_dacs(codec, cfg->speaker_outs,
1809 cfg->speaker_pins,
1810 spec->multiout.extra_out_nid,
1811 spec->speaker_paths,
1812 spec->extra_out_badness);
1813 if (err < 0)
1814 return err;
1815 badness += err;
1816 }
1817 if (!spec->no_multi_io &&
1818 cfg->line_outs == 1 && cfg->line_out_type != AUTO_PIN_SPEAKER_OUT) {
1819 err = fill_multi_ios(codec, cfg->line_out_pins[0], false);
1820 if (err < 0)
1821 return err;
1822 badness += err;
1823 }
1824
1825 if (spec->mixer_nid) {
1826 spec->aamix_out_paths[0] =
1827 check_aamix_out_path(codec, spec->out_paths[0]);
1828 if (cfg->line_out_type != AUTO_PIN_HP_OUT)
1829 spec->aamix_out_paths[1] =
1830 check_aamix_out_path(codec, spec->hp_paths[0]);
1831 if (cfg->line_out_type != AUTO_PIN_SPEAKER_OUT)
1832 spec->aamix_out_paths[2] =
1833 check_aamix_out_path(codec, spec->speaker_paths[0]);
1834 }
1835
1836 if (!spec->no_multi_io &&
1837 cfg->hp_outs && cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
1838 if (count_multiio_pins(codec, cfg->hp_pins[0]) >= 2)
1839 spec->multi_ios = 1;
1840
1841
1842 spec->multiout.num_dacs = 0;
1843 for (i = 0; i < cfg->line_outs; i++) {
1844 if (spec->private_dac_nids[i])
1845 spec->multiout.num_dacs++;
1846 else {
1847 memmove(spec->private_dac_nids + i,
1848 spec->private_dac_nids + i + 1,
1849 sizeof(hda_nid_t) * (cfg->line_outs - i - 1));
1850 spec->private_dac_nids[cfg->line_outs - 1] = 0;
1851 }
1852 }
1853
1854 spec->ext_channel_count = spec->min_channel_count =
1855 spec->multiout.num_dacs * 2;
1856
1857 if (spec->multi_ios == 2) {
1858 for (i = 0; i < 2; i++)
1859 spec->private_dac_nids[spec->multiout.num_dacs++] =
1860 spec->multi_io[i].dac;
1861 } else if (spec->multi_ios) {
1862 spec->multi_ios = 0;
1863 badness += BAD_MULTI_IO;
1864 }
1865
1866 if (spec->indep_hp && !indep_hp_possible(codec))
1867 badness += BAD_NO_INDEP_HP;
1868
1869
1870 if (cfg->line_out_type != AUTO_PIN_HP_OUT)
1871 refill_shared_dacs(codec, cfg->hp_outs,
1872 spec->multiout.hp_out_nid,
1873 spec->hp_paths);
1874 if (cfg->line_out_type != AUTO_PIN_SPEAKER_OUT)
1875 refill_shared_dacs(codec, cfg->speaker_outs,
1876 spec->multiout.extra_out_nid,
1877 spec->speaker_paths);
1878
1879 return badness;
1880}
1881
1882#define DEBUG_BADNESS
1883
1884#ifdef DEBUG_BADNESS
1885#define debug_badness(fmt, ...) \
1886 codec_dbg(codec, fmt, ##__VA_ARGS__)
1887#else
1888#define debug_badness(fmt, ...) \
1889 do { if (0) codec_dbg(codec, fmt, ##__VA_ARGS__); } while (0)
1890#endif
1891
1892#ifdef DEBUG_BADNESS
1893static inline void print_nid_path_idx(struct hda_codec *codec,
1894 const char *pfx, int idx)
1895{
1896 struct nid_path *path;
1897
1898 path = snd_hda_get_path_from_idx(codec, idx);
1899 if (path)
1900 print_nid_path(codec, pfx, path);
1901}
1902
1903static void debug_show_configs(struct hda_codec *codec,
1904 struct auto_pin_cfg *cfg)
1905{
1906 struct hda_gen_spec *spec = codec->spec;
1907 static const char * const lo_type[3] = { "LO", "SP", "HP" };
1908 int i;
1909
1910 debug_badness("multi_outs = %x/%x/%x/%x : %x/%x/%x/%x (type %s)\n",
1911 cfg->line_out_pins[0], cfg->line_out_pins[1],
1912 cfg->line_out_pins[2], cfg->line_out_pins[3],
1913 spec->multiout.dac_nids[0],
1914 spec->multiout.dac_nids[1],
1915 spec->multiout.dac_nids[2],
1916 spec->multiout.dac_nids[3],
1917 lo_type[cfg->line_out_type]);
1918 for (i = 0; i < cfg->line_outs; i++)
1919 print_nid_path_idx(codec, " out", spec->out_paths[i]);
1920 if (spec->multi_ios > 0)
1921 debug_badness("multi_ios(%d) = %x/%x : %x/%x\n",
1922 spec->multi_ios,
1923 spec->multi_io[0].pin, spec->multi_io[1].pin,
1924 spec->multi_io[0].dac, spec->multi_io[1].dac);
1925 for (i = 0; i < spec->multi_ios; i++)
1926 print_nid_path_idx(codec, " mio",
1927 spec->out_paths[cfg->line_outs + i]);
1928 if (cfg->hp_outs)
1929 debug_badness("hp_outs = %x/%x/%x/%x : %x/%x/%x/%x\n",
1930 cfg->hp_pins[0], cfg->hp_pins[1],
1931 cfg->hp_pins[2], cfg->hp_pins[3],
1932 spec->multiout.hp_out_nid[0],
1933 spec->multiout.hp_out_nid[1],
1934 spec->multiout.hp_out_nid[2],
1935 spec->multiout.hp_out_nid[3]);
1936 for (i = 0; i < cfg->hp_outs; i++)
1937 print_nid_path_idx(codec, " hp ", spec->hp_paths[i]);
1938 if (cfg->speaker_outs)
1939 debug_badness("spk_outs = %x/%x/%x/%x : %x/%x/%x/%x\n",
1940 cfg->speaker_pins[0], cfg->speaker_pins[1],
1941 cfg->speaker_pins[2], cfg->speaker_pins[3],
1942 spec->multiout.extra_out_nid[0],
1943 spec->multiout.extra_out_nid[1],
1944 spec->multiout.extra_out_nid[2],
1945 spec->multiout.extra_out_nid[3]);
1946 for (i = 0; i < cfg->speaker_outs; i++)
1947 print_nid_path_idx(codec, " spk", spec->speaker_paths[i]);
1948 for (i = 0; i < 3; i++)
1949 print_nid_path_idx(codec, " mix", spec->aamix_out_paths[i]);
1950}
1951#else
1952#define debug_show_configs(codec, cfg)
1953#endif
1954
1955
1956static void fill_all_dac_nids(struct hda_codec *codec)
1957{
1958 struct hda_gen_spec *spec = codec->spec;
1959 hda_nid_t nid;
1960
1961 spec->num_all_dacs = 0;
1962 memset(spec->all_dacs, 0, sizeof(spec->all_dacs));
1963 for_each_hda_codec_node(nid, codec) {
1964 if (get_wcaps_type(get_wcaps(codec, nid)) != AC_WID_AUD_OUT)
1965 continue;
1966 if (spec->num_all_dacs >= ARRAY_SIZE(spec->all_dacs)) {
1967 codec_err(codec, "Too many DACs!\n");
1968 break;
1969 }
1970 spec->all_dacs[spec->num_all_dacs++] = nid;
1971 }
1972}
1973
1974static int parse_output_paths(struct hda_codec *codec)
1975{
1976 struct hda_gen_spec *spec = codec->spec;
1977 struct auto_pin_cfg *cfg = &spec->autocfg;
1978 struct auto_pin_cfg *best_cfg;
1979 unsigned int val;
1980 int best_badness = INT_MAX;
1981 int badness;
1982 bool fill_hardwired = true, fill_mio_first = true;
1983 bool best_wired = true, best_mio = true;
1984 bool hp_spk_swapped = false;
1985
1986 best_cfg = kmalloc(sizeof(*best_cfg), GFP_KERNEL);
1987 if (!best_cfg)
1988 return -ENOMEM;
1989 *best_cfg = *cfg;
1990
1991 for (;;) {
1992 badness = fill_and_eval_dacs(codec, fill_hardwired,
1993 fill_mio_first);
1994 if (badness < 0) {
1995 kfree(best_cfg);
1996 return badness;
1997 }
1998 debug_badness("==> lo_type=%d, wired=%d, mio=%d, badness=0x%x\n",
1999 cfg->line_out_type, fill_hardwired, fill_mio_first,
2000 badness);
2001 debug_show_configs(codec, cfg);
2002 if (badness < best_badness) {
2003 best_badness = badness;
2004 *best_cfg = *cfg;
2005 best_wired = fill_hardwired;
2006 best_mio = fill_mio_first;
2007 }
2008 if (!badness)
2009 break;
2010 fill_mio_first = !fill_mio_first;
2011 if (!fill_mio_first)
2012 continue;
2013 fill_hardwired = !fill_hardwired;
2014 if (!fill_hardwired)
2015 continue;
2016 if (hp_spk_swapped)
2017 break;
2018 hp_spk_swapped = true;
2019 if (cfg->speaker_outs > 0 &&
2020 cfg->line_out_type == AUTO_PIN_HP_OUT) {
2021 cfg->hp_outs = cfg->line_outs;
2022 memcpy(cfg->hp_pins, cfg->line_out_pins,
2023 sizeof(cfg->hp_pins));
2024 cfg->line_outs = cfg->speaker_outs;
2025 memcpy(cfg->line_out_pins, cfg->speaker_pins,
2026 sizeof(cfg->speaker_pins));
2027 cfg->speaker_outs = 0;
2028 memset(cfg->speaker_pins, 0, sizeof(cfg->speaker_pins));
2029 cfg->line_out_type = AUTO_PIN_SPEAKER_OUT;
2030 fill_hardwired = true;
2031 continue;
2032 }
2033 if (cfg->hp_outs > 0 &&
2034 cfg->line_out_type == AUTO_PIN_SPEAKER_OUT) {
2035 cfg->speaker_outs = cfg->line_outs;
2036 memcpy(cfg->speaker_pins, cfg->line_out_pins,
2037 sizeof(cfg->speaker_pins));
2038 cfg->line_outs = cfg->hp_outs;
2039 memcpy(cfg->line_out_pins, cfg->hp_pins,
2040 sizeof(cfg->hp_pins));
2041 cfg->hp_outs = 0;
2042 memset(cfg->hp_pins, 0, sizeof(cfg->hp_pins));
2043 cfg->line_out_type = AUTO_PIN_HP_OUT;
2044 fill_hardwired = true;
2045 continue;
2046 }
2047 break;
2048 }
2049
2050 if (badness) {
2051 debug_badness("==> restoring best_cfg\n");
2052 *cfg = *best_cfg;
2053 fill_and_eval_dacs(codec, best_wired, best_mio);
2054 }
2055 debug_badness("==> Best config: lo_type=%d, wired=%d, mio=%d\n",
2056 cfg->line_out_type, best_wired, best_mio);
2057 debug_show_configs(codec, cfg);
2058
2059 if (cfg->line_out_pins[0]) {
2060 struct nid_path *path;
2061 path = snd_hda_get_path_from_idx(codec, spec->out_paths[0]);
2062 if (path)
2063 spec->vmaster_nid = look_for_out_vol_nid(codec, path);
2064 if (spec->vmaster_nid) {
2065 snd_hda_set_vmaster_tlv(codec, spec->vmaster_nid,
2066 HDA_OUTPUT, spec->vmaster_tlv);
2067 if (spec->dac_min_mute)
2068 spec->vmaster_tlv[SNDRV_CTL_TLVO_DB_SCALE_MUTE_AND_STEP] |= TLV_DB_SCALE_MUTE;
2069 }
2070 }
2071
2072
2073 if (spec->prefer_hp_amp || cfg->line_out_type == AUTO_PIN_HP_OUT)
2074 val = PIN_HP;
2075 else
2076 val = PIN_OUT;
2077 set_pin_targets(codec, cfg->line_outs, cfg->line_out_pins, val);
2078 if (cfg->line_out_type != AUTO_PIN_HP_OUT)
2079 set_pin_targets(codec, cfg->hp_outs, cfg->hp_pins, PIN_HP);
2080 if (cfg->line_out_type != AUTO_PIN_SPEAKER_OUT) {
2081 val = spec->prefer_hp_amp ? PIN_HP : PIN_OUT;
2082 set_pin_targets(codec, cfg->speaker_outs,
2083 cfg->speaker_pins, val);
2084 }
2085
2086
2087 if (spec->indep_hp && !indep_hp_possible(codec))
2088 spec->indep_hp = 0;
2089
2090 kfree(best_cfg);
2091 return 0;
2092}
2093
2094
2095static int create_multi_out_ctls(struct hda_codec *codec,
2096 const struct auto_pin_cfg *cfg)
2097{
2098 struct hda_gen_spec *spec = codec->spec;
2099 int i, err, noutputs;
2100
2101 noutputs = cfg->line_outs;
2102 if (spec->multi_ios > 0 && cfg->line_outs < 3)
2103 noutputs += spec->multi_ios;
2104
2105 for (i = 0; i < noutputs; i++) {
2106 const char *name;
2107 int index;
2108 struct nid_path *path;
2109
2110 path = snd_hda_get_path_from_idx(codec, spec->out_paths[i]);
2111 if (!path)
2112 continue;
2113
2114 name = get_line_out_pfx(codec, i, &index, NID_PATH_VOL_CTL);
2115 if (!name || !strcmp(name, "CLFE")) {
2116
2117 err = add_vol_ctl(codec, "Center", 0, 1, path);
2118 if (err < 0)
2119 return err;
2120 err = add_vol_ctl(codec, "LFE", 0, 2, path);
2121 if (err < 0)
2122 return err;
2123 } else {
2124 err = add_stereo_vol(codec, name, index, path);
2125 if (err < 0)
2126 return err;
2127 }
2128
2129 name = get_line_out_pfx(codec, i, &index, NID_PATH_MUTE_CTL);
2130 if (!name || !strcmp(name, "CLFE")) {
2131 err = add_sw_ctl(codec, "Center", 0, 1, path);
2132 if (err < 0)
2133 return err;
2134 err = add_sw_ctl(codec, "LFE", 0, 2, path);
2135 if (err < 0)
2136 return err;
2137 } else {
2138 err = add_stereo_sw(codec, name, index, path);
2139 if (err < 0)
2140 return err;
2141 }
2142 }
2143 return 0;
2144}
2145
2146static int create_extra_out(struct hda_codec *codec, int path_idx,
2147 const char *pfx, int cidx)
2148{
2149 struct nid_path *path;
2150 int err;
2151
2152 path = snd_hda_get_path_from_idx(codec, path_idx);
2153 if (!path)
2154 return 0;
2155 err = add_stereo_vol(codec, pfx, cidx, path);
2156 if (err < 0)
2157 return err;
2158 err = add_stereo_sw(codec, pfx, cidx, path);
2159 if (err < 0)
2160 return err;
2161 return 0;
2162}
2163
2164
2165static int create_extra_outs(struct hda_codec *codec, int num_pins,
2166 const int *paths, const char *pfx)
2167{
2168 int i;
2169
2170 for (i = 0; i < num_pins; i++) {
2171 const char *name;
2172 char tmp[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];
2173 int err, idx = 0;
2174
2175 if (num_pins == 2 && i == 1 && !strcmp(pfx, "Speaker"))
2176 name = "Bass Speaker";
2177 else if (num_pins >= 3) {
2178 snprintf(tmp, sizeof(tmp), "%s %s",
2179 pfx, channel_name[i]);
2180 name = tmp;
2181 } else {
2182 name = pfx;
2183 idx = i;
2184 }
2185 err = create_extra_out(codec, paths[i], name, idx);
2186 if (err < 0)
2187 return err;
2188 }
2189 return 0;
2190}
2191
2192static int create_hp_out_ctls(struct hda_codec *codec)
2193{
2194 struct hda_gen_spec *spec = codec->spec;
2195 return create_extra_outs(codec, spec->autocfg.hp_outs,
2196 spec->hp_paths,
2197 "Headphone");
2198}
2199
2200static int create_speaker_out_ctls(struct hda_codec *codec)
2201{
2202 struct hda_gen_spec *spec = codec->spec;
2203 return create_extra_outs(codec, spec->autocfg.speaker_outs,
2204 spec->speaker_paths,
2205 "Speaker");
2206}
2207
2208
2209
2210
2211
2212static void call_hp_automute(struct hda_codec *codec,
2213 struct hda_jack_callback *jack);
2214static int indep_hp_info(struct snd_kcontrol *kcontrol,
2215 struct snd_ctl_elem_info *uinfo)
2216{
2217 return snd_hda_enum_bool_helper_info(kcontrol, uinfo);
2218}
2219
2220static int indep_hp_get(struct snd_kcontrol *kcontrol,
2221 struct snd_ctl_elem_value *ucontrol)
2222{
2223 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2224 struct hda_gen_spec *spec = codec->spec;
2225 ucontrol->value.enumerated.item[0] = spec->indep_hp_enabled;
2226 return 0;
2227}
2228
2229static void update_aamix_paths(struct hda_codec *codec, bool do_mix,
2230 int nomix_path_idx, int mix_path_idx,
2231 int out_type);
2232
2233static int indep_hp_put(struct snd_kcontrol *kcontrol,
2234 struct snd_ctl_elem_value *ucontrol)
2235{
2236 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2237 struct hda_gen_spec *spec = codec->spec;
2238 unsigned int select = ucontrol->value.enumerated.item[0];
2239 int ret = 0;
2240
2241 mutex_lock(&spec->pcm_mutex);
2242 if (spec->active_streams) {
2243 ret = -EBUSY;
2244 goto unlock;
2245 }
2246
2247 if (spec->indep_hp_enabled != select) {
2248 hda_nid_t *dacp;
2249 if (spec->autocfg.line_out_type == AUTO_PIN_HP_OUT)
2250 dacp = &spec->private_dac_nids[0];
2251 else
2252 dacp = &spec->multiout.hp_out_nid[0];
2253
2254
2255 if (spec->have_aamix_ctl) {
2256 if (spec->autocfg.line_out_type == AUTO_PIN_HP_OUT)
2257 update_aamix_paths(codec, spec->aamix_mode,
2258 spec->out_paths[0],
2259 spec->aamix_out_paths[0],
2260 spec->autocfg.line_out_type);
2261 else
2262 update_aamix_paths(codec, spec->aamix_mode,
2263 spec->hp_paths[0],
2264 spec->aamix_out_paths[1],
2265 AUTO_PIN_HP_OUT);
2266 }
2267
2268 spec->indep_hp_enabled = select;
2269 if (spec->indep_hp_enabled)
2270 *dacp = 0;
2271 else
2272 *dacp = spec->alt_dac_nid;
2273
2274 call_hp_automute(codec, NULL);
2275 ret = 1;
2276 }
2277 unlock:
2278 mutex_unlock(&spec->pcm_mutex);
2279 return ret;
2280}
2281
2282static const struct snd_kcontrol_new indep_hp_ctl = {
2283 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2284 .name = "Independent HP",
2285 .info = indep_hp_info,
2286 .get = indep_hp_get,
2287 .put = indep_hp_put,
2288};
2289
2290
2291static int create_indep_hp_ctls(struct hda_codec *codec)
2292{
2293 struct hda_gen_spec *spec = codec->spec;
2294 hda_nid_t dac;
2295
2296 if (!spec->indep_hp)
2297 return 0;
2298 if (spec->autocfg.line_out_type == AUTO_PIN_HP_OUT)
2299 dac = spec->multiout.dac_nids[0];
2300 else
2301 dac = spec->multiout.hp_out_nid[0];
2302 if (!dac) {
2303 spec->indep_hp = 0;
2304 return 0;
2305 }
2306
2307 spec->indep_hp_enabled = false;
2308 spec->alt_dac_nid = dac;
2309 if (!snd_hda_gen_add_kctl(spec, NULL, &indep_hp_ctl))
2310 return -ENOMEM;
2311 return 0;
2312}
2313
2314
2315
2316
2317
2318static int ch_mode_info(struct snd_kcontrol *kcontrol,
2319 struct snd_ctl_elem_info *uinfo)
2320{
2321 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2322 struct hda_gen_spec *spec = codec->spec;
2323 int chs;
2324
2325 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
2326 uinfo->count = 1;
2327 uinfo->value.enumerated.items = spec->multi_ios + 1;
2328 if (uinfo->value.enumerated.item > spec->multi_ios)
2329 uinfo->value.enumerated.item = spec->multi_ios;
2330 chs = uinfo->value.enumerated.item * 2 + spec->min_channel_count;
2331 sprintf(uinfo->value.enumerated.name, "%dch", chs);
2332 return 0;
2333}
2334
2335static int ch_mode_get(struct snd_kcontrol *kcontrol,
2336 struct snd_ctl_elem_value *ucontrol)
2337{
2338 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2339 struct hda_gen_spec *spec = codec->spec;
2340 ucontrol->value.enumerated.item[0] =
2341 (spec->ext_channel_count - spec->min_channel_count) / 2;
2342 return 0;
2343}
2344
2345static inline struct nid_path *
2346get_multiio_path(struct hda_codec *codec, int idx)
2347{
2348 struct hda_gen_spec *spec = codec->spec;
2349 return snd_hda_get_path_from_idx(codec,
2350 spec->out_paths[spec->autocfg.line_outs + idx]);
2351}
2352
2353static void update_automute_all(struct hda_codec *codec);
2354
2355
2356
2357
2358static bool aamix_default(struct hda_gen_spec *spec)
2359{
2360 return !spec->have_aamix_ctl || spec->aamix_mode;
2361}
2362
2363static int set_multi_io(struct hda_codec *codec, int idx, bool output)
2364{
2365 struct hda_gen_spec *spec = codec->spec;
2366 hda_nid_t nid = spec->multi_io[idx].pin;
2367 struct nid_path *path;
2368
2369 path = get_multiio_path(codec, idx);
2370 if (!path)
2371 return -EINVAL;
2372
2373 if (path->active == output)
2374 return 0;
2375
2376 if (output) {
2377 set_pin_target(codec, nid, PIN_OUT, true);
2378 snd_hda_activate_path(codec, path, true, aamix_default(spec));
2379 set_pin_eapd(codec, nid, true);
2380 } else {
2381 set_pin_eapd(codec, nid, false);
2382 snd_hda_activate_path(codec, path, false, aamix_default(spec));
2383 set_pin_target(codec, nid, spec->multi_io[idx].ctl_in, true);
2384 path_power_down_sync(codec, path);
2385 }
2386
2387
2388 update_automute_all(codec);
2389
2390 return 0;
2391}
2392
2393static int ch_mode_put(struct snd_kcontrol *kcontrol,
2394 struct snd_ctl_elem_value *ucontrol)
2395{
2396 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2397 struct hda_gen_spec *spec = codec->spec;
2398 int i, ch;
2399
2400 ch = ucontrol->value.enumerated.item[0];
2401 if (ch < 0 || ch > spec->multi_ios)
2402 return -EINVAL;
2403 if (ch == (spec->ext_channel_count - spec->min_channel_count) / 2)
2404 return 0;
2405 spec->ext_channel_count = ch * 2 + spec->min_channel_count;
2406 for (i = 0; i < spec->multi_ios; i++)
2407 set_multi_io(codec, i, i < ch);
2408 spec->multiout.max_channels = max(spec->ext_channel_count,
2409 spec->const_channel_count);
2410 if (spec->need_dac_fix)
2411 spec->multiout.num_dacs = spec->multiout.max_channels / 2;
2412 return 1;
2413}
2414
2415static const struct snd_kcontrol_new channel_mode_enum = {
2416 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2417 .name = "Channel Mode",
2418 .info = ch_mode_info,
2419 .get = ch_mode_get,
2420 .put = ch_mode_put,
2421};
2422
2423static int create_multi_channel_mode(struct hda_codec *codec)
2424{
2425 struct hda_gen_spec *spec = codec->spec;
2426
2427 if (spec->multi_ios > 0) {
2428 if (!snd_hda_gen_add_kctl(spec, NULL, &channel_mode_enum))
2429 return -ENOMEM;
2430 }
2431 return 0;
2432}
2433
2434
2435
2436
2437
2438#define loopback_mixing_info indep_hp_info
2439
2440static int loopback_mixing_get(struct snd_kcontrol *kcontrol,
2441 struct snd_ctl_elem_value *ucontrol)
2442{
2443 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2444 struct hda_gen_spec *spec = codec->spec;
2445 ucontrol->value.enumerated.item[0] = spec->aamix_mode;
2446 return 0;
2447}
2448
2449static void update_aamix_paths(struct hda_codec *codec, bool do_mix,
2450 int nomix_path_idx, int mix_path_idx,
2451 int out_type)
2452{
2453 struct hda_gen_spec *spec = codec->spec;
2454 struct nid_path *nomix_path, *mix_path;
2455
2456 nomix_path = snd_hda_get_path_from_idx(codec, nomix_path_idx);
2457 mix_path = snd_hda_get_path_from_idx(codec, mix_path_idx);
2458 if (!nomix_path || !mix_path)
2459 return;
2460
2461
2462
2463
2464 if (out_type == AUTO_PIN_HP_OUT && spec->indep_hp_enabled &&
2465 mix_path->path[0] != spec->alt_dac_nid)
2466 do_mix = false;
2467
2468 if (do_mix) {
2469 snd_hda_activate_path(codec, nomix_path, false, true);
2470 snd_hda_activate_path(codec, mix_path, true, true);
2471 path_power_down_sync(codec, nomix_path);
2472 } else {
2473 snd_hda_activate_path(codec, mix_path, false, false);
2474 snd_hda_activate_path(codec, nomix_path, true, false);
2475 path_power_down_sync(codec, mix_path);
2476 }
2477}
2478
2479
2480static void update_output_paths(struct hda_codec *codec, int num_outs,
2481 const int *paths)
2482{
2483 struct hda_gen_spec *spec = codec->spec;
2484 struct nid_path *path;
2485 int i;
2486
2487 for (i = 0; i < num_outs; i++) {
2488 path = snd_hda_get_path_from_idx(codec, paths[i]);
2489 if (path)
2490 snd_hda_activate_path(codec, path, path->active,
2491 spec->aamix_mode);
2492 }
2493}
2494
2495static int loopback_mixing_put(struct snd_kcontrol *kcontrol,
2496 struct snd_ctl_elem_value *ucontrol)
2497{
2498 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2499 struct hda_gen_spec *spec = codec->spec;
2500 const struct auto_pin_cfg *cfg = &spec->autocfg;
2501 unsigned int val = ucontrol->value.enumerated.item[0];
2502
2503 if (val == spec->aamix_mode)
2504 return 0;
2505 spec->aamix_mode = val;
2506 if (has_aamix_out_paths(spec)) {
2507 update_aamix_paths(codec, val, spec->out_paths[0],
2508 spec->aamix_out_paths[0],
2509 cfg->line_out_type);
2510 update_aamix_paths(codec, val, spec->hp_paths[0],
2511 spec->aamix_out_paths[1],
2512 AUTO_PIN_HP_OUT);
2513 update_aamix_paths(codec, val, spec->speaker_paths[0],
2514 spec->aamix_out_paths[2],
2515 AUTO_PIN_SPEAKER_OUT);
2516 } else {
2517 update_output_paths(codec, cfg->line_outs, spec->out_paths);
2518 if (cfg->line_out_type != AUTO_PIN_HP_OUT)
2519 update_output_paths(codec, cfg->hp_outs, spec->hp_paths);
2520 if (cfg->line_out_type != AUTO_PIN_SPEAKER_OUT)
2521 update_output_paths(codec, cfg->speaker_outs,
2522 spec->speaker_paths);
2523 }
2524 return 1;
2525}
2526
2527static const struct snd_kcontrol_new loopback_mixing_enum = {
2528 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2529 .name = "Loopback Mixing",
2530 .info = loopback_mixing_info,
2531 .get = loopback_mixing_get,
2532 .put = loopback_mixing_put,
2533};
2534
2535static int create_loopback_mixing_ctl(struct hda_codec *codec)
2536{
2537 struct hda_gen_spec *spec = codec->spec;
2538
2539 if (!spec->mixer_nid)
2540 return 0;
2541 if (!snd_hda_gen_add_kctl(spec, NULL, &loopback_mixing_enum))
2542 return -ENOMEM;
2543 spec->have_aamix_ctl = 1;
2544 return 0;
2545}
2546
2547
2548
2549
2550
2551static void call_update_outputs(struct hda_codec *codec);
2552
2553
2554static void update_hp_mic(struct hda_codec *codec, int adc_mux, bool force)
2555{
2556 struct hda_gen_spec *spec = codec->spec;
2557 bool as_mic;
2558 unsigned int val;
2559 hda_nid_t pin;
2560
2561 pin = spec->hp_mic_pin;
2562 as_mic = spec->cur_mux[adc_mux] == spec->hp_mic_mux_idx;
2563
2564 if (!force) {
2565 val = snd_hda_codec_get_pin_target(codec, pin);
2566 if (as_mic) {
2567 if (val & PIN_IN)
2568 return;
2569 } else {
2570 if (val & PIN_OUT)
2571 return;
2572 }
2573 }
2574
2575 val = snd_hda_get_default_vref(codec, pin);
2576
2577
2578
2579 if (val == AC_PINCTL_VREF_HIZ && spec->shared_mic_vref_pin) {
2580 const hda_nid_t vref_pin = spec->shared_mic_vref_pin;
2581 unsigned int vref_val = snd_hda_get_default_vref(codec, vref_pin);
2582 if (vref_val != AC_PINCTL_VREF_HIZ)
2583 snd_hda_set_pin_ctl_cache(codec, vref_pin,
2584 PIN_IN | (as_mic ? vref_val : 0));
2585 }
2586
2587 if (!spec->hp_mic_jack_modes) {
2588 if (as_mic)
2589 val |= PIN_IN;
2590 else
2591 val = PIN_HP;
2592 set_pin_target(codec, pin, val, true);
2593 call_hp_automute(codec, NULL);
2594 }
2595}
2596
2597
2598static int create_hp_mic(struct hda_codec *codec)
2599{
2600 struct hda_gen_spec *spec = codec->spec;
2601 struct auto_pin_cfg *cfg = &spec->autocfg;
2602 unsigned int defcfg;
2603 hda_nid_t nid;
2604
2605 if (!spec->hp_mic) {
2606 if (spec->suppress_hp_mic_detect)
2607 return 0;
2608
2609
2610
2611 if (cfg->num_inputs > 1)
2612 return 0;
2613 else if (cfg->num_inputs == 1) {
2614 defcfg = snd_hda_codec_get_pincfg(codec, cfg->inputs[0].pin);
2615 if (snd_hda_get_input_pin_attr(defcfg) != INPUT_PIN_ATTR_INT)
2616 return 0;
2617 }
2618 }
2619
2620 spec->hp_mic = 0;
2621 if (cfg->num_inputs >= AUTO_CFG_MAX_INS)
2622 return 0;
2623
2624 nid = 0;
2625 if (cfg->line_out_type == AUTO_PIN_HP_OUT && cfg->line_outs > 0)
2626 nid = cfg->line_out_pins[0];
2627 else if (cfg->hp_outs > 0)
2628 nid = cfg->hp_pins[0];
2629 if (!nid)
2630 return 0;
2631
2632 if (!(snd_hda_query_pin_caps(codec, nid) & AC_PINCAP_IN))
2633 return 0;
2634
2635 cfg->inputs[cfg->num_inputs].pin = nid;
2636 cfg->inputs[cfg->num_inputs].type = AUTO_PIN_MIC;
2637 cfg->inputs[cfg->num_inputs].is_headphone_mic = 1;
2638 cfg->num_inputs++;
2639 spec->hp_mic = 1;
2640 spec->hp_mic_pin = nid;
2641
2642 spec->suppress_auto_mic = 1;
2643 codec_dbg(codec, "Enable shared I/O jack on NID 0x%x\n", nid);
2644 return 0;
2645}
2646
2647
2648
2649
2650
2651static int create_hp_mic_jack_mode(struct hda_codec *codec, hda_nid_t pin);
2652
2653static const char * const out_jack_texts[] = {
2654 "Line Out", "Headphone Out",
2655};
2656
2657static int out_jack_mode_info(struct snd_kcontrol *kcontrol,
2658 struct snd_ctl_elem_info *uinfo)
2659{
2660 return snd_hda_enum_helper_info(kcontrol, uinfo, 2, out_jack_texts);
2661}
2662
2663static int out_jack_mode_get(struct snd_kcontrol *kcontrol,
2664 struct snd_ctl_elem_value *ucontrol)
2665{
2666 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2667 hda_nid_t nid = kcontrol->private_value;
2668 if (snd_hda_codec_get_pin_target(codec, nid) == PIN_HP)
2669 ucontrol->value.enumerated.item[0] = 1;
2670 else
2671 ucontrol->value.enumerated.item[0] = 0;
2672 return 0;
2673}
2674
2675static int out_jack_mode_put(struct snd_kcontrol *kcontrol,
2676 struct snd_ctl_elem_value *ucontrol)
2677{
2678 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2679 hda_nid_t nid = kcontrol->private_value;
2680 unsigned int val;
2681
2682 val = ucontrol->value.enumerated.item[0] ? PIN_HP : PIN_OUT;
2683 if (snd_hda_codec_get_pin_target(codec, nid) == val)
2684 return 0;
2685 snd_hda_set_pin_ctl_cache(codec, nid, val);
2686 return 1;
2687}
2688
2689static const struct snd_kcontrol_new out_jack_mode_enum = {
2690 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2691 .info = out_jack_mode_info,
2692 .get = out_jack_mode_get,
2693 .put = out_jack_mode_put,
2694};
2695
2696static bool find_kctl_name(struct hda_codec *codec, const char *name, int idx)
2697{
2698 struct hda_gen_spec *spec = codec->spec;
2699 const struct snd_kcontrol_new *kctl;
2700 int i;
2701
2702 snd_array_for_each(&spec->kctls, i, kctl) {
2703 if (!strcmp(kctl->name, name) && kctl->index == idx)
2704 return true;
2705 }
2706 return false;
2707}
2708
2709static void get_jack_mode_name(struct hda_codec *codec, hda_nid_t pin,
2710 char *name, size_t name_len)
2711{
2712 struct hda_gen_spec *spec = codec->spec;
2713 int idx = 0;
2714
2715 snd_hda_get_pin_label(codec, pin, &spec->autocfg, name, name_len, &idx);
2716 strlcat(name, " Jack Mode", name_len);
2717
2718 for (; find_kctl_name(codec, name, idx); idx++)
2719 ;
2720}
2721
2722static int get_out_jack_num_items(struct hda_codec *codec, hda_nid_t pin)
2723{
2724 struct hda_gen_spec *spec = codec->spec;
2725 if (spec->add_jack_modes) {
2726 unsigned int pincap = snd_hda_query_pin_caps(codec, pin);
2727 if ((pincap & AC_PINCAP_OUT) && (pincap & AC_PINCAP_HP_DRV))
2728 return 2;
2729 }
2730 return 1;
2731}
2732
2733static int create_out_jack_modes(struct hda_codec *codec, int num_pins,
2734 hda_nid_t *pins)
2735{
2736 struct hda_gen_spec *spec = codec->spec;
2737 int i;
2738
2739 for (i = 0; i < num_pins; i++) {
2740 hda_nid_t pin = pins[i];
2741 if (pin == spec->hp_mic_pin)
2742 continue;
2743 if (get_out_jack_num_items(codec, pin) > 1) {
2744 struct snd_kcontrol_new *knew;
2745 char name[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];
2746 get_jack_mode_name(codec, pin, name, sizeof(name));
2747 knew = snd_hda_gen_add_kctl(spec, name,
2748 &out_jack_mode_enum);
2749 if (!knew)
2750 return -ENOMEM;
2751 knew->private_value = pin;
2752 }
2753 }
2754
2755 return 0;
2756}
2757
2758
2759
2760
2761
2762
2763#define NUM_VREFS 6
2764
2765static const char * const vref_texts[NUM_VREFS] = {
2766 "Line In", "Mic 50pc Bias", "Mic 0V Bias",
2767 "", "Mic 80pc Bias", "Mic 100pc Bias"
2768};
2769
2770static unsigned int get_vref_caps(struct hda_codec *codec, hda_nid_t pin)
2771{
2772 unsigned int pincap;
2773
2774 pincap = snd_hda_query_pin_caps(codec, pin);
2775 pincap = (pincap & AC_PINCAP_VREF) >> AC_PINCAP_VREF_SHIFT;
2776
2777 pincap &= ~(AC_PINCAP_VREF_GRD | AC_PINCAP_VREF_100);
2778 return pincap;
2779}
2780
2781
2782static int get_vref_idx(unsigned int vref_caps, unsigned int item_idx)
2783{
2784 unsigned int i, n = 0;
2785
2786 for (i = 0; i < NUM_VREFS; i++) {
2787 if (vref_caps & (1 << i)) {
2788 if (n == item_idx)
2789 return i;
2790 n++;
2791 }
2792 }
2793 return 0;
2794}
2795
2796
2797static int cvt_from_vref_idx(unsigned int vref_caps, unsigned int idx)
2798{
2799 unsigned int i, n = 0;
2800
2801 for (i = 0; i < NUM_VREFS; i++) {
2802 if (i == idx)
2803 return n;
2804 if (vref_caps & (1 << i))
2805 n++;
2806 }
2807 return 0;
2808}
2809
2810static int in_jack_mode_info(struct snd_kcontrol *kcontrol,
2811 struct snd_ctl_elem_info *uinfo)
2812{
2813 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2814 hda_nid_t nid = kcontrol->private_value;
2815 unsigned int vref_caps = get_vref_caps(codec, nid);
2816
2817 snd_hda_enum_helper_info(kcontrol, uinfo, hweight32(vref_caps),
2818 vref_texts);
2819
2820 strcpy(uinfo->value.enumerated.name,
2821 vref_texts[get_vref_idx(vref_caps, uinfo->value.enumerated.item)]);
2822 return 0;
2823}
2824
2825static int in_jack_mode_get(struct snd_kcontrol *kcontrol,
2826 struct snd_ctl_elem_value *ucontrol)
2827{
2828 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2829 hda_nid_t nid = kcontrol->private_value;
2830 unsigned int vref_caps = get_vref_caps(codec, nid);
2831 unsigned int idx;
2832
2833 idx = snd_hda_codec_get_pin_target(codec, nid) & AC_PINCTL_VREFEN;
2834 ucontrol->value.enumerated.item[0] = cvt_from_vref_idx(vref_caps, idx);
2835 return 0;
2836}
2837
2838static int in_jack_mode_put(struct snd_kcontrol *kcontrol,
2839 struct snd_ctl_elem_value *ucontrol)
2840{
2841 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2842 hda_nid_t nid = kcontrol->private_value;
2843 unsigned int vref_caps = get_vref_caps(codec, nid);
2844 unsigned int val, idx;
2845
2846 val = snd_hda_codec_get_pin_target(codec, nid);
2847 idx = cvt_from_vref_idx(vref_caps, val & AC_PINCTL_VREFEN);
2848 if (idx == ucontrol->value.enumerated.item[0])
2849 return 0;
2850
2851 val &= ~AC_PINCTL_VREFEN;
2852 val |= get_vref_idx(vref_caps, ucontrol->value.enumerated.item[0]);
2853 snd_hda_set_pin_ctl_cache(codec, nid, val);
2854 return 1;
2855}
2856
2857static const struct snd_kcontrol_new in_jack_mode_enum = {
2858 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2859 .info = in_jack_mode_info,
2860 .get = in_jack_mode_get,
2861 .put = in_jack_mode_put,
2862};
2863
2864static int get_in_jack_num_items(struct hda_codec *codec, hda_nid_t pin)
2865{
2866 struct hda_gen_spec *spec = codec->spec;
2867 int nitems = 0;
2868 if (spec->add_jack_modes)
2869 nitems = hweight32(get_vref_caps(codec, pin));
2870 return nitems ? nitems : 1;
2871}
2872
2873static int create_in_jack_mode(struct hda_codec *codec, hda_nid_t pin)
2874{
2875 struct hda_gen_spec *spec = codec->spec;
2876 struct snd_kcontrol_new *knew;
2877 char name[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];
2878 unsigned int defcfg;
2879
2880 if (pin == spec->hp_mic_pin)
2881 return 0;
2882
2883
2884 defcfg = snd_hda_codec_get_pincfg(codec, pin);
2885 if (snd_hda_get_input_pin_attr(defcfg) == INPUT_PIN_ATTR_INT)
2886 return 0;
2887
2888
2889 if (get_in_jack_num_items(codec, pin) <= 1)
2890 return 0;
2891
2892 get_jack_mode_name(codec, pin, name, sizeof(name));
2893 knew = snd_hda_gen_add_kctl(spec, name, &in_jack_mode_enum);
2894 if (!knew)
2895 return -ENOMEM;
2896 knew->private_value = pin;
2897 return 0;
2898}
2899
2900
2901
2902
2903static int hp_mic_jack_mode_info(struct snd_kcontrol *kcontrol,
2904 struct snd_ctl_elem_info *uinfo)
2905{
2906 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2907 hda_nid_t nid = kcontrol->private_value;
2908 int out_jacks = get_out_jack_num_items(codec, nid);
2909 int in_jacks = get_in_jack_num_items(codec, nid);
2910 const char *text = NULL;
2911 int idx;
2912
2913 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
2914 uinfo->count = 1;
2915 uinfo->value.enumerated.items = out_jacks + in_jacks;
2916 if (uinfo->value.enumerated.item >= uinfo->value.enumerated.items)
2917 uinfo->value.enumerated.item = uinfo->value.enumerated.items - 1;
2918 idx = uinfo->value.enumerated.item;
2919 if (idx < out_jacks) {
2920 if (out_jacks > 1)
2921 text = out_jack_texts[idx];
2922 else
2923 text = "Headphone Out";
2924 } else {
2925 idx -= out_jacks;
2926 if (in_jacks > 1) {
2927 unsigned int vref_caps = get_vref_caps(codec, nid);
2928 text = vref_texts[get_vref_idx(vref_caps, idx)];
2929 } else
2930 text = "Mic In";
2931 }
2932
2933 strcpy(uinfo->value.enumerated.name, text);
2934 return 0;
2935}
2936
2937static int get_cur_hp_mic_jack_mode(struct hda_codec *codec, hda_nid_t nid)
2938{
2939 int out_jacks = get_out_jack_num_items(codec, nid);
2940 int in_jacks = get_in_jack_num_items(codec, nid);
2941 unsigned int val = snd_hda_codec_get_pin_target(codec, nid);
2942 int idx = 0;
2943
2944 if (val & PIN_OUT) {
2945 if (out_jacks > 1 && val == PIN_HP)
2946 idx = 1;
2947 } else if (val & PIN_IN) {
2948 idx = out_jacks;
2949 if (in_jacks > 1) {
2950 unsigned int vref_caps = get_vref_caps(codec, nid);
2951 val &= AC_PINCTL_VREFEN;
2952 idx += cvt_from_vref_idx(vref_caps, val);
2953 }
2954 }
2955 return idx;
2956}
2957
2958static int hp_mic_jack_mode_get(struct snd_kcontrol *kcontrol,
2959 struct snd_ctl_elem_value *ucontrol)
2960{
2961 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2962 hda_nid_t nid = kcontrol->private_value;
2963 ucontrol->value.enumerated.item[0] =
2964 get_cur_hp_mic_jack_mode(codec, nid);
2965 return 0;
2966}
2967
2968static int hp_mic_jack_mode_put(struct snd_kcontrol *kcontrol,
2969 struct snd_ctl_elem_value *ucontrol)
2970{
2971 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2972 hda_nid_t nid = kcontrol->private_value;
2973 int out_jacks = get_out_jack_num_items(codec, nid);
2974 int in_jacks = get_in_jack_num_items(codec, nid);
2975 unsigned int val, oldval, idx;
2976
2977 oldval = get_cur_hp_mic_jack_mode(codec, nid);
2978 idx = ucontrol->value.enumerated.item[0];
2979 if (oldval == idx)
2980 return 0;
2981
2982 if (idx < out_jacks) {
2983 if (out_jacks > 1)
2984 val = idx ? PIN_HP : PIN_OUT;
2985 else
2986 val = PIN_HP;
2987 } else {
2988 idx -= out_jacks;
2989 if (in_jacks > 1) {
2990 unsigned int vref_caps = get_vref_caps(codec, nid);
2991 val = snd_hda_codec_get_pin_target(codec, nid);
2992 val &= ~(AC_PINCTL_VREFEN | PIN_HP);
2993 val |= get_vref_idx(vref_caps, idx) | PIN_IN;
2994 } else
2995 val = snd_hda_get_default_vref(codec, nid) | PIN_IN;
2996 }
2997 snd_hda_set_pin_ctl_cache(codec, nid, val);
2998 call_hp_automute(codec, NULL);
2999
3000 return 1;
3001}
3002
3003static const struct snd_kcontrol_new hp_mic_jack_mode_enum = {
3004 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3005 .info = hp_mic_jack_mode_info,
3006 .get = hp_mic_jack_mode_get,
3007 .put = hp_mic_jack_mode_put,
3008};
3009
3010static int create_hp_mic_jack_mode(struct hda_codec *codec, hda_nid_t pin)
3011{
3012 struct hda_gen_spec *spec = codec->spec;
3013 struct snd_kcontrol_new *knew;
3014
3015 knew = snd_hda_gen_add_kctl(spec, "Headphone Mic Jack Mode",
3016 &hp_mic_jack_mode_enum);
3017 if (!knew)
3018 return -ENOMEM;
3019 knew->private_value = pin;
3020 spec->hp_mic_jack_modes = 1;
3021 return 0;
3022}
3023
3024
3025
3026
3027
3028
3029static int add_loopback_list(struct hda_gen_spec *spec, hda_nid_t mix, int idx)
3030{
3031 struct hda_amp_list *list;
3032
3033 list = snd_array_new(&spec->loopback_list);
3034 if (!list)
3035 return -ENOMEM;
3036 list->nid = mix;
3037 list->dir = HDA_INPUT;
3038 list->idx = idx;
3039 spec->loopback.amplist = spec->loopback_list.list;
3040 return 0;
3041}
3042
3043
3044
3045
3046static bool look_for_mix_leaf_ctls(struct hda_codec *codec, hda_nid_t mix_nid,
3047 hda_nid_t pin, unsigned int *mix_val,
3048 unsigned int *mute_val)
3049{
3050 int idx, num_conns;
3051 const hda_nid_t *list;
3052 hda_nid_t nid;
3053
3054 idx = snd_hda_get_conn_index(codec, mix_nid, pin, true);
3055 if (idx < 0)
3056 return false;
3057
3058 *mix_val = *mute_val = 0;
3059 if (nid_has_volume(codec, mix_nid, HDA_INPUT))
3060 *mix_val = HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT);
3061 if (nid_has_mute(codec, mix_nid, HDA_INPUT))
3062 *mute_val = HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT);
3063 if (*mix_val && *mute_val)
3064 return true;
3065
3066
3067 num_conns = snd_hda_get_conn_list(codec, mix_nid, &list);
3068 if (num_conns < idx)
3069 return false;
3070 nid = list[idx];
3071 if (!*mix_val && nid_has_volume(codec, nid, HDA_OUTPUT) &&
3072 !is_ctl_associated(codec, nid, HDA_OUTPUT, 0, NID_PATH_VOL_CTL))
3073 *mix_val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
3074 if (!*mute_val && nid_has_mute(codec, nid, HDA_OUTPUT) &&
3075 !is_ctl_associated(codec, nid, HDA_OUTPUT, 0, NID_PATH_MUTE_CTL))
3076 *mute_val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
3077
3078 return *mix_val || *mute_val;
3079}
3080
3081
3082static int new_analog_input(struct hda_codec *codec, int input_idx,
3083 hda_nid_t pin, const char *ctlname, int ctlidx,
3084 hda_nid_t mix_nid)
3085{
3086 struct hda_gen_spec *spec = codec->spec;
3087 struct nid_path *path;
3088 unsigned int mix_val, mute_val;
3089 int err, idx;
3090
3091 if (!look_for_mix_leaf_ctls(codec, mix_nid, pin, &mix_val, &mute_val))
3092 return 0;
3093
3094 path = snd_hda_add_new_path(codec, pin, mix_nid, 0);
3095 if (!path)
3096 return -EINVAL;
3097 print_nid_path(codec, "loopback", path);
3098 spec->loopback_paths[input_idx] = snd_hda_get_path_idx(codec, path);
3099
3100 idx = path->idx[path->depth - 1];
3101 if (mix_val) {
3102 err = __add_pb_vol_ctrl(spec, HDA_CTL_WIDGET_VOL, ctlname, ctlidx, mix_val);
3103 if (err < 0)
3104 return err;
3105 path->ctls[NID_PATH_VOL_CTL] = mix_val;
3106 }
3107
3108 if (mute_val) {
3109 err = __add_pb_sw_ctrl(spec, HDA_CTL_WIDGET_MUTE, ctlname, ctlidx, mute_val);
3110 if (err < 0)
3111 return err;
3112 path->ctls[NID_PATH_MUTE_CTL] = mute_val;
3113 }
3114
3115 path->active = true;
3116 path->stream_enabled = true;
3117 err = add_loopback_list(spec, mix_nid, idx);
3118 if (err < 0)
3119 return err;
3120
3121 if (spec->mixer_nid != spec->mixer_merge_nid &&
3122 !spec->loopback_merge_path) {
3123 path = snd_hda_add_new_path(codec, spec->mixer_nid,
3124 spec->mixer_merge_nid, 0);
3125 if (path) {
3126 print_nid_path(codec, "loopback-merge", path);
3127 path->active = true;
3128 path->pin_fixed = true;
3129 path->stream_enabled = true;
3130 spec->loopback_merge_path =
3131 snd_hda_get_path_idx(codec, path);
3132 }
3133 }
3134
3135 return 0;
3136}
3137
3138static int is_input_pin(struct hda_codec *codec, hda_nid_t nid)
3139{
3140 unsigned int pincap = snd_hda_query_pin_caps(codec, nid);
3141 return (pincap & AC_PINCAP_IN) != 0;
3142}
3143
3144
3145static int fill_adc_nids(struct hda_codec *codec)
3146{
3147 struct hda_gen_spec *spec = codec->spec;
3148 hda_nid_t nid;
3149 hda_nid_t *adc_nids = spec->adc_nids;
3150 int max_nums = ARRAY_SIZE(spec->adc_nids);
3151 int nums = 0;
3152
3153 for_each_hda_codec_node(nid, codec) {
3154 unsigned int caps = get_wcaps(codec, nid);
3155 int type = get_wcaps_type(caps);
3156
3157 if (type != AC_WID_AUD_IN || (caps & AC_WCAP_DIGITAL))
3158 continue;
3159 adc_nids[nums] = nid;
3160 if (++nums >= max_nums)
3161 break;
3162 }
3163 spec->num_adc_nids = nums;
3164
3165
3166 spec->num_all_adcs = nums;
3167 memcpy(spec->all_adcs, spec->adc_nids, nums * sizeof(hda_nid_t));
3168
3169 return nums;
3170}
3171
3172
3173
3174
3175static int check_dyn_adc_switch(struct hda_codec *codec)
3176{
3177 struct hda_gen_spec *spec = codec->spec;
3178 struct hda_input_mux *imux = &spec->input_mux;
3179 unsigned int ok_bits;
3180 int i, n, nums;
3181
3182 nums = 0;
3183 ok_bits = 0;
3184 for (n = 0; n < spec->num_adc_nids; n++) {
3185 for (i = 0; i < imux->num_items; i++) {
3186 if (!spec->input_paths[i][n])
3187 break;
3188 }
3189 if (i >= imux->num_items) {
3190 ok_bits |= (1 << n);
3191 nums++;
3192 }
3193 }
3194
3195 if (!ok_bits) {
3196
3197 for (i = 0; i < imux->num_items; i++) {
3198 for (n = 0; n < spec->num_adc_nids; n++) {
3199 if (spec->input_paths[i][n]) {
3200 spec->dyn_adc_idx[i] = n;
3201 break;
3202 }
3203 }
3204 }
3205
3206 codec_dbg(codec, "enabling ADC switching\n");
3207 spec->dyn_adc_switch = 1;
3208 } else if (nums != spec->num_adc_nids) {
3209
3210 nums = 0;
3211 for (n = 0; n < spec->num_adc_nids; n++) {
3212 if (!(ok_bits & (1 << n)))
3213 continue;
3214 if (n != nums) {
3215 spec->adc_nids[nums] = spec->adc_nids[n];
3216 for (i = 0; i < imux->num_items; i++) {
3217 invalidate_nid_path(codec,
3218 spec->input_paths[i][nums]);
3219 spec->input_paths[i][nums] =
3220 spec->input_paths[i][n];
3221 spec->input_paths[i][n] = 0;
3222 }
3223 }
3224 nums++;
3225 }
3226 spec->num_adc_nids = nums;
3227 }
3228
3229 if (imux->num_items == 1 ||
3230 (imux->num_items == 2 && spec->hp_mic)) {
3231 codec_dbg(codec, "reducing to a single ADC\n");
3232 spec->num_adc_nids = 1;
3233 }
3234
3235
3236 if (!spec->dyn_adc_switch && spec->multi_cap_vol)
3237 spec->num_adc_nids = 1;
3238
3239 return 0;
3240}
3241
3242
3243static int parse_capture_source(struct hda_codec *codec, hda_nid_t pin,
3244 int cfg_idx, int num_adcs,
3245 const char *label, int anchor)
3246{
3247 struct hda_gen_spec *spec = codec->spec;
3248 struct hda_input_mux *imux = &spec->input_mux;
3249 int imux_idx = imux->num_items;
3250 bool imux_added = false;
3251 int c;
3252
3253 for (c = 0; c < num_adcs; c++) {
3254 struct nid_path *path;
3255 hda_nid_t adc = spec->adc_nids[c];
3256
3257 if (!is_reachable_path(codec, pin, adc))
3258 continue;
3259 path = snd_hda_add_new_path(codec, pin, adc, anchor);
3260 if (!path)
3261 continue;
3262 print_nid_path(codec, "input", path);
3263 spec->input_paths[imux_idx][c] =
3264 snd_hda_get_path_idx(codec, path);
3265
3266 if (!imux_added) {
3267 if (spec->hp_mic_pin == pin)
3268 spec->hp_mic_mux_idx = imux->num_items;
3269 spec->imux_pins[imux->num_items] = pin;
3270 snd_hda_add_imux_item(codec, imux, label, cfg_idx, NULL);
3271 imux_added = true;
3272 if (spec->dyn_adc_switch)
3273 spec->dyn_adc_idx[imux_idx] = c;
3274 }
3275 }
3276
3277 return 0;
3278}
3279
3280
3281
3282
3283
3284
3285static int fill_input_pin_labels(struct hda_codec *codec)
3286{
3287 struct hda_gen_spec *spec = codec->spec;
3288 const struct auto_pin_cfg *cfg = &spec->autocfg;
3289 int i;
3290
3291 for (i = 0; i < cfg->num_inputs; i++) {
3292 hda_nid_t pin = cfg->inputs[i].pin;
3293 const char *label;
3294 int j, idx;
3295
3296 if (!is_input_pin(codec, pin))
3297 continue;
3298
3299 label = hda_get_autocfg_input_label(codec, cfg, i);
3300 idx = 0;
3301 for (j = i - 1; j >= 0; j--) {
3302 if (spec->input_labels[j] &&
3303 !strcmp(spec->input_labels[j], label)) {
3304 idx = spec->input_label_idxs[j] + 1;
3305 break;
3306 }
3307 }
3308
3309 spec->input_labels[i] = label;
3310 spec->input_label_idxs[i] = idx;
3311 }
3312
3313 return 0;
3314}
3315
3316#define CFG_IDX_MIX 99
3317
3318static int create_input_ctls(struct hda_codec *codec)
3319{
3320 struct hda_gen_spec *spec = codec->spec;
3321 const struct auto_pin_cfg *cfg = &spec->autocfg;
3322 hda_nid_t mixer = spec->mixer_nid;
3323 int num_adcs;
3324 int i, err;
3325 unsigned int val;
3326
3327 num_adcs = fill_adc_nids(codec);
3328 if (num_adcs < 0)
3329 return 0;
3330
3331 err = fill_input_pin_labels(codec);
3332 if (err < 0)
3333 return err;
3334
3335 for (i = 0; i < cfg->num_inputs; i++) {
3336 hda_nid_t pin;
3337
3338 pin = cfg->inputs[i].pin;
3339 if (!is_input_pin(codec, pin))
3340 continue;
3341
3342 val = PIN_IN;
3343 if (cfg->inputs[i].type == AUTO_PIN_MIC)
3344 val |= snd_hda_get_default_vref(codec, pin);
3345 if (pin != spec->hp_mic_pin &&
3346 !snd_hda_codec_get_pin_target(codec, pin))
3347 set_pin_target(codec, pin, val, false);
3348
3349 if (mixer) {
3350 if (is_reachable_path(codec, pin, mixer)) {
3351 err = new_analog_input(codec, i, pin,
3352 spec->input_labels[i],
3353 spec->input_label_idxs[i],
3354 mixer);
3355 if (err < 0)
3356 return err;
3357 }
3358 }
3359
3360 err = parse_capture_source(codec, pin, i, num_adcs,
3361 spec->input_labels[i], -mixer);
3362 if (err < 0)
3363 return err;
3364
3365 if (spec->add_jack_modes) {
3366 err = create_in_jack_mode(codec, pin);
3367 if (err < 0)
3368 return err;
3369 }
3370 }
3371
3372
3373 if (mixer && spec->add_stereo_mix_input == HDA_HINT_STEREO_MIX_ENABLE) {
3374 err = parse_capture_source(codec, mixer, CFG_IDX_MIX, num_adcs,
3375 "Stereo Mix", 0);
3376 if (err < 0)
3377 return err;
3378 else
3379 spec->suppress_auto_mic = 1;
3380 }
3381
3382 return 0;
3383}
3384
3385
3386
3387
3388
3389
3390
3391static struct nid_path *get_input_path(struct hda_codec *codec, int adc_idx, int imux_idx)
3392{
3393 struct hda_gen_spec *spec = codec->spec;
3394 if (imux_idx < 0 || imux_idx >= HDA_MAX_NUM_INPUTS) {
3395 snd_BUG();
3396 return NULL;
3397 }
3398 if (spec->dyn_adc_switch)
3399 adc_idx = spec->dyn_adc_idx[imux_idx];
3400 if (adc_idx < 0 || adc_idx >= AUTO_CFG_MAX_INS) {
3401 snd_BUG();
3402 return NULL;
3403 }
3404 return snd_hda_get_path_from_idx(codec, spec->input_paths[imux_idx][adc_idx]);
3405}
3406
3407static int mux_select(struct hda_codec *codec, unsigned int adc_idx,
3408 unsigned int idx);
3409
3410static int mux_enum_info(struct snd_kcontrol *kcontrol,
3411 struct snd_ctl_elem_info *uinfo)
3412{
3413 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3414 struct hda_gen_spec *spec = codec->spec;
3415 return snd_hda_input_mux_info(&spec->input_mux, uinfo);
3416}
3417
3418static int mux_enum_get(struct snd_kcontrol *kcontrol,
3419 struct snd_ctl_elem_value *ucontrol)
3420{
3421 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3422 struct hda_gen_spec *spec = codec->spec;
3423
3424 unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
3425
3426 ucontrol->value.enumerated.item[0] = spec->cur_mux[adc_idx];
3427 return 0;
3428}
3429
3430static int mux_enum_put(struct snd_kcontrol *kcontrol,
3431 struct snd_ctl_elem_value *ucontrol)
3432{
3433 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3434 unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
3435 return mux_select(codec, adc_idx,
3436 ucontrol->value.enumerated.item[0]);
3437}
3438
3439static const struct snd_kcontrol_new cap_src_temp = {
3440 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3441 .name = "Input Source",
3442 .info = mux_enum_info,
3443 .get = mux_enum_get,
3444 .put = mux_enum_put,
3445};
3446
3447
3448
3449
3450
3451typedef int (*put_call_t)(struct snd_kcontrol *kcontrol,
3452 struct snd_ctl_elem_value *ucontrol);
3453
3454
3455static int cap_put_caller(struct snd_kcontrol *kcontrol,
3456 struct snd_ctl_elem_value *ucontrol,
3457 put_call_t func, int type)
3458{
3459 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3460 struct hda_gen_spec *spec = codec->spec;
3461 const struct hda_input_mux *imux;
3462 struct nid_path *path;
3463 int i, adc_idx, ret, err = 0;
3464
3465 imux = &spec->input_mux;
3466 adc_idx = kcontrol->id.index;
3467 mutex_lock(&codec->control_mutex);
3468 for (i = 0; i < imux->num_items; i++) {
3469 path = get_input_path(codec, adc_idx, i);
3470 if (!path || !path->ctls[type])
3471 continue;
3472 kcontrol->private_value = path->ctls[type];
3473 ret = func(kcontrol, ucontrol);
3474 if (ret < 0) {
3475 err = ret;
3476 break;
3477 }
3478 if (ret > 0)
3479 err = 1;
3480 }
3481 mutex_unlock(&codec->control_mutex);
3482 if (err >= 0 && spec->cap_sync_hook)
3483 spec->cap_sync_hook(codec, kcontrol, ucontrol);
3484 return err;
3485}
3486
3487
3488#define cap_vol_info snd_hda_mixer_amp_volume_info
3489#define cap_vol_get snd_hda_mixer_amp_volume_get
3490#define cap_vol_tlv snd_hda_mixer_amp_tlv
3491
3492static int cap_vol_put(struct snd_kcontrol *kcontrol,
3493 struct snd_ctl_elem_value *ucontrol)
3494{
3495 return cap_put_caller(kcontrol, ucontrol,
3496 snd_hda_mixer_amp_volume_put,
3497 NID_PATH_VOL_CTL);
3498}
3499
3500static const struct snd_kcontrol_new cap_vol_temp = {
3501 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3502 .name = "Capture Volume",
3503 .access = (SNDRV_CTL_ELEM_ACCESS_READWRITE |
3504 SNDRV_CTL_ELEM_ACCESS_TLV_READ |
3505 SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK),
3506 .info = cap_vol_info,
3507 .get = cap_vol_get,
3508 .put = cap_vol_put,
3509 .tlv = { .c = cap_vol_tlv },
3510};
3511
3512
3513#define cap_sw_info snd_ctl_boolean_stereo_info
3514#define cap_sw_get snd_hda_mixer_amp_switch_get
3515
3516static int cap_sw_put(struct snd_kcontrol *kcontrol,
3517 struct snd_ctl_elem_value *ucontrol)
3518{
3519 return cap_put_caller(kcontrol, ucontrol,
3520 snd_hda_mixer_amp_switch_put,
3521 NID_PATH_MUTE_CTL);
3522}
3523
3524static const struct snd_kcontrol_new cap_sw_temp = {
3525 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3526 .name = "Capture Switch",
3527 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
3528 .info = cap_sw_info,
3529 .get = cap_sw_get,
3530 .put = cap_sw_put,
3531};
3532
3533static int parse_capvol_in_path(struct hda_codec *codec, struct nid_path *path)
3534{
3535 hda_nid_t nid;
3536 int i, depth;
3537
3538 path->ctls[NID_PATH_VOL_CTL] = path->ctls[NID_PATH_MUTE_CTL] = 0;
3539 for (depth = 0; depth < 3; depth++) {
3540 if (depth >= path->depth)
3541 return -EINVAL;
3542 i = path->depth - depth - 1;
3543 nid = path->path[i];
3544 if (!path->ctls[NID_PATH_VOL_CTL]) {
3545 if (nid_has_volume(codec, nid, HDA_OUTPUT))
3546 path->ctls[NID_PATH_VOL_CTL] =
3547 HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
3548 else if (nid_has_volume(codec, nid, HDA_INPUT)) {
3549 int idx = path->idx[i];
3550 if (!depth && codec->single_adc_amp)
3551 idx = 0;
3552 path->ctls[NID_PATH_VOL_CTL] =
3553 HDA_COMPOSE_AMP_VAL(nid, 3, idx, HDA_INPUT);
3554 }
3555 }
3556 if (!path->ctls[NID_PATH_MUTE_CTL]) {
3557 if (nid_has_mute(codec, nid, HDA_OUTPUT))
3558 path->ctls[NID_PATH_MUTE_CTL] =
3559 HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
3560 else if (nid_has_mute(codec, nid, HDA_INPUT)) {
3561 int idx = path->idx[i];
3562 if (!depth && codec->single_adc_amp)
3563 idx = 0;
3564 path->ctls[NID_PATH_MUTE_CTL] =
3565 HDA_COMPOSE_AMP_VAL(nid, 3, idx, HDA_INPUT);
3566 }
3567 }
3568 }
3569 return 0;
3570}
3571
3572static bool is_inv_dmic_pin(struct hda_codec *codec, hda_nid_t nid)
3573{
3574 struct hda_gen_spec *spec = codec->spec;
3575 struct auto_pin_cfg *cfg = &spec->autocfg;
3576 unsigned int val;
3577 int i;
3578
3579 if (!spec->inv_dmic_split)
3580 return false;
3581 for (i = 0; i < cfg->num_inputs; i++) {
3582 if (cfg->inputs[i].pin != nid)
3583 continue;
3584 if (cfg->inputs[i].type != AUTO_PIN_MIC)
3585 return false;
3586 val = snd_hda_codec_get_pincfg(codec, nid);
3587 return snd_hda_get_input_pin_attr(val) == INPUT_PIN_ATTR_INT;
3588 }
3589 return false;
3590}
3591
3592
3593static int cap_single_sw_put(struct snd_kcontrol *kcontrol,
3594 struct snd_ctl_elem_value *ucontrol)
3595{
3596 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3597 struct hda_gen_spec *spec = codec->spec;
3598 int ret;
3599
3600 ret = snd_hda_mixer_amp_switch_put(kcontrol, ucontrol);
3601 if (ret < 0)
3602 return ret;
3603
3604 if (spec->cap_sync_hook)
3605 spec->cap_sync_hook(codec, kcontrol, ucontrol);
3606
3607 return ret;
3608}
3609
3610static int add_single_cap_ctl(struct hda_codec *codec, const char *label,
3611 int idx, bool is_switch, unsigned int ctl,
3612 bool inv_dmic)
3613{
3614 struct hda_gen_spec *spec = codec->spec;
3615 char tmpname[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];
3616 int type = is_switch ? HDA_CTL_WIDGET_MUTE : HDA_CTL_WIDGET_VOL;
3617 const char *sfx = is_switch ? "Switch" : "Volume";
3618 unsigned int chs = inv_dmic ? 1 : 3;
3619 struct snd_kcontrol_new *knew;
3620
3621 if (!ctl)
3622 return 0;
3623
3624 if (label)
3625 snprintf(tmpname, sizeof(tmpname),
3626 "%s Capture %s", label, sfx);
3627 else
3628 snprintf(tmpname, sizeof(tmpname),
3629 "Capture %s", sfx);
3630 knew = add_control(spec, type, tmpname, idx,
3631 amp_val_replace_channels(ctl, chs));
3632 if (!knew)
3633 return -ENOMEM;
3634 if (is_switch) {
3635 knew->put = cap_single_sw_put;
3636 if (spec->mic_mute_led)
3637 knew->access |= SNDRV_CTL_ELEM_ACCESS_MIC_LED;
3638 }
3639 if (!inv_dmic)
3640 return 0;
3641
3642
3643 if (label)
3644 snprintf(tmpname, sizeof(tmpname),
3645 "Inverted %s Capture %s", label, sfx);
3646 else
3647 snprintf(tmpname, sizeof(tmpname),
3648 "Inverted Capture %s", sfx);
3649 knew = add_control(spec, type, tmpname, idx,
3650 amp_val_replace_channels(ctl, 2));
3651 if (!knew)
3652 return -ENOMEM;
3653 if (is_switch) {
3654 knew->put = cap_single_sw_put;
3655 if (spec->mic_mute_led)
3656 knew->access |= SNDRV_CTL_ELEM_ACCESS_MIC_LED;
3657 }
3658 return 0;
3659}
3660
3661
3662static int create_single_cap_vol_ctl(struct hda_codec *codec, int idx,
3663 unsigned int vol_ctl, unsigned int sw_ctl,
3664 bool inv_dmic)
3665{
3666 int err;
3667 err = add_single_cap_ctl(codec, NULL, idx, false, vol_ctl, inv_dmic);
3668 if (err < 0)
3669 return err;
3670 err = add_single_cap_ctl(codec, NULL, idx, true, sw_ctl, inv_dmic);
3671 if (err < 0)
3672 return err;
3673 return 0;
3674}
3675
3676
3677static int create_bind_cap_vol_ctl(struct hda_codec *codec, int idx,
3678 unsigned int vol_ctl, unsigned int sw_ctl)
3679{
3680 struct hda_gen_spec *spec = codec->spec;
3681 struct snd_kcontrol_new *knew;
3682
3683 if (vol_ctl) {
3684 knew = snd_hda_gen_add_kctl(spec, NULL, &cap_vol_temp);
3685 if (!knew)
3686 return -ENOMEM;
3687 knew->index = idx;
3688 knew->private_value = vol_ctl;
3689 knew->subdevice = HDA_SUBDEV_AMP_FLAG;
3690 }
3691 if (sw_ctl) {
3692 knew = snd_hda_gen_add_kctl(spec, NULL, &cap_sw_temp);
3693 if (!knew)
3694 return -ENOMEM;
3695 knew->index = idx;
3696 knew->private_value = sw_ctl;
3697 knew->subdevice = HDA_SUBDEV_AMP_FLAG;
3698 if (spec->mic_mute_led)
3699 knew->access |= SNDRV_CTL_ELEM_ACCESS_MIC_LED;
3700 }
3701 return 0;
3702}
3703
3704
3705static unsigned int get_first_cap_ctl(struct hda_codec *codec, int idx, int type)
3706{
3707 struct nid_path *path;
3708 unsigned int ctl;
3709 int i;
3710
3711 path = get_input_path(codec, 0, idx);
3712 if (!path)
3713 return 0;
3714 ctl = path->ctls[type];
3715 if (!ctl)
3716 return 0;
3717 for (i = 0; i < idx - 1; i++) {
3718 path = get_input_path(codec, 0, i);
3719 if (path && path->ctls[type] == ctl)
3720 return 0;
3721 }
3722 return ctl;
3723}
3724
3725
3726static int create_multi_cap_vol_ctl(struct hda_codec *codec)
3727{
3728 struct hda_gen_spec *spec = codec->spec;
3729 struct hda_input_mux *imux = &spec->input_mux;
3730 int i, err, type;
3731
3732 for (i = 0; i < imux->num_items; i++) {
3733 bool inv_dmic;
3734 int idx;
3735
3736 idx = imux->items[i].index;
3737 if (idx >= spec->autocfg.num_inputs)
3738 continue;
3739 inv_dmic = is_inv_dmic_pin(codec, spec->imux_pins[i]);
3740
3741 for (type = 0; type < 2; type++) {
3742 err = add_single_cap_ctl(codec,
3743 spec->input_labels[idx],
3744 spec->input_label_idxs[idx],
3745 type,
3746 get_first_cap_ctl(codec, i, type),
3747 inv_dmic);
3748 if (err < 0)
3749 return err;
3750 }
3751 }
3752 return 0;
3753}
3754
3755static int create_capture_mixers(struct hda_codec *codec)
3756{
3757 struct hda_gen_spec *spec = codec->spec;
3758 struct hda_input_mux *imux = &spec->input_mux;
3759 int i, n, nums, err;
3760
3761 if (spec->dyn_adc_switch)
3762 nums = 1;
3763 else
3764 nums = spec->num_adc_nids;
3765
3766 if (!spec->auto_mic && imux->num_items > 1) {
3767 struct snd_kcontrol_new *knew;
3768 const char *name;
3769 name = nums > 1 ? "Input Source" : "Capture Source";
3770 knew = snd_hda_gen_add_kctl(spec, name, &cap_src_temp);
3771 if (!knew)
3772 return -ENOMEM;
3773 knew->count = nums;
3774 }
3775
3776 for (n = 0; n < nums; n++) {
3777 bool multi = false;
3778 bool multi_cap_vol = spec->multi_cap_vol;
3779 bool inv_dmic = false;
3780 int vol, sw;
3781
3782 vol = sw = 0;
3783 for (i = 0; i < imux->num_items; i++) {
3784 struct nid_path *path;
3785 path = get_input_path(codec, n, i);
3786 if (!path)
3787 continue;
3788 parse_capvol_in_path(codec, path);
3789 if (!vol)
3790 vol = path->ctls[NID_PATH_VOL_CTL];
3791 else if (vol != path->ctls[NID_PATH_VOL_CTL]) {
3792 multi = true;
3793 if (!same_amp_caps(codec, vol,
3794 path->ctls[NID_PATH_VOL_CTL], HDA_INPUT))
3795 multi_cap_vol = true;
3796 }
3797 if (!sw)
3798 sw = path->ctls[NID_PATH_MUTE_CTL];
3799 else if (sw != path->ctls[NID_PATH_MUTE_CTL]) {
3800 multi = true;
3801 if (!same_amp_caps(codec, sw,
3802 path->ctls[NID_PATH_MUTE_CTL], HDA_INPUT))
3803 multi_cap_vol = true;
3804 }
3805 if (is_inv_dmic_pin(codec, spec->imux_pins[i]))
3806 inv_dmic = true;
3807 }
3808
3809 if (!multi)
3810 err = create_single_cap_vol_ctl(codec, n, vol, sw,
3811 inv_dmic);
3812 else if (!multi_cap_vol && !inv_dmic)
3813 err = create_bind_cap_vol_ctl(codec, n, vol, sw);
3814 else
3815 err = create_multi_cap_vol_ctl(codec);
3816 if (err < 0)
3817 return err;
3818 }
3819
3820 return 0;
3821}
3822
3823
3824
3825
3826
3827
3828static bool check_boost_vol(struct hda_codec *codec, hda_nid_t nid,
3829 int dir, int idx)
3830{
3831 unsigned int step;
3832
3833 if (!nid_has_volume(codec, nid, dir) ||
3834 is_ctl_associated(codec, nid, dir, idx, NID_PATH_VOL_CTL) ||
3835 is_ctl_associated(codec, nid, dir, idx, NID_PATH_BOOST_CTL))
3836 return false;
3837
3838 step = (query_amp_caps(codec, nid, dir) & AC_AMPCAP_STEP_SIZE)
3839 >> AC_AMPCAP_STEP_SIZE_SHIFT;
3840 if (step < 0x20)
3841 return false;
3842 return true;
3843}
3844
3845
3846static unsigned int look_for_boost_amp(struct hda_codec *codec,
3847 struct nid_path *path)
3848{
3849 unsigned int val = 0;
3850 hda_nid_t nid;
3851 int depth;
3852
3853 for (depth = 0; depth < 3; depth++) {
3854 if (depth >= path->depth - 1)
3855 break;
3856 nid = path->path[depth];
3857 if (depth && check_boost_vol(codec, nid, HDA_OUTPUT, 0)) {
3858 val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
3859 break;
3860 } else if (check_boost_vol(codec, nid, HDA_INPUT,
3861 path->idx[depth])) {
3862 val = HDA_COMPOSE_AMP_VAL(nid, 3, path->idx[depth],
3863 HDA_INPUT);
3864 break;
3865 }
3866 }
3867
3868 return val;
3869}
3870
3871static int parse_mic_boost(struct hda_codec *codec)
3872{
3873 struct hda_gen_spec *spec = codec->spec;
3874 struct auto_pin_cfg *cfg = &spec->autocfg;
3875 struct hda_input_mux *imux = &spec->input_mux;
3876 int i;
3877
3878 if (!spec->num_adc_nids)
3879 return 0;
3880
3881 for (i = 0; i < imux->num_items; i++) {
3882 struct nid_path *path;
3883 unsigned int val;
3884 int idx;
3885 char boost_label[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];
3886
3887 idx = imux->items[i].index;
3888 if (idx >= imux->num_items)
3889 continue;
3890
3891
3892 if (cfg->inputs[idx].type > AUTO_PIN_LINE_IN)
3893 continue;
3894
3895 path = get_input_path(codec, 0, i);
3896 if (!path)
3897 continue;
3898
3899 val = look_for_boost_amp(codec, path);
3900 if (!val)
3901 continue;
3902
3903
3904 snprintf(boost_label, sizeof(boost_label),
3905 "%s Boost Volume", spec->input_labels[idx]);
3906 if (!add_control(spec, HDA_CTL_WIDGET_VOL, boost_label,
3907 spec->input_label_idxs[idx], val))
3908 return -ENOMEM;
3909
3910 path->ctls[NID_PATH_BOOST_CTL] = val;
3911 }
3912 return 0;
3913}
3914
3915#ifdef CONFIG_SND_HDA_GENERIC_LEDS
3916
3917
3918
3919
3920static int create_mute_led_cdev(struct hda_codec *codec,
3921 int (*callback)(struct led_classdev *,
3922 enum led_brightness),
3923 bool micmute)
3924{
3925 struct led_classdev *cdev;
3926
3927 cdev = devm_kzalloc(&codec->core.dev, sizeof(*cdev), GFP_KERNEL);
3928 if (!cdev)
3929 return -ENOMEM;
3930
3931 cdev->name = micmute ? "hda::micmute" : "hda::mute";
3932 cdev->max_brightness = 1;
3933 cdev->default_trigger = micmute ? "audio-micmute" : "audio-mute";
3934 cdev->brightness_set_blocking = callback;
3935 cdev->brightness = ledtrig_audio_get(micmute ? LED_AUDIO_MICMUTE : LED_AUDIO_MUTE);
3936 cdev->flags = LED_CORE_SUSPENDRESUME;
3937
3938 return devm_led_classdev_register(&codec->core.dev, cdev);
3939}
3940
3941
3942
3943
3944
3945
3946int snd_hda_gen_add_mute_led_cdev(struct hda_codec *codec,
3947 int (*callback)(struct led_classdev *,
3948 enum led_brightness))
3949{
3950 struct hda_gen_spec *spec = codec->spec;
3951 int err;
3952
3953 if (callback) {
3954 err = create_mute_led_cdev(codec, callback, false);
3955 if (err) {
3956 codec_warn(codec, "failed to create a mute LED cdev\n");
3957 return err;
3958 }
3959 }
3960
3961 if (spec->vmaster_mute.hook)
3962 codec_err(codec, "vmaster hook already present before cdev!\n");
3963
3964 spec->vmaster_mute_led = 1;
3965 return 0;
3966}
3967EXPORT_SYMBOL_GPL(snd_hda_gen_add_mute_led_cdev);
3968
3969
3970
3971
3972
3973
3974
3975
3976
3977
3978
3979
3980
3981
3982
3983int snd_hda_gen_add_micmute_led_cdev(struct hda_codec *codec,
3984 int (*callback)(struct led_classdev *,
3985 enum led_brightness))
3986{
3987 struct hda_gen_spec *spec = codec->spec;
3988 int err;
3989
3990 if (callback) {
3991 err = create_mute_led_cdev(codec, callback, true);
3992 if (err) {
3993 codec_warn(codec, "failed to create a mic-mute LED cdev\n");
3994 return err;
3995 }
3996 }
3997
3998 spec->mic_mute_led = 1;
3999 return 0;
4000}
4001EXPORT_SYMBOL_GPL(snd_hda_gen_add_micmute_led_cdev);
4002#endif
4003
4004
4005
4006
4007static void parse_digital(struct hda_codec *codec)
4008{
4009 struct hda_gen_spec *spec = codec->spec;
4010 struct nid_path *path;
4011 int i, nums;
4012 hda_nid_t dig_nid, pin;
4013
4014
4015 nums = 0;
4016 for (i = 0; i < spec->autocfg.dig_outs; i++) {
4017 pin = spec->autocfg.dig_out_pins[i];
4018 dig_nid = look_for_dac(codec, pin, true);
4019 if (!dig_nid)
4020 continue;
4021 path = snd_hda_add_new_path(codec, dig_nid, pin, 0);
4022 if (!path)
4023 continue;
4024 print_nid_path(codec, "digout", path);
4025 path->active = true;
4026 path->pin_fixed = true;
4027 spec->digout_paths[i] = snd_hda_get_path_idx(codec, path);
4028 set_pin_target(codec, pin, PIN_OUT, false);
4029 if (!nums) {
4030 spec->multiout.dig_out_nid = dig_nid;
4031 spec->dig_out_type = spec->autocfg.dig_out_type[0];
4032 } else {
4033 spec->multiout.follower_dig_outs = spec->follower_dig_outs;
4034 if (nums >= ARRAY_SIZE(spec->follower_dig_outs) - 1)
4035 break;
4036 spec->follower_dig_outs[nums - 1] = dig_nid;
4037 }
4038 nums++;
4039 }
4040
4041 if (spec->autocfg.dig_in_pin) {
4042 pin = spec->autocfg.dig_in_pin;
4043 for_each_hda_codec_node(dig_nid, codec) {
4044 unsigned int wcaps = get_wcaps(codec, dig_nid);
4045 if (get_wcaps_type(wcaps) != AC_WID_AUD_IN)
4046 continue;
4047 if (!(wcaps & AC_WCAP_DIGITAL))
4048 continue;
4049 path = snd_hda_add_new_path(codec, pin, dig_nid, 0);
4050 if (path) {
4051 print_nid_path(codec, "digin", path);
4052 path->active = true;
4053 path->pin_fixed = true;
4054 spec->dig_in_nid = dig_nid;
4055 spec->digin_path = snd_hda_get_path_idx(codec, path);
4056 set_pin_target(codec, pin, PIN_IN, false);
4057 break;
4058 }
4059 }
4060 }
4061}
4062
4063
4064
4065
4066
4067
4068static bool dyn_adc_pcm_resetup(struct hda_codec *codec, int cur);
4069
4070
4071static int mux_select(struct hda_codec *codec, unsigned int adc_idx,
4072 unsigned int idx)
4073{
4074 struct hda_gen_spec *spec = codec->spec;
4075 const struct hda_input_mux *imux;
4076 struct nid_path *old_path, *path;
4077
4078 imux = &spec->input_mux;
4079 if (!imux->num_items)
4080 return 0;
4081
4082 if (idx >= imux->num_items)
4083 idx = imux->num_items - 1;
4084 if (spec->cur_mux[adc_idx] == idx)
4085 return 0;
4086
4087 old_path = get_input_path(codec, adc_idx, spec->cur_mux[adc_idx]);
4088 if (!old_path)
4089 return 0;
4090 if (old_path->active)
4091 snd_hda_activate_path(codec, old_path, false, false);
4092
4093 spec->cur_mux[adc_idx] = idx;
4094
4095 if (spec->hp_mic)
4096 update_hp_mic(codec, adc_idx, false);
4097
4098 if (spec->dyn_adc_switch)
4099 dyn_adc_pcm_resetup(codec, idx);
4100
4101 path = get_input_path(codec, adc_idx, idx);
4102 if (!path)
4103 return 0;
4104 if (path->active)
4105 return 0;
4106 snd_hda_activate_path(codec, path, true, false);
4107 if (spec->cap_sync_hook)
4108 spec->cap_sync_hook(codec, NULL, NULL);
4109 path_power_down_sync(codec, old_path);
4110 return 1;
4111}
4112
4113
4114
4115
4116
4117
4118static hda_nid_t set_path_power(struct hda_codec *codec, hda_nid_t nid,
4119 int pin_state, int stream_state)
4120{
4121 struct hda_gen_spec *spec = codec->spec;
4122 hda_nid_t last, changed = 0;
4123 struct nid_path *path;
4124 int n;
4125
4126 snd_array_for_each(&spec->paths, n, path) {
4127 if (!path->depth)
4128 continue;
4129 if (path->path[0] == nid ||
4130 path->path[path->depth - 1] == nid) {
4131 bool pin_old = path->pin_enabled;
4132 bool stream_old = path->stream_enabled;
4133
4134 if (pin_state >= 0)
4135 path->pin_enabled = pin_state;
4136 if (stream_state >= 0)
4137 path->stream_enabled = stream_state;
4138 if ((!path->pin_fixed && path->pin_enabled != pin_old)
4139 || path->stream_enabled != stream_old) {
4140 last = path_power_update(codec, path, true);
4141 if (last)
4142 changed = last;
4143 }
4144 }
4145 }
4146 return changed;
4147}
4148
4149
4150static bool detect_pin_state(struct hda_codec *codec, hda_nid_t pin)
4151{
4152 if (!is_jack_detectable(codec, pin))
4153 return true;
4154 return snd_hda_jack_detect_state(codec, pin) != HDA_JACK_NOT_PRESENT;
4155}
4156
4157
4158
4159
4160
4161
4162
4163static hda_nid_t set_pin_power_jack(struct hda_codec *codec, hda_nid_t pin,
4164 int power)
4165{
4166 bool on;
4167
4168 if (!codec->power_save_node)
4169 return 0;
4170
4171 on = detect_pin_state(codec, pin);
4172
4173 if (power >= 0 && on != power)
4174 return 0;
4175 return set_path_power(codec, pin, on, -1);
4176}
4177
4178static void pin_power_callback(struct hda_codec *codec,
4179 struct hda_jack_callback *jack,
4180 bool on)
4181{
4182 if (jack && jack->nid)
4183 sync_power_state_change(codec,
4184 set_pin_power_jack(codec, jack->nid, on));
4185}
4186
4187
4188static void pin_power_up_callback(struct hda_codec *codec,
4189 struct hda_jack_callback *jack)
4190{
4191 pin_power_callback(codec, jack, true);
4192}
4193
4194
4195static void pin_power_down_callback(struct hda_codec *codec,
4196 struct hda_jack_callback *jack)
4197{
4198 pin_power_callback(codec, jack, false);
4199}
4200
4201
4202static void add_pin_power_ctls(struct hda_codec *codec, int num_pins,
4203 const hda_nid_t *pins, bool on)
4204{
4205 int i;
4206 hda_jack_callback_fn cb =
4207 on ? pin_power_up_callback : pin_power_down_callback;
4208
4209 for (i = 0; i < num_pins && pins[i]; i++) {
4210 if (is_jack_detectable(codec, pins[i]))
4211 snd_hda_jack_detect_enable_callback(codec, pins[i], cb);
4212 else
4213 set_path_power(codec, pins[i], true, -1);
4214 }
4215}
4216
4217
4218
4219
4220static void add_all_pin_power_ctls(struct hda_codec *codec, bool on)
4221{
4222 struct hda_gen_spec *spec = codec->spec;
4223 struct auto_pin_cfg *cfg = &spec->autocfg;
4224 int i;
4225
4226 if (!codec->power_save_node)
4227 return;
4228 add_pin_power_ctls(codec, cfg->line_outs, cfg->line_out_pins, on);
4229 if (cfg->line_out_type != AUTO_PIN_HP_OUT)
4230 add_pin_power_ctls(codec, cfg->hp_outs, cfg->hp_pins, on);
4231 if (cfg->line_out_type != AUTO_PIN_SPEAKER_OUT)
4232 add_pin_power_ctls(codec, cfg->speaker_outs, cfg->speaker_pins, on);
4233 for (i = 0; i < cfg->num_inputs; i++)
4234 add_pin_power_ctls(codec, 1, &cfg->inputs[i].pin, on);
4235}
4236
4237
4238static void sync_pin_power_ctls(struct hda_codec *codec, int num_pins,
4239 const hda_nid_t *pins)
4240{
4241 int i;
4242
4243 for (i = 0; i < num_pins && pins[i]; i++)
4244 if (is_jack_detectable(codec, pins[i]))
4245 set_pin_power_jack(codec, pins[i], -1);
4246}
4247
4248
4249static void sync_all_pin_power_ctls(struct hda_codec *codec)
4250{
4251 struct hda_gen_spec *spec = codec->spec;
4252 struct auto_pin_cfg *cfg = &spec->autocfg;
4253 int i;
4254
4255 if (!codec->power_save_node)
4256 return;
4257 sync_pin_power_ctls(codec, cfg->line_outs, cfg->line_out_pins);
4258 if (cfg->line_out_type != AUTO_PIN_HP_OUT)
4259 sync_pin_power_ctls(codec, cfg->hp_outs, cfg->hp_pins);
4260 if (cfg->line_out_type != AUTO_PIN_SPEAKER_OUT)
4261 sync_pin_power_ctls(codec, cfg->speaker_outs, cfg->speaker_pins);
4262 for (i = 0; i < cfg->num_inputs; i++)
4263 sync_pin_power_ctls(codec, 1, &cfg->inputs[i].pin);
4264}
4265
4266
4267static int add_fake_paths(struct hda_codec *codec, hda_nid_t nid,
4268 int num_pins, const hda_nid_t *pins)
4269{
4270 struct hda_gen_spec *spec = codec->spec;
4271 struct nid_path *path;
4272 int i;
4273
4274 for (i = 0; i < num_pins; i++) {
4275 if (!pins[i])
4276 break;
4277 if (get_nid_path(codec, nid, pins[i], 0))
4278 continue;
4279 path = snd_array_new(&spec->paths);
4280 if (!path)
4281 return -ENOMEM;
4282 memset(path, 0, sizeof(*path));
4283 path->depth = 2;
4284 path->path[0] = nid;
4285 path->path[1] = pins[i];
4286 path->active = true;
4287 }
4288 return 0;
4289}
4290
4291
4292static int add_fake_beep_paths(struct hda_codec *codec)
4293{
4294 struct hda_gen_spec *spec = codec->spec;
4295 struct auto_pin_cfg *cfg = &spec->autocfg;
4296 hda_nid_t nid = spec->beep_nid;
4297 int err;
4298
4299 if (!codec->power_save_node || !nid)
4300 return 0;
4301 err = add_fake_paths(codec, nid, cfg->line_outs, cfg->line_out_pins);
4302 if (err < 0)
4303 return err;
4304 if (cfg->line_out_type != AUTO_PIN_HP_OUT) {
4305 err = add_fake_paths(codec, nid, cfg->hp_outs, cfg->hp_pins);
4306 if (err < 0)
4307 return err;
4308 }
4309 if (cfg->line_out_type != AUTO_PIN_SPEAKER_OUT) {
4310 err = add_fake_paths(codec, nid, cfg->speaker_outs,
4311 cfg->speaker_pins);
4312 if (err < 0)
4313 return err;
4314 }
4315 return 0;
4316}
4317
4318
4319static void beep_power_hook(struct hda_beep *beep, bool on)
4320{
4321 set_path_power(beep->codec, beep->nid, -1, on);
4322}
4323
4324
4325
4326
4327
4328
4329int snd_hda_gen_fix_pin_power(struct hda_codec *codec, hda_nid_t pin)
4330{
4331 struct hda_gen_spec *spec = codec->spec;
4332 struct nid_path *path;
4333
4334 path = snd_array_new(&spec->paths);
4335 if (!path)
4336 return -ENOMEM;
4337 memset(path, 0, sizeof(*path));
4338 path->depth = 1;
4339 path->path[0] = pin;
4340 path->active = true;
4341 path->pin_fixed = true;
4342 path->stream_enabled = true;
4343 return 0;
4344}
4345EXPORT_SYMBOL_GPL(snd_hda_gen_fix_pin_power);
4346
4347
4348
4349
4350
4351
4352static bool detect_jacks(struct hda_codec *codec, int num_pins, const hda_nid_t *pins)
4353{
4354 int i;
4355 bool present = false;
4356
4357 for (i = 0; i < num_pins; i++) {
4358 hda_nid_t nid = pins[i];
4359 if (!nid)
4360 break;
4361
4362 if (snd_hda_codec_get_pin_target(codec, nid) & AC_PINCTL_IN_EN)
4363 continue;
4364 if (snd_hda_jack_detect_state(codec, nid) == HDA_JACK_PRESENT)
4365 present = true;
4366 }
4367 return present;
4368}
4369
4370
4371static void do_automute(struct hda_codec *codec, int num_pins, const hda_nid_t *pins,
4372 int *paths, bool mute)
4373{
4374 struct hda_gen_spec *spec = codec->spec;
4375 int i;
4376
4377 for (i = 0; i < num_pins; i++) {
4378 hda_nid_t nid = pins[i];
4379 unsigned int val, oldval;
4380 if (!nid)
4381 break;
4382
4383 oldval = snd_hda_codec_get_pin_target(codec, nid);
4384 if (oldval & PIN_IN)
4385 continue;
4386
4387 if (spec->auto_mute_via_amp) {
4388 struct nid_path *path;
4389 hda_nid_t mute_nid;
4390
4391 path = snd_hda_get_path_from_idx(codec, paths[i]);
4392 if (!path)
4393 continue;
4394 mute_nid = get_amp_nid_(path->ctls[NID_PATH_MUTE_CTL]);
4395 if (!mute_nid)
4396 continue;
4397 if (mute)
4398 spec->mute_bits |= (1ULL << mute_nid);
4399 else
4400 spec->mute_bits &= ~(1ULL << mute_nid);
4401 continue;
4402 } else {
4403
4404
4405
4406 if (spec->keep_vref_in_automute)
4407 val = oldval & ~PIN_HP;
4408 else
4409 val = 0;
4410 if (!mute)
4411 val |= oldval;
4412
4413
4414
4415
4416
4417 update_pin_ctl(codec, nid, val);
4418 }
4419
4420 set_pin_eapd(codec, nid, !mute);
4421 if (codec->power_save_node) {
4422 bool on = !mute;
4423 if (on)
4424 on = detect_pin_state(codec, nid);
4425 set_path_power(codec, nid, on, -1);
4426 }
4427 }
4428}
4429
4430
4431
4432
4433
4434
4435
4436void snd_hda_gen_update_outputs(struct hda_codec *codec)
4437{
4438 struct hda_gen_spec *spec = codec->spec;
4439 int *paths;
4440 int on;
4441
4442
4443
4444
4445
4446 if (spec->autocfg.line_out_type == AUTO_PIN_HP_OUT)
4447 paths = spec->out_paths;
4448 else
4449 paths = spec->hp_paths;
4450 do_automute(codec, ARRAY_SIZE(spec->autocfg.hp_pins),
4451 spec->autocfg.hp_pins, paths, spec->master_mute);
4452
4453 if (!spec->automute_speaker)
4454 on = 0;
4455 else
4456 on = spec->hp_jack_present | spec->line_jack_present;
4457 on |= spec->master_mute;
4458 spec->speaker_muted = on;
4459 if (spec->autocfg.line_out_type == AUTO_PIN_SPEAKER_OUT)
4460 paths = spec->out_paths;
4461 else
4462 paths = spec->speaker_paths;
4463 do_automute(codec, ARRAY_SIZE(spec->autocfg.speaker_pins),
4464 spec->autocfg.speaker_pins, paths, on);
4465
4466
4467
4468 if (spec->autocfg.line_out_pins[0] == spec->autocfg.hp_pins[0] ||
4469 spec->autocfg.line_out_pins[0] == spec->autocfg.speaker_pins[0])
4470 return;
4471 if (!spec->automute_lo)
4472 on = 0;
4473 else
4474 on = spec->hp_jack_present;
4475 on |= spec->master_mute;
4476 spec->line_out_muted = on;
4477 paths = spec->out_paths;
4478 do_automute(codec, ARRAY_SIZE(spec->autocfg.line_out_pins),
4479 spec->autocfg.line_out_pins, paths, on);
4480}
4481EXPORT_SYMBOL_GPL(snd_hda_gen_update_outputs);
4482
4483static void call_update_outputs(struct hda_codec *codec)
4484{
4485 struct hda_gen_spec *spec = codec->spec;
4486 if (spec->automute_hook)
4487 spec->automute_hook(codec);
4488 else
4489 snd_hda_gen_update_outputs(codec);
4490
4491
4492 if (spec->auto_mute_via_amp && !codec->bus->shutdown)
4493 snd_ctl_sync_vmaster(spec->vmaster_mute.sw_kctl, false);
4494}
4495
4496
4497
4498
4499
4500
4501void snd_hda_gen_hp_automute(struct hda_codec *codec,
4502 struct hda_jack_callback *jack)
4503{
4504 struct hda_gen_spec *spec = codec->spec;
4505 hda_nid_t *pins = spec->autocfg.hp_pins;
4506 int num_pins = ARRAY_SIZE(spec->autocfg.hp_pins);
4507
4508
4509 if (spec->indep_hp_enabled) {
4510 pins++;
4511 num_pins--;
4512 }
4513
4514 spec->hp_jack_present = detect_jacks(codec, num_pins, pins);
4515 if (!spec->detect_hp || (!spec->automute_speaker && !spec->automute_lo))
4516 return;
4517 call_update_outputs(codec);
4518}
4519EXPORT_SYMBOL_GPL(snd_hda_gen_hp_automute);
4520
4521
4522
4523
4524
4525
4526void snd_hda_gen_line_automute(struct hda_codec *codec,
4527 struct hda_jack_callback *jack)
4528{
4529 struct hda_gen_spec *spec = codec->spec;
4530
4531 if (spec->autocfg.line_out_type == AUTO_PIN_SPEAKER_OUT)
4532 return;
4533
4534 if (spec->autocfg.line_out_pins[0] == spec->autocfg.hp_pins[0])
4535 return;
4536
4537 spec->line_jack_present =
4538 detect_jacks(codec, ARRAY_SIZE(spec->autocfg.line_out_pins),
4539 spec->autocfg.line_out_pins);
4540 if (!spec->automute_speaker || !spec->detect_lo)
4541 return;
4542 call_update_outputs(codec);
4543}
4544EXPORT_SYMBOL_GPL(snd_hda_gen_line_automute);
4545
4546
4547
4548
4549
4550
4551void snd_hda_gen_mic_autoswitch(struct hda_codec *codec,
4552 struct hda_jack_callback *jack)
4553{
4554 struct hda_gen_spec *spec = codec->spec;
4555 int i;
4556
4557 if (!spec->auto_mic)
4558 return;
4559
4560 for (i = spec->am_num_entries - 1; i > 0; i--) {
4561 hda_nid_t pin = spec->am_entry[i].pin;
4562
4563 if (snd_hda_codec_get_pin_target(codec, pin) & AC_PINCTL_OUT_EN)
4564 continue;
4565 if (snd_hda_jack_detect_state(codec, pin) == HDA_JACK_PRESENT) {
4566 mux_select(codec, 0, spec->am_entry[i].idx);
4567 return;
4568 }
4569 }
4570 mux_select(codec, 0, spec->am_entry[0].idx);
4571}
4572EXPORT_SYMBOL_GPL(snd_hda_gen_mic_autoswitch);
4573
4574
4575static void call_hp_automute(struct hda_codec *codec,
4576 struct hda_jack_callback *jack)
4577{
4578 struct hda_gen_spec *spec = codec->spec;
4579 if (spec->hp_automute_hook)
4580 spec->hp_automute_hook(codec, jack);
4581 else
4582 snd_hda_gen_hp_automute(codec, jack);
4583}
4584
4585static void call_line_automute(struct hda_codec *codec,
4586 struct hda_jack_callback *jack)
4587{
4588 struct hda_gen_spec *spec = codec->spec;
4589 if (spec->line_automute_hook)
4590 spec->line_automute_hook(codec, jack);
4591 else
4592 snd_hda_gen_line_automute(codec, jack);
4593}
4594
4595static void call_mic_autoswitch(struct hda_codec *codec,
4596 struct hda_jack_callback *jack)
4597{
4598 struct hda_gen_spec *spec = codec->spec;
4599 if (spec->mic_autoswitch_hook)
4600 spec->mic_autoswitch_hook(codec, jack);
4601 else
4602 snd_hda_gen_mic_autoswitch(codec, jack);
4603}
4604
4605
4606static void update_automute_all(struct hda_codec *codec)
4607{
4608 call_hp_automute(codec, NULL);
4609 call_line_automute(codec, NULL);
4610 call_mic_autoswitch(codec, NULL);
4611}
4612
4613
4614
4615
4616static int automute_mode_info(struct snd_kcontrol *kcontrol,
4617 struct snd_ctl_elem_info *uinfo)
4618{
4619 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
4620 struct hda_gen_spec *spec = codec->spec;
4621 static const char * const texts3[] = {
4622 "Disabled", "Speaker Only", "Line Out+Speaker"
4623 };
4624
4625 if (spec->automute_speaker_possible && spec->automute_lo_possible)
4626 return snd_hda_enum_helper_info(kcontrol, uinfo, 3, texts3);
4627 return snd_hda_enum_bool_helper_info(kcontrol, uinfo);
4628}
4629
4630static int automute_mode_get(struct snd_kcontrol *kcontrol,
4631 struct snd_ctl_elem_value *ucontrol)
4632{
4633 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
4634 struct hda_gen_spec *spec = codec->spec;
4635 unsigned int val = 0;
4636 if (spec->automute_speaker)
4637 val++;
4638 if (spec->automute_lo)
4639 val++;
4640
4641 ucontrol->value.enumerated.item[0] = val;
4642 return 0;
4643}
4644
4645static int automute_mode_put(struct snd_kcontrol *kcontrol,
4646 struct snd_ctl_elem_value *ucontrol)
4647{
4648 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
4649 struct hda_gen_spec *spec = codec->spec;
4650
4651 switch (ucontrol->value.enumerated.item[0]) {
4652 case 0:
4653 if (!spec->automute_speaker && !spec->automute_lo)
4654 return 0;
4655 spec->automute_speaker = 0;
4656 spec->automute_lo = 0;
4657 break;
4658 case 1:
4659 if (spec->automute_speaker_possible) {
4660 if (!spec->automute_lo && spec->automute_speaker)
4661 return 0;
4662 spec->automute_speaker = 1;
4663 spec->automute_lo = 0;
4664 } else if (spec->automute_lo_possible) {
4665 if (spec->automute_lo)
4666 return 0;
4667 spec->automute_lo = 1;
4668 } else
4669 return -EINVAL;
4670 break;
4671 case 2:
4672 if (!spec->automute_lo_possible || !spec->automute_speaker_possible)
4673 return -EINVAL;
4674 if (spec->automute_speaker && spec->automute_lo)
4675 return 0;
4676 spec->automute_speaker = 1;
4677 spec->automute_lo = 1;
4678 break;
4679 default:
4680 return -EINVAL;
4681 }
4682 call_update_outputs(codec);
4683 return 1;
4684}
4685
4686static const struct snd_kcontrol_new automute_mode_enum = {
4687 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
4688 .name = "Auto-Mute Mode",
4689 .info = automute_mode_info,
4690 .get = automute_mode_get,
4691 .put = automute_mode_put,
4692};
4693
4694static int add_automute_mode_enum(struct hda_codec *codec)
4695{
4696 struct hda_gen_spec *spec = codec->spec;
4697
4698 if (!snd_hda_gen_add_kctl(spec, NULL, &automute_mode_enum))
4699 return -ENOMEM;
4700 return 0;
4701}
4702
4703
4704
4705
4706
4707static int check_auto_mute_availability(struct hda_codec *codec)
4708{
4709 struct hda_gen_spec *spec = codec->spec;
4710 struct auto_pin_cfg *cfg = &spec->autocfg;
4711 int present = 0;
4712 int i, err;
4713
4714 if (spec->suppress_auto_mute)
4715 return 0;
4716
4717 if (cfg->hp_pins[0])
4718 present++;
4719 if (cfg->line_out_pins[0])
4720 present++;
4721 if (cfg->speaker_pins[0])
4722 present++;
4723 if (present < 2)
4724 return 0;
4725
4726 if (!cfg->speaker_pins[0] &&
4727 cfg->line_out_type == AUTO_PIN_SPEAKER_OUT) {
4728 memcpy(cfg->speaker_pins, cfg->line_out_pins,
4729 sizeof(cfg->speaker_pins));
4730 cfg->speaker_outs = cfg->line_outs;
4731 }
4732
4733 if (!cfg->hp_pins[0] &&
4734 cfg->line_out_type == AUTO_PIN_HP_OUT) {
4735 memcpy(cfg->hp_pins, cfg->line_out_pins,
4736 sizeof(cfg->hp_pins));
4737 cfg->hp_outs = cfg->line_outs;
4738 }
4739
4740 for (i = 0; i < cfg->hp_outs; i++) {
4741 hda_nid_t nid = cfg->hp_pins[i];
4742 if (!is_jack_detectable(codec, nid))
4743 continue;
4744 codec_dbg(codec, "Enable HP auto-muting on NID 0x%x\n", nid);
4745 snd_hda_jack_detect_enable_callback(codec, nid,
4746 call_hp_automute);
4747 spec->detect_hp = 1;
4748 }
4749
4750 if (cfg->line_out_type == AUTO_PIN_LINE_OUT && cfg->line_outs) {
4751 if (cfg->speaker_outs)
4752 for (i = 0; i < cfg->line_outs; i++) {
4753 hda_nid_t nid = cfg->line_out_pins[i];
4754 if (!is_jack_detectable(codec, nid))
4755 continue;
4756 codec_dbg(codec, "Enable Line-Out auto-muting on NID 0x%x\n", nid);
4757 snd_hda_jack_detect_enable_callback(codec, nid,
4758 call_line_automute);
4759 spec->detect_lo = 1;
4760 }
4761 spec->automute_lo_possible = spec->detect_hp;
4762 }
4763
4764 spec->automute_speaker_possible = cfg->speaker_outs &&
4765 (spec->detect_hp || spec->detect_lo);
4766
4767 spec->automute_lo = spec->automute_lo_possible;
4768 spec->automute_speaker = spec->automute_speaker_possible;
4769
4770 if (spec->automute_speaker_possible || spec->automute_lo_possible) {
4771
4772 err = add_automute_mode_enum(codec);
4773 if (err < 0)
4774 return err;
4775 }
4776 return 0;
4777}
4778
4779
4780static bool auto_mic_check_imux(struct hda_codec *codec)
4781{
4782 struct hda_gen_spec *spec = codec->spec;
4783 const struct hda_input_mux *imux;
4784 int i;
4785
4786 imux = &spec->input_mux;
4787 for (i = 0; i < spec->am_num_entries; i++) {
4788 spec->am_entry[i].idx =
4789 find_idx_in_nid_list(spec->am_entry[i].pin,
4790 spec->imux_pins, imux->num_items);
4791 if (spec->am_entry[i].idx < 0)
4792 return false;
4793 }
4794
4795
4796 for (i = 1; i < spec->am_num_entries; i++)
4797 snd_hda_jack_detect_enable_callback(codec,
4798 spec->am_entry[i].pin,
4799 call_mic_autoswitch);
4800 return true;
4801}
4802
4803static int compare_attr(const void *ap, const void *bp)
4804{
4805 const struct automic_entry *a = ap;
4806 const struct automic_entry *b = bp;
4807 return (int)(a->attr - b->attr);
4808}
4809
4810
4811
4812
4813
4814static int check_auto_mic_availability(struct hda_codec *codec)
4815{
4816 struct hda_gen_spec *spec = codec->spec;
4817 struct auto_pin_cfg *cfg = &spec->autocfg;
4818 unsigned int types;
4819 int i, num_pins;
4820
4821 if (spec->suppress_auto_mic)
4822 return 0;
4823
4824 types = 0;
4825 num_pins = 0;
4826 for (i = 0; i < cfg->num_inputs; i++) {
4827 hda_nid_t nid = cfg->inputs[i].pin;
4828 unsigned int attr;
4829 attr = snd_hda_codec_get_pincfg(codec, nid);
4830 attr = snd_hda_get_input_pin_attr(attr);
4831 if (types & (1 << attr))
4832 return 0;
4833 switch (attr) {
4834 case INPUT_PIN_ATTR_INT:
4835 if (cfg->inputs[i].type != AUTO_PIN_MIC)
4836 return 0;
4837 break;
4838 case INPUT_PIN_ATTR_UNUSED:
4839 return 0;
4840 default:
4841 if (cfg->inputs[i].type > AUTO_PIN_LINE_IN)
4842 return 0;
4843 if (!spec->line_in_auto_switch &&
4844 cfg->inputs[i].type != AUTO_PIN_MIC)
4845 return 0;
4846 if (!is_jack_detectable(codec, nid))
4847 return 0;
4848 break;
4849 }
4850 if (num_pins >= MAX_AUTO_MIC_PINS)
4851 return 0;
4852 types |= (1 << attr);
4853 spec->am_entry[num_pins].pin = nid;
4854 spec->am_entry[num_pins].attr = attr;
4855 num_pins++;
4856 }
4857
4858 if (num_pins < 2)
4859 return 0;
4860
4861 spec->am_num_entries = num_pins;
4862
4863
4864
4865 sort(spec->am_entry, num_pins, sizeof(spec->am_entry[0]),
4866 compare_attr, NULL);
4867
4868 if (!auto_mic_check_imux(codec))
4869 return 0;
4870
4871 spec->auto_mic = 1;
4872 spec->num_adc_nids = 1;
4873 spec->cur_mux[0] = spec->am_entry[0].idx;
4874 codec_dbg(codec, "Enable auto-mic switch on NID 0x%x/0x%x/0x%x\n",
4875 spec->am_entry[0].pin,
4876 spec->am_entry[1].pin,
4877 spec->am_entry[2].pin);
4878
4879 return 0;
4880}
4881
4882
4883
4884
4885
4886
4887
4888
4889unsigned int snd_hda_gen_path_power_filter(struct hda_codec *codec,
4890 hda_nid_t nid,
4891 unsigned int power_state)
4892{
4893 struct hda_gen_spec *spec = codec->spec;
4894
4895 if (!spec->power_down_unused && !codec->power_save_node)
4896 return power_state;
4897 if (power_state != AC_PWRST_D0 || nid == codec->core.afg)
4898 return power_state;
4899 if (get_wcaps_type(get_wcaps(codec, nid)) >= AC_WID_POWER)
4900 return power_state;
4901 if (is_active_nid_for_any(codec, nid))
4902 return power_state;
4903 return AC_PWRST_D3;
4904}
4905EXPORT_SYMBOL_GPL(snd_hda_gen_path_power_filter);
4906
4907
4908static void mute_all_mixer_nid(struct hda_codec *codec, hda_nid_t mix)
4909{
4910 int i, nums;
4911 const hda_nid_t *conn;
4912 bool has_amp;
4913
4914 nums = snd_hda_get_conn_list(codec, mix, &conn);
4915 has_amp = nid_has_mute(codec, mix, HDA_INPUT);
4916 for (i = 0; i < nums; i++) {
4917 if (has_amp)
4918 update_amp(codec, mix, HDA_INPUT, i,
4919 0xff, HDA_AMP_MUTE);
4920 else if (nid_has_volume(codec, conn[i], HDA_OUTPUT))
4921 update_amp(codec, conn[i], HDA_OUTPUT, 0,
4922 0xff, HDA_AMP_MUTE);
4923 }
4924}
4925
4926
4927
4928
4929
4930
4931
4932
4933
4934void snd_hda_gen_stream_pm(struct hda_codec *codec, hda_nid_t nid, bool on)
4935{
4936 if (codec->power_save_node)
4937 set_path_power(codec, nid, -1, on);
4938}
4939EXPORT_SYMBOL_GPL(snd_hda_gen_stream_pm);
4940
4941
4942
4943
4944
4945
4946
4947
4948
4949
4950int snd_hda_gen_parse_auto_config(struct hda_codec *codec,
4951 struct auto_pin_cfg *cfg)
4952{
4953 struct hda_gen_spec *spec = codec->spec;
4954 int err;
4955
4956 parse_user_hints(codec);
4957
4958 if (spec->vmaster_mute_led || spec->mic_mute_led)
4959 snd_ctl_led_request();
4960
4961 if (spec->mixer_nid && !spec->mixer_merge_nid)
4962 spec->mixer_merge_nid = spec->mixer_nid;
4963
4964 if (cfg != &spec->autocfg) {
4965 spec->autocfg = *cfg;
4966 cfg = &spec->autocfg;
4967 }
4968
4969 if (!spec->main_out_badness)
4970 spec->main_out_badness = &hda_main_out_badness;
4971 if (!spec->extra_out_badness)
4972 spec->extra_out_badness = &hda_extra_out_badness;
4973
4974 fill_all_dac_nids(codec);
4975
4976 if (!cfg->line_outs) {
4977 if (cfg->dig_outs || cfg->dig_in_pin) {
4978 spec->multiout.max_channels = 2;
4979 spec->no_analog = 1;
4980 goto dig_only;
4981 }
4982 if (!cfg->num_inputs && !cfg->dig_in_pin)
4983 return 0;
4984 }
4985
4986 if (!spec->no_primary_hp &&
4987 cfg->line_out_type == AUTO_PIN_SPEAKER_OUT &&
4988 cfg->line_outs <= cfg->hp_outs) {
4989
4990 cfg->speaker_outs = cfg->line_outs;
4991 memcpy(cfg->speaker_pins, cfg->line_out_pins,
4992 sizeof(cfg->speaker_pins));
4993 cfg->line_outs = cfg->hp_outs;
4994 memcpy(cfg->line_out_pins, cfg->hp_pins, sizeof(cfg->hp_pins));
4995 cfg->hp_outs = 0;
4996 memset(cfg->hp_pins, 0, sizeof(cfg->hp_pins));
4997 cfg->line_out_type = AUTO_PIN_HP_OUT;
4998 }
4999
5000 err = parse_output_paths(codec);
5001 if (err < 0)
5002 return err;
5003 err = create_multi_channel_mode(codec);
5004 if (err < 0)
5005 return err;
5006 err = create_multi_out_ctls(codec, cfg);
5007 if (err < 0)
5008 return err;
5009 err = create_hp_out_ctls(codec);
5010 if (err < 0)
5011 return err;
5012 err = create_speaker_out_ctls(codec);
5013 if (err < 0)
5014 return err;
5015 err = create_indep_hp_ctls(codec);
5016 if (err < 0)
5017 return err;
5018 err = create_loopback_mixing_ctl(codec);
5019 if (err < 0)
5020 return err;
5021 err = create_hp_mic(codec);
5022 if (err < 0)
5023 return err;
5024 err = create_input_ctls(codec);
5025 if (err < 0)
5026 return err;
5027
5028
5029 add_all_pin_power_ctls(codec, false);
5030
5031 spec->const_channel_count = spec->ext_channel_count;
5032
5033 if (cfg->line_out_type != AUTO_PIN_SPEAKER_OUT)
5034 spec->const_channel_count = max(spec->const_channel_count,
5035 cfg->speaker_outs * 2);
5036 if (cfg->line_out_type != AUTO_PIN_HP_OUT)
5037 spec->const_channel_count = max(spec->const_channel_count,
5038 cfg->hp_outs * 2);
5039 spec->multiout.max_channels = max(spec->ext_channel_count,
5040 spec->const_channel_count);
5041
5042 err = check_auto_mute_availability(codec);
5043 if (err < 0)
5044 return err;
5045
5046 err = check_dyn_adc_switch(codec);
5047 if (err < 0)
5048 return err;
5049
5050 err = check_auto_mic_availability(codec);
5051 if (err < 0)
5052 return err;
5053
5054
5055 if (!spec->auto_mic && spec->mixer_nid &&
5056 spec->add_stereo_mix_input == HDA_HINT_STEREO_MIX_AUTO &&
5057 spec->input_mux.num_items > 1) {
5058 err = parse_capture_source(codec, spec->mixer_nid,
5059 CFG_IDX_MIX, spec->num_all_adcs,
5060 "Stereo Mix", 0);
5061 if (err < 0)
5062 return err;
5063 }
5064
5065
5066 err = create_capture_mixers(codec);
5067 if (err < 0)
5068 return err;
5069
5070 err = parse_mic_boost(codec);
5071 if (err < 0)
5072 return err;
5073
5074
5075
5076
5077 if (spec->hp_mic_pin &&
5078 (spec->auto_mic || spec->input_mux.num_items == 1 ||
5079 spec->add_jack_modes)) {
5080 err = create_hp_mic_jack_mode(codec, spec->hp_mic_pin);
5081 if (err < 0)
5082 return err;
5083 }
5084
5085 if (spec->add_jack_modes) {
5086 if (cfg->line_out_type != AUTO_PIN_SPEAKER_OUT) {
5087 err = create_out_jack_modes(codec, cfg->line_outs,
5088 cfg->line_out_pins);
5089 if (err < 0)
5090 return err;
5091 }
5092 if (cfg->line_out_type != AUTO_PIN_HP_OUT) {
5093 err = create_out_jack_modes(codec, cfg->hp_outs,
5094 cfg->hp_pins);
5095 if (err < 0)
5096 return err;
5097 }
5098 }
5099
5100
5101 add_all_pin_power_ctls(codec, true);
5102
5103
5104 if (spec->mixer_nid)
5105 mute_all_mixer_nid(codec, spec->mixer_nid);
5106
5107 dig_only:
5108 parse_digital(codec);
5109
5110 if (spec->power_down_unused || codec->power_save_node) {
5111 if (!codec->power_filter)
5112 codec->power_filter = snd_hda_gen_path_power_filter;
5113 if (!codec->patch_ops.stream_pm)
5114 codec->patch_ops.stream_pm = snd_hda_gen_stream_pm;
5115 }
5116
5117 if (!spec->no_analog && spec->beep_nid) {
5118 err = snd_hda_attach_beep_device(codec, spec->beep_nid);
5119 if (err < 0)
5120 return err;
5121 if (codec->beep && codec->power_save_node) {
5122 err = add_fake_beep_paths(codec);
5123 if (err < 0)
5124 return err;
5125 codec->beep->power_hook = beep_power_hook;
5126 }
5127 }
5128
5129 return 1;
5130}
5131EXPORT_SYMBOL_GPL(snd_hda_gen_parse_auto_config);
5132
5133
5134
5135
5136
5137
5138
5139static const char * const follower_pfxs[] = {
5140 "Front", "Surround", "Center", "LFE", "Side",
5141 "Headphone", "Speaker", "Mono", "Line Out",
5142 "CLFE", "Bass Speaker", "PCM",
5143 "Speaker Front", "Speaker Surround", "Speaker CLFE", "Speaker Side",
5144 "Headphone Front", "Headphone Surround", "Headphone CLFE",
5145 "Headphone Side", "Headphone+LO", "Speaker+LO",
5146 NULL,
5147};
5148
5149
5150
5151
5152
5153
5154
5155int snd_hda_gen_build_controls(struct hda_codec *codec)
5156{
5157 struct hda_gen_spec *spec = codec->spec;
5158 int err;
5159
5160 if (spec->kctls.used) {
5161 err = snd_hda_add_new_ctls(codec, spec->kctls.list);
5162 if (err < 0)
5163 return err;
5164 }
5165
5166 if (spec->multiout.dig_out_nid) {
5167 err = snd_hda_create_dig_out_ctls(codec,
5168 spec->multiout.dig_out_nid,
5169 spec->multiout.dig_out_nid,
5170 spec->pcm_rec[1]->pcm_type);
5171 if (err < 0)
5172 return err;
5173 if (!spec->no_analog) {
5174 err = snd_hda_create_spdif_share_sw(codec,
5175 &spec->multiout);
5176 if (err < 0)
5177 return err;
5178 spec->multiout.share_spdif = 1;
5179 }
5180 }
5181 if (spec->dig_in_nid) {
5182 err = snd_hda_create_spdif_in_ctls(codec, spec->dig_in_nid);
5183 if (err < 0)
5184 return err;
5185 }
5186
5187
5188 if (!spec->no_analog && !spec->suppress_vmaster &&
5189 !snd_hda_find_mixer_ctl(codec, "Master Playback Volume")) {
5190 err = snd_hda_add_vmaster(codec, "Master Playback Volume",
5191 spec->vmaster_tlv, follower_pfxs,
5192 "Playback Volume", 0);
5193 if (err < 0)
5194 return err;
5195 }
5196 if (!spec->no_analog && !spec->suppress_vmaster &&
5197 !snd_hda_find_mixer_ctl(codec, "Master Playback Switch")) {
5198 err = __snd_hda_add_vmaster(codec, "Master Playback Switch",
5199 NULL, follower_pfxs,
5200 "Playback Switch", true,
5201 spec->vmaster_mute_led ?
5202 SNDRV_CTL_ELEM_ACCESS_SPK_LED : 0,
5203 &spec->vmaster_mute.sw_kctl);
5204 if (err < 0)
5205 return err;
5206 if (spec->vmaster_mute.hook) {
5207 snd_hda_add_vmaster_hook(codec, &spec->vmaster_mute);
5208 snd_hda_sync_vmaster_hook(&spec->vmaster_mute);
5209 }
5210 }
5211
5212 free_kctls(spec);
5213
5214 err = snd_hda_jack_add_kctls(codec, &spec->autocfg);
5215 if (err < 0)
5216 return err;
5217
5218 return 0;
5219}
5220EXPORT_SYMBOL_GPL(snd_hda_gen_build_controls);
5221
5222
5223
5224
5225
5226
5227static void call_pcm_playback_hook(struct hda_pcm_stream *hinfo,
5228 struct hda_codec *codec,
5229 struct snd_pcm_substream *substream,
5230 int action)
5231{
5232 struct hda_gen_spec *spec = codec->spec;
5233 if (spec->pcm_playback_hook)
5234 spec->pcm_playback_hook(hinfo, codec, substream, action);
5235}
5236
5237static void call_pcm_capture_hook(struct hda_pcm_stream *hinfo,
5238 struct hda_codec *codec,
5239 struct snd_pcm_substream *substream,
5240 int action)
5241{
5242 struct hda_gen_spec *spec = codec->spec;
5243 if (spec->pcm_capture_hook)
5244 spec->pcm_capture_hook(hinfo, codec, substream, action);
5245}
5246
5247
5248
5249
5250static int playback_pcm_open(struct hda_pcm_stream *hinfo,
5251 struct hda_codec *codec,
5252 struct snd_pcm_substream *substream)
5253{
5254 struct hda_gen_spec *spec = codec->spec;
5255 int err;
5256
5257 mutex_lock(&spec->pcm_mutex);
5258 err = snd_hda_multi_out_analog_open(codec,
5259 &spec->multiout, substream,
5260 hinfo);
5261 if (!err) {
5262 spec->active_streams |= 1 << STREAM_MULTI_OUT;
5263 call_pcm_playback_hook(hinfo, codec, substream,
5264 HDA_GEN_PCM_ACT_OPEN);
5265 }
5266 mutex_unlock(&spec->pcm_mutex);
5267 return err;
5268}
5269
5270static int playback_pcm_prepare(struct hda_pcm_stream *hinfo,
5271 struct hda_codec *codec,
5272 unsigned int stream_tag,
5273 unsigned int format,
5274 struct snd_pcm_substream *substream)
5275{
5276 struct hda_gen_spec *spec = codec->spec;
5277 int err;
5278
5279 err = snd_hda_multi_out_analog_prepare(codec, &spec->multiout,
5280 stream_tag, format, substream);
5281 if (!err)
5282 call_pcm_playback_hook(hinfo, codec, substream,
5283 HDA_GEN_PCM_ACT_PREPARE);
5284 return err;
5285}
5286
5287static int playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
5288 struct hda_codec *codec,
5289 struct snd_pcm_substream *substream)
5290{
5291 struct hda_gen_spec *spec = codec->spec;
5292 int err;
5293
5294 err = snd_hda_multi_out_analog_cleanup(codec, &spec->multiout);
5295 if (!err)
5296 call_pcm_playback_hook(hinfo, codec, substream,
5297 HDA_GEN_PCM_ACT_CLEANUP);
5298 return err;
5299}
5300
5301static int playback_pcm_close(struct hda_pcm_stream *hinfo,
5302 struct hda_codec *codec,
5303 struct snd_pcm_substream *substream)
5304{
5305 struct hda_gen_spec *spec = codec->spec;
5306 mutex_lock(&spec->pcm_mutex);
5307 spec->active_streams &= ~(1 << STREAM_MULTI_OUT);
5308 call_pcm_playback_hook(hinfo, codec, substream,
5309 HDA_GEN_PCM_ACT_CLOSE);
5310 mutex_unlock(&spec->pcm_mutex);
5311 return 0;
5312}
5313
5314static int capture_pcm_open(struct hda_pcm_stream *hinfo,
5315 struct hda_codec *codec,
5316 struct snd_pcm_substream *substream)
5317{
5318 call_pcm_capture_hook(hinfo, codec, substream, HDA_GEN_PCM_ACT_OPEN);
5319 return 0;
5320}
5321
5322static int capture_pcm_prepare(struct hda_pcm_stream *hinfo,
5323 struct hda_codec *codec,
5324 unsigned int stream_tag,
5325 unsigned int format,
5326 struct snd_pcm_substream *substream)
5327{
5328 snd_hda_codec_setup_stream(codec, hinfo->nid, stream_tag, 0, format);
5329 call_pcm_capture_hook(hinfo, codec, substream,
5330 HDA_GEN_PCM_ACT_PREPARE);
5331 return 0;
5332}
5333
5334static int capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
5335 struct hda_codec *codec,
5336 struct snd_pcm_substream *substream)
5337{
5338 snd_hda_codec_cleanup_stream(codec, hinfo->nid);
5339 call_pcm_capture_hook(hinfo, codec, substream,
5340 HDA_GEN_PCM_ACT_CLEANUP);
5341 return 0;
5342}
5343
5344static int capture_pcm_close(struct hda_pcm_stream *hinfo,
5345 struct hda_codec *codec,
5346 struct snd_pcm_substream *substream)
5347{
5348 call_pcm_capture_hook(hinfo, codec, substream, HDA_GEN_PCM_ACT_CLOSE);
5349 return 0;
5350}
5351
5352static int alt_playback_pcm_open(struct hda_pcm_stream *hinfo,
5353 struct hda_codec *codec,
5354 struct snd_pcm_substream *substream)
5355{
5356 struct hda_gen_spec *spec = codec->spec;
5357 int err = 0;
5358
5359 mutex_lock(&spec->pcm_mutex);
5360 if (spec->indep_hp && !spec->indep_hp_enabled)
5361 err = -EBUSY;
5362 else
5363 spec->active_streams |= 1 << STREAM_INDEP_HP;
5364 call_pcm_playback_hook(hinfo, codec, substream,
5365 HDA_GEN_PCM_ACT_OPEN);
5366 mutex_unlock(&spec->pcm_mutex);
5367 return err;
5368}
5369
5370static int alt_playback_pcm_close(struct hda_pcm_stream *hinfo,
5371 struct hda_codec *codec,
5372 struct snd_pcm_substream *substream)
5373{
5374 struct hda_gen_spec *spec = codec->spec;
5375 mutex_lock(&spec->pcm_mutex);
5376 spec->active_streams &= ~(1 << STREAM_INDEP_HP);
5377 call_pcm_playback_hook(hinfo, codec, substream,
5378 HDA_GEN_PCM_ACT_CLOSE);
5379 mutex_unlock(&spec->pcm_mutex);
5380 return 0;
5381}
5382
5383static int alt_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
5384 struct hda_codec *codec,
5385 unsigned int stream_tag,
5386 unsigned int format,
5387 struct snd_pcm_substream *substream)
5388{
5389 snd_hda_codec_setup_stream(codec, hinfo->nid, stream_tag, 0, format);
5390 call_pcm_playback_hook(hinfo, codec, substream,
5391 HDA_GEN_PCM_ACT_PREPARE);
5392 return 0;
5393}
5394
5395static int alt_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
5396 struct hda_codec *codec,
5397 struct snd_pcm_substream *substream)
5398{
5399 snd_hda_codec_cleanup_stream(codec, hinfo->nid);
5400 call_pcm_playback_hook(hinfo, codec, substream,
5401 HDA_GEN_PCM_ACT_CLEANUP);
5402 return 0;
5403}
5404
5405
5406
5407
5408static int dig_playback_pcm_open(struct hda_pcm_stream *hinfo,
5409 struct hda_codec *codec,
5410 struct snd_pcm_substream *substream)
5411{
5412 struct hda_gen_spec *spec = codec->spec;
5413 return snd_hda_multi_out_dig_open(codec, &spec->multiout);
5414}
5415
5416static int dig_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
5417 struct hda_codec *codec,
5418 unsigned int stream_tag,
5419 unsigned int format,
5420 struct snd_pcm_substream *substream)
5421{
5422 struct hda_gen_spec *spec = codec->spec;
5423 return snd_hda_multi_out_dig_prepare(codec, &spec->multiout,
5424 stream_tag, format, substream);
5425}
5426
5427static int dig_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
5428 struct hda_codec *codec,
5429 struct snd_pcm_substream *substream)
5430{
5431 struct hda_gen_spec *spec = codec->spec;
5432 return snd_hda_multi_out_dig_cleanup(codec, &spec->multiout);
5433}
5434
5435static int dig_playback_pcm_close(struct hda_pcm_stream *hinfo,
5436 struct hda_codec *codec,
5437 struct snd_pcm_substream *substream)
5438{
5439 struct hda_gen_spec *spec = codec->spec;
5440 return snd_hda_multi_out_dig_close(codec, &spec->multiout);
5441}
5442
5443
5444
5445
5446#define alt_capture_pcm_open capture_pcm_open
5447#define alt_capture_pcm_close capture_pcm_close
5448
5449static int alt_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
5450 struct hda_codec *codec,
5451 unsigned int stream_tag,
5452 unsigned int format,
5453 struct snd_pcm_substream *substream)
5454{
5455 struct hda_gen_spec *spec = codec->spec;
5456
5457 snd_hda_codec_setup_stream(codec, spec->adc_nids[substream->number + 1],
5458 stream_tag, 0, format);
5459 call_pcm_capture_hook(hinfo, codec, substream,
5460 HDA_GEN_PCM_ACT_PREPARE);
5461 return 0;
5462}
5463
5464static int alt_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
5465 struct hda_codec *codec,
5466 struct snd_pcm_substream *substream)
5467{
5468 struct hda_gen_spec *spec = codec->spec;
5469
5470 snd_hda_codec_cleanup_stream(codec,
5471 spec->adc_nids[substream->number + 1]);
5472 call_pcm_capture_hook(hinfo, codec, substream,
5473 HDA_GEN_PCM_ACT_CLEANUP);
5474 return 0;
5475}
5476
5477
5478
5479static const struct hda_pcm_stream pcm_analog_playback = {
5480 .substreams = 1,
5481 .channels_min = 2,
5482 .channels_max = 8,
5483
5484 .ops = {
5485 .open = playback_pcm_open,
5486 .close = playback_pcm_close,
5487 .prepare = playback_pcm_prepare,
5488 .cleanup = playback_pcm_cleanup
5489 },
5490};
5491
5492static const struct hda_pcm_stream pcm_analog_capture = {
5493 .substreams = 1,
5494 .channels_min = 2,
5495 .channels_max = 2,
5496
5497 .ops = {
5498 .open = capture_pcm_open,
5499 .close = capture_pcm_close,
5500 .prepare = capture_pcm_prepare,
5501 .cleanup = capture_pcm_cleanup
5502 },
5503};
5504
5505static const struct hda_pcm_stream pcm_analog_alt_playback = {
5506 .substreams = 1,
5507 .channels_min = 2,
5508 .channels_max = 2,
5509
5510 .ops = {
5511 .open = alt_playback_pcm_open,
5512 .close = alt_playback_pcm_close,
5513 .prepare = alt_playback_pcm_prepare,
5514 .cleanup = alt_playback_pcm_cleanup
5515 },
5516};
5517
5518static const struct hda_pcm_stream pcm_analog_alt_capture = {
5519 .substreams = 2,
5520 .channels_min = 2,
5521 .channels_max = 2,
5522
5523 .ops = {
5524 .open = alt_capture_pcm_open,
5525 .close = alt_capture_pcm_close,
5526 .prepare = alt_capture_pcm_prepare,
5527 .cleanup = alt_capture_pcm_cleanup
5528 },
5529};
5530
5531static const struct hda_pcm_stream pcm_digital_playback = {
5532 .substreams = 1,
5533 .channels_min = 2,
5534 .channels_max = 2,
5535
5536 .ops = {
5537 .open = dig_playback_pcm_open,
5538 .close = dig_playback_pcm_close,
5539 .prepare = dig_playback_pcm_prepare,
5540 .cleanup = dig_playback_pcm_cleanup
5541 },
5542};
5543
5544static const struct hda_pcm_stream pcm_digital_capture = {
5545 .substreams = 1,
5546 .channels_min = 2,
5547 .channels_max = 2,
5548
5549};
5550
5551
5552static const struct hda_pcm_stream pcm_null_stream = {
5553 .substreams = 0,
5554 .channels_min = 0,
5555 .channels_max = 0,
5556};
5557
5558
5559
5560
5561static bool dyn_adc_pcm_resetup(struct hda_codec *codec, int cur)
5562{
5563 struct hda_gen_spec *spec = codec->spec;
5564 hda_nid_t new_adc = spec->adc_nids[spec->dyn_adc_idx[cur]];
5565
5566 if (spec->cur_adc && spec->cur_adc != new_adc) {
5567
5568 __snd_hda_codec_cleanup_stream(codec, spec->cur_adc, 1);
5569 spec->cur_adc = new_adc;
5570 snd_hda_codec_setup_stream(codec, new_adc,
5571 spec->cur_adc_stream_tag, 0,
5572 spec->cur_adc_format);
5573 return true;
5574 }
5575 return false;
5576}
5577
5578
5579static int dyn_adc_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
5580 struct hda_codec *codec,
5581 unsigned int stream_tag,
5582 unsigned int format,
5583 struct snd_pcm_substream *substream)
5584{
5585 struct hda_gen_spec *spec = codec->spec;
5586 spec->cur_adc = spec->adc_nids[spec->dyn_adc_idx[spec->cur_mux[0]]];
5587 spec->cur_adc_stream_tag = stream_tag;
5588 spec->cur_adc_format = format;
5589 snd_hda_codec_setup_stream(codec, spec->cur_adc, stream_tag, 0, format);
5590 call_pcm_capture_hook(hinfo, codec, substream, HDA_GEN_PCM_ACT_PREPARE);
5591 return 0;
5592}
5593
5594static int dyn_adc_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
5595 struct hda_codec *codec,
5596 struct snd_pcm_substream *substream)
5597{
5598 struct hda_gen_spec *spec = codec->spec;
5599 snd_hda_codec_cleanup_stream(codec, spec->cur_adc);
5600 spec->cur_adc = 0;
5601 call_pcm_capture_hook(hinfo, codec, substream, HDA_GEN_PCM_ACT_CLEANUP);
5602 return 0;
5603}
5604
5605static const struct hda_pcm_stream dyn_adc_pcm_analog_capture = {
5606 .substreams = 1,
5607 .channels_min = 2,
5608 .channels_max = 2,
5609 .nid = 0,
5610 .ops = {
5611 .prepare = dyn_adc_capture_pcm_prepare,
5612 .cleanup = dyn_adc_capture_pcm_cleanup
5613 },
5614};
5615
5616static void fill_pcm_stream_name(char *str, size_t len, const char *sfx,
5617 const char *chip_name)
5618{
5619 char *p;
5620
5621 if (*str)
5622 return;
5623 strscpy(str, chip_name, len);
5624
5625
5626 for (p = strchr(str, ' '); p; p = strchr(p + 1, ' ')) {
5627 if (!isalnum(p[1])) {
5628 *p = 0;
5629 break;
5630 }
5631 }
5632 strlcat(str, sfx, len);
5633}
5634
5635
5636
5637
5638static void setup_pcm_stream(struct hda_pcm_stream *str,
5639 const struct hda_pcm_stream *default_str,
5640 const struct hda_pcm_stream *spec_str,
5641 hda_nid_t nid)
5642{
5643 *str = *default_str;
5644 if (nid)
5645 str->nid = nid;
5646 if (spec_str) {
5647 if (spec_str->substreams)
5648 str->substreams = spec_str->substreams;
5649 if (spec_str->channels_min)
5650 str->channels_min = spec_str->channels_min;
5651 if (spec_str->channels_max)
5652 str->channels_max = spec_str->channels_max;
5653 if (spec_str->rates)
5654 str->rates = spec_str->rates;
5655 if (spec_str->formats)
5656 str->formats = spec_str->formats;
5657 if (spec_str->maxbps)
5658 str->maxbps = spec_str->maxbps;
5659 }
5660}
5661
5662
5663
5664
5665
5666
5667
5668int snd_hda_gen_build_pcms(struct hda_codec *codec)
5669{
5670 struct hda_gen_spec *spec = codec->spec;
5671 struct hda_pcm *info;
5672 bool have_multi_adcs;
5673
5674 if (spec->no_analog)
5675 goto skip_analog;
5676
5677 fill_pcm_stream_name(spec->stream_name_analog,
5678 sizeof(spec->stream_name_analog),
5679 " Analog", codec->core.chip_name);
5680 info = snd_hda_codec_pcm_new(codec, "%s", spec->stream_name_analog);
5681 if (!info)
5682 return -ENOMEM;
5683 spec->pcm_rec[0] = info;
5684
5685 if (spec->multiout.num_dacs > 0) {
5686 setup_pcm_stream(&info->stream[SNDRV_PCM_STREAM_PLAYBACK],
5687 &pcm_analog_playback,
5688 spec->stream_analog_playback,
5689 spec->multiout.dac_nids[0]);
5690 info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max =
5691 spec->multiout.max_channels;
5692 if (spec->autocfg.line_out_type == AUTO_PIN_SPEAKER_OUT &&
5693 spec->autocfg.line_outs == 2)
5694 info->stream[SNDRV_PCM_STREAM_PLAYBACK].chmap =
5695 snd_pcm_2_1_chmaps;
5696 }
5697 if (spec->num_adc_nids) {
5698 setup_pcm_stream(&info->stream[SNDRV_PCM_STREAM_CAPTURE],
5699 (spec->dyn_adc_switch ?
5700 &dyn_adc_pcm_analog_capture : &pcm_analog_capture),
5701 spec->stream_analog_capture,
5702 spec->adc_nids[0]);
5703 }
5704
5705 skip_analog:
5706
5707 if (spec->multiout.dig_out_nid || spec->dig_in_nid) {
5708 fill_pcm_stream_name(spec->stream_name_digital,
5709 sizeof(spec->stream_name_digital),
5710 " Digital", codec->core.chip_name);
5711 info = snd_hda_codec_pcm_new(codec, "%s",
5712 spec->stream_name_digital);
5713 if (!info)
5714 return -ENOMEM;
5715 codec->follower_dig_outs = spec->multiout.follower_dig_outs;
5716 spec->pcm_rec[1] = info;
5717 if (spec->dig_out_type)
5718 info->pcm_type = spec->dig_out_type;
5719 else
5720 info->pcm_type = HDA_PCM_TYPE_SPDIF;
5721 if (spec->multiout.dig_out_nid)
5722 setup_pcm_stream(&info->stream[SNDRV_PCM_STREAM_PLAYBACK],
5723 &pcm_digital_playback,
5724 spec->stream_digital_playback,
5725 spec->multiout.dig_out_nid);
5726 if (spec->dig_in_nid)
5727 setup_pcm_stream(&info->stream[SNDRV_PCM_STREAM_CAPTURE],
5728 &pcm_digital_capture,
5729 spec->stream_digital_capture,
5730 spec->dig_in_nid);
5731 }
5732
5733 if (spec->no_analog)
5734 return 0;
5735
5736
5737
5738
5739 have_multi_adcs = (spec->num_adc_nids > 1) &&
5740 !spec->dyn_adc_switch && !spec->auto_mic;
5741
5742 if (spec->alt_dac_nid || have_multi_adcs) {
5743 fill_pcm_stream_name(spec->stream_name_alt_analog,
5744 sizeof(spec->stream_name_alt_analog),
5745 " Alt Analog", codec->core.chip_name);
5746 info = snd_hda_codec_pcm_new(codec, "%s",
5747 spec->stream_name_alt_analog);
5748 if (!info)
5749 return -ENOMEM;
5750 spec->pcm_rec[2] = info;
5751 if (spec->alt_dac_nid)
5752 setup_pcm_stream(&info->stream[SNDRV_PCM_STREAM_PLAYBACK],
5753 &pcm_analog_alt_playback,
5754 spec->stream_analog_alt_playback,
5755 spec->alt_dac_nid);
5756 else
5757 setup_pcm_stream(&info->stream[SNDRV_PCM_STREAM_PLAYBACK],
5758 &pcm_null_stream, NULL, 0);
5759 if (have_multi_adcs) {
5760 setup_pcm_stream(&info->stream[SNDRV_PCM_STREAM_CAPTURE],
5761 &pcm_analog_alt_capture,
5762 spec->stream_analog_alt_capture,
5763 spec->adc_nids[1]);
5764 info->stream[SNDRV_PCM_STREAM_CAPTURE].substreams =
5765 spec->num_adc_nids - 1;
5766 } else {
5767 setup_pcm_stream(&info->stream[SNDRV_PCM_STREAM_CAPTURE],
5768 &pcm_null_stream, NULL, 0);
5769 }
5770 }
5771
5772 return 0;
5773}
5774EXPORT_SYMBOL_GPL(snd_hda_gen_build_pcms);
5775
5776
5777
5778
5779
5780
5781
5782static void set_output_and_unmute(struct hda_codec *codec, int path_idx)
5783{
5784 struct nid_path *path;
5785 hda_nid_t pin;
5786
5787 path = snd_hda_get_path_from_idx(codec, path_idx);
5788 if (!path || !path->depth)
5789 return;
5790 pin = path->path[path->depth - 1];
5791 restore_pin_ctl(codec, pin);
5792 snd_hda_activate_path(codec, path, path->active,
5793 aamix_default(codec->spec));
5794 set_pin_eapd(codec, pin, path->active);
5795}
5796
5797
5798static void init_multi_out(struct hda_codec *codec)
5799{
5800 struct hda_gen_spec *spec = codec->spec;
5801 int i;
5802
5803 for (i = 0; i < spec->autocfg.line_outs; i++)
5804 set_output_and_unmute(codec, spec->out_paths[i]);
5805}
5806
5807
5808static void __init_extra_out(struct hda_codec *codec, int num_outs, int *paths)
5809{
5810 int i;
5811
5812 for (i = 0; i < num_outs; i++)
5813 set_output_and_unmute(codec, paths[i]);
5814}
5815
5816
5817static void init_extra_out(struct hda_codec *codec)
5818{
5819 struct hda_gen_spec *spec = codec->spec;
5820
5821 if (spec->autocfg.line_out_type != AUTO_PIN_HP_OUT)
5822 __init_extra_out(codec, spec->autocfg.hp_outs, spec->hp_paths);
5823 if (spec->autocfg.line_out_type != AUTO_PIN_SPEAKER_OUT)
5824 __init_extra_out(codec, spec->autocfg.speaker_outs,
5825 spec->speaker_paths);
5826}
5827
5828
5829static void init_multi_io(struct hda_codec *codec)
5830{
5831 struct hda_gen_spec *spec = codec->spec;
5832 int i;
5833
5834 for (i = 0; i < spec->multi_ios; i++) {
5835 hda_nid_t pin = spec->multi_io[i].pin;
5836 struct nid_path *path;
5837 path = get_multiio_path(codec, i);
5838 if (!path)
5839 continue;
5840 if (!spec->multi_io[i].ctl_in)
5841 spec->multi_io[i].ctl_in =
5842 snd_hda_codec_get_pin_target(codec, pin);
5843 snd_hda_activate_path(codec, path, path->active,
5844 aamix_default(spec));
5845 }
5846}
5847
5848static void init_aamix_paths(struct hda_codec *codec)
5849{
5850 struct hda_gen_spec *spec = codec->spec;
5851
5852 if (!spec->have_aamix_ctl)
5853 return;
5854 if (!has_aamix_out_paths(spec))
5855 return;
5856 update_aamix_paths(codec, spec->aamix_mode, spec->out_paths[0],
5857 spec->aamix_out_paths[0],
5858 spec->autocfg.line_out_type);
5859 update_aamix_paths(codec, spec->aamix_mode, spec->hp_paths[0],
5860 spec->aamix_out_paths[1],
5861 AUTO_PIN_HP_OUT);
5862 update_aamix_paths(codec, spec->aamix_mode, spec->speaker_paths[0],
5863 spec->aamix_out_paths[2],
5864 AUTO_PIN_SPEAKER_OUT);
5865}
5866
5867
5868static void init_analog_input(struct hda_codec *codec)
5869{
5870 struct hda_gen_spec *spec = codec->spec;
5871 struct auto_pin_cfg *cfg = &spec->autocfg;
5872 int i;
5873
5874 for (i = 0; i < cfg->num_inputs; i++) {
5875 hda_nid_t nid = cfg->inputs[i].pin;
5876 if (is_input_pin(codec, nid))
5877 restore_pin_ctl(codec, nid);
5878
5879
5880 if (spec->mixer_nid) {
5881 resume_path_from_idx(codec, spec->loopback_paths[i]);
5882 resume_path_from_idx(codec, spec->loopback_merge_path);
5883 }
5884 }
5885}
5886
5887
5888static void init_input_src(struct hda_codec *codec)
5889{
5890 struct hda_gen_spec *spec = codec->spec;
5891 struct hda_input_mux *imux = &spec->input_mux;
5892 struct nid_path *path;
5893 int i, c, nums;
5894
5895 if (spec->dyn_adc_switch)
5896 nums = 1;
5897 else
5898 nums = spec->num_adc_nids;
5899
5900 for (c = 0; c < nums; c++) {
5901 for (i = 0; i < imux->num_items; i++) {
5902 path = get_input_path(codec, c, i);
5903 if (path) {
5904 bool active = path->active;
5905 if (i == spec->cur_mux[c])
5906 active = true;
5907 snd_hda_activate_path(codec, path, active, false);
5908 }
5909 }
5910 if (spec->hp_mic)
5911 update_hp_mic(codec, c, true);
5912 }
5913
5914 if (spec->cap_sync_hook)
5915 spec->cap_sync_hook(codec, NULL, NULL);
5916}
5917
5918
5919static void init_digital(struct hda_codec *codec)
5920{
5921 struct hda_gen_spec *spec = codec->spec;
5922 int i;
5923 hda_nid_t pin;
5924
5925 for (i = 0; i < spec->autocfg.dig_outs; i++)
5926 set_output_and_unmute(codec, spec->digout_paths[i]);
5927 pin = spec->autocfg.dig_in_pin;
5928 if (pin) {
5929 restore_pin_ctl(codec, pin);
5930 resume_path_from_idx(codec, spec->digin_path);
5931 }
5932}
5933
5934
5935
5936
5937static void clear_unsol_on_unused_pins(struct hda_codec *codec)
5938{
5939 const struct hda_pincfg *pin;
5940 int i;
5941
5942 snd_array_for_each(&codec->init_pins, i, pin) {
5943 hda_nid_t nid = pin->nid;
5944 if (is_jack_detectable(codec, nid) &&
5945 !snd_hda_jack_tbl_get(codec, nid))
5946 snd_hda_codec_write_cache(codec, nid, 0,
5947 AC_VERB_SET_UNSOLICITED_ENABLE, 0);
5948 }
5949}
5950
5951
5952
5953
5954
5955
5956
5957int snd_hda_gen_init(struct hda_codec *codec)
5958{
5959 struct hda_gen_spec *spec = codec->spec;
5960
5961 if (spec->init_hook)
5962 spec->init_hook(codec);
5963
5964 if (!spec->skip_verbs)
5965 snd_hda_apply_verbs(codec);
5966
5967 init_multi_out(codec);
5968 init_extra_out(codec);
5969 init_multi_io(codec);
5970 init_aamix_paths(codec);
5971 init_analog_input(codec);
5972 init_input_src(codec);
5973 init_digital(codec);
5974
5975 clear_unsol_on_unused_pins(codec);
5976
5977 sync_all_pin_power_ctls(codec);
5978
5979
5980 update_automute_all(codec);
5981
5982 snd_hda_regmap_sync(codec);
5983
5984 if (spec->vmaster_mute.sw_kctl && spec->vmaster_mute.hook)
5985 snd_hda_sync_vmaster_hook(&spec->vmaster_mute);
5986
5987 hda_call_check_power_status(codec, 0x01);
5988 return 0;
5989}
5990EXPORT_SYMBOL_GPL(snd_hda_gen_init);
5991
5992
5993
5994
5995
5996
5997
5998void snd_hda_gen_free(struct hda_codec *codec)
5999{
6000 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_FREE);
6001 snd_hda_gen_spec_free(codec->spec);
6002 kfree(codec->spec);
6003 codec->spec = NULL;
6004}
6005EXPORT_SYMBOL_GPL(snd_hda_gen_free);
6006
6007#ifdef CONFIG_PM
6008
6009
6010
6011
6012
6013
6014
6015int snd_hda_gen_check_power_status(struct hda_codec *codec, hda_nid_t nid)
6016{
6017 struct hda_gen_spec *spec = codec->spec;
6018 return snd_hda_check_amp_list_power(codec, &spec->loopback, nid);
6019}
6020EXPORT_SYMBOL_GPL(snd_hda_gen_check_power_status);
6021#endif
6022
6023
6024
6025
6026
6027
6028static const struct hda_codec_ops generic_patch_ops = {
6029 .build_controls = snd_hda_gen_build_controls,
6030 .build_pcms = snd_hda_gen_build_pcms,
6031 .init = snd_hda_gen_init,
6032 .free = snd_hda_gen_free,
6033 .unsol_event = snd_hda_jack_unsol_event,
6034#ifdef CONFIG_PM
6035 .check_power_status = snd_hda_gen_check_power_status,
6036#endif
6037};
6038
6039
6040
6041
6042
6043static int snd_hda_parse_generic_codec(struct hda_codec *codec)
6044{
6045 struct hda_gen_spec *spec;
6046 int err;
6047
6048 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
6049 if (!spec)
6050 return -ENOMEM;
6051 snd_hda_gen_spec_init(spec);
6052 codec->spec = spec;
6053
6054 err = snd_hda_parse_pin_defcfg(codec, &spec->autocfg, NULL, 0);
6055 if (err < 0)
6056 goto error;
6057
6058 err = snd_hda_gen_parse_auto_config(codec, &spec->autocfg);
6059 if (err < 0)
6060 goto error;
6061
6062 codec->patch_ops = generic_patch_ops;
6063 return 0;
6064
6065error:
6066 snd_hda_gen_free(codec);
6067 return err;
6068}
6069
6070static const struct hda_device_id snd_hda_id_generic[] = {
6071 HDA_CODEC_ENTRY(HDA_CODEC_ID_GENERIC, "Generic", snd_hda_parse_generic_codec),
6072 {}
6073};
6074MODULE_DEVICE_TABLE(hdaudio, snd_hda_id_generic);
6075
6076static struct hda_codec_driver generic_driver = {
6077 .id = snd_hda_id_generic,
6078};
6079
6080module_hda_codec_driver(generic_driver);
6081
6082MODULE_LICENSE("GPL");
6083MODULE_DESCRIPTION("Generic HD-audio codec parser");
6084