1 // SPDX-License-Identifier: GPL-2.0-or-later
3 * Universal Interface for Intel High Definition Audio Codec
5 * Generic widget tree parser
7 * Copyright (c) 2004 Takashi Iwai <tiwai@suse.de>
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"
28 #include "hda_generic.h"
32 * snd_hda_gen_spec_init - initialize hda_gen_spec struct
33 * @spec: hda_gen_spec object to initialize
35 * Initialize the given hda_gen_spec object.
37 int snd_hda_gen_spec_init(struct hda_gen_spec *spec)
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);
45 EXPORT_SYMBOL_GPL(snd_hda_gen_spec_init);
48 * snd_hda_gen_add_kctl - Add a new kctl_new struct from the template
49 * @spec: hda_gen_spec object
50 * @name: name string to override the template, NULL if unchanged
51 * @temp: template for the new kctl
53 * Add a new kctl (actually snd_kcontrol_new to be instantiated later)
54 * element based on the given snd_kcontrol_new template @temp and the
55 * name string @name to the list in @spec.
56 * Returns the newly created object or NULL as error.
58 struct snd_kcontrol_new *
59 snd_hda_gen_add_kctl(struct hda_gen_spec *spec, const char *name,
60 const struct snd_kcontrol_new *temp)
62 struct snd_kcontrol_new *knew = snd_array_new(&spec->kctls);
67 knew->name = kstrdup(name, GFP_KERNEL);
69 knew->name = kstrdup(knew->name, GFP_KERNEL);
74 EXPORT_SYMBOL_GPL(snd_hda_gen_add_kctl);
76 static void free_kctls(struct hda_gen_spec *spec)
78 if (spec->kctls.list) {
79 struct snd_kcontrol_new *kctl = spec->kctls.list;
81 for (i = 0; i < spec->kctls.used; i++)
84 snd_array_free(&spec->kctls);
87 static void snd_hda_gen_spec_free(struct hda_gen_spec *spec)
92 snd_array_free(&spec->paths);
93 snd_array_free(&spec->loopback_list);
99 static void parse_user_hints(struct hda_codec *codec)
101 struct hda_gen_spec *spec = codec->spec;
104 val = snd_hda_get_bool_hint(codec, "jack_detect");
106 codec->no_jack_detect = !val;
107 val = snd_hda_get_bool_hint(codec, "inv_jack_detect");
109 codec->inv_jack_detect = !!val;
110 val = snd_hda_get_bool_hint(codec, "trigger_sense");
112 codec->no_trigger_sense = !val;
113 val = snd_hda_get_bool_hint(codec, "inv_eapd");
115 codec->inv_eapd = !!val;
116 val = snd_hda_get_bool_hint(codec, "pcm_format_first");
118 codec->pcm_format_first = !!val;
119 val = snd_hda_get_bool_hint(codec, "sticky_stream");
121 codec->no_sticky_stream = !val;
122 val = snd_hda_get_bool_hint(codec, "spdif_status_reset");
124 codec->spdif_status_reset = !!val;
125 val = snd_hda_get_bool_hint(codec, "pin_amp_workaround");
127 codec->pin_amp_workaround = !!val;
128 val = snd_hda_get_bool_hint(codec, "single_adc_amp");
130 codec->single_adc_amp = !!val;
131 val = snd_hda_get_bool_hint(codec, "power_save_node");
133 codec->power_save_node = !!val;
135 val = snd_hda_get_bool_hint(codec, "auto_mute");
137 spec->suppress_auto_mute = !val;
138 val = snd_hda_get_bool_hint(codec, "auto_mic");
140 spec->suppress_auto_mic = !val;
141 val = snd_hda_get_bool_hint(codec, "line_in_auto_switch");
143 spec->line_in_auto_switch = !!val;
144 val = snd_hda_get_bool_hint(codec, "auto_mute_via_amp");
146 spec->auto_mute_via_amp = !!val;
147 val = snd_hda_get_bool_hint(codec, "need_dac_fix");
149 spec->need_dac_fix = !!val;
150 val = snd_hda_get_bool_hint(codec, "primary_hp");
152 spec->no_primary_hp = !val;
153 val = snd_hda_get_bool_hint(codec, "multi_io");
155 spec->no_multi_io = !val;
156 val = snd_hda_get_bool_hint(codec, "multi_cap_vol");
158 spec->multi_cap_vol = !!val;
159 val = snd_hda_get_bool_hint(codec, "inv_dmic_split");
161 spec->inv_dmic_split = !!val;
162 val = snd_hda_get_bool_hint(codec, "indep_hp");
164 spec->indep_hp = !!val;
165 val = snd_hda_get_bool_hint(codec, "add_stereo_mix_input");
167 spec->add_stereo_mix_input = !!val;
168 /* the following two are just for compatibility */
169 val = snd_hda_get_bool_hint(codec, "add_out_jack_modes");
171 spec->add_jack_modes = !!val;
172 val = snd_hda_get_bool_hint(codec, "add_in_jack_modes");
174 spec->add_jack_modes = !!val;
175 val = snd_hda_get_bool_hint(codec, "add_jack_modes");
177 spec->add_jack_modes = !!val;
178 val = snd_hda_get_bool_hint(codec, "power_down_unused");
180 spec->power_down_unused = !!val;
181 val = snd_hda_get_bool_hint(codec, "add_hp_mic");
183 spec->hp_mic = !!val;
184 val = snd_hda_get_bool_hint(codec, "hp_mic_detect");
186 spec->suppress_hp_mic_detect = !val;
187 val = snd_hda_get_bool_hint(codec, "vmaster");
189 spec->suppress_vmaster = !val;
191 if (!snd_hda_get_int_hint(codec, "mixer_nid", &val))
192 spec->mixer_nid = val;
196 * pin control value accesses
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)
203 /* restore the pinctl based on the cached value */
204 static inline void restore_pin_ctl(struct hda_codec *codec, hda_nid_t pin)
206 update_pin_ctl(codec, pin, snd_hda_codec_get_pin_target(codec, pin));
209 /* set the pinctl target value and write it if requested */
210 static void set_pin_target(struct hda_codec *codec, hda_nid_t pin,
211 unsigned int val, bool do_write)
215 val = snd_hda_correct_pin_ctl(codec, pin, val);
216 snd_hda_codec_set_pin_target(codec, pin, val);
218 update_pin_ctl(codec, pin, val);
221 /* set pinctl target values for all given pins */
222 static void set_pin_targets(struct hda_codec *codec, int num_pins,
223 hda_nid_t *pins, unsigned int val)
226 for (i = 0; i < num_pins; i++)
227 set_pin_target(codec, pins[i], val, false);
234 /* return the position of NID in the list, or -1 if not found */
235 static int find_idx_in_nid_list(hda_nid_t nid, const hda_nid_t *list, int nums)
238 for (i = 0; i < nums; i++)
244 /* return true if the given NID is contained in the path */
245 static bool is_nid_contained(struct nid_path *path, hda_nid_t nid)
247 return find_idx_in_nid_list(nid, path->path, path->depth) >= 0;
250 static struct nid_path *get_nid_path(struct hda_codec *codec,
251 hda_nid_t from_nid, hda_nid_t to_nid,
254 struct hda_gen_spec *spec = codec->spec;
255 struct nid_path *path;
258 snd_array_for_each(&spec->paths, i, path) {
259 if (path->depth <= 0)
261 if ((!from_nid || path->path[0] == from_nid) &&
262 (!to_nid || path->path[path->depth - 1] == to_nid)) {
264 (anchor_nid > 0 && is_nid_contained(path, anchor_nid)) ||
265 (anchor_nid < 0 && !is_nid_contained(path, anchor_nid)))
273 * snd_hda_get_path_idx - get the index number corresponding to the path
275 * @codec: the HDA codec
276 * @path: nid_path object
278 * The returned index starts from 1, i.e. the actual array index with offset 1,
279 * and zero is handled as an invalid path
281 int snd_hda_get_path_idx(struct hda_codec *codec, struct nid_path *path)
283 struct hda_gen_spec *spec = codec->spec;
284 struct nid_path *array = spec->paths.list;
287 if (!spec->paths.used)
290 if (idx < 0 || idx >= spec->paths.used)
294 EXPORT_SYMBOL_GPL(snd_hda_get_path_idx);
297 * snd_hda_get_path_from_idx - get the path instance corresponding to the
299 * @codec: the HDA codec
300 * @idx: the path index
302 struct nid_path *snd_hda_get_path_from_idx(struct hda_codec *codec, int idx)
304 struct hda_gen_spec *spec = codec->spec;
306 if (idx <= 0 || idx > spec->paths.used)
308 return snd_array_elem(&spec->paths, idx - 1);
310 EXPORT_SYMBOL_GPL(snd_hda_get_path_from_idx);
312 /* check whether the given DAC is already found in any existing paths */
313 static bool is_dac_already_used(struct hda_codec *codec, hda_nid_t nid)
315 struct hda_gen_spec *spec = codec->spec;
316 const struct nid_path *path;
319 snd_array_for_each(&spec->paths, i, path) {
320 if (path->path[0] == nid)
326 /* check whether the given two widgets can be connected */
327 static bool is_reachable_path(struct hda_codec *codec,
328 hda_nid_t from_nid, hda_nid_t to_nid)
330 if (!from_nid || !to_nid)
332 return snd_hda_get_conn_index(codec, to_nid, from_nid, true) >= 0;
335 /* nid, dir and idx */
336 #define AMP_VAL_COMPARE_MASK (0xffff | (1U << 18) | (0x0f << 19))
338 /* check whether the given ctl is already assigned in any path elements */
339 static bool is_ctl_used(struct hda_codec *codec, unsigned int val, int type)
341 struct hda_gen_spec *spec = codec->spec;
342 const struct nid_path *path;
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)
353 /* check whether a control with the given (nid, dir, idx) was assigned */
354 static bool is_ctl_associated(struct hda_codec *codec, hda_nid_t nid,
355 int dir, int idx, int type)
357 unsigned int val = HDA_COMPOSE_AMP_VAL(nid, 3, idx, dir);
358 return is_ctl_used(codec, val, type);
361 static void print_nid_path(struct hda_codec *codec,
362 const char *pfx, struct nid_path *path)
369 for (i = 0; i < path->depth; i++)
370 pos += scnprintf(pos, sizeof(buf) - (pos - buf), "%s%02x",
371 pos != buf ? ":" : "",
374 codec_dbg(codec, "%s path: depth=%d '%s'\n", pfx, path->depth, buf);
377 /* called recursively */
378 static 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,
383 const hda_nid_t *conn;
386 if (to_nid == anchor_nid)
387 anchor_nid = 0; /* anchor passed */
388 else if (to_nid == (hda_nid_t)(-anchor_nid))
389 return false; /* hit the exclusive nid */
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 /* special case: when from_nid is 0,
395 * try to find an empty DAC
398 get_wcaps_type(get_wcaps(codec, conn[i])) != AC_WID_AUD_OUT ||
399 is_dac_already_used(codec, conn[i]))
402 /* anchor is not requested or already passed? */
406 if (depth >= MAX_NID_PATH_DEPTH)
408 for (i = 0; i < nums; i++) {
410 type = get_wcaps_type(get_wcaps(codec, conn[i]));
411 if (type == AC_WID_AUD_OUT || type == AC_WID_AUD_IN ||
414 if (__parse_nid_path(codec, from_nid, conn[i],
415 anchor_nid, path, depth + 1))
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;
430 * snd_hda_parse_nid_path - parse the widget path from the given nid to
432 * @codec: the HDA codec
433 * @from_nid: the NID where the path start from
434 * @to_nid: the NID where the path ends at
435 * @anchor_nid: the anchor indication
436 * @path: the path object to store the result
438 * Returns true if a matching path is found.
440 * The parsing behavior depends on parameters:
441 * when @from_nid is 0, try to find an empty DAC;
442 * when @anchor_nid is set to a positive value, only paths through the widget
443 * with the given value are evaluated.
444 * when @anchor_nid is set to a negative value, paths through the widget
445 * with the negative of given value are excluded, only other paths are chosen.
446 * when @anchor_nid is zero, no special handling about path selection.
448 static 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)
452 if (__parse_nid_path(codec, from_nid, to_nid, anchor_nid, path, 1)) {
453 path->path[path->depth] = to_nid;
461 * snd_hda_add_new_path - parse the path between the given NIDs and
462 * add to the path list
463 * @codec: the HDA codec
464 * @from_nid: the NID where the path start from
465 * @to_nid: the NID where the path ends at
466 * @anchor_nid: the anchor indication, see snd_hda_parse_nid_path()
468 * If no valid path is found, returns NULL.
471 snd_hda_add_new_path(struct hda_codec *codec, hda_nid_t from_nid,
472 hda_nid_t to_nid, int anchor_nid)
474 struct hda_gen_spec *spec = codec->spec;
475 struct nid_path *path;
477 if (from_nid && to_nid && !is_reachable_path(codec, from_nid, to_nid))
480 /* check whether the path has been already added */
481 path = get_nid_path(codec, from_nid, to_nid, anchor_nid);
485 path = snd_array_new(&spec->paths);
488 memset(path, 0, sizeof(*path));
489 if (snd_hda_parse_nid_path(codec, from_nid, to_nid, anchor_nid, path))
495 EXPORT_SYMBOL_GPL(snd_hda_add_new_path);
497 /* clear the given path as invalid so that it won't be picked up later */
498 static void invalidate_nid_path(struct hda_codec *codec, int idx)
500 struct nid_path *path = snd_hda_get_path_from_idx(codec, idx);
503 memset(path, 0, sizeof(*path));
506 /* return a DAC if paired to the given pin by codec driver */
507 static hda_nid_t get_preferred_dac(struct hda_codec *codec, hda_nid_t pin)
509 struct hda_gen_spec *spec = codec->spec;
510 const hda_nid_t *list = spec->preferred_dacs;
514 for (; *list; list += 2)
520 /* look for an empty DAC slot */
521 static hda_nid_t look_for_dac(struct hda_codec *codec, hda_nid_t pin,
524 struct hda_gen_spec *spec = codec->spec;
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))
532 cap_digital = !!(get_wcaps(codec, nid) & AC_WCAP_DIGITAL);
533 if (is_digital != cap_digital)
535 if (is_reachable_path(codec, nid, pin))
541 /* replace the channels in the composed amp value with the given number */
542 static unsigned int amp_val_replace_channels(unsigned int val, unsigned int chs)
544 val &= ~(0x3U << 16);
549 static bool same_amp_caps(struct hda_codec *codec, hda_nid_t nid1,
550 hda_nid_t nid2, int dir)
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));
558 /* look for a widget suitable for assigning a mute switch in the path */
559 static hda_nid_t look_for_out_mute_nid(struct hda_codec *codec,
560 struct nid_path *path)
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];
574 /* look for a widget suitable for assigning a volume ctl in the path */
575 static hda_nid_t look_for_out_vol_nid(struct hda_codec *codec,
576 struct nid_path *path)
578 struct hda_gen_spec *spec = codec->spec;
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)
585 if (nid_has_volume(codec, nid, HDA_OUTPUT))
592 * path activation / deactivation
595 /* can have the amp-in capability? */
596 static bool has_amp_in(struct hda_codec *codec, struct nid_path *path, int idx)
598 hda_nid_t nid = path->path[idx];
599 unsigned int caps = get_wcaps(codec, nid);
600 unsigned int type = get_wcaps_type(caps);
602 if (!(caps & AC_WCAP_IN_AMP))
604 if (type == AC_WID_PIN && idx > 0) /* only for input pins */
609 /* can have the amp-out capability? */
610 static bool has_amp_out(struct hda_codec *codec, struct nid_path *path, int idx)
612 hda_nid_t nid = path->path[idx];
613 unsigned int caps = get_wcaps(codec, nid);
614 unsigned int type = get_wcaps_type(caps);
616 if (!(caps & AC_WCAP_OUT_AMP))
618 if (type == AC_WID_PIN && !idx) /* only for output pins */
623 /* check whether the given (nid,dir,idx) is active */
624 static bool is_active_nid(struct hda_codec *codec, hda_nid_t nid,
625 unsigned int dir, unsigned int idx)
627 struct hda_gen_spec *spec = codec->spec;
628 int type = get_wcaps_type(get_wcaps(codec, nid));
629 const struct nid_path *path;
632 if (nid == codec->core.afg)
635 snd_array_for_each(&spec->paths, n, path) {
638 if (codec->power_save_node) {
639 if (!path->stream_enabled)
641 /* ignore unplugged paths except for DAC/ADC */
642 if (!(path->pin_enabled || path->pin_fixed) &&
643 type != AC_WID_AUD_OUT && type != AC_WID_AUD_IN)
646 for (i = 0; i < path->depth; i++) {
647 if (path->path[i] == nid) {
648 if (dir == HDA_OUTPUT || idx == -1 ||
658 /* check whether the NID is referred by any active paths */
659 #define is_active_nid_for_any(codec, nid) \
660 is_active_nid(codec, nid, HDA_OUTPUT, -1)
662 /* get the default amp value for the target state */
663 static int get_amp_val_to_activate(struct hda_codec *codec, hda_nid_t nid,
664 int dir, unsigned int caps, bool enable)
666 unsigned int val = 0;
668 if (caps & AC_AMPCAP_NUM_STEPS) {
671 val = (caps & AC_AMPCAP_OFFSET) >> AC_AMPCAP_OFFSET_SHIFT;
673 if (caps & (AC_AMPCAP_MUTE | AC_AMPCAP_MIN_MUTE)) {
680 /* is this a stereo widget or a stereo-to-mono mix? */
681 static bool is_stereo_amps(struct hda_codec *codec, hda_nid_t nid, int dir)
683 unsigned int wcaps = get_wcaps(codec, nid);
686 if (wcaps & AC_WCAP_STEREO)
688 if (dir != HDA_INPUT || get_wcaps_type(wcaps) != AC_WID_AUD_MIX)
690 if (snd_hda_get_num_conns(codec, nid) != 1)
692 if (snd_hda_get_connections(codec, nid, &conn, 1) < 0)
694 return !!(get_wcaps(codec, conn) & AC_WCAP_STEREO);
697 /* initialize the amp value (only at the first time) */
698 static void init_amp(struct hda_codec *codec, hda_nid_t nid, int dir, int idx)
700 unsigned int caps = query_amp_caps(codec, nid, dir);
701 int val = get_amp_val_to_activate(codec, nid, dir, caps, false);
703 if (is_stereo_amps(codec, nid, dir))
704 snd_hda_codec_amp_init_stereo(codec, nid, dir, idx, 0xff, val);
706 snd_hda_codec_amp_init(codec, nid, 0, dir, idx, 0xff, val);
709 /* update the amp, doing in stereo or mono depending on NID */
710 static int update_amp(struct hda_codec *codec, hda_nid_t nid, int dir, int idx,
711 unsigned int mask, unsigned int val)
713 if (is_stereo_amps(codec, nid, dir))
714 return snd_hda_codec_amp_stereo(codec, nid, dir, idx,
717 return snd_hda_codec_amp_update(codec, nid, 0, dir, idx,
721 /* calculate amp value mask we can modify;
722 * if the given amp is controlled by mixers, don't touch it
724 static unsigned int get_amp_mask_to_modify(struct hda_codec *codec,
725 hda_nid_t nid, int dir, int idx,
728 unsigned int mask = 0xff;
730 if (caps & (AC_AMPCAP_MUTE | AC_AMPCAP_MIN_MUTE)) {
731 if (is_ctl_associated(codec, nid, dir, idx, NID_PATH_MUTE_CTL))
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))
742 static void activate_amp(struct hda_codec *codec, hda_nid_t nid, int dir,
743 int idx, int idx_to_check, bool enable)
746 unsigned int mask, val;
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);
755 update_amp(codec, nid, dir, idx, mask, val);
758 static void check_and_activate_amp(struct hda_codec *codec, hda_nid_t nid,
759 int dir, int idx, int idx_to_check,
762 /* check whether the given amp is still used by others */
763 if (!enable && is_active_nid(codec, nid, dir, idx_to_check))
765 activate_amp(codec, nid, dir, idx, idx_to_check, enable);
768 static void activate_amp_out(struct hda_codec *codec, struct nid_path *path,
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);
776 static void activate_amp_in(struct hda_codec *codec, struct nid_path *path,
777 int i, bool enable, bool add_aamix)
779 struct hda_gen_spec *spec = codec->spec;
780 const hda_nid_t *conn;
783 hda_nid_t nid = path->path[i];
785 nums = snd_hda_get_conn_list(codec, nid, &conn);
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)) {
796 for (n = 0; n < nums; n++)
797 init_amp(codec, nid, HDA_INPUT, n);
799 /* here is a little bit tricky in comparison with activate_amp_out();
800 * when aa-mixer is available, we need to enable the path as well
802 for (n = 0; n < nums; n++) {
804 if (conn[n] != spec->mixer_merge_nid)
806 /* when aamix is disabled, force to off */
808 activate_amp(codec, nid, HDA_INPUT, n, n, false);
812 check_and_activate_amp(codec, nid, HDA_INPUT, n, idx, enable);
816 /* sync power of each widget in the given path */
817 static hda_nid_t path_power_update(struct hda_codec *codec,
818 struct nid_path *path,
819 bool allow_powerdown)
821 hda_nid_t nid, changed = 0;
824 for (i = 0; i < path->depth; i++) {
826 if (!(get_wcaps(codec, nid) & AC_WCAP_POWER))
828 if (nid == codec->core.afg)
830 if (!allow_powerdown || is_active_nid_for_any(codec, nid))
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);
840 /* all known codecs seem to be capable to handl
841 * widgets state even in D3, so far.
842 * if any new codecs need to restore the widget
843 * states after D0 transition, call the function
847 if (state == AC_PWRST_D0)
848 snd_hdac_regmap_sync_node(&codec->core, nid);
855 /* do sync with the last power state change */
856 static void sync_power_state_change(struct hda_codec *codec, hda_nid_t nid)
860 snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_POWER_STATE, 0);
865 * snd_hda_activate_path - activate or deactivate the given path
866 * @codec: the HDA codec
867 * @path: the path to activate/deactivate
868 * @enable: flag to activate or not
869 * @add_aamix: enable the input from aamix NID
871 * If @add_aamix is set, enable the input from aa-mix NID as well (if any).
873 void snd_hda_activate_path(struct hda_codec *codec, struct nid_path *path,
874 bool enable, bool add_aamix)
876 struct hda_gen_spec *spec = codec->spec;
879 path->active = enable;
881 /* make sure the widget is powered up */
882 if (enable && (spec->power_down_unused || codec->power_save_node))
883 path_power_update(codec, path, codec->power_save_node);
885 for (i = path->depth - 1; i >= 0; i--) {
886 hda_nid_t nid = path->path[i];
888 if (enable && path->multi[i])
889 snd_hda_codec_write_cache(codec, nid, 0,
890 AC_VERB_SET_CONNECT_SEL,
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);
898 EXPORT_SYMBOL_GPL(snd_hda_activate_path);
900 /* if the given path is inactive, put widgets into D3 (only if suitable) */
901 static void path_power_down_sync(struct hda_codec *codec, struct nid_path *path)
903 struct hda_gen_spec *spec = codec->spec;
905 if (!(spec->power_down_unused || codec->power_save_node) || path->active)
907 sync_power_state_change(codec, path_power_update(codec, path, true));
910 /* turn on/off EAPD on the given pin */
911 static void set_pin_eapd(struct hda_codec *codec, hda_nid_t pin, bool enable)
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))
917 if (spec->keep_eapd_on && !enable)
921 snd_hda_codec_write_cache(codec, pin, 0,
922 AC_VERB_SET_EAPD_BTLENABLE,
923 enable ? 0x02 : 0x00);
926 /* re-initialize the path specified by the given path index */
927 static void resume_path_from_idx(struct hda_codec *codec, int path_idx)
929 struct nid_path *path = snd_hda_get_path_from_idx(codec, path_idx);
931 snd_hda_activate_path(codec, path, path->active, false);
936 * Helper functions for creating mixer ctl elements
939 static int hda_gen_mixer_mute_put(struct snd_kcontrol *kcontrol,
940 struct snd_ctl_elem_value *ucontrol);
941 static int hda_gen_bind_mute_get(struct snd_kcontrol *kcontrol,
942 struct snd_ctl_elem_value *ucontrol);
943 static int hda_gen_bind_mute_put(struct snd_kcontrol *kcontrol,
944 struct snd_ctl_elem_value *ucontrol);
951 static const struct snd_kcontrol_new control_templates[] = {
952 HDA_CODEC_VOLUME(NULL, 0, 0, 0),
953 /* only the put callback is replaced for handling the special mute */
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, /* replaced */
960 .private_value = HDA_COMPOSE_AMP_VAL(0, 3, 0, 0),
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, /* replaced */
967 .private_value = HDA_COMPOSE_AMP_VAL(0, 3, 0, 0),
971 /* add dynamic controls from template */
972 static struct snd_kcontrol_new *
973 add_control(struct hda_gen_spec *spec, int type, const char *name,
974 int cidx, unsigned long val)
976 struct snd_kcontrol_new *knew;
978 knew = snd_hda_gen_add_kctl(spec, name, &control_templates[type]);
982 if (get_amp_nid_(val))
983 knew->subdevice = HDA_SUBDEV_AMP_FLAG;
984 knew->private_value = val;
988 static int add_control_with_pfx(struct hda_gen_spec *spec, int type,
989 const char *pfx, const char *dir,
990 const char *sfx, int cidx, unsigned long val)
992 char name[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];
993 snprintf(name, sizeof(name), "%s %s %s", pfx, dir, sfx);
994 if (!add_control(spec, type, name, cidx, val))
999 #define add_pb_vol_ctrl(spec, type, pfx, val) \
1000 add_control_with_pfx(spec, type, pfx, "Playback", "Volume", 0, val)
1001 #define add_pb_sw_ctrl(spec, type, pfx, val) \
1002 add_control_with_pfx(spec, type, pfx, "Playback", "Switch", 0, val)
1003 #define __add_pb_vol_ctrl(spec, type, pfx, cidx, val) \
1004 add_control_with_pfx(spec, type, pfx, "Playback", "Volume", cidx, val)
1005 #define __add_pb_sw_ctrl(spec, type, pfx, cidx, val) \
1006 add_control_with_pfx(spec, type, pfx, "Playback", "Switch", cidx, val)
1008 static int add_vol_ctl(struct hda_codec *codec, const char *pfx, int cidx,
1009 unsigned int chs, struct nid_path *path)
1014 val = path->ctls[NID_PATH_VOL_CTL];
1017 val = amp_val_replace_channels(val, chs);
1018 return __add_pb_vol_ctrl(codec->spec, HDA_CTL_WIDGET_VOL, pfx, cidx, val);
1021 /* return the channel bits suitable for the given path->ctls[] */
1022 static int get_default_ch_nums(struct hda_codec *codec, struct nid_path *path,
1025 int chs = 1; /* mono (left only) */
1027 hda_nid_t nid = get_amp_nid_(path->ctls[type]);
1028 if (nid && (get_wcaps(codec, nid) & AC_WCAP_STEREO))
1029 chs = 3; /* stereo */
1034 static int add_stereo_vol(struct hda_codec *codec, const char *pfx, int cidx,
1035 struct nid_path *path)
1037 int chs = get_default_ch_nums(codec, path, NID_PATH_VOL_CTL);
1038 return add_vol_ctl(codec, pfx, cidx, chs, path);
1041 /* create a mute-switch for the given mixer widget;
1042 * if it has multiple sources (e.g. DAC and loopback), create a bind-mute
1044 static int add_sw_ctl(struct hda_codec *codec, const char *pfx, int cidx,
1045 unsigned int chs, struct nid_path *path)
1048 int type = HDA_CTL_WIDGET_MUTE;
1052 val = path->ctls[NID_PATH_MUTE_CTL];
1055 val = amp_val_replace_channels(val, chs);
1056 if (get_amp_direction_(val) == HDA_INPUT) {
1057 hda_nid_t nid = get_amp_nid_(val);
1058 int nums = snd_hda_get_num_conns(codec, nid);
1060 type = HDA_CTL_BIND_MUTE;
1064 return __add_pb_sw_ctrl(codec->spec, type, pfx, cidx, val);
1067 static int add_stereo_sw(struct hda_codec *codec, const char *pfx,
1068 int cidx, struct nid_path *path)
1070 int chs = get_default_ch_nums(codec, path, NID_PATH_MUTE_CTL);
1071 return add_sw_ctl(codec, pfx, cidx, chs, path);
1074 /* playback mute control with the software mute bit check */
1075 static void sync_auto_mute_bits(struct snd_kcontrol *kcontrol,
1076 struct snd_ctl_elem_value *ucontrol)
1078 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1079 struct hda_gen_spec *spec = codec->spec;
1081 if (spec->auto_mute_via_amp) {
1082 hda_nid_t nid = get_amp_nid(kcontrol);
1083 bool enabled = !((spec->mute_bits >> nid) & 1);
1084 ucontrol->value.integer.value[0] &= enabled;
1085 ucontrol->value.integer.value[1] &= enabled;
1089 static int hda_gen_mixer_mute_put(struct snd_kcontrol *kcontrol,
1090 struct snd_ctl_elem_value *ucontrol)
1092 sync_auto_mute_bits(kcontrol, ucontrol);
1093 return snd_hda_mixer_amp_switch_put(kcontrol, ucontrol);
1097 * Bound mute controls
1099 #define AMP_VAL_IDX_SHIFT 19
1100 #define AMP_VAL_IDX_MASK (0x0f<<19)
1102 static int hda_gen_bind_mute_get(struct snd_kcontrol *kcontrol,
1103 struct snd_ctl_elem_value *ucontrol)
1105 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1109 mutex_lock(&codec->control_mutex);
1110 pval = kcontrol->private_value;
1111 kcontrol->private_value = pval & ~AMP_VAL_IDX_MASK; /* index 0 */
1112 err = snd_hda_mixer_amp_switch_get(kcontrol, ucontrol);
1113 kcontrol->private_value = pval;
1114 mutex_unlock(&codec->control_mutex);
1118 static int hda_gen_bind_mute_put(struct snd_kcontrol *kcontrol,
1119 struct snd_ctl_elem_value *ucontrol)
1121 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1123 int i, indices, err = 0, change = 0;
1125 sync_auto_mute_bits(kcontrol, ucontrol);
1127 mutex_lock(&codec->control_mutex);
1128 pval = kcontrol->private_value;
1129 indices = (pval & AMP_VAL_IDX_MASK) >> AMP_VAL_IDX_SHIFT;
1130 for (i = 0; i < indices; i++) {
1131 kcontrol->private_value = (pval & ~AMP_VAL_IDX_MASK) |
1132 (i << AMP_VAL_IDX_SHIFT);
1133 err = snd_hda_mixer_amp_switch_put(kcontrol, ucontrol);
1138 kcontrol->private_value = pval;
1139 mutex_unlock(&codec->control_mutex);
1140 return err < 0 ? err : change;
1143 /* any ctl assigned to the path with the given index? */
1144 static bool path_has_mixer(struct hda_codec *codec, int path_idx, int ctl_type)
1146 struct nid_path *path = snd_hda_get_path_from_idx(codec, path_idx);
1147 return path && path->ctls[ctl_type];
1150 static const char * const channel_name[] = {
1151 "Front", "Surround", "CLFE", "Side", "Back",
1154 /* give some appropriate ctl name prefix for the given line out channel */
1155 static const char *get_line_out_pfx(struct hda_codec *codec, int ch,
1156 int *index, int ctl_type)
1158 struct hda_gen_spec *spec = codec->spec;
1159 struct auto_pin_cfg *cfg = &spec->autocfg;
1162 if (cfg->line_outs == 1 && !spec->multi_ios &&
1163 !codec->force_pin_prefix &&
1164 !cfg->hp_outs && !cfg->speaker_outs)
1165 return spec->vmaster_mute.hook ? "PCM" : "Master";
1167 /* if there is really a single DAC used in the whole output paths,
1168 * use it master (or "PCM" if a vmaster hook is present)
1170 if (spec->multiout.num_dacs == 1 && !spec->mixer_nid &&
1171 !codec->force_pin_prefix &&
1172 !spec->multiout.hp_out_nid[0] && !spec->multiout.extra_out_nid[0])
1173 return spec->vmaster_mute.hook ? "PCM" : "Master";
1175 /* multi-io channels */
1176 if (ch >= cfg->line_outs)
1179 switch (cfg->line_out_type) {
1180 case AUTO_PIN_SPEAKER_OUT:
1181 /* if the primary channel vol/mute is shared with HP volume,
1182 * don't name it as Speaker
1184 if (!ch && cfg->hp_outs &&
1185 !path_has_mixer(codec, spec->hp_paths[0], ctl_type))
1187 if (cfg->line_outs == 1)
1189 if (cfg->line_outs == 2)
1190 return ch ? "Bass Speaker" : "Speaker";
1192 case AUTO_PIN_HP_OUT:
1193 /* if the primary channel vol/mute is shared with spk volume,
1194 * don't name it as Headphone
1196 if (!ch && cfg->speaker_outs &&
1197 !path_has_mixer(codec, spec->speaker_paths[0], ctl_type))
1199 /* for multi-io case, only the primary out */
1200 if (ch && spec->multi_ios)
1204 case AUTO_PIN_LINE_OUT:
1205 /* This deals with the case where one HP or one Speaker or
1206 * one HP + one Speaker need to share the DAC with LO
1209 bool hp_lo_shared = false, spk_lo_shared = false;
1211 if (cfg->speaker_outs)
1212 spk_lo_shared = !path_has_mixer(codec,
1213 spec->speaker_paths[0], ctl_type);
1215 hp_lo_shared = !path_has_mixer(codec, spec->hp_paths[0], ctl_type);
1216 if (hp_lo_shared && spk_lo_shared)
1217 return spec->vmaster_mute.hook ? "PCM" : "Master";
1219 return "Headphone+LO";
1221 return "Speaker+LO";
1225 /* for a single channel output, we don't have to name the channel */
1226 if (cfg->line_outs == 1 && !spec->multi_ios)
1230 if (ch >= ARRAY_SIZE(channel_name)) {
1235 return channel_name[ch];
1239 * Parse output paths
1242 /* badness definition */
1244 /* No primary DAC is found for the main output */
1245 BAD_NO_PRIMARY_DAC = 0x10000,
1246 /* No DAC is found for the extra output */
1247 BAD_NO_DAC = 0x4000,
1248 /* No possible multi-ios */
1249 BAD_MULTI_IO = 0x120,
1250 /* No individual DAC for extra output */
1251 BAD_NO_EXTRA_DAC = 0x102,
1252 /* No individual DAC for extra surrounds */
1253 BAD_NO_EXTRA_SURR_DAC = 0x101,
1254 /* Primary DAC shared with main surrounds */
1255 BAD_SHARED_SURROUND = 0x100,
1256 /* No independent HP possible */
1257 BAD_NO_INDEP_HP = 0x10,
1258 /* Primary DAC shared with main CLFE */
1259 BAD_SHARED_CLFE = 0x10,
1260 /* Primary DAC shared with extra surrounds */
1261 BAD_SHARED_EXTRA_SURROUND = 0x10,
1262 /* Volume widget is shared */
1263 BAD_SHARED_VOL = 0x10,
1266 /* look for widgets in the given path which are appropriate for
1267 * volume and mute controls, and assign the values to ctls[].
1269 * When no appropriate widget is found in the path, the badness value
1270 * is incremented depending on the situation. The function returns the
1271 * total badness for both volume and mute controls.
1273 static int assign_out_path_ctls(struct hda_codec *codec, struct nid_path *path)
1275 struct hda_gen_spec *spec = codec->spec;
1281 return BAD_SHARED_VOL * 2;
1283 if (path->ctls[NID_PATH_VOL_CTL] ||
1284 path->ctls[NID_PATH_MUTE_CTL])
1285 return 0; /* already evaluated */
1287 nid = look_for_out_vol_nid(codec, path);
1289 val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
1290 if (spec->dac_min_mute)
1291 val |= HDA_AMP_VAL_MIN_MUTE;
1292 if (is_ctl_used(codec, val, NID_PATH_VOL_CTL))
1293 badness += BAD_SHARED_VOL;
1295 path->ctls[NID_PATH_VOL_CTL] = val;
1297 badness += BAD_SHARED_VOL;
1298 nid = look_for_out_mute_nid(codec, path);
1300 unsigned int wid_type = get_wcaps_type(get_wcaps(codec, nid));
1301 if (wid_type == AC_WID_PIN || wid_type == AC_WID_AUD_OUT ||
1302 nid_has_mute(codec, nid, HDA_OUTPUT))
1303 val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
1305 val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT);
1306 if (is_ctl_used(codec, val, NID_PATH_MUTE_CTL))
1307 badness += BAD_SHARED_VOL;
1309 path->ctls[NID_PATH_MUTE_CTL] = val;
1311 badness += BAD_SHARED_VOL;
1315 const struct badness_table hda_main_out_badness = {
1316 .no_primary_dac = BAD_NO_PRIMARY_DAC,
1317 .no_dac = BAD_NO_DAC,
1318 .shared_primary = BAD_NO_PRIMARY_DAC,
1319 .shared_surr = BAD_SHARED_SURROUND,
1320 .shared_clfe = BAD_SHARED_CLFE,
1321 .shared_surr_main = BAD_SHARED_SURROUND,
1323 EXPORT_SYMBOL_GPL(hda_main_out_badness);
1325 const struct badness_table hda_extra_out_badness = {
1326 .no_primary_dac = BAD_NO_DAC,
1327 .no_dac = BAD_NO_DAC,
1328 .shared_primary = BAD_NO_EXTRA_DAC,
1329 .shared_surr = BAD_SHARED_EXTRA_SURROUND,
1330 .shared_clfe = BAD_SHARED_EXTRA_SURROUND,
1331 .shared_surr_main = BAD_NO_EXTRA_SURR_DAC,
1333 EXPORT_SYMBOL_GPL(hda_extra_out_badness);
1335 /* get the DAC of the primary output corresponding to the given array index */
1336 static hda_nid_t get_primary_out(struct hda_codec *codec, int idx)
1338 struct hda_gen_spec *spec = codec->spec;
1339 struct auto_pin_cfg *cfg = &spec->autocfg;
1341 if (cfg->line_outs > idx)
1342 return spec->private_dac_nids[idx];
1343 idx -= cfg->line_outs;
1344 if (spec->multi_ios > idx)
1345 return spec->multi_io[idx].dac;
1349 /* return the DAC if it's reachable, otherwise zero */
1350 static inline hda_nid_t try_dac(struct hda_codec *codec,
1351 hda_nid_t dac, hda_nid_t pin)
1353 return is_reachable_path(codec, dac, pin) ? dac : 0;
1356 /* try to assign DACs to pins and return the resultant badness */
1357 static int try_assign_dacs(struct hda_codec *codec, int num_outs,
1358 const hda_nid_t *pins, hda_nid_t *dacs,
1360 const struct badness_table *bad)
1362 struct hda_gen_spec *spec = codec->spec;
1370 for (i = 0; i < num_outs; i++) {
1371 struct nid_path *path;
1372 hda_nid_t pin = pins[i];
1374 if (!spec->obey_preferred_dacs) {
1375 path = snd_hda_get_path_from_idx(codec, path_idx[i]);
1377 badness += assign_out_path_ctls(codec, path);
1382 dacs[i] = get_preferred_dac(codec, pin);
1384 if (is_dac_already_used(codec, dacs[i]))
1385 badness += bad->shared_primary;
1386 } else if (spec->obey_preferred_dacs) {
1387 badness += BAD_NO_PRIMARY_DAC;
1391 dacs[i] = look_for_dac(codec, pin, false);
1392 if (!dacs[i] && !i) {
1393 /* try to steal the DAC of surrounds for the front */
1394 for (j = 1; j < num_outs; j++) {
1395 if (is_reachable_path(codec, dacs[j], pin)) {
1398 invalidate_nid_path(codec, path_idx[j]);
1407 dac = try_dac(codec, get_primary_out(codec, i), pin);
1409 dac = try_dac(codec, dacs[0], pin);
1411 dac = try_dac(codec, get_primary_out(codec, i), pin);
1414 badness += bad->shared_primary;
1416 badness += bad->shared_surr;
1418 badness += bad->shared_clfe;
1419 } else if (is_reachable_path(codec, spec->private_dac_nids[0], pin)) {
1420 dac = spec->private_dac_nids[0];
1421 badness += bad->shared_surr_main;
1423 badness += bad->no_primary_dac;
1425 badness += bad->no_dac;
1429 path = snd_hda_add_new_path(codec, dac, pin, -spec->mixer_nid);
1430 if (!path && !i && spec->mixer_nid) {
1431 /* try with aamix */
1432 path = snd_hda_add_new_path(codec, dac, pin, 0);
1436 badness += bad->no_dac;
1438 /* print_nid_path(codec, "output", path); */
1439 path->active = true;
1440 path_idx[i] = snd_hda_get_path_idx(codec, path);
1441 badness += assign_out_path_ctls(codec, path);
1448 /* return NID if the given pin has only a single connection to a certain DAC */
1449 static hda_nid_t get_dac_if_single(struct hda_codec *codec, hda_nid_t pin)
1451 struct hda_gen_spec *spec = codec->spec;
1453 hda_nid_t nid_found = 0;
1455 for (i = 0; i < spec->num_all_dacs; i++) {
1456 hda_nid_t nid = spec->all_dacs[i];
1457 if (!nid || is_dac_already_used(codec, nid))
1459 if (is_reachable_path(codec, nid, pin)) {
1468 /* check whether the given pin can be a multi-io pin */
1469 static bool can_be_multiio_pin(struct hda_codec *codec,
1470 unsigned int location, hda_nid_t nid)
1472 unsigned int defcfg, caps;
1474 defcfg = snd_hda_codec_get_pincfg(codec, nid);
1475 if (get_defcfg_connect(defcfg) != AC_JACK_PORT_COMPLEX)
1477 if (location && get_defcfg_location(defcfg) != location)
1479 caps = snd_hda_query_pin_caps(codec, nid);
1480 if (!(caps & AC_PINCAP_OUT))
1485 /* count the number of input pins that are capable to be multi-io */
1486 static int count_multiio_pins(struct hda_codec *codec, hda_nid_t reference_pin)
1488 struct hda_gen_spec *spec = codec->spec;
1489 struct auto_pin_cfg *cfg = &spec->autocfg;
1490 unsigned int defcfg = snd_hda_codec_get_pincfg(codec, reference_pin);
1491 unsigned int location = get_defcfg_location(defcfg);
1495 for (type = AUTO_PIN_LINE_IN; type >= AUTO_PIN_MIC; type--) {
1496 for (i = 0; i < cfg->num_inputs; i++) {
1497 if (cfg->inputs[i].type != type)
1499 if (can_be_multiio_pin(codec, location,
1500 cfg->inputs[i].pin))
1510 * When hardwired is set, try to fill ony hardwired pins, and returns
1511 * zero if any pins are filled, non-zero if nothing found.
1512 * When hardwired is off, try to fill possible input pins, and returns
1513 * the badness value.
1515 static int fill_multi_ios(struct hda_codec *codec,
1516 hda_nid_t reference_pin,
1519 struct hda_gen_spec *spec = codec->spec;
1520 struct auto_pin_cfg *cfg = &spec->autocfg;
1521 int type, i, j, num_pins, old_pins;
1522 unsigned int defcfg = snd_hda_codec_get_pincfg(codec, reference_pin);
1523 unsigned int location = get_defcfg_location(defcfg);
1525 struct nid_path *path;
1527 old_pins = spec->multi_ios;
1531 num_pins = count_multiio_pins(codec, reference_pin);
1535 for (type = AUTO_PIN_LINE_IN; type >= AUTO_PIN_MIC; type--) {
1536 for (i = 0; i < cfg->num_inputs; i++) {
1537 hda_nid_t nid = cfg->inputs[i].pin;
1540 if (cfg->inputs[i].type != type)
1542 if (!can_be_multiio_pin(codec, location, nid))
1544 for (j = 0; j < spec->multi_ios; j++) {
1545 if (nid == spec->multi_io[j].pin)
1548 if (j < spec->multi_ios)
1552 dac = get_dac_if_single(codec, nid);
1554 dac = look_for_dac(codec, nid, false);
1559 path = snd_hda_add_new_path(codec, dac, nid,
1565 /* print_nid_path(codec, "multiio", path); */
1566 spec->multi_io[spec->multi_ios].pin = nid;
1567 spec->multi_io[spec->multi_ios].dac = dac;
1568 spec->out_paths[cfg->line_outs + spec->multi_ios] =
1569 snd_hda_get_path_idx(codec, path);
1571 if (spec->multi_ios >= 2)
1577 badness = BAD_MULTI_IO;
1578 if (old_pins == spec->multi_ios) {
1580 return 1; /* nothing found */
1582 return badness; /* no badness if nothing found */
1584 if (!hardwired && spec->multi_ios < 2) {
1585 /* cancel newly assigned paths */
1586 spec->paths.used -= spec->multi_ios - old_pins;
1587 spec->multi_ios = old_pins;
1591 /* assign volume and mute controls */
1592 for (i = old_pins; i < spec->multi_ios; i++) {
1593 path = snd_hda_get_path_from_idx(codec, spec->out_paths[cfg->line_outs + i]);
1594 badness += assign_out_path_ctls(codec, path);
1600 /* map DACs for all pins in the list if they are single connections */
1601 static bool map_singles(struct hda_codec *codec, int outs,
1602 const hda_nid_t *pins, hda_nid_t *dacs, int *path_idx)
1604 struct hda_gen_spec *spec = codec->spec;
1607 for (i = 0; i < outs; i++) {
1608 struct nid_path *path;
1612 dac = get_dac_if_single(codec, pins[i]);
1615 path = snd_hda_add_new_path(codec, dac, pins[i],
1617 if (!path && !i && spec->mixer_nid)
1618 path = snd_hda_add_new_path(codec, dac, pins[i], 0);
1622 /* print_nid_path(codec, "output", path); */
1623 path->active = true;
1624 path_idx[i] = snd_hda_get_path_idx(codec, path);
1630 static inline bool has_aamix_out_paths(struct hda_gen_spec *spec)
1632 return spec->aamix_out_paths[0] || spec->aamix_out_paths[1] ||
1633 spec->aamix_out_paths[2];
1636 /* create a new path including aamix if available, and return its index */
1637 static int check_aamix_out_path(struct hda_codec *codec, int path_idx)
1639 struct hda_gen_spec *spec = codec->spec;
1640 struct nid_path *path;
1641 hda_nid_t path_dac, dac, pin;
1643 path = snd_hda_get_path_from_idx(codec, path_idx);
1644 if (!path || !path->depth ||
1645 is_nid_contained(path, spec->mixer_nid))
1647 path_dac = path->path[0];
1648 dac = spec->private_dac_nids[0];
1649 pin = path->path[path->depth - 1];
1650 path = snd_hda_add_new_path(codec, dac, pin, spec->mixer_nid);
1652 if (dac != path_dac)
1654 else if (spec->multiout.hp_out_nid[0])
1655 dac = spec->multiout.hp_out_nid[0];
1656 else if (spec->multiout.extra_out_nid[0])
1657 dac = spec->multiout.extra_out_nid[0];
1661 path = snd_hda_add_new_path(codec, dac, pin,
1666 /* print_nid_path(codec, "output-aamix", path); */
1667 path->active = false; /* unused as default */
1668 path->pin_fixed = true; /* static route */
1669 return snd_hda_get_path_idx(codec, path);
1672 /* check whether the independent HP is available with the current config */
1673 static bool indep_hp_possible(struct hda_codec *codec)
1675 struct hda_gen_spec *spec = codec->spec;
1676 struct auto_pin_cfg *cfg = &spec->autocfg;
1677 struct nid_path *path;
1680 if (cfg->line_out_type == AUTO_PIN_HP_OUT)
1681 idx = spec->out_paths[0];
1683 idx = spec->hp_paths[0];
1684 path = snd_hda_get_path_from_idx(codec, idx);
1688 /* assume no path conflicts unless aamix is involved */
1689 if (!spec->mixer_nid || !is_nid_contained(path, spec->mixer_nid))
1692 /* check whether output paths contain aamix */
1693 for (i = 0; i < cfg->line_outs; i++) {
1694 if (spec->out_paths[i] == idx)
1696 path = snd_hda_get_path_from_idx(codec, spec->out_paths[i]);
1697 if (path && is_nid_contained(path, spec->mixer_nid))
1700 for (i = 0; i < cfg->speaker_outs; i++) {
1701 path = snd_hda_get_path_from_idx(codec, spec->speaker_paths[i]);
1702 if (path && is_nid_contained(path, spec->mixer_nid))
1709 /* fill the empty entries in the dac array for speaker/hp with the
1710 * shared dac pointed by the paths
1712 static void refill_shared_dacs(struct hda_codec *codec, int num_outs,
1713 hda_nid_t *dacs, int *path_idx)
1715 struct nid_path *path;
1718 for (i = 0; i < num_outs; i++) {
1721 path = snd_hda_get_path_from_idx(codec, path_idx[i]);
1724 dacs[i] = path->path[0];
1728 /* fill in the dac_nids table from the parsed pin configuration */
1729 static int fill_and_eval_dacs(struct hda_codec *codec,
1730 bool fill_hardwired,
1731 bool fill_mio_first)
1733 struct hda_gen_spec *spec = codec->spec;
1734 struct auto_pin_cfg *cfg = &spec->autocfg;
1735 int i, err, badness;
1737 /* set num_dacs once to full for look_for_dac() */
1738 spec->multiout.num_dacs = cfg->line_outs;
1739 spec->multiout.dac_nids = spec->private_dac_nids;
1740 memset(spec->private_dac_nids, 0, sizeof(spec->private_dac_nids));
1741 memset(spec->multiout.hp_out_nid, 0, sizeof(spec->multiout.hp_out_nid));
1742 memset(spec->multiout.extra_out_nid, 0, sizeof(spec->multiout.extra_out_nid));
1743 spec->multi_ios = 0;
1744 snd_array_free(&spec->paths);
1746 /* clear path indices */
1747 memset(spec->out_paths, 0, sizeof(spec->out_paths));
1748 memset(spec->hp_paths, 0, sizeof(spec->hp_paths));
1749 memset(spec->speaker_paths, 0, sizeof(spec->speaker_paths));
1750 memset(spec->aamix_out_paths, 0, sizeof(spec->aamix_out_paths));
1751 memset(spec->digout_paths, 0, sizeof(spec->digout_paths));
1752 memset(spec->input_paths, 0, sizeof(spec->input_paths));
1753 memset(spec->loopback_paths, 0, sizeof(spec->loopback_paths));
1754 memset(&spec->digin_path, 0, sizeof(spec->digin_path));
1758 /* fill hard-wired DACs first */
1759 if (fill_hardwired) {
1762 mapped = map_singles(codec, cfg->line_outs,
1764 spec->private_dac_nids,
1766 mapped |= map_singles(codec, cfg->hp_outs,
1768 spec->multiout.hp_out_nid,
1770 mapped |= map_singles(codec, cfg->speaker_outs,
1772 spec->multiout.extra_out_nid,
1773 spec->speaker_paths);
1774 if (!spec->no_multi_io &&
1775 fill_mio_first && cfg->line_outs == 1 &&
1776 cfg->line_out_type != AUTO_PIN_SPEAKER_OUT) {
1777 err = fill_multi_ios(codec, cfg->line_out_pins[0], true);
1784 badness += try_assign_dacs(codec, cfg->line_outs, cfg->line_out_pins,
1785 spec->private_dac_nids, spec->out_paths,
1786 spec->main_out_badness);
1788 if (!spec->no_multi_io && fill_mio_first &&
1789 cfg->line_outs == 1 && cfg->line_out_type != AUTO_PIN_SPEAKER_OUT) {
1790 /* try to fill multi-io first */
1791 err = fill_multi_ios(codec, cfg->line_out_pins[0], false);
1794 /* we don't count badness at this stage yet */
1797 if (cfg->line_out_type != AUTO_PIN_HP_OUT) {
1798 err = try_assign_dacs(codec, cfg->hp_outs, cfg->hp_pins,
1799 spec->multiout.hp_out_nid,
1801 spec->extra_out_badness);
1806 if (cfg->line_out_type != AUTO_PIN_SPEAKER_OUT) {
1807 err = try_assign_dacs(codec, cfg->speaker_outs,
1809 spec->multiout.extra_out_nid,
1810 spec->speaker_paths,
1811 spec->extra_out_badness);
1816 if (!spec->no_multi_io &&
1817 cfg->line_outs == 1 && cfg->line_out_type != AUTO_PIN_SPEAKER_OUT) {
1818 err = fill_multi_ios(codec, cfg->line_out_pins[0], false);
1824 if (spec->mixer_nid) {
1825 spec->aamix_out_paths[0] =
1826 check_aamix_out_path(codec, spec->out_paths[0]);
1827 if (cfg->line_out_type != AUTO_PIN_HP_OUT)
1828 spec->aamix_out_paths[1] =
1829 check_aamix_out_path(codec, spec->hp_paths[0]);
1830 if (cfg->line_out_type != AUTO_PIN_SPEAKER_OUT)
1831 spec->aamix_out_paths[2] =
1832 check_aamix_out_path(codec, spec->speaker_paths[0]);
1835 if (!spec->no_multi_io &&
1836 cfg->hp_outs && cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
1837 if (count_multiio_pins(codec, cfg->hp_pins[0]) >= 2)
1838 spec->multi_ios = 1; /* give badness */
1840 /* re-count num_dacs and squash invalid entries */
1841 spec->multiout.num_dacs = 0;
1842 for (i = 0; i < cfg->line_outs; i++) {
1843 if (spec->private_dac_nids[i])
1844 spec->multiout.num_dacs++;
1846 memmove(spec->private_dac_nids + i,
1847 spec->private_dac_nids + i + 1,
1848 sizeof(hda_nid_t) * (cfg->line_outs - i - 1));
1849 spec->private_dac_nids[cfg->line_outs - 1] = 0;
1853 spec->ext_channel_count = spec->min_channel_count =
1854 spec->multiout.num_dacs * 2;
1856 if (spec->multi_ios == 2) {
1857 for (i = 0; i < 2; i++)
1858 spec->private_dac_nids[spec->multiout.num_dacs++] =
1859 spec->multi_io[i].dac;
1860 } else if (spec->multi_ios) {
1861 spec->multi_ios = 0;
1862 badness += BAD_MULTI_IO;
1865 if (spec->indep_hp && !indep_hp_possible(codec))
1866 badness += BAD_NO_INDEP_HP;
1868 /* re-fill the shared DAC for speaker / headphone */
1869 if (cfg->line_out_type != AUTO_PIN_HP_OUT)
1870 refill_shared_dacs(codec, cfg->hp_outs,
1871 spec->multiout.hp_out_nid,
1873 if (cfg->line_out_type != AUTO_PIN_SPEAKER_OUT)
1874 refill_shared_dacs(codec, cfg->speaker_outs,
1875 spec->multiout.extra_out_nid,
1876 spec->speaker_paths);
1881 #define DEBUG_BADNESS
1883 #ifdef DEBUG_BADNESS
1884 #define debug_badness(fmt, ...) \
1885 codec_dbg(codec, fmt, ##__VA_ARGS__)
1887 #define debug_badness(fmt, ...) \
1888 do { if (0) codec_dbg(codec, fmt, ##__VA_ARGS__); } while (0)
1891 #ifdef DEBUG_BADNESS
1892 static inline void print_nid_path_idx(struct hda_codec *codec,
1893 const char *pfx, int idx)
1895 struct nid_path *path;
1897 path = snd_hda_get_path_from_idx(codec, idx);
1899 print_nid_path(codec, pfx, path);
1902 static void debug_show_configs(struct hda_codec *codec,
1903 struct auto_pin_cfg *cfg)
1905 struct hda_gen_spec *spec = codec->spec;
1906 static const char * const lo_type[3] = { "LO", "SP", "HP" };
1909 debug_badness("multi_outs = %x/%x/%x/%x : %x/%x/%x/%x (type %s)\n",
1910 cfg->line_out_pins[0], cfg->line_out_pins[1],
1911 cfg->line_out_pins[2], cfg->line_out_pins[3],
1912 spec->multiout.dac_nids[0],
1913 spec->multiout.dac_nids[1],
1914 spec->multiout.dac_nids[2],
1915 spec->multiout.dac_nids[3],
1916 lo_type[cfg->line_out_type]);
1917 for (i = 0; i < cfg->line_outs; i++)
1918 print_nid_path_idx(codec, " out", spec->out_paths[i]);
1919 if (spec->multi_ios > 0)
1920 debug_badness("multi_ios(%d) = %x/%x : %x/%x\n",
1922 spec->multi_io[0].pin, spec->multi_io[1].pin,
1923 spec->multi_io[0].dac, spec->multi_io[1].dac);
1924 for (i = 0; i < spec->multi_ios; i++)
1925 print_nid_path_idx(codec, " mio",
1926 spec->out_paths[cfg->line_outs + i]);
1928 debug_badness("hp_outs = %x/%x/%x/%x : %x/%x/%x/%x\n",
1929 cfg->hp_pins[0], cfg->hp_pins[1],
1930 cfg->hp_pins[2], cfg->hp_pins[3],
1931 spec->multiout.hp_out_nid[0],
1932 spec->multiout.hp_out_nid[1],
1933 spec->multiout.hp_out_nid[2],
1934 spec->multiout.hp_out_nid[3]);
1935 for (i = 0; i < cfg->hp_outs; i++)
1936 print_nid_path_idx(codec, " hp ", spec->hp_paths[i]);
1937 if (cfg->speaker_outs)
1938 debug_badness("spk_outs = %x/%x/%x/%x : %x/%x/%x/%x\n",
1939 cfg->speaker_pins[0], cfg->speaker_pins[1],
1940 cfg->speaker_pins[2], cfg->speaker_pins[3],
1941 spec->multiout.extra_out_nid[0],
1942 spec->multiout.extra_out_nid[1],
1943 spec->multiout.extra_out_nid[2],
1944 spec->multiout.extra_out_nid[3]);
1945 for (i = 0; i < cfg->speaker_outs; i++)
1946 print_nid_path_idx(codec, " spk", spec->speaker_paths[i]);
1947 for (i = 0; i < 3; i++)
1948 print_nid_path_idx(codec, " mix", spec->aamix_out_paths[i]);
1951 #define debug_show_configs(codec, cfg) /* NOP */
1954 /* find all available DACs of the codec */
1955 static void fill_all_dac_nids(struct hda_codec *codec)
1957 struct hda_gen_spec *spec = codec->spec;
1960 spec->num_all_dacs = 0;
1961 memset(spec->all_dacs, 0, sizeof(spec->all_dacs));
1962 for_each_hda_codec_node(nid, codec) {
1963 if (get_wcaps_type(get_wcaps(codec, nid)) != AC_WID_AUD_OUT)
1965 if (spec->num_all_dacs >= ARRAY_SIZE(spec->all_dacs)) {
1966 codec_err(codec, "Too many DACs!\n");
1969 spec->all_dacs[spec->num_all_dacs++] = nid;
1973 static int parse_output_paths(struct hda_codec *codec)
1975 struct hda_gen_spec *spec = codec->spec;
1976 struct auto_pin_cfg *cfg = &spec->autocfg;
1977 struct auto_pin_cfg *best_cfg;
1979 int best_badness = INT_MAX;
1981 bool fill_hardwired = true, fill_mio_first = true;
1982 bool best_wired = true, best_mio = true;
1983 bool hp_spk_swapped = false;
1985 best_cfg = kmalloc(sizeof(*best_cfg), GFP_KERNEL);
1991 badness = fill_and_eval_dacs(codec, fill_hardwired,
1997 debug_badness("==> lo_type=%d, wired=%d, mio=%d, badness=0x%x\n",
1998 cfg->line_out_type, fill_hardwired, fill_mio_first,
2000 debug_show_configs(codec, cfg);
2001 if (badness < best_badness) {
2002 best_badness = badness;
2004 best_wired = fill_hardwired;
2005 best_mio = fill_mio_first;
2009 fill_mio_first = !fill_mio_first;
2010 if (!fill_mio_first)
2012 fill_hardwired = !fill_hardwired;
2013 if (!fill_hardwired)
2017 hp_spk_swapped = true;
2018 if (cfg->speaker_outs > 0 &&
2019 cfg->line_out_type == AUTO_PIN_HP_OUT) {
2020 cfg->hp_outs = cfg->line_outs;
2021 memcpy(cfg->hp_pins, cfg->line_out_pins,
2022 sizeof(cfg->hp_pins));
2023 cfg->line_outs = cfg->speaker_outs;
2024 memcpy(cfg->line_out_pins, cfg->speaker_pins,
2025 sizeof(cfg->speaker_pins));
2026 cfg->speaker_outs = 0;
2027 memset(cfg->speaker_pins, 0, sizeof(cfg->speaker_pins));
2028 cfg->line_out_type = AUTO_PIN_SPEAKER_OUT;
2029 fill_hardwired = true;
2032 if (cfg->hp_outs > 0 &&
2033 cfg->line_out_type == AUTO_PIN_SPEAKER_OUT) {
2034 cfg->speaker_outs = cfg->line_outs;
2035 memcpy(cfg->speaker_pins, cfg->line_out_pins,
2036 sizeof(cfg->speaker_pins));
2037 cfg->line_outs = cfg->hp_outs;
2038 memcpy(cfg->line_out_pins, cfg->hp_pins,
2039 sizeof(cfg->hp_pins));
2041 memset(cfg->hp_pins, 0, sizeof(cfg->hp_pins));
2042 cfg->line_out_type = AUTO_PIN_HP_OUT;
2043 fill_hardwired = true;
2050 debug_badness("==> restoring best_cfg\n");
2052 fill_and_eval_dacs(codec, best_wired, best_mio);
2054 debug_badness("==> Best config: lo_type=%d, wired=%d, mio=%d\n",
2055 cfg->line_out_type, best_wired, best_mio);
2056 debug_show_configs(codec, cfg);
2058 if (cfg->line_out_pins[0]) {
2059 struct nid_path *path;
2060 path = snd_hda_get_path_from_idx(codec, spec->out_paths[0]);
2062 spec->vmaster_nid = look_for_out_vol_nid(codec, path);
2063 if (spec->vmaster_nid) {
2064 snd_hda_set_vmaster_tlv(codec, spec->vmaster_nid,
2065 HDA_OUTPUT, spec->vmaster_tlv);
2066 if (spec->dac_min_mute)
2067 spec->vmaster_tlv[SNDRV_CTL_TLVO_DB_SCALE_MUTE_AND_STEP] |= TLV_DB_SCALE_MUTE;
2071 /* set initial pinctl targets */
2072 if (spec->prefer_hp_amp || cfg->line_out_type == AUTO_PIN_HP_OUT)
2076 set_pin_targets(codec, cfg->line_outs, cfg->line_out_pins, val);
2077 if (cfg->line_out_type != AUTO_PIN_HP_OUT)
2078 set_pin_targets(codec, cfg->hp_outs, cfg->hp_pins, PIN_HP);
2079 if (cfg->line_out_type != AUTO_PIN_SPEAKER_OUT) {
2080 val = spec->prefer_hp_amp ? PIN_HP : PIN_OUT;
2081 set_pin_targets(codec, cfg->speaker_outs,
2082 cfg->speaker_pins, val);
2085 /* clear indep_hp flag if not available */
2086 if (spec->indep_hp && !indep_hp_possible(codec))
2093 /* add playback controls from the parsed DAC table */
2094 static int create_multi_out_ctls(struct hda_codec *codec,
2095 const struct auto_pin_cfg *cfg)
2097 struct hda_gen_spec *spec = codec->spec;
2098 int i, err, noutputs;
2100 noutputs = cfg->line_outs;
2101 if (spec->multi_ios > 0 && cfg->line_outs < 3)
2102 noutputs += spec->multi_ios;
2104 for (i = 0; i < noutputs; i++) {
2107 struct nid_path *path;
2109 path = snd_hda_get_path_from_idx(codec, spec->out_paths[i]);
2113 name = get_line_out_pfx(codec, i, &index, NID_PATH_VOL_CTL);
2114 if (!name || !strcmp(name, "CLFE")) {
2116 err = add_vol_ctl(codec, "Center", 0, 1, path);
2119 err = add_vol_ctl(codec, "LFE", 0, 2, path);
2123 err = add_stereo_vol(codec, name, index, path);
2128 name = get_line_out_pfx(codec, i, &index, NID_PATH_MUTE_CTL);
2129 if (!name || !strcmp(name, "CLFE")) {
2130 err = add_sw_ctl(codec, "Center", 0, 1, path);
2133 err = add_sw_ctl(codec, "LFE", 0, 2, path);
2137 err = add_stereo_sw(codec, name, index, path);
2145 static int create_extra_out(struct hda_codec *codec, int path_idx,
2146 const char *pfx, int cidx)
2148 struct nid_path *path;
2151 path = snd_hda_get_path_from_idx(codec, path_idx);
2154 err = add_stereo_vol(codec, pfx, cidx, path);
2157 err = add_stereo_sw(codec, pfx, cidx, path);
2163 /* add playback controls for speaker and HP outputs */
2164 static int create_extra_outs(struct hda_codec *codec, int num_pins,
2165 const int *paths, const char *pfx)
2169 for (i = 0; i < num_pins; i++) {
2171 char tmp[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];
2174 if (num_pins == 2 && i == 1 && !strcmp(pfx, "Speaker"))
2175 name = "Bass Speaker";
2176 else if (num_pins >= 3) {
2177 snprintf(tmp, sizeof(tmp), "%s %s",
2178 pfx, channel_name[i]);
2184 err = create_extra_out(codec, paths[i], name, idx);
2191 static int create_hp_out_ctls(struct hda_codec *codec)
2193 struct hda_gen_spec *spec = codec->spec;
2194 return create_extra_outs(codec, spec->autocfg.hp_outs,
2199 static int create_speaker_out_ctls(struct hda_codec *codec)
2201 struct hda_gen_spec *spec = codec->spec;
2202 return create_extra_outs(codec, spec->autocfg.speaker_outs,
2203 spec->speaker_paths,
2208 * independent HP controls
2211 static void call_hp_automute(struct hda_codec *codec,
2212 struct hda_jack_callback *jack);
2213 static int indep_hp_info(struct snd_kcontrol *kcontrol,
2214 struct snd_ctl_elem_info *uinfo)
2216 return snd_hda_enum_bool_helper_info(kcontrol, uinfo);
2219 static int indep_hp_get(struct snd_kcontrol *kcontrol,
2220 struct snd_ctl_elem_value *ucontrol)
2222 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2223 struct hda_gen_spec *spec = codec->spec;
2224 ucontrol->value.enumerated.item[0] = spec->indep_hp_enabled;
2228 static void update_aamix_paths(struct hda_codec *codec, bool do_mix,
2229 int nomix_path_idx, int mix_path_idx,
2232 static int indep_hp_put(struct snd_kcontrol *kcontrol,
2233 struct snd_ctl_elem_value *ucontrol)
2235 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2236 struct hda_gen_spec *spec = codec->spec;
2237 unsigned int select = ucontrol->value.enumerated.item[0];
2240 mutex_lock(&spec->pcm_mutex);
2241 if (spec->active_streams) {
2246 if (spec->indep_hp_enabled != select) {
2248 if (spec->autocfg.line_out_type == AUTO_PIN_HP_OUT)
2249 dacp = &spec->private_dac_nids[0];
2251 dacp = &spec->multiout.hp_out_nid[0];
2253 /* update HP aamix paths in case it conflicts with indep HP */
2254 if (spec->have_aamix_ctl) {
2255 if (spec->autocfg.line_out_type == AUTO_PIN_HP_OUT)
2256 update_aamix_paths(codec, spec->aamix_mode,
2258 spec->aamix_out_paths[0],
2259 spec->autocfg.line_out_type);
2261 update_aamix_paths(codec, spec->aamix_mode,
2263 spec->aamix_out_paths[1],
2267 spec->indep_hp_enabled = select;
2268 if (spec->indep_hp_enabled)
2271 *dacp = spec->alt_dac_nid;
2273 call_hp_automute(codec, NULL);
2277 mutex_unlock(&spec->pcm_mutex);
2281 static const struct snd_kcontrol_new indep_hp_ctl = {
2282 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2283 .name = "Independent HP",
2284 .info = indep_hp_info,
2285 .get = indep_hp_get,
2286 .put = indep_hp_put,
2290 static int create_indep_hp_ctls(struct hda_codec *codec)
2292 struct hda_gen_spec *spec = codec->spec;
2295 if (!spec->indep_hp)
2297 if (spec->autocfg.line_out_type == AUTO_PIN_HP_OUT)
2298 dac = spec->multiout.dac_nids[0];
2300 dac = spec->multiout.hp_out_nid[0];
2306 spec->indep_hp_enabled = false;
2307 spec->alt_dac_nid = dac;
2308 if (!snd_hda_gen_add_kctl(spec, NULL, &indep_hp_ctl))
2314 * channel mode enum control
2317 static int ch_mode_info(struct snd_kcontrol *kcontrol,
2318 struct snd_ctl_elem_info *uinfo)
2320 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2321 struct hda_gen_spec *spec = codec->spec;
2324 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
2326 uinfo->value.enumerated.items = spec->multi_ios + 1;
2327 if (uinfo->value.enumerated.item > spec->multi_ios)
2328 uinfo->value.enumerated.item = spec->multi_ios;
2329 chs = uinfo->value.enumerated.item * 2 + spec->min_channel_count;
2330 sprintf(uinfo->value.enumerated.name, "%dch", chs);
2334 static int ch_mode_get(struct snd_kcontrol *kcontrol,
2335 struct snd_ctl_elem_value *ucontrol)
2337 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2338 struct hda_gen_spec *spec = codec->spec;
2339 ucontrol->value.enumerated.item[0] =
2340 (spec->ext_channel_count - spec->min_channel_count) / 2;
2344 static inline struct nid_path *
2345 get_multiio_path(struct hda_codec *codec, int idx)
2347 struct hda_gen_spec *spec = codec->spec;
2348 return snd_hda_get_path_from_idx(codec,
2349 spec->out_paths[spec->autocfg.line_outs + idx]);
2352 static void update_automute_all(struct hda_codec *codec);
2354 /* Default value to be passed as aamix argument for snd_hda_activate_path();
2355 * used for output paths
2357 static bool aamix_default(struct hda_gen_spec *spec)
2359 return !spec->have_aamix_ctl || spec->aamix_mode;
2362 static int set_multi_io(struct hda_codec *codec, int idx, bool output)
2364 struct hda_gen_spec *spec = codec->spec;
2365 hda_nid_t nid = spec->multi_io[idx].pin;
2366 struct nid_path *path;
2368 path = get_multiio_path(codec, idx);
2372 if (path->active == output)
2376 set_pin_target(codec, nid, PIN_OUT, true);
2377 snd_hda_activate_path(codec, path, true, aamix_default(spec));
2378 set_pin_eapd(codec, nid, true);
2380 set_pin_eapd(codec, nid, false);
2381 snd_hda_activate_path(codec, path, false, aamix_default(spec));
2382 set_pin_target(codec, nid, spec->multi_io[idx].ctl_in, true);
2383 path_power_down_sync(codec, path);
2386 /* update jack retasking in case it modifies any of them */
2387 update_automute_all(codec);
2392 static int ch_mode_put(struct snd_kcontrol *kcontrol,
2393 struct snd_ctl_elem_value *ucontrol)
2395 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2396 struct hda_gen_spec *spec = codec->spec;
2399 ch = ucontrol->value.enumerated.item[0];
2400 if (ch < 0 || ch > spec->multi_ios)
2402 if (ch == (spec->ext_channel_count - spec->min_channel_count) / 2)
2404 spec->ext_channel_count = ch * 2 + spec->min_channel_count;
2405 for (i = 0; i < spec->multi_ios; i++)
2406 set_multi_io(codec, i, i < ch);
2407 spec->multiout.max_channels = max(spec->ext_channel_count,
2408 spec->const_channel_count);
2409 if (spec->need_dac_fix)
2410 spec->multiout.num_dacs = spec->multiout.max_channels / 2;
2414 static const struct snd_kcontrol_new channel_mode_enum = {
2415 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2416 .name = "Channel Mode",
2417 .info = ch_mode_info,
2422 static int create_multi_channel_mode(struct hda_codec *codec)
2424 struct hda_gen_spec *spec = codec->spec;
2426 if (spec->multi_ios > 0) {
2427 if (!snd_hda_gen_add_kctl(spec, NULL, &channel_mode_enum))
2434 * aamix loopback enable/disable switch
2437 #define loopback_mixing_info indep_hp_info
2439 static int loopback_mixing_get(struct snd_kcontrol *kcontrol,
2440 struct snd_ctl_elem_value *ucontrol)
2442 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2443 struct hda_gen_spec *spec = codec->spec;
2444 ucontrol->value.enumerated.item[0] = spec->aamix_mode;
2448 static void update_aamix_paths(struct hda_codec *codec, bool do_mix,
2449 int nomix_path_idx, int mix_path_idx,
2452 struct hda_gen_spec *spec = codec->spec;
2453 struct nid_path *nomix_path, *mix_path;
2455 nomix_path = snd_hda_get_path_from_idx(codec, nomix_path_idx);
2456 mix_path = snd_hda_get_path_from_idx(codec, mix_path_idx);
2457 if (!nomix_path || !mix_path)
2460 /* if HP aamix path is driven from a different DAC and the
2461 * independent HP mode is ON, can't turn on aamix path
2463 if (out_type == AUTO_PIN_HP_OUT && spec->indep_hp_enabled &&
2464 mix_path->path[0] != spec->alt_dac_nid)
2468 snd_hda_activate_path(codec, nomix_path, false, true);
2469 snd_hda_activate_path(codec, mix_path, true, true);
2470 path_power_down_sync(codec, nomix_path);
2472 snd_hda_activate_path(codec, mix_path, false, false);
2473 snd_hda_activate_path(codec, nomix_path, true, false);
2474 path_power_down_sync(codec, mix_path);
2478 /* re-initialize the output paths; only called from loopback_mixing_put() */
2479 static void update_output_paths(struct hda_codec *codec, int num_outs,
2482 struct hda_gen_spec *spec = codec->spec;
2483 struct nid_path *path;
2486 for (i = 0; i < num_outs; i++) {
2487 path = snd_hda_get_path_from_idx(codec, paths[i]);
2489 snd_hda_activate_path(codec, path, path->active,
2494 static int loopback_mixing_put(struct snd_kcontrol *kcontrol,
2495 struct snd_ctl_elem_value *ucontrol)
2497 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2498 struct hda_gen_spec *spec = codec->spec;
2499 const struct auto_pin_cfg *cfg = &spec->autocfg;
2500 unsigned int val = ucontrol->value.enumerated.item[0];
2502 if (val == spec->aamix_mode)
2504 spec->aamix_mode = val;
2505 if (has_aamix_out_paths(spec)) {
2506 update_aamix_paths(codec, val, spec->out_paths[0],
2507 spec->aamix_out_paths[0],
2508 cfg->line_out_type);
2509 update_aamix_paths(codec, val, spec->hp_paths[0],
2510 spec->aamix_out_paths[1],
2512 update_aamix_paths(codec, val, spec->speaker_paths[0],
2513 spec->aamix_out_paths[2],
2514 AUTO_PIN_SPEAKER_OUT);
2516 update_output_paths(codec, cfg->line_outs, spec->out_paths);
2517 if (cfg->line_out_type != AUTO_PIN_HP_OUT)
2518 update_output_paths(codec, cfg->hp_outs, spec->hp_paths);
2519 if (cfg->line_out_type != AUTO_PIN_SPEAKER_OUT)
2520 update_output_paths(codec, cfg->speaker_outs,
2521 spec->speaker_paths);
2526 static const struct snd_kcontrol_new loopback_mixing_enum = {
2527 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2528 .name = "Loopback Mixing",
2529 .info = loopback_mixing_info,
2530 .get = loopback_mixing_get,
2531 .put = loopback_mixing_put,
2534 static int create_loopback_mixing_ctl(struct hda_codec *codec)
2536 struct hda_gen_spec *spec = codec->spec;
2538 if (!spec->mixer_nid)
2540 if (!snd_hda_gen_add_kctl(spec, NULL, &loopback_mixing_enum))
2542 spec->have_aamix_ctl = 1;
2547 * shared headphone/mic handling
2550 static void call_update_outputs(struct hda_codec *codec);
2552 /* for shared I/O, change the pin-control accordingly */
2553 static void update_hp_mic(struct hda_codec *codec, int adc_mux, bool force)
2555 struct hda_gen_spec *spec = codec->spec;
2560 pin = spec->hp_mic_pin;
2561 as_mic = spec->cur_mux[adc_mux] == spec->hp_mic_mux_idx;
2564 val = snd_hda_codec_get_pin_target(codec, pin);
2574 val = snd_hda_get_default_vref(codec, pin);
2575 /* if the HP pin doesn't support VREF and the codec driver gives an
2576 * alternative pin, set up the VREF on that pin instead
2578 if (val == AC_PINCTL_VREF_HIZ && spec->shared_mic_vref_pin) {
2579 const hda_nid_t vref_pin = spec->shared_mic_vref_pin;
2580 unsigned int vref_val = snd_hda_get_default_vref(codec, vref_pin);
2581 if (vref_val != AC_PINCTL_VREF_HIZ)
2582 snd_hda_set_pin_ctl_cache(codec, vref_pin,
2583 PIN_IN | (as_mic ? vref_val : 0));
2586 if (!spec->hp_mic_jack_modes) {
2591 set_pin_target(codec, pin, val, true);
2592 call_hp_automute(codec, NULL);
2596 /* create a shared input with the headphone out */
2597 static int create_hp_mic(struct hda_codec *codec)
2599 struct hda_gen_spec *spec = codec->spec;
2600 struct auto_pin_cfg *cfg = &spec->autocfg;
2601 unsigned int defcfg;
2604 if (!spec->hp_mic) {
2605 if (spec->suppress_hp_mic_detect)
2607 /* automatic detection: only if no input or a single internal
2608 * input pin is found, try to detect the shared hp/mic
2610 if (cfg->num_inputs > 1)
2612 else if (cfg->num_inputs == 1) {
2613 defcfg = snd_hda_codec_get_pincfg(codec, cfg->inputs[0].pin);
2614 if (snd_hda_get_input_pin_attr(defcfg) != INPUT_PIN_ATTR_INT)
2619 spec->hp_mic = 0; /* clear once */
2620 if (cfg->num_inputs >= AUTO_CFG_MAX_INS)
2624 if (cfg->line_out_type == AUTO_PIN_HP_OUT && cfg->line_outs > 0)
2625 nid = cfg->line_out_pins[0];
2626 else if (cfg->hp_outs > 0)
2627 nid = cfg->hp_pins[0];
2631 if (!(snd_hda_query_pin_caps(codec, nid) & AC_PINCAP_IN))
2632 return 0; /* no input */
2634 cfg->inputs[cfg->num_inputs].pin = nid;
2635 cfg->inputs[cfg->num_inputs].type = AUTO_PIN_MIC;
2636 cfg->inputs[cfg->num_inputs].is_headphone_mic = 1;
2639 spec->hp_mic_pin = nid;
2640 /* we can't handle auto-mic together with HP-mic */
2641 spec->suppress_auto_mic = 1;
2642 codec_dbg(codec, "Enable shared I/O jack on NID 0x%x\n", nid);
2650 static int create_hp_mic_jack_mode(struct hda_codec *codec, hda_nid_t pin);
2652 static const char * const out_jack_texts[] = {
2653 "Line Out", "Headphone Out",
2656 static int out_jack_mode_info(struct snd_kcontrol *kcontrol,
2657 struct snd_ctl_elem_info *uinfo)
2659 return snd_hda_enum_helper_info(kcontrol, uinfo, 2, out_jack_texts);
2662 static int out_jack_mode_get(struct snd_kcontrol *kcontrol,
2663 struct snd_ctl_elem_value *ucontrol)
2665 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2666 hda_nid_t nid = kcontrol->private_value;
2667 if (snd_hda_codec_get_pin_target(codec, nid) == PIN_HP)
2668 ucontrol->value.enumerated.item[0] = 1;
2670 ucontrol->value.enumerated.item[0] = 0;
2674 static int out_jack_mode_put(struct snd_kcontrol *kcontrol,
2675 struct snd_ctl_elem_value *ucontrol)
2677 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2678 hda_nid_t nid = kcontrol->private_value;
2681 val = ucontrol->value.enumerated.item[0] ? PIN_HP : PIN_OUT;
2682 if (snd_hda_codec_get_pin_target(codec, nid) == val)
2684 snd_hda_set_pin_ctl_cache(codec, nid, val);
2688 static const struct snd_kcontrol_new out_jack_mode_enum = {
2689 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2690 .info = out_jack_mode_info,
2691 .get = out_jack_mode_get,
2692 .put = out_jack_mode_put,
2695 static bool find_kctl_name(struct hda_codec *codec, const char *name, int idx)
2697 struct hda_gen_spec *spec = codec->spec;
2698 const struct snd_kcontrol_new *kctl;
2701 snd_array_for_each(&spec->kctls, i, kctl) {
2702 if (!strcmp(kctl->name, name) && kctl->index == idx)
2708 static void get_jack_mode_name(struct hda_codec *codec, hda_nid_t pin,
2709 char *name, size_t name_len)
2711 struct hda_gen_spec *spec = codec->spec;
2714 snd_hda_get_pin_label(codec, pin, &spec->autocfg, name, name_len, &idx);
2715 strlcat(name, " Jack Mode", name_len);
2717 for (; find_kctl_name(codec, name, idx); idx++)
2721 static int get_out_jack_num_items(struct hda_codec *codec, hda_nid_t pin)
2723 struct hda_gen_spec *spec = codec->spec;
2724 if (spec->add_jack_modes) {
2725 unsigned int pincap = snd_hda_query_pin_caps(codec, pin);
2726 if ((pincap & AC_PINCAP_OUT) && (pincap & AC_PINCAP_HP_DRV))
2732 static int create_out_jack_modes(struct hda_codec *codec, int num_pins,
2735 struct hda_gen_spec *spec = codec->spec;
2738 for (i = 0; i < num_pins; i++) {
2739 hda_nid_t pin = pins[i];
2740 if (pin == spec->hp_mic_pin)
2742 if (get_out_jack_num_items(codec, pin) > 1) {
2743 struct snd_kcontrol_new *knew;
2744 char name[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];
2745 get_jack_mode_name(codec, pin, name, sizeof(name));
2746 knew = snd_hda_gen_add_kctl(spec, name,
2747 &out_jack_mode_enum);
2750 knew->private_value = pin;
2761 /* from AC_PINCTL_VREF_HIZ to AC_PINCTL_VREF_100 */
2764 static const char * const vref_texts[NUM_VREFS] = {
2765 "Line In", "Mic 50pc Bias", "Mic 0V Bias",
2766 "", "Mic 80pc Bias", "Mic 100pc Bias"
2769 static unsigned int get_vref_caps(struct hda_codec *codec, hda_nid_t pin)
2771 unsigned int pincap;
2773 pincap = snd_hda_query_pin_caps(codec, pin);
2774 pincap = (pincap & AC_PINCAP_VREF) >> AC_PINCAP_VREF_SHIFT;
2775 /* filter out unusual vrefs */
2776 pincap &= ~(AC_PINCAP_VREF_GRD | AC_PINCAP_VREF_100);
2780 /* convert from the enum item index to the vref ctl index (0=HIZ, 1=50%...) */
2781 static int get_vref_idx(unsigned int vref_caps, unsigned int item_idx)
2783 unsigned int i, n = 0;
2785 for (i = 0; i < NUM_VREFS; i++) {
2786 if (vref_caps & (1 << i)) {
2795 /* convert back from the vref ctl index to the enum item index */
2796 static int cvt_from_vref_idx(unsigned int vref_caps, unsigned int idx)
2798 unsigned int i, n = 0;
2800 for (i = 0; i < NUM_VREFS; i++) {
2803 if (vref_caps & (1 << i))
2809 static int in_jack_mode_info(struct snd_kcontrol *kcontrol,
2810 struct snd_ctl_elem_info *uinfo)
2812 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2813 hda_nid_t nid = kcontrol->private_value;
2814 unsigned int vref_caps = get_vref_caps(codec, nid);
2816 snd_hda_enum_helper_info(kcontrol, uinfo, hweight32(vref_caps),
2818 /* set the right text */
2819 strcpy(uinfo->value.enumerated.name,
2820 vref_texts[get_vref_idx(vref_caps, uinfo->value.enumerated.item)]);
2824 static int in_jack_mode_get(struct snd_kcontrol *kcontrol,
2825 struct snd_ctl_elem_value *ucontrol)
2827 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2828 hda_nid_t nid = kcontrol->private_value;
2829 unsigned int vref_caps = get_vref_caps(codec, nid);
2832 idx = snd_hda_codec_get_pin_target(codec, nid) & AC_PINCTL_VREFEN;
2833 ucontrol->value.enumerated.item[0] = cvt_from_vref_idx(vref_caps, idx);
2837 static int in_jack_mode_put(struct snd_kcontrol *kcontrol,
2838 struct snd_ctl_elem_value *ucontrol)
2840 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2841 hda_nid_t nid = kcontrol->private_value;
2842 unsigned int vref_caps = get_vref_caps(codec, nid);
2843 unsigned int val, idx;
2845 val = snd_hda_codec_get_pin_target(codec, nid);
2846 idx = cvt_from_vref_idx(vref_caps, val & AC_PINCTL_VREFEN);
2847 if (idx == ucontrol->value.enumerated.item[0])
2850 val &= ~AC_PINCTL_VREFEN;
2851 val |= get_vref_idx(vref_caps, ucontrol->value.enumerated.item[0]);
2852 snd_hda_set_pin_ctl_cache(codec, nid, val);
2856 static const struct snd_kcontrol_new in_jack_mode_enum = {
2857 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2858 .info = in_jack_mode_info,
2859 .get = in_jack_mode_get,
2860 .put = in_jack_mode_put,
2863 static int get_in_jack_num_items(struct hda_codec *codec, hda_nid_t pin)
2865 struct hda_gen_spec *spec = codec->spec;
2867 if (spec->add_jack_modes)
2868 nitems = hweight32(get_vref_caps(codec, pin));
2869 return nitems ? nitems : 1;
2872 static int create_in_jack_mode(struct hda_codec *codec, hda_nid_t pin)
2874 struct hda_gen_spec *spec = codec->spec;
2875 struct snd_kcontrol_new *knew;
2876 char name[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];
2877 unsigned int defcfg;
2879 if (pin == spec->hp_mic_pin)
2880 return 0; /* already done in create_out_jack_mode() */
2882 /* no jack mode for fixed pins */
2883 defcfg = snd_hda_codec_get_pincfg(codec, pin);
2884 if (snd_hda_get_input_pin_attr(defcfg) == INPUT_PIN_ATTR_INT)
2887 /* no multiple vref caps? */
2888 if (get_in_jack_num_items(codec, pin) <= 1)
2891 get_jack_mode_name(codec, pin, name, sizeof(name));
2892 knew = snd_hda_gen_add_kctl(spec, name, &in_jack_mode_enum);
2895 knew->private_value = pin;
2900 * HP/mic shared jack mode
2902 static int hp_mic_jack_mode_info(struct snd_kcontrol *kcontrol,
2903 struct snd_ctl_elem_info *uinfo)
2905 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2906 hda_nid_t nid = kcontrol->private_value;
2907 int out_jacks = get_out_jack_num_items(codec, nid);
2908 int in_jacks = get_in_jack_num_items(codec, nid);
2909 const char *text = NULL;
2912 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
2914 uinfo->value.enumerated.items = out_jacks + in_jacks;
2915 if (uinfo->value.enumerated.item >= uinfo->value.enumerated.items)
2916 uinfo->value.enumerated.item = uinfo->value.enumerated.items - 1;
2917 idx = uinfo->value.enumerated.item;
2918 if (idx < out_jacks) {
2920 text = out_jack_texts[idx];
2922 text = "Headphone Out";
2926 unsigned int vref_caps = get_vref_caps(codec, nid);
2927 text = vref_texts[get_vref_idx(vref_caps, idx)];
2932 strcpy(uinfo->value.enumerated.name, text);
2936 static int get_cur_hp_mic_jack_mode(struct hda_codec *codec, hda_nid_t nid)
2938 int out_jacks = get_out_jack_num_items(codec, nid);
2939 int in_jacks = get_in_jack_num_items(codec, nid);
2940 unsigned int val = snd_hda_codec_get_pin_target(codec, nid);
2943 if (val & PIN_OUT) {
2944 if (out_jacks > 1 && val == PIN_HP)
2946 } else if (val & PIN_IN) {
2949 unsigned int vref_caps = get_vref_caps(codec, nid);
2950 val &= AC_PINCTL_VREFEN;
2951 idx += cvt_from_vref_idx(vref_caps, val);
2957 static int hp_mic_jack_mode_get(struct snd_kcontrol *kcontrol,
2958 struct snd_ctl_elem_value *ucontrol)
2960 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2961 hda_nid_t nid = kcontrol->private_value;
2962 ucontrol->value.enumerated.item[0] =
2963 get_cur_hp_mic_jack_mode(codec, nid);
2967 static int hp_mic_jack_mode_put(struct snd_kcontrol *kcontrol,
2968 struct snd_ctl_elem_value *ucontrol)
2970 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2971 hda_nid_t nid = kcontrol->private_value;
2972 int out_jacks = get_out_jack_num_items(codec, nid);
2973 int in_jacks = get_in_jack_num_items(codec, nid);
2974 unsigned int val, oldval, idx;
2976 oldval = get_cur_hp_mic_jack_mode(codec, nid);
2977 idx = ucontrol->value.enumerated.item[0];
2981 if (idx < out_jacks) {
2983 val = idx ? PIN_HP : PIN_OUT;
2989 unsigned int vref_caps = get_vref_caps(codec, nid);
2990 val = snd_hda_codec_get_pin_target(codec, nid);
2991 val &= ~(AC_PINCTL_VREFEN | PIN_HP);
2992 val |= get_vref_idx(vref_caps, idx) | PIN_IN;
2994 val = snd_hda_get_default_vref(codec, nid) | PIN_IN;
2996 snd_hda_set_pin_ctl_cache(codec, nid, val);
2997 call_hp_automute(codec, NULL);
3002 static const struct snd_kcontrol_new hp_mic_jack_mode_enum = {
3003 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3004 .info = hp_mic_jack_mode_info,
3005 .get = hp_mic_jack_mode_get,
3006 .put = hp_mic_jack_mode_put,
3009 static int create_hp_mic_jack_mode(struct hda_codec *codec, hda_nid_t pin)
3011 struct hda_gen_spec *spec = codec->spec;
3012 struct snd_kcontrol_new *knew;
3014 knew = snd_hda_gen_add_kctl(spec, "Headphone Mic Jack Mode",
3015 &hp_mic_jack_mode_enum);
3018 knew->private_value = pin;
3019 spec->hp_mic_jack_modes = 1;
3027 /* add the powersave loopback-list entry */
3028 static int add_loopback_list(struct hda_gen_spec *spec, hda_nid_t mix, int idx)
3030 struct hda_amp_list *list;
3032 list = snd_array_new(&spec->loopback_list);
3036 list->dir = HDA_INPUT;
3038 spec->loopback.amplist = spec->loopback_list.list;
3042 /* return true if either a volume or a mute amp is found for the given
3043 * aamix path; the amp has to be either in the mixer node or its direct leaf
3045 static bool look_for_mix_leaf_ctls(struct hda_codec *codec, hda_nid_t mix_nid,
3046 hda_nid_t pin, unsigned int *mix_val,
3047 unsigned int *mute_val)
3050 const hda_nid_t *list;
3053 idx = snd_hda_get_conn_index(codec, mix_nid, pin, true);
3057 *mix_val = *mute_val = 0;
3058 if (nid_has_volume(codec, mix_nid, HDA_INPUT))
3059 *mix_val = HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT);
3060 if (nid_has_mute(codec, mix_nid, HDA_INPUT))
3061 *mute_val = HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT);
3062 if (*mix_val && *mute_val)
3065 /* check leaf node */
3066 num_conns = snd_hda_get_conn_list(codec, mix_nid, &list);
3067 if (num_conns < idx)
3070 if (!*mix_val && nid_has_volume(codec, nid, HDA_OUTPUT) &&
3071 !is_ctl_associated(codec, nid, HDA_OUTPUT, 0, NID_PATH_VOL_CTL))
3072 *mix_val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
3073 if (!*mute_val && nid_has_mute(codec, nid, HDA_OUTPUT) &&
3074 !is_ctl_associated(codec, nid, HDA_OUTPUT, 0, NID_PATH_MUTE_CTL))
3075 *mute_val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
3077 return *mix_val || *mute_val;
3080 /* create input playback/capture controls for the given pin */
3081 static int new_analog_input(struct hda_codec *codec, int input_idx,
3082 hda_nid_t pin, const char *ctlname, int ctlidx,
3085 struct hda_gen_spec *spec = codec->spec;
3086 struct nid_path *path;
3087 unsigned int mix_val, mute_val;
3090 if (!look_for_mix_leaf_ctls(codec, mix_nid, pin, &mix_val, &mute_val))
3093 path = snd_hda_add_new_path(codec, pin, mix_nid, 0);
3096 print_nid_path(codec, "loopback", path);
3097 spec->loopback_paths[input_idx] = snd_hda_get_path_idx(codec, path);
3099 idx = path->idx[path->depth - 1];
3101 err = __add_pb_vol_ctrl(spec, HDA_CTL_WIDGET_VOL, ctlname, ctlidx, mix_val);
3104 path->ctls[NID_PATH_VOL_CTL] = mix_val;
3108 err = __add_pb_sw_ctrl(spec, HDA_CTL_WIDGET_MUTE, ctlname, ctlidx, mute_val);
3111 path->ctls[NID_PATH_MUTE_CTL] = mute_val;
3114 path->active = true;
3115 path->stream_enabled = true; /* no DAC/ADC involved */
3116 err = add_loopback_list(spec, mix_nid, idx);
3120 if (spec->mixer_nid != spec->mixer_merge_nid &&
3121 !spec->loopback_merge_path) {
3122 path = snd_hda_add_new_path(codec, spec->mixer_nid,
3123 spec->mixer_merge_nid, 0);
3125 print_nid_path(codec, "loopback-merge", path);
3126 path->active = true;
3127 path->pin_fixed = true; /* static route */
3128 path->stream_enabled = true; /* no DAC/ADC involved */
3129 spec->loopback_merge_path =
3130 snd_hda_get_path_idx(codec, path);
3137 static int is_input_pin(struct hda_codec *codec, hda_nid_t nid)
3139 unsigned int pincap = snd_hda_query_pin_caps(codec, nid);
3140 return (pincap & AC_PINCAP_IN) != 0;
3143 /* Parse the codec tree and retrieve ADCs */
3144 static int fill_adc_nids(struct hda_codec *codec)
3146 struct hda_gen_spec *spec = codec->spec;
3148 hda_nid_t *adc_nids = spec->adc_nids;
3149 int max_nums = ARRAY_SIZE(spec->adc_nids);
3152 for_each_hda_codec_node(nid, codec) {
3153 unsigned int caps = get_wcaps(codec, nid);
3154 int type = get_wcaps_type(caps);
3156 if (type != AC_WID_AUD_IN || (caps & AC_WCAP_DIGITAL))
3158 adc_nids[nums] = nid;
3159 if (++nums >= max_nums)
3162 spec->num_adc_nids = nums;
3164 /* copy the detected ADCs to all_adcs[] */
3165 spec->num_all_adcs = nums;
3166 memcpy(spec->all_adcs, spec->adc_nids, nums * sizeof(hda_nid_t));
3171 /* filter out invalid adc_nids that don't give all active input pins;
3172 * if needed, check whether dynamic ADC-switching is available
3174 static int check_dyn_adc_switch(struct hda_codec *codec)
3176 struct hda_gen_spec *spec = codec->spec;
3177 struct hda_input_mux *imux = &spec->input_mux;
3178 unsigned int ok_bits;
3183 for (n = 0; n < spec->num_adc_nids; n++) {
3184 for (i = 0; i < imux->num_items; i++) {
3185 if (!spec->input_paths[i][n])
3188 if (i >= imux->num_items) {
3189 ok_bits |= (1 << n);
3195 /* check whether ADC-switch is possible */
3196 for (i = 0; i < imux->num_items; i++) {
3197 for (n = 0; n < spec->num_adc_nids; n++) {
3198 if (spec->input_paths[i][n]) {
3199 spec->dyn_adc_idx[i] = n;
3205 codec_dbg(codec, "enabling ADC switching\n");
3206 spec->dyn_adc_switch = 1;
3207 } else if (nums != spec->num_adc_nids) {
3208 /* shrink the invalid adcs and input paths */
3210 for (n = 0; n < spec->num_adc_nids; n++) {
3211 if (!(ok_bits & (1 << n)))
3214 spec->adc_nids[nums] = spec->adc_nids[n];
3215 for (i = 0; i < imux->num_items; i++) {
3216 invalidate_nid_path(codec,
3217 spec->input_paths[i][nums]);
3218 spec->input_paths[i][nums] =
3219 spec->input_paths[i][n];
3220 spec->input_paths[i][n] = 0;
3225 spec->num_adc_nids = nums;
3228 if (imux->num_items == 1 ||
3229 (imux->num_items == 2 && spec->hp_mic)) {
3230 codec_dbg(codec, "reducing to a single ADC\n");
3231 spec->num_adc_nids = 1; /* reduce to a single ADC */
3234 /* single index for individual volumes ctls */
3235 if (!spec->dyn_adc_switch && spec->multi_cap_vol)
3236 spec->num_adc_nids = 1;
3241 /* parse capture source paths from the given pin and create imux items */
3242 static int parse_capture_source(struct hda_codec *codec, hda_nid_t pin,
3243 int cfg_idx, int num_adcs,
3244 const char *label, int anchor)
3246 struct hda_gen_spec *spec = codec->spec;
3247 struct hda_input_mux *imux = &spec->input_mux;
3248 int imux_idx = imux->num_items;
3249 bool imux_added = false;
3252 for (c = 0; c < num_adcs; c++) {
3253 struct nid_path *path;
3254 hda_nid_t adc = spec->adc_nids[c];
3256 if (!is_reachable_path(codec, pin, adc))
3258 path = snd_hda_add_new_path(codec, pin, adc, anchor);
3261 print_nid_path(codec, "input", path);
3262 spec->input_paths[imux_idx][c] =
3263 snd_hda_get_path_idx(codec, path);
3266 if (spec->hp_mic_pin == pin)
3267 spec->hp_mic_mux_idx = imux->num_items;
3268 spec->imux_pins[imux->num_items] = pin;
3269 snd_hda_add_imux_item(codec, imux, label, cfg_idx, NULL);
3271 if (spec->dyn_adc_switch)
3272 spec->dyn_adc_idx[imux_idx] = c;
3280 * create playback/capture controls for input pins
3283 /* fill the label for each input at first */
3284 static int fill_input_pin_labels(struct hda_codec *codec)
3286 struct hda_gen_spec *spec = codec->spec;
3287 const struct auto_pin_cfg *cfg = &spec->autocfg;
3290 for (i = 0; i < cfg->num_inputs; i++) {
3291 hda_nid_t pin = cfg->inputs[i].pin;
3295 if (!is_input_pin(codec, pin))
3298 label = hda_get_autocfg_input_label(codec, cfg, i);
3300 for (j = i - 1; j >= 0; j--) {
3301 if (spec->input_labels[j] &&
3302 !strcmp(spec->input_labels[j], label)) {
3303 idx = spec->input_label_idxs[j] + 1;
3308 spec->input_labels[i] = label;
3309 spec->input_label_idxs[i] = idx;
3315 #define CFG_IDX_MIX 99 /* a dummy cfg->input idx for stereo mix */
3317 static int create_input_ctls(struct hda_codec *codec)
3319 struct hda_gen_spec *spec = codec->spec;
3320 const struct auto_pin_cfg *cfg = &spec->autocfg;
3321 hda_nid_t mixer = spec->mixer_nid;
3326 num_adcs = fill_adc_nids(codec);
3330 err = fill_input_pin_labels(codec);
3334 for (i = 0; i < cfg->num_inputs; i++) {
3337 pin = cfg->inputs[i].pin;
3338 if (!is_input_pin(codec, pin))
3342 if (cfg->inputs[i].type == AUTO_PIN_MIC)
3343 val |= snd_hda_get_default_vref(codec, pin);
3344 if (pin != spec->hp_mic_pin &&
3345 !snd_hda_codec_get_pin_target(codec, pin))
3346 set_pin_target(codec, pin, val, false);
3349 if (is_reachable_path(codec, pin, mixer)) {
3350 err = new_analog_input(codec, i, pin,
3351 spec->input_labels[i],
3352 spec->input_label_idxs[i],
3359 err = parse_capture_source(codec, pin, i, num_adcs,
3360 spec->input_labels[i], -mixer);
3364 if (spec->add_jack_modes) {
3365 err = create_in_jack_mode(codec, pin);
3371 /* add stereo mix when explicitly enabled via hint */
3372 if (mixer && spec->add_stereo_mix_input == HDA_HINT_STEREO_MIX_ENABLE) {
3373 err = parse_capture_source(codec, mixer, CFG_IDX_MIX, num_adcs,
3378 spec->suppress_auto_mic = 1;
3389 /* get the input path specified by the given adc and imux indices */
3390 static struct nid_path *get_input_path(struct hda_codec *codec, int adc_idx, int imux_idx)
3392 struct hda_gen_spec *spec = codec->spec;
3393 if (imux_idx < 0 || imux_idx >= HDA_MAX_NUM_INPUTS) {
3397 if (spec->dyn_adc_switch)
3398 adc_idx = spec->dyn_adc_idx[imux_idx];
3399 if (adc_idx < 0 || adc_idx >= AUTO_CFG_MAX_INS) {
3403 return snd_hda_get_path_from_idx(codec, spec->input_paths[imux_idx][adc_idx]);
3406 static int mux_select(struct hda_codec *codec, unsigned int adc_idx,
3409 static int mux_enum_info(struct snd_kcontrol *kcontrol,
3410 struct snd_ctl_elem_info *uinfo)
3412 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3413 struct hda_gen_spec *spec = codec->spec;
3414 return snd_hda_input_mux_info(&spec->input_mux, uinfo);
3417 static int mux_enum_get(struct snd_kcontrol *kcontrol,
3418 struct snd_ctl_elem_value *ucontrol)
3420 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3421 struct hda_gen_spec *spec = codec->spec;
3422 /* the ctls are created at once with multiple counts */
3423 unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
3425 ucontrol->value.enumerated.item[0] = spec->cur_mux[adc_idx];
3429 static int mux_enum_put(struct snd_kcontrol *kcontrol,
3430 struct snd_ctl_elem_value *ucontrol)
3432 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3433 unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
3434 return mux_select(codec, adc_idx,
3435 ucontrol->value.enumerated.item[0]);
3438 static const struct snd_kcontrol_new cap_src_temp = {
3439 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3440 .name = "Input Source",
3441 .info = mux_enum_info,
3442 .get = mux_enum_get,
3443 .put = mux_enum_put,
3447 * capture volume and capture switch ctls
3450 typedef int (*put_call_t)(struct snd_kcontrol *kcontrol,
3451 struct snd_ctl_elem_value *ucontrol);
3453 /* call the given amp update function for all amps in the imux list at once */
3454 static int cap_put_caller(struct snd_kcontrol *kcontrol,
3455 struct snd_ctl_elem_value *ucontrol,
3456 put_call_t func, int type)
3458 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3459 struct hda_gen_spec *spec = codec->spec;
3460 const struct hda_input_mux *imux;
3461 struct nid_path *path;
3462 int i, adc_idx, ret, err = 0;
3464 imux = &spec->input_mux;
3465 adc_idx = kcontrol->id.index;
3466 mutex_lock(&codec->control_mutex);
3467 for (i = 0; i < imux->num_items; i++) {
3468 path = get_input_path(codec, adc_idx, i);
3469 if (!path || !path->ctls[type])
3471 kcontrol->private_value = path->ctls[type];
3472 ret = func(kcontrol, ucontrol);
3480 mutex_unlock(&codec->control_mutex);
3481 if (err >= 0 && spec->cap_sync_hook)
3482 spec->cap_sync_hook(codec, kcontrol, ucontrol);
3486 /* capture volume ctl callbacks */
3487 #define cap_vol_info snd_hda_mixer_amp_volume_info
3488 #define cap_vol_get snd_hda_mixer_amp_volume_get
3489 #define cap_vol_tlv snd_hda_mixer_amp_tlv
3491 static int cap_vol_put(struct snd_kcontrol *kcontrol,
3492 struct snd_ctl_elem_value *ucontrol)
3494 return cap_put_caller(kcontrol, ucontrol,
3495 snd_hda_mixer_amp_volume_put,
3499 static const struct snd_kcontrol_new cap_vol_temp = {
3500 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3501 .name = "Capture Volume",
3502 .access = (SNDRV_CTL_ELEM_ACCESS_READWRITE |
3503 SNDRV_CTL_ELEM_ACCESS_TLV_READ |
3504 SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK),
3505 .info = cap_vol_info,
3508 .tlv = { .c = cap_vol_tlv },
3511 /* capture switch ctl callbacks */
3512 #define cap_sw_info snd_ctl_boolean_stereo_info
3513 #define cap_sw_get snd_hda_mixer_amp_switch_get
3515 static int cap_sw_put(struct snd_kcontrol *kcontrol,
3516 struct snd_ctl_elem_value *ucontrol)
3518 return cap_put_caller(kcontrol, ucontrol,
3519 snd_hda_mixer_amp_switch_put,
3523 static const struct snd_kcontrol_new cap_sw_temp = {
3524 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3525 .name = "Capture Switch",
3526 .info = cap_sw_info,
3531 static int parse_capvol_in_path(struct hda_codec *codec, struct nid_path *path)
3536 path->ctls[NID_PATH_VOL_CTL] = path->ctls[NID_PATH_MUTE_CTL] = 0;
3537 for (depth = 0; depth < 3; depth++) {
3538 if (depth >= path->depth)
3540 i = path->depth - depth - 1;
3541 nid = path->path[i];
3542 if (!path->ctls[NID_PATH_VOL_CTL]) {
3543 if (nid_has_volume(codec, nid, HDA_OUTPUT))
3544 path->ctls[NID_PATH_VOL_CTL] =
3545 HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
3546 else if (nid_has_volume(codec, nid, HDA_INPUT)) {
3547 int idx = path->idx[i];
3548 if (!depth && codec->single_adc_amp)
3550 path->ctls[NID_PATH_VOL_CTL] =
3551 HDA_COMPOSE_AMP_VAL(nid, 3, idx, HDA_INPUT);
3554 if (!path->ctls[NID_PATH_MUTE_CTL]) {
3555 if (nid_has_mute(codec, nid, HDA_OUTPUT))
3556 path->ctls[NID_PATH_MUTE_CTL] =
3557 HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
3558 else if (nid_has_mute(codec, nid, HDA_INPUT)) {
3559 int idx = path->idx[i];
3560 if (!depth && codec->single_adc_amp)
3562 path->ctls[NID_PATH_MUTE_CTL] =
3563 HDA_COMPOSE_AMP_VAL(nid, 3, idx, HDA_INPUT);
3570 static bool is_inv_dmic_pin(struct hda_codec *codec, hda_nid_t nid)
3572 struct hda_gen_spec *spec = codec->spec;
3573 struct auto_pin_cfg *cfg = &spec->autocfg;
3577 if (!spec->inv_dmic_split)
3579 for (i = 0; i < cfg->num_inputs; i++) {
3580 if (cfg->inputs[i].pin != nid)
3582 if (cfg->inputs[i].type != AUTO_PIN_MIC)
3584 val = snd_hda_codec_get_pincfg(codec, nid);
3585 return snd_hda_get_input_pin_attr(val) == INPUT_PIN_ATTR_INT;
3590 /* capture switch put callback for a single control with hook call */
3591 static int cap_single_sw_put(struct snd_kcontrol *kcontrol,
3592 struct snd_ctl_elem_value *ucontrol)
3594 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3595 struct hda_gen_spec *spec = codec->spec;
3598 ret = snd_hda_mixer_amp_switch_put(kcontrol, ucontrol);
3602 if (spec->cap_sync_hook)
3603 spec->cap_sync_hook(codec, kcontrol, ucontrol);
3608 static int add_single_cap_ctl(struct hda_codec *codec, const char *label,
3609 int idx, bool is_switch, unsigned int ctl,
3612 struct hda_gen_spec *spec = codec->spec;
3613 char tmpname[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];
3614 int type = is_switch ? HDA_CTL_WIDGET_MUTE : HDA_CTL_WIDGET_VOL;
3615 const char *sfx = is_switch ? "Switch" : "Volume";
3616 unsigned int chs = inv_dmic ? 1 : 3;
3617 struct snd_kcontrol_new *knew;
3623 snprintf(tmpname, sizeof(tmpname),
3624 "%s Capture %s", label, sfx);
3626 snprintf(tmpname, sizeof(tmpname),
3628 knew = add_control(spec, type, tmpname, idx,
3629 amp_val_replace_channels(ctl, chs));
3633 knew->put = cap_single_sw_put;
3637 /* Make independent right kcontrol */
3639 snprintf(tmpname, sizeof(tmpname),
3640 "Inverted %s Capture %s", label, sfx);
3642 snprintf(tmpname, sizeof(tmpname),
3643 "Inverted Capture %s", sfx);
3644 knew = add_control(spec, type, tmpname, idx,
3645 amp_val_replace_channels(ctl, 2));
3649 knew->put = cap_single_sw_put;
3653 /* create single (and simple) capture volume and switch controls */
3654 static int create_single_cap_vol_ctl(struct hda_codec *codec, int idx,
3655 unsigned int vol_ctl, unsigned int sw_ctl,
3659 err = add_single_cap_ctl(codec, NULL, idx, false, vol_ctl, inv_dmic);
3662 err = add_single_cap_ctl(codec, NULL, idx, true, sw_ctl, inv_dmic);
3668 /* create bound capture volume and switch controls */
3669 static int create_bind_cap_vol_ctl(struct hda_codec *codec, int idx,
3670 unsigned int vol_ctl, unsigned int sw_ctl)
3672 struct hda_gen_spec *spec = codec->spec;
3673 struct snd_kcontrol_new *knew;
3676 knew = snd_hda_gen_add_kctl(spec, NULL, &cap_vol_temp);
3680 knew->private_value = vol_ctl;
3681 knew->subdevice = HDA_SUBDEV_AMP_FLAG;
3684 knew = snd_hda_gen_add_kctl(spec, NULL, &cap_sw_temp);
3688 knew->private_value = sw_ctl;
3689 knew->subdevice = HDA_SUBDEV_AMP_FLAG;
3694 /* return the vol ctl when used first in the imux list */
3695 static unsigned int get_first_cap_ctl(struct hda_codec *codec, int idx, int type)
3697 struct nid_path *path;
3701 path = get_input_path(codec, 0, idx);
3704 ctl = path->ctls[type];
3707 for (i = 0; i < idx - 1; i++) {
3708 path = get_input_path(codec, 0, i);
3709 if (path && path->ctls[type] == ctl)
3715 /* create individual capture volume and switch controls per input */
3716 static int create_multi_cap_vol_ctl(struct hda_codec *codec)
3718 struct hda_gen_spec *spec = codec->spec;
3719 struct hda_input_mux *imux = &spec->input_mux;
3722 for (i = 0; i < imux->num_items; i++) {
3726 idx = imux->items[i].index;
3727 if (idx >= spec->autocfg.num_inputs)
3729 inv_dmic = is_inv_dmic_pin(codec, spec->imux_pins[i]);
3731 for (type = 0; type < 2; type++) {
3732 err = add_single_cap_ctl(codec,
3733 spec->input_labels[idx],
3734 spec->input_label_idxs[idx],
3736 get_first_cap_ctl(codec, i, type),
3745 static int create_capture_mixers(struct hda_codec *codec)
3747 struct hda_gen_spec *spec = codec->spec;
3748 struct hda_input_mux *imux = &spec->input_mux;
3749 int i, n, nums, err;
3751 if (spec->dyn_adc_switch)
3754 nums = spec->num_adc_nids;
3756 if (!spec->auto_mic && imux->num_items > 1) {
3757 struct snd_kcontrol_new *knew;
3759 name = nums > 1 ? "Input Source" : "Capture Source";
3760 knew = snd_hda_gen_add_kctl(spec, name, &cap_src_temp);
3766 for (n = 0; n < nums; n++) {
3768 bool multi_cap_vol = spec->multi_cap_vol;
3769 bool inv_dmic = false;
3773 for (i = 0; i < imux->num_items; i++) {
3774 struct nid_path *path;
3775 path = get_input_path(codec, n, i);
3778 parse_capvol_in_path(codec, path);
3780 vol = path->ctls[NID_PATH_VOL_CTL];
3781 else if (vol != path->ctls[NID_PATH_VOL_CTL]) {
3783 if (!same_amp_caps(codec, vol,
3784 path->ctls[NID_PATH_VOL_CTL], HDA_INPUT))
3785 multi_cap_vol = true;
3788 sw = path->ctls[NID_PATH_MUTE_CTL];
3789 else if (sw != path->ctls[NID_PATH_MUTE_CTL]) {
3791 if (!same_amp_caps(codec, sw,
3792 path->ctls[NID_PATH_MUTE_CTL], HDA_INPUT))
3793 multi_cap_vol = true;
3795 if (is_inv_dmic_pin(codec, spec->imux_pins[i]))
3800 err = create_single_cap_vol_ctl(codec, n, vol, sw,
3802 else if (!multi_cap_vol && !inv_dmic)
3803 err = create_bind_cap_vol_ctl(codec, n, vol, sw);
3805 err = create_multi_cap_vol_ctl(codec);
3814 * add mic boosts if needed
3817 /* check whether the given amp is feasible as a boost volume */
3818 static bool check_boost_vol(struct hda_codec *codec, hda_nid_t nid,
3823 if (!nid_has_volume(codec, nid, dir) ||
3824 is_ctl_associated(codec, nid, dir, idx, NID_PATH_VOL_CTL) ||
3825 is_ctl_associated(codec, nid, dir, idx, NID_PATH_BOOST_CTL))
3828 step = (query_amp_caps(codec, nid, dir) & AC_AMPCAP_STEP_SIZE)
3829 >> AC_AMPCAP_STEP_SIZE_SHIFT;
3835 /* look for a boost amp in a widget close to the pin */
3836 static unsigned int look_for_boost_amp(struct hda_codec *codec,
3837 struct nid_path *path)
3839 unsigned int val = 0;
3843 for (depth = 0; depth < 3; depth++) {
3844 if (depth >= path->depth - 1)
3846 nid = path->path[depth];
3847 if (depth && check_boost_vol(codec, nid, HDA_OUTPUT, 0)) {
3848 val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
3850 } else if (check_boost_vol(codec, nid, HDA_INPUT,
3851 path->idx[depth])) {
3852 val = HDA_COMPOSE_AMP_VAL(nid, 3, path->idx[depth],
3861 static int parse_mic_boost(struct hda_codec *codec)
3863 struct hda_gen_spec *spec = codec->spec;
3864 struct auto_pin_cfg *cfg = &spec->autocfg;
3865 struct hda_input_mux *imux = &spec->input_mux;
3868 if (!spec->num_adc_nids)
3871 for (i = 0; i < imux->num_items; i++) {
3872 struct nid_path *path;
3875 char boost_label[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];
3877 idx = imux->items[i].index;
3878 if (idx >= imux->num_items)
3881 /* check only line-in and mic pins */
3882 if (cfg->inputs[idx].type > AUTO_PIN_LINE_IN)
3885 path = get_input_path(codec, 0, i);
3889 val = look_for_boost_amp(codec, path);
3893 /* create a boost control */
3894 snprintf(boost_label, sizeof(boost_label),
3895 "%s Boost Volume", spec->input_labels[idx]);
3896 if (!add_control(spec, HDA_CTL_WIDGET_VOL, boost_label,
3897 spec->input_label_idxs[idx], val))
3900 path->ctls[NID_PATH_BOOST_CTL] = val;
3906 * mic mute LED hook helpers
3911 MICMUTE_LED_FOLLOW_CAPTURE,
3912 MICMUTE_LED_FOLLOW_MUTE,
3915 static void call_micmute_led_update(struct hda_codec *codec)
3917 struct hda_gen_spec *spec = codec->spec;
3920 switch (spec->micmute_led.led_mode) {
3921 case MICMUTE_LED_ON:
3924 case MICMUTE_LED_OFF:
3927 case MICMUTE_LED_FOLLOW_CAPTURE:
3928 val = !!spec->micmute_led.capture;
3930 case MICMUTE_LED_FOLLOW_MUTE:
3932 val = !spec->micmute_led.capture;
3936 if (val == spec->micmute_led.led_value)
3938 spec->micmute_led.led_value = val;
3939 if (spec->micmute_led.update)
3940 spec->micmute_led.update(codec);
3943 static void update_micmute_led(struct hda_codec *codec,
3944 struct snd_kcontrol *kcontrol,
3945 struct snd_ctl_elem_value *ucontrol)
3947 struct hda_gen_spec *spec = codec->spec;
3950 if (spec->micmute_led.old_hook)
3951 spec->micmute_led.old_hook(codec, kcontrol, ucontrol);
3955 mask = 1U << snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
3956 if (!strcmp("Capture Switch", ucontrol->id.name)) {
3957 /* TODO: How do I verify if it's a mono or stereo here? */
3958 if (ucontrol->value.integer.value[0] ||
3959 ucontrol->value.integer.value[1])
3960 spec->micmute_led.capture |= mask;
3962 spec->micmute_led.capture &= ~mask;
3963 call_micmute_led_update(codec);
3967 static int micmute_led_mode_info(struct snd_kcontrol *kcontrol,
3968 struct snd_ctl_elem_info *uinfo)
3970 static const char * const texts[] = {
3971 "On", "Off", "Follow Capture", "Follow Mute",
3974 return snd_ctl_enum_info(uinfo, 1, ARRAY_SIZE(texts), texts);
3977 static int micmute_led_mode_get(struct snd_kcontrol *kcontrol,
3978 struct snd_ctl_elem_value *ucontrol)
3980 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3981 struct hda_gen_spec *spec = codec->spec;
3983 ucontrol->value.enumerated.item[0] = spec->micmute_led.led_mode;
3987 static int micmute_led_mode_put(struct snd_kcontrol *kcontrol,
3988 struct snd_ctl_elem_value *ucontrol)
3990 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3991 struct hda_gen_spec *spec = codec->spec;
3994 mode = ucontrol->value.enumerated.item[0];
3995 if (mode > MICMUTE_LED_FOLLOW_MUTE)
3996 mode = MICMUTE_LED_FOLLOW_MUTE;
3997 if (mode == spec->micmute_led.led_mode)
3999 spec->micmute_led.led_mode = mode;
4000 call_micmute_led_update(codec);
4004 static const struct snd_kcontrol_new micmute_led_mode_ctl = {
4005 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
4006 .name = "Mic Mute-LED Mode",
4007 .info = micmute_led_mode_info,
4008 .get = micmute_led_mode_get,
4009 .put = micmute_led_mode_put,
4013 * snd_hda_gen_add_micmute_led - helper for setting up mic mute LED hook
4014 * @codec: the HDA codec
4015 * @hook: the callback for updating LED
4017 * Called from the codec drivers for offering the mic mute LED controls.
4018 * When established, it sets up cap_sync_hook and triggers the callback at
4019 * each time when the capture mixer switch changes. The callback is supposed
4020 * to update the LED accordingly.
4022 * Returns 0 if the hook is established or a negative error code.
4024 int snd_hda_gen_add_micmute_led(struct hda_codec *codec,
4025 void (*hook)(struct hda_codec *))
4027 struct hda_gen_spec *spec = codec->spec;
4029 spec->micmute_led.led_mode = MICMUTE_LED_FOLLOW_MUTE;
4030 spec->micmute_led.capture = 0;
4031 spec->micmute_led.led_value = -1;
4032 spec->micmute_led.old_hook = spec->cap_sync_hook;
4033 spec->micmute_led.update = hook;
4034 spec->cap_sync_hook = update_micmute_led;
4035 if (!snd_hda_gen_add_kctl(spec, NULL, &micmute_led_mode_ctl))
4039 EXPORT_SYMBOL_GPL(snd_hda_gen_add_micmute_led);
4041 #if IS_REACHABLE(CONFIG_LEDS_TRIGGER_AUDIO)
4042 static void call_ledtrig_micmute(struct hda_codec *codec)
4044 struct hda_gen_spec *spec = codec->spec;
4046 ledtrig_audio_set(LED_AUDIO_MICMUTE,
4047 spec->micmute_led.led_value ? LED_ON : LED_OFF);
4052 * snd_hda_gen_fixup_micmute_led - A fixup for mic-mute LED trigger
4054 * Pass this function to the quirk entry if another driver supports the
4055 * audio mic-mute LED trigger. Then this will bind the mixer capture switch
4056 * change with the LED.
4058 * Note that this fixup has to be called after other fixup that sets
4059 * cap_sync_hook. Otherwise the chaining wouldn't work.
4061 void snd_hda_gen_fixup_micmute_led(struct hda_codec *codec,
4062 const struct hda_fixup *fix, int action)
4064 #if IS_REACHABLE(CONFIG_LEDS_TRIGGER_AUDIO)
4065 if (action == HDA_FIXUP_ACT_PROBE)
4066 snd_hda_gen_add_micmute_led(codec, call_ledtrig_micmute);
4069 EXPORT_SYMBOL_GPL(snd_hda_gen_fixup_micmute_led);
4072 * parse digital I/Os and set up NIDs in BIOS auto-parse mode
4074 static void parse_digital(struct hda_codec *codec)
4076 struct hda_gen_spec *spec = codec->spec;
4077 struct nid_path *path;
4079 hda_nid_t dig_nid, pin;
4081 /* support multiple SPDIFs; the secondary is set up as a slave */
4083 for (i = 0; i < spec->autocfg.dig_outs; i++) {
4084 pin = spec->autocfg.dig_out_pins[i];
4085 dig_nid = look_for_dac(codec, pin, true);
4088 path = snd_hda_add_new_path(codec, dig_nid, pin, 0);
4091 print_nid_path(codec, "digout", path);
4092 path->active = true;
4093 path->pin_fixed = true; /* no jack detection */
4094 spec->digout_paths[i] = snd_hda_get_path_idx(codec, path);
4095 set_pin_target(codec, pin, PIN_OUT, false);
4097 spec->multiout.dig_out_nid = dig_nid;
4098 spec->dig_out_type = spec->autocfg.dig_out_type[0];
4100 spec->multiout.slave_dig_outs = spec->slave_dig_outs;
4101 if (nums >= ARRAY_SIZE(spec->slave_dig_outs) - 1)
4103 spec->slave_dig_outs[nums - 1] = dig_nid;
4108 if (spec->autocfg.dig_in_pin) {
4109 pin = spec->autocfg.dig_in_pin;
4110 for_each_hda_codec_node(dig_nid, codec) {
4111 unsigned int wcaps = get_wcaps(codec, dig_nid);
4112 if (get_wcaps_type(wcaps) != AC_WID_AUD_IN)
4114 if (!(wcaps & AC_WCAP_DIGITAL))
4116 path = snd_hda_add_new_path(codec, pin, dig_nid, 0);
4118 print_nid_path(codec, "digin", path);
4119 path->active = true;
4120 path->pin_fixed = true; /* no jack */
4121 spec->dig_in_nid = dig_nid;
4122 spec->digin_path = snd_hda_get_path_idx(codec, path);
4123 set_pin_target(codec, pin, PIN_IN, false);
4132 * input MUX handling
4135 static bool dyn_adc_pcm_resetup(struct hda_codec *codec, int cur);
4137 /* select the given imux item; either unmute exclusively or select the route */
4138 static int mux_select(struct hda_codec *codec, unsigned int adc_idx,
4141 struct hda_gen_spec *spec = codec->spec;
4142 const struct hda_input_mux *imux;
4143 struct nid_path *old_path, *path;
4145 imux = &spec->input_mux;
4146 if (!imux->num_items)
4149 if (idx >= imux->num_items)
4150 idx = imux->num_items - 1;
4151 if (spec->cur_mux[adc_idx] == idx)
4154 old_path = get_input_path(codec, adc_idx, spec->cur_mux[adc_idx]);
4157 if (old_path->active)
4158 snd_hda_activate_path(codec, old_path, false, false);
4160 spec->cur_mux[adc_idx] = idx;
4163 update_hp_mic(codec, adc_idx, false);
4165 if (spec->dyn_adc_switch)
4166 dyn_adc_pcm_resetup(codec, idx);
4168 path = get_input_path(codec, adc_idx, idx);
4173 snd_hda_activate_path(codec, path, true, false);
4174 if (spec->cap_sync_hook)
4175 spec->cap_sync_hook(codec, NULL, NULL);
4176 path_power_down_sync(codec, old_path);
4180 /* power up/down widgets in the all paths that match with the given NID
4181 * as terminals (either start- or endpoint)
4183 * returns the last changed NID, or zero if unchanged.
4185 static hda_nid_t set_path_power(struct hda_codec *codec, hda_nid_t nid,
4186 int pin_state, int stream_state)
4188 struct hda_gen_spec *spec = codec->spec;
4189 hda_nid_t last, changed = 0;
4190 struct nid_path *path;
4193 snd_array_for_each(&spec->paths, n, path) {
4196 if (path->path[0] == nid ||
4197 path->path[path->depth - 1] == nid) {
4198 bool pin_old = path->pin_enabled;
4199 bool stream_old = path->stream_enabled;
4202 path->pin_enabled = pin_state;
4203 if (stream_state >= 0)
4204 path->stream_enabled = stream_state;
4205 if ((!path->pin_fixed && path->pin_enabled != pin_old)
4206 || path->stream_enabled != stream_old) {
4207 last = path_power_update(codec, path, true);
4216 /* check the jack status for power control */
4217 static bool detect_pin_state(struct hda_codec *codec, hda_nid_t pin)
4219 if (!is_jack_detectable(codec, pin))
4221 return snd_hda_jack_detect_state(codec, pin) != HDA_JACK_NOT_PRESENT;
4224 /* power up/down the paths of the given pin according to the jack state;
4225 * power = 0/1 : only power up/down if it matches with the jack state,
4226 * < 0 : force power up/down to follow the jack sate
4228 * returns the last changed NID, or zero if unchanged.
4230 static hda_nid_t set_pin_power_jack(struct hda_codec *codec, hda_nid_t pin,
4235 if (!codec->power_save_node)
4238 on = detect_pin_state(codec, pin);
4240 if (power >= 0 && on != power)
4242 return set_path_power(codec, pin, on, -1);
4245 static void pin_power_callback(struct hda_codec *codec,
4246 struct hda_jack_callback *jack,
4249 if (jack && jack->nid)
4250 sync_power_state_change(codec,
4251 set_pin_power_jack(codec, jack->nid, on));
4254 /* callback only doing power up -- called at first */
4255 static void pin_power_up_callback(struct hda_codec *codec,
4256 struct hda_jack_callback *jack)
4258 pin_power_callback(codec, jack, true);
4261 /* callback only doing power down -- called at last */
4262 static void pin_power_down_callback(struct hda_codec *codec,
4263 struct hda_jack_callback *jack)
4265 pin_power_callback(codec, jack, false);
4268 /* set up the power up/down callbacks */
4269 static void add_pin_power_ctls(struct hda_codec *codec, int num_pins,
4270 const hda_nid_t *pins, bool on)
4273 hda_jack_callback_fn cb =
4274 on ? pin_power_up_callback : pin_power_down_callback;
4276 for (i = 0; i < num_pins && pins[i]; i++) {
4277 if (is_jack_detectable(codec, pins[i]))
4278 snd_hda_jack_detect_enable_callback(codec, pins[i], cb);
4280 set_path_power(codec, pins[i], true, -1);
4284 /* enabled power callback to each available I/O pin with jack detections;
4285 * the digital I/O pins are excluded because of the unreliable detectsion
4287 static void add_all_pin_power_ctls(struct hda_codec *codec, bool on)
4289 struct hda_gen_spec *spec = codec->spec;
4290 struct auto_pin_cfg *cfg = &spec->autocfg;
4293 if (!codec->power_save_node)
4295 add_pin_power_ctls(codec, cfg->line_outs, cfg->line_out_pins, on);
4296 if (cfg->line_out_type != AUTO_PIN_HP_OUT)
4297 add_pin_power_ctls(codec, cfg->hp_outs, cfg->hp_pins, on);
4298 if (cfg->line_out_type != AUTO_PIN_SPEAKER_OUT)
4299 add_pin_power_ctls(codec, cfg->speaker_outs, cfg->speaker_pins, on);
4300 for (i = 0; i < cfg->num_inputs; i++)
4301 add_pin_power_ctls(codec, 1, &cfg->inputs[i].pin, on);
4304 /* sync path power up/down with the jack states of given pins */
4305 static void sync_pin_power_ctls(struct hda_codec *codec, int num_pins,
4306 const hda_nid_t *pins)
4310 for (i = 0; i < num_pins && pins[i]; i++)
4311 if (is_jack_detectable(codec, pins[i]))
4312 set_pin_power_jack(codec, pins[i], -1);
4315 /* sync path power up/down with pins; called at init and resume */
4316 static void sync_all_pin_power_ctls(struct hda_codec *codec)
4318 struct hda_gen_spec *spec = codec->spec;
4319 struct auto_pin_cfg *cfg = &spec->autocfg;
4322 if (!codec->power_save_node)
4324 sync_pin_power_ctls(codec, cfg->line_outs, cfg->line_out_pins);
4325 if (cfg->line_out_type != AUTO_PIN_HP_OUT)
4326 sync_pin_power_ctls(codec, cfg->hp_outs, cfg->hp_pins);
4327 if (cfg->line_out_type != AUTO_PIN_SPEAKER_OUT)
4328 sync_pin_power_ctls(codec, cfg->speaker_outs, cfg->speaker_pins);
4329 for (i = 0; i < cfg->num_inputs; i++)
4330 sync_pin_power_ctls(codec, 1, &cfg->inputs[i].pin);
4333 /* add fake paths if not present yet */
4334 static int add_fake_paths(struct hda_codec *codec, hda_nid_t nid,
4335 int num_pins, const hda_nid_t *pins)
4337 struct hda_gen_spec *spec = codec->spec;
4338 struct nid_path *path;
4341 for (i = 0; i < num_pins; i++) {
4344 if (get_nid_path(codec, nid, pins[i], 0))
4346 path = snd_array_new(&spec->paths);
4349 memset(path, 0, sizeof(*path));
4351 path->path[0] = nid;
4352 path->path[1] = pins[i];
4353 path->active = true;
4358 /* create fake paths to all outputs from beep */
4359 static int add_fake_beep_paths(struct hda_codec *codec)
4361 struct hda_gen_spec *spec = codec->spec;
4362 struct auto_pin_cfg *cfg = &spec->autocfg;
4363 hda_nid_t nid = spec->beep_nid;
4366 if (!codec->power_save_node || !nid)
4368 err = add_fake_paths(codec, nid, cfg->line_outs, cfg->line_out_pins);
4371 if (cfg->line_out_type != AUTO_PIN_HP_OUT) {
4372 err = add_fake_paths(codec, nid, cfg->hp_outs, cfg->hp_pins);
4376 if (cfg->line_out_type != AUTO_PIN_SPEAKER_OUT) {
4377 err = add_fake_paths(codec, nid, cfg->speaker_outs,
4385 /* power up/down beep widget and its output paths */
4386 static void beep_power_hook(struct hda_beep *beep, bool on)
4388 set_path_power(beep->codec, beep->nid, -1, on);
4392 * snd_hda_gen_fix_pin_power - Fix the power of the given pin widget to D0
4393 * @codec: the HDA codec
4394 * @pin: NID of pin to fix
4396 int snd_hda_gen_fix_pin_power(struct hda_codec *codec, hda_nid_t pin)
4398 struct hda_gen_spec *spec = codec->spec;
4399 struct nid_path *path;
4401 path = snd_array_new(&spec->paths);
4404 memset(path, 0, sizeof(*path));
4406 path->path[0] = pin;
4407 path->active = true;
4408 path->pin_fixed = true;
4409 path->stream_enabled = true;
4412 EXPORT_SYMBOL_GPL(snd_hda_gen_fix_pin_power);
4415 * Jack detections for HP auto-mute and mic-switch
4418 /* check each pin in the given array; returns true if any of them is plugged */
4419 static bool detect_jacks(struct hda_codec *codec, int num_pins, const hda_nid_t *pins)
4422 bool present = false;
4424 for (i = 0; i < num_pins; i++) {
4425 hda_nid_t nid = pins[i];
4428 /* don't detect pins retasked as inputs */
4429 if (snd_hda_codec_get_pin_target(codec, nid) & AC_PINCTL_IN_EN)
4431 if (snd_hda_jack_detect_state(codec, nid) == HDA_JACK_PRESENT)
4437 /* standard HP/line-out auto-mute helper */
4438 static void do_automute(struct hda_codec *codec, int num_pins, const hda_nid_t *pins,
4439 int *paths, bool mute)
4441 struct hda_gen_spec *spec = codec->spec;
4444 for (i = 0; i < num_pins; i++) {
4445 hda_nid_t nid = pins[i];
4446 unsigned int val, oldval;
4450 oldval = snd_hda_codec_get_pin_target(codec, nid);
4451 if (oldval & PIN_IN)
4452 continue; /* no mute for inputs */
4454 if (spec->auto_mute_via_amp) {
4455 struct nid_path *path;
4458 path = snd_hda_get_path_from_idx(codec, paths[i]);
4461 mute_nid = get_amp_nid_(path->ctls[NID_PATH_MUTE_CTL]);
4465 spec->mute_bits |= (1ULL << mute_nid);
4467 spec->mute_bits &= ~(1ULL << mute_nid);
4470 /* don't reset VREF value in case it's controlling
4471 * the amp (see alc861_fixup_asus_amp_vref_0f())
4473 if (spec->keep_vref_in_automute)
4474 val = oldval & ~PIN_HP;
4479 /* here we call update_pin_ctl() so that the pinctl is
4480 * changed without changing the pinctl target value;
4481 * the original target value will be still referred at
4482 * the init / resume again
4484 update_pin_ctl(codec, nid, val);
4487 set_pin_eapd(codec, nid, !mute);
4488 if (codec->power_save_node) {
4491 on = detect_pin_state(codec, nid);
4492 set_path_power(codec, nid, on, -1);
4498 * snd_hda_gen_update_outputs - Toggle outputs muting
4499 * @codec: the HDA codec
4501 * Update the mute status of all outputs based on the current jack states.
4503 void snd_hda_gen_update_outputs(struct hda_codec *codec)
4505 struct hda_gen_spec *spec = codec->spec;
4509 /* Control HP pins/amps depending on master_mute state;
4510 * in general, HP pins/amps control should be enabled in all cases,
4511 * but currently set only for master_mute, just to be safe
4513 if (spec->autocfg.line_out_type == AUTO_PIN_HP_OUT)
4514 paths = spec->out_paths;
4516 paths = spec->hp_paths;
4517 do_automute(codec, ARRAY_SIZE(spec->autocfg.hp_pins),
4518 spec->autocfg.hp_pins, paths, spec->master_mute);
4520 if (!spec->automute_speaker)
4523 on = spec->hp_jack_present | spec->line_jack_present;
4524 on |= spec->master_mute;
4525 spec->speaker_muted = on;
4526 if (spec->autocfg.line_out_type == AUTO_PIN_SPEAKER_OUT)
4527 paths = spec->out_paths;
4529 paths = spec->speaker_paths;
4530 do_automute(codec, ARRAY_SIZE(spec->autocfg.speaker_pins),
4531 spec->autocfg.speaker_pins, paths, on);
4533 /* toggle line-out mutes if needed, too */
4534 /* if LO is a copy of either HP or Speaker, don't need to handle it */
4535 if (spec->autocfg.line_out_pins[0] == spec->autocfg.hp_pins[0] ||
4536 spec->autocfg.line_out_pins[0] == spec->autocfg.speaker_pins[0])
4538 if (!spec->automute_lo)
4541 on = spec->hp_jack_present;
4542 on |= spec->master_mute;
4543 spec->line_out_muted = on;
4544 paths = spec->out_paths;
4545 do_automute(codec, ARRAY_SIZE(spec->autocfg.line_out_pins),
4546 spec->autocfg.line_out_pins, paths, on);
4548 EXPORT_SYMBOL_GPL(snd_hda_gen_update_outputs);
4550 static void call_update_outputs(struct hda_codec *codec)
4552 struct hda_gen_spec *spec = codec->spec;
4553 if (spec->automute_hook)
4554 spec->automute_hook(codec);
4556 snd_hda_gen_update_outputs(codec);
4558 /* sync the whole vmaster slaves to reflect the new auto-mute status */
4559 if (spec->auto_mute_via_amp && !codec->bus->shutdown)
4560 snd_ctl_sync_vmaster(spec->vmaster_mute.sw_kctl, false);
4564 * snd_hda_gen_hp_automute - standard HP-automute helper
4565 * @codec: the HDA codec
4566 * @jack: jack object, NULL for the whole
4568 void snd_hda_gen_hp_automute(struct hda_codec *codec,
4569 struct hda_jack_callback *jack)
4571 struct hda_gen_spec *spec = codec->spec;
4572 hda_nid_t *pins = spec->autocfg.hp_pins;
4573 int num_pins = ARRAY_SIZE(spec->autocfg.hp_pins);
4575 /* No detection for the first HP jack during indep-HP mode */
4576 if (spec->indep_hp_enabled) {
4581 spec->hp_jack_present = detect_jacks(codec, num_pins, pins);
4582 if (!spec->detect_hp || (!spec->automute_speaker && !spec->automute_lo))
4584 call_update_outputs(codec);
4586 EXPORT_SYMBOL_GPL(snd_hda_gen_hp_automute);
4589 * snd_hda_gen_line_automute - standard line-out-automute helper
4590 * @codec: the HDA codec
4591 * @jack: jack object, NULL for the whole
4593 void snd_hda_gen_line_automute(struct hda_codec *codec,
4594 struct hda_jack_callback *jack)
4596 struct hda_gen_spec *spec = codec->spec;
4598 if (spec->autocfg.line_out_type == AUTO_PIN_SPEAKER_OUT)
4600 /* check LO jack only when it's different from HP */
4601 if (spec->autocfg.line_out_pins[0] == spec->autocfg.hp_pins[0])
4604 spec->line_jack_present =
4605 detect_jacks(codec, ARRAY_SIZE(spec->autocfg.line_out_pins),
4606 spec->autocfg.line_out_pins);
4607 if (!spec->automute_speaker || !spec->detect_lo)
4609 call_update_outputs(codec);
4611 EXPORT_SYMBOL_GPL(snd_hda_gen_line_automute);
4614 * snd_hda_gen_mic_autoswitch - standard mic auto-switch helper
4615 * @codec: the HDA codec
4616 * @jack: jack object, NULL for the whole
4618 void snd_hda_gen_mic_autoswitch(struct hda_codec *codec,
4619 struct hda_jack_callback *jack)
4621 struct hda_gen_spec *spec = codec->spec;
4624 if (!spec->auto_mic)
4627 for (i = spec->am_num_entries - 1; i > 0; i--) {
4628 hda_nid_t pin = spec->am_entry[i].pin;
4629 /* don't detect pins retasked as outputs */
4630 if (snd_hda_codec_get_pin_target(codec, pin) & AC_PINCTL_OUT_EN)
4632 if (snd_hda_jack_detect_state(codec, pin) == HDA_JACK_PRESENT) {
4633 mux_select(codec, 0, spec->am_entry[i].idx);
4637 mux_select(codec, 0, spec->am_entry[0].idx);
4639 EXPORT_SYMBOL_GPL(snd_hda_gen_mic_autoswitch);
4641 /* call appropriate hooks */
4642 static void call_hp_automute(struct hda_codec *codec,
4643 struct hda_jack_callback *jack)
4645 struct hda_gen_spec *spec = codec->spec;
4646 if (spec->hp_automute_hook)
4647 spec->hp_automute_hook(codec, jack);
4649 snd_hda_gen_hp_automute(codec, jack);
4652 static void call_line_automute(struct hda_codec *codec,
4653 struct hda_jack_callback *jack)
4655 struct hda_gen_spec *spec = codec->spec;
4656 if (spec->line_automute_hook)
4657 spec->line_automute_hook(codec, jack);
4659 snd_hda_gen_line_automute(codec, jack);
4662 static void call_mic_autoswitch(struct hda_codec *codec,
4663 struct hda_jack_callback *jack)
4665 struct hda_gen_spec *spec = codec->spec;
4666 if (spec->mic_autoswitch_hook)
4667 spec->mic_autoswitch_hook(codec, jack);
4669 snd_hda_gen_mic_autoswitch(codec, jack);
4672 /* update jack retasking */
4673 static void update_automute_all(struct hda_codec *codec)
4675 call_hp_automute(codec, NULL);
4676 call_line_automute(codec, NULL);
4677 call_mic_autoswitch(codec, NULL);
4681 * Auto-Mute mode mixer enum support
4683 static int automute_mode_info(struct snd_kcontrol *kcontrol,
4684 struct snd_ctl_elem_info *uinfo)
4686 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
4687 struct hda_gen_spec *spec = codec->spec;
4688 static const char * const texts3[] = {
4689 "Disabled", "Speaker Only", "Line Out+Speaker"
4692 if (spec->automute_speaker_possible && spec->automute_lo_possible)
4693 return snd_hda_enum_helper_info(kcontrol, uinfo, 3, texts3);
4694 return snd_hda_enum_bool_helper_info(kcontrol, uinfo);
4697 static int automute_mode_get(struct snd_kcontrol *kcontrol,
4698 struct snd_ctl_elem_value *ucontrol)
4700 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
4701 struct hda_gen_spec *spec = codec->spec;
4702 unsigned int val = 0;
4703 if (spec->automute_speaker)
4705 if (spec->automute_lo)
4708 ucontrol->value.enumerated.item[0] = val;
4712 static int automute_mode_put(struct snd_kcontrol *kcontrol,
4713 struct snd_ctl_elem_value *ucontrol)
4715 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
4716 struct hda_gen_spec *spec = codec->spec;
4718 switch (ucontrol->value.enumerated.item[0]) {
4720 if (!spec->automute_speaker && !spec->automute_lo)
4722 spec->automute_speaker = 0;
4723 spec->automute_lo = 0;
4726 if (spec->automute_speaker_possible) {
4727 if (!spec->automute_lo && spec->automute_speaker)
4729 spec->automute_speaker = 1;
4730 spec->automute_lo = 0;
4731 } else if (spec->automute_lo_possible) {
4732 if (spec->automute_lo)
4734 spec->automute_lo = 1;
4739 if (!spec->automute_lo_possible || !spec->automute_speaker_possible)
4741 if (spec->automute_speaker && spec->automute_lo)
4743 spec->automute_speaker = 1;
4744 spec->automute_lo = 1;
4749 call_update_outputs(codec);
4753 static const struct snd_kcontrol_new automute_mode_enum = {
4754 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
4755 .name = "Auto-Mute Mode",
4756 .info = automute_mode_info,
4757 .get = automute_mode_get,
4758 .put = automute_mode_put,
4761 static int add_automute_mode_enum(struct hda_codec *codec)
4763 struct hda_gen_spec *spec = codec->spec;
4765 if (!snd_hda_gen_add_kctl(spec, NULL, &automute_mode_enum))
4771 * Check the availability of HP/line-out auto-mute;
4772 * Set up appropriately if really supported
4774 static int check_auto_mute_availability(struct hda_codec *codec)
4776 struct hda_gen_spec *spec = codec->spec;
4777 struct auto_pin_cfg *cfg = &spec->autocfg;
4781 if (spec->suppress_auto_mute)
4784 if (cfg->hp_pins[0])
4786 if (cfg->line_out_pins[0])
4788 if (cfg->speaker_pins[0])
4790 if (present < 2) /* need two different output types */
4793 if (!cfg->speaker_pins[0] &&
4794 cfg->line_out_type == AUTO_PIN_SPEAKER_OUT) {
4795 memcpy(cfg->speaker_pins, cfg->line_out_pins,
4796 sizeof(cfg->speaker_pins));
4797 cfg->speaker_outs = cfg->line_outs;
4800 if (!cfg->hp_pins[0] &&
4801 cfg->line_out_type == AUTO_PIN_HP_OUT) {
4802 memcpy(cfg->hp_pins, cfg->line_out_pins,
4803 sizeof(cfg->hp_pins));
4804 cfg->hp_outs = cfg->line_outs;
4807 for (i = 0; i < cfg->hp_outs; i++) {
4808 hda_nid_t nid = cfg->hp_pins[i];
4809 if (!is_jack_detectable(codec, nid))
4811 codec_dbg(codec, "Enable HP auto-muting on NID 0x%x\n", nid);
4812 snd_hda_jack_detect_enable_callback(codec, nid,
4814 spec->detect_hp = 1;
4817 if (cfg->line_out_type == AUTO_PIN_LINE_OUT && cfg->line_outs) {
4818 if (cfg->speaker_outs)
4819 for (i = 0; i < cfg->line_outs; i++) {
4820 hda_nid_t nid = cfg->line_out_pins[i];
4821 if (!is_jack_detectable(codec, nid))
4823 codec_dbg(codec, "Enable Line-Out auto-muting on NID 0x%x\n", nid);
4824 snd_hda_jack_detect_enable_callback(codec, nid,
4825 call_line_automute);
4826 spec->detect_lo = 1;
4828 spec->automute_lo_possible = spec->detect_hp;
4831 spec->automute_speaker_possible = cfg->speaker_outs &&
4832 (spec->detect_hp || spec->detect_lo);
4834 spec->automute_lo = spec->automute_lo_possible;
4835 spec->automute_speaker = spec->automute_speaker_possible;
4837 if (spec->automute_speaker_possible || spec->automute_lo_possible) {
4838 /* create a control for automute mode */
4839 err = add_automute_mode_enum(codec);
4846 /* check whether all auto-mic pins are valid; setup indices if OK */
4847 static bool auto_mic_check_imux(struct hda_codec *codec)
4849 struct hda_gen_spec *spec = codec->spec;
4850 const struct hda_input_mux *imux;
4853 imux = &spec->input_mux;
4854 for (i = 0; i < spec->am_num_entries; i++) {
4855 spec->am_entry[i].idx =
4856 find_idx_in_nid_list(spec->am_entry[i].pin,
4857 spec->imux_pins, imux->num_items);
4858 if (spec->am_entry[i].idx < 0)
4859 return false; /* no corresponding imux */
4862 /* we don't need the jack detection for the first pin */
4863 for (i = 1; i < spec->am_num_entries; i++)
4864 snd_hda_jack_detect_enable_callback(codec,
4865 spec->am_entry[i].pin,
4866 call_mic_autoswitch);
4870 static int compare_attr(const void *ap, const void *bp)
4872 const struct automic_entry *a = ap;
4873 const struct automic_entry *b = bp;
4874 return (int)(a->attr - b->attr);
4878 * Check the availability of auto-mic switch;
4879 * Set up if really supported
4881 static int check_auto_mic_availability(struct hda_codec *codec)
4883 struct hda_gen_spec *spec = codec->spec;
4884 struct auto_pin_cfg *cfg = &spec->autocfg;
4888 if (spec->suppress_auto_mic)
4893 for (i = 0; i < cfg->num_inputs; i++) {
4894 hda_nid_t nid = cfg->inputs[i].pin;
4896 attr = snd_hda_codec_get_pincfg(codec, nid);
4897 attr = snd_hda_get_input_pin_attr(attr);
4898 if (types & (1 << attr))
4899 return 0; /* already occupied */
4901 case INPUT_PIN_ATTR_INT:
4902 if (cfg->inputs[i].type != AUTO_PIN_MIC)
4903 return 0; /* invalid type */
4905 case INPUT_PIN_ATTR_UNUSED:
4906 return 0; /* invalid entry */
4908 if (cfg->inputs[i].type > AUTO_PIN_LINE_IN)
4909 return 0; /* invalid type */
4910 if (!spec->line_in_auto_switch &&
4911 cfg->inputs[i].type != AUTO_PIN_MIC)
4912 return 0; /* only mic is allowed */
4913 if (!is_jack_detectable(codec, nid))
4914 return 0; /* no unsol support */
4917 if (num_pins >= MAX_AUTO_MIC_PINS)
4919 types |= (1 << attr);
4920 spec->am_entry[num_pins].pin = nid;
4921 spec->am_entry[num_pins].attr = attr;
4928 spec->am_num_entries = num_pins;
4929 /* sort the am_entry in the order of attr so that the pin with a
4930 * higher attr will be selected when the jack is plugged.
4932 sort(spec->am_entry, num_pins, sizeof(spec->am_entry[0]),
4933 compare_attr, NULL);
4935 if (!auto_mic_check_imux(codec))
4939 spec->num_adc_nids = 1;
4940 spec->cur_mux[0] = spec->am_entry[0].idx;
4941 codec_dbg(codec, "Enable auto-mic switch on NID 0x%x/0x%x/0x%x\n",
4942 spec->am_entry[0].pin,
4943 spec->am_entry[1].pin,
4944 spec->am_entry[2].pin);
4950 * snd_hda_gen_path_power_filter - power_filter hook to make inactive widgets
4952 * @codec: the HDA codec
4953 * @nid: NID to evalute
4954 * @power_state: target power state
4956 unsigned int snd_hda_gen_path_power_filter(struct hda_codec *codec,
4958 unsigned int power_state)
4960 struct hda_gen_spec *spec = codec->spec;
4962 if (!spec->power_down_unused && !codec->power_save_node)
4964 if (power_state != AC_PWRST_D0 || nid == codec->core.afg)
4966 if (get_wcaps_type(get_wcaps(codec, nid)) >= AC_WID_POWER)
4968 if (is_active_nid_for_any(codec, nid))
4972 EXPORT_SYMBOL_GPL(snd_hda_gen_path_power_filter);
4974 /* mute all aamix inputs initially; parse up to the first leaves */
4975 static void mute_all_mixer_nid(struct hda_codec *codec, hda_nid_t mix)
4978 const hda_nid_t *conn;
4981 nums = snd_hda_get_conn_list(codec, mix, &conn);
4982 has_amp = nid_has_mute(codec, mix, HDA_INPUT);
4983 for (i = 0; i < nums; i++) {
4985 update_amp(codec, mix, HDA_INPUT, i,
4986 0xff, HDA_AMP_MUTE);
4987 else if (nid_has_volume(codec, conn[i], HDA_OUTPUT))
4988 update_amp(codec, conn[i], HDA_OUTPUT, 0,
4989 0xff, HDA_AMP_MUTE);
4994 * snd_hda_gen_stream_pm - Stream power management callback
4995 * @codec: the HDA codec
4996 * @nid: audio widget
4997 * @on: power on/off flag
4999 * Set this in patch_ops.stream_pm. Only valid with power_save_node flag.
5001 void snd_hda_gen_stream_pm(struct hda_codec *codec, hda_nid_t nid, bool on)
5003 if (codec->power_save_node)
5004 set_path_power(codec, nid, -1, on);
5006 EXPORT_SYMBOL_GPL(snd_hda_gen_stream_pm);
5009 * snd_hda_gen_parse_auto_config - Parse the given BIOS configuration and
5010 * set up the hda_gen_spec
5011 * @codec: the HDA codec
5012 * @cfg: Parsed pin configuration
5014 * return 1 if successful, 0 if the proper config is not found,
5015 * or a negative error code
5017 int snd_hda_gen_parse_auto_config(struct hda_codec *codec,
5018 struct auto_pin_cfg *cfg)
5020 struct hda_gen_spec *spec = codec->spec;
5023 parse_user_hints(codec);
5025 if (spec->mixer_nid && !spec->mixer_merge_nid)
5026 spec->mixer_merge_nid = spec->mixer_nid;
5028 if (cfg != &spec->autocfg) {
5029 spec->autocfg = *cfg;
5030 cfg = &spec->autocfg;
5033 if (!spec->main_out_badness)
5034 spec->main_out_badness = &hda_main_out_badness;
5035 if (!spec->extra_out_badness)
5036 spec->extra_out_badness = &hda_extra_out_badness;
5038 fill_all_dac_nids(codec);
5040 if (!cfg->line_outs) {
5041 if (cfg->dig_outs || cfg->dig_in_pin) {
5042 spec->multiout.max_channels = 2;
5043 spec->no_analog = 1;
5046 if (!cfg->num_inputs && !cfg->dig_in_pin)
5047 return 0; /* can't find valid BIOS pin config */
5050 if (!spec->no_primary_hp &&
5051 cfg->line_out_type == AUTO_PIN_SPEAKER_OUT &&
5052 cfg->line_outs <= cfg->hp_outs) {
5053 /* use HP as primary out */
5054 cfg->speaker_outs = cfg->line_outs;
5055 memcpy(cfg->speaker_pins, cfg->line_out_pins,
5056 sizeof(cfg->speaker_pins));
5057 cfg->line_outs = cfg->hp_outs;
5058 memcpy(cfg->line_out_pins, cfg->hp_pins, sizeof(cfg->hp_pins));
5060 memset(cfg->hp_pins, 0, sizeof(cfg->hp_pins));
5061 cfg->line_out_type = AUTO_PIN_HP_OUT;
5064 err = parse_output_paths(codec);
5067 err = create_multi_channel_mode(codec);
5070 err = create_multi_out_ctls(codec, cfg);
5073 err = create_hp_out_ctls(codec);
5076 err = create_speaker_out_ctls(codec);
5079 err = create_indep_hp_ctls(codec);
5082 err = create_loopback_mixing_ctl(codec);
5085 err = create_hp_mic(codec);
5088 err = create_input_ctls(codec);
5092 /* add power-down pin callbacks at first */
5093 add_all_pin_power_ctls(codec, false);
5095 spec->const_channel_count = spec->ext_channel_count;
5096 /* check the multiple speaker and headphone pins */
5097 if (cfg->line_out_type != AUTO_PIN_SPEAKER_OUT)
5098 spec->const_channel_count = max(spec->const_channel_count,
5099 cfg->speaker_outs * 2);
5100 if (cfg->line_out_type != AUTO_PIN_HP_OUT)
5101 spec->const_channel_count = max(spec->const_channel_count,
5103 spec->multiout.max_channels = max(spec->ext_channel_count,
5104 spec->const_channel_count);
5106 err = check_auto_mute_availability(codec);
5110 err = check_dyn_adc_switch(codec);
5114 err = check_auto_mic_availability(codec);
5118 /* add stereo mix if available and not enabled yet */
5119 if (!spec->auto_mic && spec->mixer_nid &&
5120 spec->add_stereo_mix_input == HDA_HINT_STEREO_MIX_AUTO &&
5121 spec->input_mux.num_items > 1) {
5122 err = parse_capture_source(codec, spec->mixer_nid,
5123 CFG_IDX_MIX, spec->num_all_adcs,
5130 err = create_capture_mixers(codec);
5134 err = parse_mic_boost(codec);
5138 /* create "Headphone Mic Jack Mode" if no input selection is
5139 * available (or user specifies add_jack_modes hint)
5141 if (spec->hp_mic_pin &&
5142 (spec->auto_mic || spec->input_mux.num_items == 1 ||
5143 spec->add_jack_modes)) {
5144 err = create_hp_mic_jack_mode(codec, spec->hp_mic_pin);
5149 if (spec->add_jack_modes) {
5150 if (cfg->line_out_type != AUTO_PIN_SPEAKER_OUT) {
5151 err = create_out_jack_modes(codec, cfg->line_outs,
5152 cfg->line_out_pins);
5156 if (cfg->line_out_type != AUTO_PIN_HP_OUT) {
5157 err = create_out_jack_modes(codec, cfg->hp_outs,
5164 /* add power-up pin callbacks at last */
5165 add_all_pin_power_ctls(codec, true);
5167 /* mute all aamix input initially */
5168 if (spec->mixer_nid)
5169 mute_all_mixer_nid(codec, spec->mixer_nid);
5172 parse_digital(codec);
5174 if (spec->power_down_unused || codec->power_save_node) {
5175 if (!codec->power_filter)
5176 codec->power_filter = snd_hda_gen_path_power_filter;
5177 if (!codec->patch_ops.stream_pm)
5178 codec->patch_ops.stream_pm = snd_hda_gen_stream_pm;
5181 if (!spec->no_analog && spec->beep_nid) {
5182 err = snd_hda_attach_beep_device(codec, spec->beep_nid);
5185 if (codec->beep && codec->power_save_node) {
5186 err = add_fake_beep_paths(codec);
5189 codec->beep->power_hook = beep_power_hook;
5195 EXPORT_SYMBOL_GPL(snd_hda_gen_parse_auto_config);
5199 * Build control elements
5202 /* slave controls for virtual master */
5203 static const char * const slave_pfxs[] = {
5204 "Front", "Surround", "Center", "LFE", "Side",
5205 "Headphone", "Speaker", "Mono", "Line Out",
5206 "CLFE", "Bass Speaker", "PCM",
5207 "Speaker Front", "Speaker Surround", "Speaker CLFE", "Speaker Side",
5208 "Headphone Front", "Headphone Surround", "Headphone CLFE",
5209 "Headphone Side", "Headphone+LO", "Speaker+LO",
5214 * snd_hda_gen_build_controls - Build controls from the parsed results
5215 * @codec: the HDA codec
5217 * Pass this to build_controls patch_ops.
5219 int snd_hda_gen_build_controls(struct hda_codec *codec)
5221 struct hda_gen_spec *spec = codec->spec;
5224 if (spec->kctls.used) {
5225 err = snd_hda_add_new_ctls(codec, spec->kctls.list);
5230 if (spec->multiout.dig_out_nid) {
5231 err = snd_hda_create_dig_out_ctls(codec,
5232 spec->multiout.dig_out_nid,
5233 spec->multiout.dig_out_nid,
5234 spec->pcm_rec[1]->pcm_type);
5237 if (!spec->no_analog) {
5238 err = snd_hda_create_spdif_share_sw(codec,
5242 spec->multiout.share_spdif = 1;
5245 if (spec->dig_in_nid) {
5246 err = snd_hda_create_spdif_in_ctls(codec, spec->dig_in_nid);
5251 /* if we have no master control, let's create it */
5252 if (!spec->no_analog && !spec->suppress_vmaster &&
5253 !snd_hda_find_mixer_ctl(codec, "Master Playback Volume")) {
5254 err = snd_hda_add_vmaster(codec, "Master Playback Volume",
5255 spec->vmaster_tlv, slave_pfxs,
5260 if (!spec->no_analog && !spec->suppress_vmaster &&
5261 !snd_hda_find_mixer_ctl(codec, "Master Playback Switch")) {
5262 err = __snd_hda_add_vmaster(codec, "Master Playback Switch",
5265 true, &spec->vmaster_mute.sw_kctl);
5268 if (spec->vmaster_mute.hook) {
5269 snd_hda_add_vmaster_hook(codec, &spec->vmaster_mute,
5270 spec->vmaster_mute_enum);
5271 snd_hda_sync_vmaster_hook(&spec->vmaster_mute);
5275 free_kctls(spec); /* no longer needed */
5277 err = snd_hda_jack_add_kctls(codec, &spec->autocfg);
5283 EXPORT_SYMBOL_GPL(snd_hda_gen_build_controls);
5290 static void call_pcm_playback_hook(struct hda_pcm_stream *hinfo,
5291 struct hda_codec *codec,
5292 struct snd_pcm_substream *substream,
5295 struct hda_gen_spec *spec = codec->spec;
5296 if (spec->pcm_playback_hook)
5297 spec->pcm_playback_hook(hinfo, codec, substream, action);
5300 static void call_pcm_capture_hook(struct hda_pcm_stream *hinfo,
5301 struct hda_codec *codec,
5302 struct snd_pcm_substream *substream,
5305 struct hda_gen_spec *spec = codec->spec;
5306 if (spec->pcm_capture_hook)
5307 spec->pcm_capture_hook(hinfo, codec, substream, action);
5311 * Analog playback callbacks
5313 static int playback_pcm_open(struct hda_pcm_stream *hinfo,
5314 struct hda_codec *codec,
5315 struct snd_pcm_substream *substream)
5317 struct hda_gen_spec *spec = codec->spec;
5320 mutex_lock(&spec->pcm_mutex);
5321 err = snd_hda_multi_out_analog_open(codec,
5322 &spec->multiout, substream,
5325 spec->active_streams |= 1 << STREAM_MULTI_OUT;
5326 call_pcm_playback_hook(hinfo, codec, substream,
5327 HDA_GEN_PCM_ACT_OPEN);
5329 mutex_unlock(&spec->pcm_mutex);
5333 static int playback_pcm_prepare(struct hda_pcm_stream *hinfo,
5334 struct hda_codec *codec,
5335 unsigned int stream_tag,
5336 unsigned int format,
5337 struct snd_pcm_substream *substream)
5339 struct hda_gen_spec *spec = codec->spec;
5342 err = snd_hda_multi_out_analog_prepare(codec, &spec->multiout,
5343 stream_tag, format, substream);
5345 call_pcm_playback_hook(hinfo, codec, substream,
5346 HDA_GEN_PCM_ACT_PREPARE);
5350 static int playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
5351 struct hda_codec *codec,
5352 struct snd_pcm_substream *substream)
5354 struct hda_gen_spec *spec = codec->spec;
5357 err = snd_hda_multi_out_analog_cleanup(codec, &spec->multiout);
5359 call_pcm_playback_hook(hinfo, codec, substream,
5360 HDA_GEN_PCM_ACT_CLEANUP);
5364 static int playback_pcm_close(struct hda_pcm_stream *hinfo,
5365 struct hda_codec *codec,
5366 struct snd_pcm_substream *substream)
5368 struct hda_gen_spec *spec = codec->spec;
5369 mutex_lock(&spec->pcm_mutex);
5370 spec->active_streams &= ~(1 << STREAM_MULTI_OUT);
5371 call_pcm_playback_hook(hinfo, codec, substream,
5372 HDA_GEN_PCM_ACT_CLOSE);
5373 mutex_unlock(&spec->pcm_mutex);
5377 static int capture_pcm_open(struct hda_pcm_stream *hinfo,
5378 struct hda_codec *codec,
5379 struct snd_pcm_substream *substream)
5381 call_pcm_capture_hook(hinfo, codec, substream, HDA_GEN_PCM_ACT_OPEN);
5385 static int capture_pcm_prepare(struct hda_pcm_stream *hinfo,
5386 struct hda_codec *codec,
5387 unsigned int stream_tag,
5388 unsigned int format,
5389 struct snd_pcm_substream *substream)
5391 snd_hda_codec_setup_stream(codec, hinfo->nid, stream_tag, 0, format);
5392 call_pcm_capture_hook(hinfo, codec, substream,
5393 HDA_GEN_PCM_ACT_PREPARE);
5397 static int capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
5398 struct hda_codec *codec,
5399 struct snd_pcm_substream *substream)
5401 snd_hda_codec_cleanup_stream(codec, hinfo->nid);
5402 call_pcm_capture_hook(hinfo, codec, substream,
5403 HDA_GEN_PCM_ACT_CLEANUP);
5407 static int capture_pcm_close(struct hda_pcm_stream *hinfo,
5408 struct hda_codec *codec,
5409 struct snd_pcm_substream *substream)
5411 call_pcm_capture_hook(hinfo, codec, substream, HDA_GEN_PCM_ACT_CLOSE);
5415 static int alt_playback_pcm_open(struct hda_pcm_stream *hinfo,
5416 struct hda_codec *codec,
5417 struct snd_pcm_substream *substream)
5419 struct hda_gen_spec *spec = codec->spec;
5422 mutex_lock(&spec->pcm_mutex);
5423 if (spec->indep_hp && !spec->indep_hp_enabled)
5426 spec->active_streams |= 1 << STREAM_INDEP_HP;
5427 call_pcm_playback_hook(hinfo, codec, substream,
5428 HDA_GEN_PCM_ACT_OPEN);
5429 mutex_unlock(&spec->pcm_mutex);
5433 static int alt_playback_pcm_close(struct hda_pcm_stream *hinfo,
5434 struct hda_codec *codec,
5435 struct snd_pcm_substream *substream)
5437 struct hda_gen_spec *spec = codec->spec;
5438 mutex_lock(&spec->pcm_mutex);
5439 spec->active_streams &= ~(1 << STREAM_INDEP_HP);
5440 call_pcm_playback_hook(hinfo, codec, substream,
5441 HDA_GEN_PCM_ACT_CLOSE);
5442 mutex_unlock(&spec->pcm_mutex);
5446 static int alt_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
5447 struct hda_codec *codec,
5448 unsigned int stream_tag,
5449 unsigned int format,
5450 struct snd_pcm_substream *substream)
5452 snd_hda_codec_setup_stream(codec, hinfo->nid, stream_tag, 0, format);
5453 call_pcm_playback_hook(hinfo, codec, substream,
5454 HDA_GEN_PCM_ACT_PREPARE);
5458 static int alt_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
5459 struct hda_codec *codec,
5460 struct snd_pcm_substream *substream)
5462 snd_hda_codec_cleanup_stream(codec, hinfo->nid);
5463 call_pcm_playback_hook(hinfo, codec, substream,
5464 HDA_GEN_PCM_ACT_CLEANUP);
5471 static int dig_playback_pcm_open(struct hda_pcm_stream *hinfo,
5472 struct hda_codec *codec,
5473 struct snd_pcm_substream *substream)
5475 struct hda_gen_spec *spec = codec->spec;
5476 return snd_hda_multi_out_dig_open(codec, &spec->multiout);
5479 static int dig_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
5480 struct hda_codec *codec,
5481 unsigned int stream_tag,
5482 unsigned int format,
5483 struct snd_pcm_substream *substream)
5485 struct hda_gen_spec *spec = codec->spec;
5486 return snd_hda_multi_out_dig_prepare(codec, &spec->multiout,
5487 stream_tag, format, substream);
5490 static int dig_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
5491 struct hda_codec *codec,
5492 struct snd_pcm_substream *substream)
5494 struct hda_gen_spec *spec = codec->spec;
5495 return snd_hda_multi_out_dig_cleanup(codec, &spec->multiout);
5498 static int dig_playback_pcm_close(struct hda_pcm_stream *hinfo,
5499 struct hda_codec *codec,
5500 struct snd_pcm_substream *substream)
5502 struct hda_gen_spec *spec = codec->spec;
5503 return snd_hda_multi_out_dig_close(codec, &spec->multiout);
5509 #define alt_capture_pcm_open capture_pcm_open
5510 #define alt_capture_pcm_close capture_pcm_close
5512 static int alt_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
5513 struct hda_codec *codec,
5514 unsigned int stream_tag,
5515 unsigned int format,
5516 struct snd_pcm_substream *substream)
5518 struct hda_gen_spec *spec = codec->spec;
5520 snd_hda_codec_setup_stream(codec, spec->adc_nids[substream->number + 1],
5521 stream_tag, 0, format);
5522 call_pcm_capture_hook(hinfo, codec, substream,
5523 HDA_GEN_PCM_ACT_PREPARE);
5527 static int alt_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
5528 struct hda_codec *codec,
5529 struct snd_pcm_substream *substream)
5531 struct hda_gen_spec *spec = codec->spec;
5533 snd_hda_codec_cleanup_stream(codec,
5534 spec->adc_nids[substream->number + 1]);
5535 call_pcm_capture_hook(hinfo, codec, substream,
5536 HDA_GEN_PCM_ACT_CLEANUP);
5542 static const struct hda_pcm_stream pcm_analog_playback = {
5546 /* NID is set in build_pcms */
5548 .open = playback_pcm_open,
5549 .close = playback_pcm_close,
5550 .prepare = playback_pcm_prepare,
5551 .cleanup = playback_pcm_cleanup
5555 static const struct hda_pcm_stream pcm_analog_capture = {
5559 /* NID is set in build_pcms */
5561 .open = capture_pcm_open,
5562 .close = capture_pcm_close,
5563 .prepare = capture_pcm_prepare,
5564 .cleanup = capture_pcm_cleanup
5568 static const struct hda_pcm_stream pcm_analog_alt_playback = {
5572 /* NID is set in build_pcms */
5574 .open = alt_playback_pcm_open,
5575 .close = alt_playback_pcm_close,
5576 .prepare = alt_playback_pcm_prepare,
5577 .cleanup = alt_playback_pcm_cleanup
5581 static const struct hda_pcm_stream pcm_analog_alt_capture = {
5582 .substreams = 2, /* can be overridden */
5585 /* NID is set in build_pcms */
5587 .open = alt_capture_pcm_open,
5588 .close = alt_capture_pcm_close,
5589 .prepare = alt_capture_pcm_prepare,
5590 .cleanup = alt_capture_pcm_cleanup
5594 static const struct hda_pcm_stream pcm_digital_playback = {
5598 /* NID is set in build_pcms */
5600 .open = dig_playback_pcm_open,
5601 .close = dig_playback_pcm_close,
5602 .prepare = dig_playback_pcm_prepare,
5603 .cleanup = dig_playback_pcm_cleanup
5607 static const struct hda_pcm_stream pcm_digital_capture = {
5611 /* NID is set in build_pcms */
5614 /* Used by build_pcms to flag that a PCM has no playback stream */
5615 static const struct hda_pcm_stream pcm_null_stream = {
5622 * dynamic changing ADC PCM streams
5624 static bool dyn_adc_pcm_resetup(struct hda_codec *codec, int cur)
5626 struct hda_gen_spec *spec = codec->spec;
5627 hda_nid_t new_adc = spec->adc_nids[spec->dyn_adc_idx[cur]];
5629 if (spec->cur_adc && spec->cur_adc != new_adc) {
5630 /* stream is running, let's swap the current ADC */
5631 __snd_hda_codec_cleanup_stream(codec, spec->cur_adc, 1);
5632 spec->cur_adc = new_adc;
5633 snd_hda_codec_setup_stream(codec, new_adc,
5634 spec->cur_adc_stream_tag, 0,
5635 spec->cur_adc_format);
5641 /* analog capture with dynamic dual-adc changes */
5642 static int dyn_adc_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
5643 struct hda_codec *codec,
5644 unsigned int stream_tag,
5645 unsigned int format,
5646 struct snd_pcm_substream *substream)
5648 struct hda_gen_spec *spec = codec->spec;
5649 spec->cur_adc = spec->adc_nids[spec->dyn_adc_idx[spec->cur_mux[0]]];
5650 spec->cur_adc_stream_tag = stream_tag;
5651 spec->cur_adc_format = format;
5652 snd_hda_codec_setup_stream(codec, spec->cur_adc, stream_tag, 0, format);
5653 call_pcm_capture_hook(hinfo, codec, substream, HDA_GEN_PCM_ACT_PREPARE);
5657 static int dyn_adc_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
5658 struct hda_codec *codec,
5659 struct snd_pcm_substream *substream)
5661 struct hda_gen_spec *spec = codec->spec;
5662 snd_hda_codec_cleanup_stream(codec, spec->cur_adc);
5664 call_pcm_capture_hook(hinfo, codec, substream, HDA_GEN_PCM_ACT_CLEANUP);
5668 static const struct hda_pcm_stream dyn_adc_pcm_analog_capture = {
5672 .nid = 0, /* fill later */
5674 .prepare = dyn_adc_capture_pcm_prepare,
5675 .cleanup = dyn_adc_capture_pcm_cleanup
5679 static void fill_pcm_stream_name(char *str, size_t len, const char *sfx,
5680 const char *chip_name)
5686 strlcpy(str, chip_name, len);
5688 /* drop non-alnum chars after a space */
5689 for (p = strchr(str, ' '); p; p = strchr(p + 1, ' ')) {
5690 if (!isalnum(p[1])) {
5695 strlcat(str, sfx, len);
5698 /* copy PCM stream info from @default_str, and override non-NULL entries
5699 * from @spec_str and @nid
5701 static void setup_pcm_stream(struct hda_pcm_stream *str,
5702 const struct hda_pcm_stream *default_str,
5703 const struct hda_pcm_stream *spec_str,
5706 *str = *default_str;
5710 if (spec_str->substreams)
5711 str->substreams = spec_str->substreams;
5712 if (spec_str->channels_min)
5713 str->channels_min = spec_str->channels_min;
5714 if (spec_str->channels_max)
5715 str->channels_max = spec_str->channels_max;
5716 if (spec_str->rates)
5717 str->rates = spec_str->rates;
5718 if (spec_str->formats)
5719 str->formats = spec_str->formats;
5720 if (spec_str->maxbps)
5721 str->maxbps = spec_str->maxbps;
5726 * snd_hda_gen_build_pcms - build PCM streams based on the parsed results
5727 * @codec: the HDA codec
5729 * Pass this to build_pcms patch_ops.
5731 int snd_hda_gen_build_pcms(struct hda_codec *codec)
5733 struct hda_gen_spec *spec = codec->spec;
5734 struct hda_pcm *info;
5735 bool have_multi_adcs;
5737 if (spec->no_analog)
5740 fill_pcm_stream_name(spec->stream_name_analog,
5741 sizeof(spec->stream_name_analog),
5742 " Analog", codec->core.chip_name);
5743 info = snd_hda_codec_pcm_new(codec, "%s", spec->stream_name_analog);
5746 spec->pcm_rec[0] = info;
5748 if (spec->multiout.num_dacs > 0) {
5749 setup_pcm_stream(&info->stream[SNDRV_PCM_STREAM_PLAYBACK],
5750 &pcm_analog_playback,
5751 spec->stream_analog_playback,
5752 spec->multiout.dac_nids[0]);
5753 info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max =
5754 spec->multiout.max_channels;
5755 if (spec->autocfg.line_out_type == AUTO_PIN_SPEAKER_OUT &&
5756 spec->autocfg.line_outs == 2)
5757 info->stream[SNDRV_PCM_STREAM_PLAYBACK].chmap =
5760 if (spec->num_adc_nids) {
5761 setup_pcm_stream(&info->stream[SNDRV_PCM_STREAM_CAPTURE],
5762 (spec->dyn_adc_switch ?
5763 &dyn_adc_pcm_analog_capture : &pcm_analog_capture),
5764 spec->stream_analog_capture,
5769 /* SPDIF for stream index #1 */
5770 if (spec->multiout.dig_out_nid || spec->dig_in_nid) {
5771 fill_pcm_stream_name(spec->stream_name_digital,
5772 sizeof(spec->stream_name_digital),
5773 " Digital", codec->core.chip_name);
5774 info = snd_hda_codec_pcm_new(codec, "%s",
5775 spec->stream_name_digital);
5778 codec->slave_dig_outs = spec->multiout.slave_dig_outs;
5779 spec->pcm_rec[1] = info;
5780 if (spec->dig_out_type)
5781 info->pcm_type = spec->dig_out_type;
5783 info->pcm_type = HDA_PCM_TYPE_SPDIF;
5784 if (spec->multiout.dig_out_nid)
5785 setup_pcm_stream(&info->stream[SNDRV_PCM_STREAM_PLAYBACK],
5786 &pcm_digital_playback,
5787 spec->stream_digital_playback,
5788 spec->multiout.dig_out_nid);
5789 if (spec->dig_in_nid)
5790 setup_pcm_stream(&info->stream[SNDRV_PCM_STREAM_CAPTURE],
5791 &pcm_digital_capture,
5792 spec->stream_digital_capture,
5796 if (spec->no_analog)
5799 /* If the use of more than one ADC is requested for the current
5800 * model, configure a second analog capture-only PCM.
5802 have_multi_adcs = (spec->num_adc_nids > 1) &&
5803 !spec->dyn_adc_switch && !spec->auto_mic;
5804 /* Additional Analaog capture for index #2 */
5805 if (spec->alt_dac_nid || have_multi_adcs) {
5806 fill_pcm_stream_name(spec->stream_name_alt_analog,
5807 sizeof(spec->stream_name_alt_analog),
5808 " Alt Analog", codec->core.chip_name);
5809 info = snd_hda_codec_pcm_new(codec, "%s",
5810 spec->stream_name_alt_analog);
5813 spec->pcm_rec[2] = info;
5814 if (spec->alt_dac_nid)
5815 setup_pcm_stream(&info->stream[SNDRV_PCM_STREAM_PLAYBACK],
5816 &pcm_analog_alt_playback,
5817 spec->stream_analog_alt_playback,
5820 setup_pcm_stream(&info->stream[SNDRV_PCM_STREAM_PLAYBACK],
5821 &pcm_null_stream, NULL, 0);
5822 if (have_multi_adcs) {
5823 setup_pcm_stream(&info->stream[SNDRV_PCM_STREAM_CAPTURE],
5824 &pcm_analog_alt_capture,
5825 spec->stream_analog_alt_capture,
5827 info->stream[SNDRV_PCM_STREAM_CAPTURE].substreams =
5828 spec->num_adc_nids - 1;
5830 setup_pcm_stream(&info->stream[SNDRV_PCM_STREAM_CAPTURE],
5831 &pcm_null_stream, NULL, 0);
5837 EXPORT_SYMBOL_GPL(snd_hda_gen_build_pcms);
5841 * Standard auto-parser initializations
5844 /* configure the given path as a proper output */
5845 static void set_output_and_unmute(struct hda_codec *codec, int path_idx)
5847 struct nid_path *path;
5850 path = snd_hda_get_path_from_idx(codec, path_idx);
5851 if (!path || !path->depth)
5853 pin = path->path[path->depth - 1];
5854 restore_pin_ctl(codec, pin);
5855 snd_hda_activate_path(codec, path, path->active,
5856 aamix_default(codec->spec));
5857 set_pin_eapd(codec, pin, path->active);
5860 /* initialize primary output paths */
5861 static void init_multi_out(struct hda_codec *codec)
5863 struct hda_gen_spec *spec = codec->spec;
5866 for (i = 0; i < spec->autocfg.line_outs; i++)
5867 set_output_and_unmute(codec, spec->out_paths[i]);
5871 static void __init_extra_out(struct hda_codec *codec, int num_outs, int *paths)
5875 for (i = 0; i < num_outs; i++)
5876 set_output_and_unmute(codec, paths[i]);
5879 /* initialize hp and speaker paths */
5880 static void init_extra_out(struct hda_codec *codec)
5882 struct hda_gen_spec *spec = codec->spec;
5884 if (spec->autocfg.line_out_type != AUTO_PIN_HP_OUT)
5885 __init_extra_out(codec, spec->autocfg.hp_outs, spec->hp_paths);
5886 if (spec->autocfg.line_out_type != AUTO_PIN_SPEAKER_OUT)
5887 __init_extra_out(codec, spec->autocfg.speaker_outs,
5888 spec->speaker_paths);
5891 /* initialize multi-io paths */
5892 static void init_multi_io(struct hda_codec *codec)
5894 struct hda_gen_spec *spec = codec->spec;
5897 for (i = 0; i < spec->multi_ios; i++) {
5898 hda_nid_t pin = spec->multi_io[i].pin;
5899 struct nid_path *path;
5900 path = get_multiio_path(codec, i);
5903 if (!spec->multi_io[i].ctl_in)
5904 spec->multi_io[i].ctl_in =
5905 snd_hda_codec_get_pin_target(codec, pin);
5906 snd_hda_activate_path(codec, path, path->active,
5907 aamix_default(spec));
5911 static void init_aamix_paths(struct hda_codec *codec)
5913 struct hda_gen_spec *spec = codec->spec;
5915 if (!spec->have_aamix_ctl)
5917 if (!has_aamix_out_paths(spec))
5919 update_aamix_paths(codec, spec->aamix_mode, spec->out_paths[0],
5920 spec->aamix_out_paths[0],
5921 spec->autocfg.line_out_type);
5922 update_aamix_paths(codec, spec->aamix_mode, spec->hp_paths[0],
5923 spec->aamix_out_paths[1],
5925 update_aamix_paths(codec, spec->aamix_mode, spec->speaker_paths[0],
5926 spec->aamix_out_paths[2],
5927 AUTO_PIN_SPEAKER_OUT);
5930 /* set up input pins and loopback paths */
5931 static void init_analog_input(struct hda_codec *codec)
5933 struct hda_gen_spec *spec = codec->spec;
5934 struct auto_pin_cfg *cfg = &spec->autocfg;
5937 for (i = 0; i < cfg->num_inputs; i++) {
5938 hda_nid_t nid = cfg->inputs[i].pin;
5939 if (is_input_pin(codec, nid))
5940 restore_pin_ctl(codec, nid);
5942 /* init loopback inputs */
5943 if (spec->mixer_nid) {
5944 resume_path_from_idx(codec, spec->loopback_paths[i]);
5945 resume_path_from_idx(codec, spec->loopback_merge_path);
5950 /* initialize ADC paths */
5951 static void init_input_src(struct hda_codec *codec)
5953 struct hda_gen_spec *spec = codec->spec;
5954 struct hda_input_mux *imux = &spec->input_mux;
5955 struct nid_path *path;
5958 if (spec->dyn_adc_switch)
5961 nums = spec->num_adc_nids;
5963 for (c = 0; c < nums; c++) {
5964 for (i = 0; i < imux->num_items; i++) {
5965 path = get_input_path(codec, c, i);
5967 bool active = path->active;
5968 if (i == spec->cur_mux[c])
5970 snd_hda_activate_path(codec, path, active, false);
5974 update_hp_mic(codec, c, true);
5977 if (spec->cap_sync_hook)
5978 spec->cap_sync_hook(codec, NULL, NULL);
5981 /* set right pin controls for digital I/O */
5982 static void init_digital(struct hda_codec *codec)
5984 struct hda_gen_spec *spec = codec->spec;
5988 for (i = 0; i < spec->autocfg.dig_outs; i++)
5989 set_output_and_unmute(codec, spec->digout_paths[i]);
5990 pin = spec->autocfg.dig_in_pin;
5992 restore_pin_ctl(codec, pin);
5993 resume_path_from_idx(codec, spec->digin_path);
5997 /* clear unsol-event tags on unused pins; Conexant codecs seem to leave
5998 * invalid unsol tags by some reason
6000 static void clear_unsol_on_unused_pins(struct hda_codec *codec)
6002 const struct hda_pincfg *pin;
6005 snd_array_for_each(&codec->init_pins, i, pin) {
6006 hda_nid_t nid = pin->nid;
6007 if (is_jack_detectable(codec, nid) &&
6008 !snd_hda_jack_tbl_get(codec, nid))
6009 snd_hda_codec_write_cache(codec, nid, 0,
6010 AC_VERB_SET_UNSOLICITED_ENABLE, 0);
6015 * snd_hda_gen_init - initialize the generic spec
6016 * @codec: the HDA codec
6018 * This can be put as patch_ops init function.
6020 int snd_hda_gen_init(struct hda_codec *codec)
6022 struct hda_gen_spec *spec = codec->spec;
6024 if (spec->init_hook)
6025 spec->init_hook(codec);
6027 if (!spec->skip_verbs)
6028 snd_hda_apply_verbs(codec);
6030 init_multi_out(codec);
6031 init_extra_out(codec);
6032 init_multi_io(codec);
6033 init_aamix_paths(codec);
6034 init_analog_input(codec);
6035 init_input_src(codec);
6036 init_digital(codec);
6038 clear_unsol_on_unused_pins(codec);
6040 sync_all_pin_power_ctls(codec);
6042 /* call init functions of standard auto-mute helpers */
6043 update_automute_all(codec);
6045 snd_hda_regmap_sync(codec);
6047 if (spec->vmaster_mute.sw_kctl && spec->vmaster_mute.hook)
6048 snd_hda_sync_vmaster_hook(&spec->vmaster_mute);
6050 hda_call_check_power_status(codec, 0x01);
6053 EXPORT_SYMBOL_GPL(snd_hda_gen_init);
6056 * snd_hda_gen_free - free the generic spec
6057 * @codec: the HDA codec
6059 * This can be put as patch_ops free function.
6061 void snd_hda_gen_free(struct hda_codec *codec)
6063 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_FREE);
6064 snd_hda_gen_spec_free(codec->spec);
6068 EXPORT_SYMBOL_GPL(snd_hda_gen_free);
6071 * snd_hda_gen_reboot_notify - Make codec enter D3 before rebooting
6072 * @codec: the HDA codec
6074 * This can be put as patch_ops reboot_notify function.
6076 void snd_hda_gen_reboot_notify(struct hda_codec *codec)
6078 /* Make the codec enter D3 to avoid spurious noises from the internal
6079 * speaker during (and after) reboot
6081 snd_hda_codec_set_power_to_all(codec, codec->core.afg, AC_PWRST_D3);
6082 snd_hda_codec_write(codec, codec->core.afg, 0,
6083 AC_VERB_SET_POWER_STATE, AC_PWRST_D3);
6086 EXPORT_SYMBOL_GPL(snd_hda_gen_reboot_notify);
6090 * snd_hda_gen_check_power_status - check the loopback power save state
6091 * @codec: the HDA codec
6092 * @nid: NID to inspect
6094 * This can be put as patch_ops check_power_status function.
6096 int snd_hda_gen_check_power_status(struct hda_codec *codec, hda_nid_t nid)
6098 struct hda_gen_spec *spec = codec->spec;
6099 return snd_hda_check_amp_list_power(codec, &spec->loopback, nid);
6101 EXPORT_SYMBOL_GPL(snd_hda_gen_check_power_status);
6106 * the generic codec support
6109 static const struct hda_codec_ops generic_patch_ops = {
6110 .build_controls = snd_hda_gen_build_controls,
6111 .build_pcms = snd_hda_gen_build_pcms,
6112 .init = snd_hda_gen_init,
6113 .free = snd_hda_gen_free,
6114 .unsol_event = snd_hda_jack_unsol_event,
6115 .reboot_notify = snd_hda_gen_reboot_notify,
6117 .check_power_status = snd_hda_gen_check_power_status,
6122 * snd_hda_parse_generic_codec - Generic codec parser
6123 * @codec: the HDA codec
6125 static int snd_hda_parse_generic_codec(struct hda_codec *codec)
6127 struct hda_gen_spec *spec;
6130 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
6133 snd_hda_gen_spec_init(spec);
6136 err = snd_hda_parse_pin_defcfg(codec, &spec->autocfg, NULL, 0);
6140 err = snd_hda_gen_parse_auto_config(codec, &spec->autocfg);
6144 codec->patch_ops = generic_patch_ops;
6148 snd_hda_gen_free(codec);
6152 static const struct hda_device_id snd_hda_id_generic[] = {
6153 HDA_CODEC_ENTRY(HDA_CODEC_ID_GENERIC, "Generic", snd_hda_parse_generic_codec),
6156 MODULE_DEVICE_TABLE(hdaudio, snd_hda_id_generic);
6158 static struct hda_codec_driver generic_driver = {
6159 .id = snd_hda_id_generic,
6162 module_hda_codec_driver(generic_driver);
6164 MODULE_LICENSE("GPL");
6165 MODULE_DESCRIPTION("Generic HD-audio codec parser");