2 * Universal Interface for Intel High Definition Audio Codec
4 * Generic widget tree parser
6 * Copyright (c) 2004 Takashi Iwai <tiwai@suse.de>
8 * This driver is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 2 of the License, or
11 * (at your option) any later version.
13 * This driver is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, write to the Free Software
20 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
23 #include <linux/init.h>
24 #include <linux/slab.h>
25 #include <linux/export.h>
26 #include <linux/sort.h>
27 #include <linux/delay.h>
28 #include <linux/ctype.h>
29 #include <linux/string.h>
30 #include <linux/bitops.h>
31 #include <linux/module.h>
32 #include <sound/core.h>
33 #include <sound/jack.h>
34 #include <sound/tlv.h>
35 #include "hda_codec.h"
36 #include "hda_local.h"
37 #include "hda_auto_parser.h"
40 #include "hda_generic.h"
44 * snd_hda_gen_spec_init - initialize hda_gen_spec struct
45 * @spec: hda_gen_spec object to initialize
47 * Initialize the given hda_gen_spec object.
49 int snd_hda_gen_spec_init(struct hda_gen_spec *spec)
51 snd_array_init(&spec->kctls, sizeof(struct snd_kcontrol_new), 32);
52 snd_array_init(&spec->paths, sizeof(struct nid_path), 8);
53 snd_array_init(&spec->loopback_list, sizeof(struct hda_amp_list), 8);
54 mutex_init(&spec->pcm_mutex);
57 EXPORT_SYMBOL_GPL(snd_hda_gen_spec_init);
60 * snd_hda_gen_add_kctl - Add a new kctl_new struct from the template
61 * @spec: hda_gen_spec object
62 * @name: name string to override the template, NULL if unchanged
63 * @temp: template for the new kctl
65 * Add a new kctl (actually snd_kcontrol_new to be instantiated later)
66 * element based on the given snd_kcontrol_new template @temp and the
67 * name string @name to the list in @spec.
68 * Returns the newly created object or NULL as error.
70 struct snd_kcontrol_new *
71 snd_hda_gen_add_kctl(struct hda_gen_spec *spec, const char *name,
72 const struct snd_kcontrol_new *temp)
74 struct snd_kcontrol_new *knew = snd_array_new(&spec->kctls);
79 knew->name = kstrdup(name, GFP_KERNEL);
81 knew->name = kstrdup(knew->name, GFP_KERNEL);
86 EXPORT_SYMBOL_GPL(snd_hda_gen_add_kctl);
88 static void free_kctls(struct hda_gen_spec *spec)
90 if (spec->kctls.list) {
91 struct snd_kcontrol_new *kctl = spec->kctls.list;
93 for (i = 0; i < spec->kctls.used; i++)
96 snd_array_free(&spec->kctls);
99 static void snd_hda_gen_spec_free(struct hda_gen_spec *spec)
104 snd_array_free(&spec->paths);
105 snd_array_free(&spec->loopback_list);
111 static void parse_user_hints(struct hda_codec *codec)
113 struct hda_gen_spec *spec = codec->spec;
116 val = snd_hda_get_bool_hint(codec, "jack_detect");
118 codec->no_jack_detect = !val;
119 val = snd_hda_get_bool_hint(codec, "inv_jack_detect");
121 codec->inv_jack_detect = !!val;
122 val = snd_hda_get_bool_hint(codec, "trigger_sense");
124 codec->no_trigger_sense = !val;
125 val = snd_hda_get_bool_hint(codec, "inv_eapd");
127 codec->inv_eapd = !!val;
128 val = snd_hda_get_bool_hint(codec, "pcm_format_first");
130 codec->pcm_format_first = !!val;
131 val = snd_hda_get_bool_hint(codec, "sticky_stream");
133 codec->no_sticky_stream = !val;
134 val = snd_hda_get_bool_hint(codec, "spdif_status_reset");
136 codec->spdif_status_reset = !!val;
137 val = snd_hda_get_bool_hint(codec, "pin_amp_workaround");
139 codec->pin_amp_workaround = !!val;
140 val = snd_hda_get_bool_hint(codec, "single_adc_amp");
142 codec->single_adc_amp = !!val;
143 val = snd_hda_get_bool_hint(codec, "power_save_node");
145 codec->power_save_node = !!val;
147 val = snd_hda_get_bool_hint(codec, "auto_mute");
149 spec->suppress_auto_mute = !val;
150 val = snd_hda_get_bool_hint(codec, "auto_mic");
152 spec->suppress_auto_mic = !val;
153 val = snd_hda_get_bool_hint(codec, "line_in_auto_switch");
155 spec->line_in_auto_switch = !!val;
156 val = snd_hda_get_bool_hint(codec, "auto_mute_via_amp");
158 spec->auto_mute_via_amp = !!val;
159 val = snd_hda_get_bool_hint(codec, "need_dac_fix");
161 spec->need_dac_fix = !!val;
162 val = snd_hda_get_bool_hint(codec, "primary_hp");
164 spec->no_primary_hp = !val;
165 val = snd_hda_get_bool_hint(codec, "multi_io");
167 spec->no_multi_io = !val;
168 val = snd_hda_get_bool_hint(codec, "multi_cap_vol");
170 spec->multi_cap_vol = !!val;
171 val = snd_hda_get_bool_hint(codec, "inv_dmic_split");
173 spec->inv_dmic_split = !!val;
174 val = snd_hda_get_bool_hint(codec, "indep_hp");
176 spec->indep_hp = !!val;
177 val = snd_hda_get_bool_hint(codec, "add_stereo_mix_input");
179 spec->add_stereo_mix_input = !!val;
180 /* the following two are just for compatibility */
181 val = snd_hda_get_bool_hint(codec, "add_out_jack_modes");
183 spec->add_jack_modes = !!val;
184 val = snd_hda_get_bool_hint(codec, "add_in_jack_modes");
186 spec->add_jack_modes = !!val;
187 val = snd_hda_get_bool_hint(codec, "add_jack_modes");
189 spec->add_jack_modes = !!val;
190 val = snd_hda_get_bool_hint(codec, "power_down_unused");
192 spec->power_down_unused = !!val;
193 val = snd_hda_get_bool_hint(codec, "add_hp_mic");
195 spec->hp_mic = !!val;
196 val = snd_hda_get_bool_hint(codec, "hp_mic_detect");
198 spec->suppress_hp_mic_detect = !val;
199 val = snd_hda_get_bool_hint(codec, "vmaster");
201 spec->suppress_vmaster = !val;
203 if (!snd_hda_get_int_hint(codec, "mixer_nid", &val))
204 spec->mixer_nid = val;
208 * pin control value accesses
211 #define update_pin_ctl(codec, pin, val) \
212 snd_hda_codec_write_cache(codec, pin, 0, \
213 AC_VERB_SET_PIN_WIDGET_CONTROL, val)
215 /* restore the pinctl based on the cached value */
216 static inline void restore_pin_ctl(struct hda_codec *codec, hda_nid_t pin)
218 update_pin_ctl(codec, pin, snd_hda_codec_get_pin_target(codec, pin));
221 /* set the pinctl target value and write it if requested */
222 static void set_pin_target(struct hda_codec *codec, hda_nid_t pin,
223 unsigned int val, bool do_write)
227 val = snd_hda_correct_pin_ctl(codec, pin, val);
228 snd_hda_codec_set_pin_target(codec, pin, val);
230 update_pin_ctl(codec, pin, val);
233 /* set pinctl target values for all given pins */
234 static void set_pin_targets(struct hda_codec *codec, int num_pins,
235 hda_nid_t *pins, unsigned int val)
238 for (i = 0; i < num_pins; i++)
239 set_pin_target(codec, pins[i], val, false);
246 /* return the position of NID in the list, or -1 if not found */
247 static int find_idx_in_nid_list(hda_nid_t nid, const hda_nid_t *list, int nums)
250 for (i = 0; i < nums; i++)
256 /* return true if the given NID is contained in the path */
257 static bool is_nid_contained(struct nid_path *path, hda_nid_t nid)
259 return find_idx_in_nid_list(nid, path->path, path->depth) >= 0;
262 static struct nid_path *get_nid_path(struct hda_codec *codec,
263 hda_nid_t from_nid, hda_nid_t to_nid,
266 struct hda_gen_spec *spec = codec->spec;
267 struct nid_path *path;
270 snd_array_for_each(&spec->paths, i, path) {
271 if (path->depth <= 0)
273 if ((!from_nid || path->path[0] == from_nid) &&
274 (!to_nid || path->path[path->depth - 1] == to_nid)) {
276 (anchor_nid > 0 && is_nid_contained(path, anchor_nid)) ||
277 (anchor_nid < 0 && !is_nid_contained(path, anchor_nid)))
285 * snd_hda_get_path_idx - get the index number corresponding to the path
287 * @codec: the HDA codec
288 * @path: nid_path object
290 * The returned index starts from 1, i.e. the actual array index with offset 1,
291 * and zero is handled as an invalid path
293 int snd_hda_get_path_idx(struct hda_codec *codec, struct nid_path *path)
295 struct hda_gen_spec *spec = codec->spec;
296 struct nid_path *array = spec->paths.list;
299 if (!spec->paths.used)
302 if (idx < 0 || idx >= spec->paths.used)
306 EXPORT_SYMBOL_GPL(snd_hda_get_path_idx);
309 * snd_hda_get_path_from_idx - get the path instance corresponding to the
311 * @codec: the HDA codec
312 * @idx: the path index
314 struct nid_path *snd_hda_get_path_from_idx(struct hda_codec *codec, int idx)
316 struct hda_gen_spec *spec = codec->spec;
318 if (idx <= 0 || idx > spec->paths.used)
320 return snd_array_elem(&spec->paths, idx - 1);
322 EXPORT_SYMBOL_GPL(snd_hda_get_path_from_idx);
324 /* check whether the given DAC is already found in any existing paths */
325 static bool is_dac_already_used(struct hda_codec *codec, hda_nid_t nid)
327 struct hda_gen_spec *spec = codec->spec;
328 const struct nid_path *path;
331 snd_array_for_each(&spec->paths, i, path) {
332 if (path->path[0] == nid)
338 /* check whether the given two widgets can be connected */
339 static bool is_reachable_path(struct hda_codec *codec,
340 hda_nid_t from_nid, hda_nid_t to_nid)
342 if (!from_nid || !to_nid)
344 return snd_hda_get_conn_index(codec, to_nid, from_nid, true) >= 0;
347 /* nid, dir and idx */
348 #define AMP_VAL_COMPARE_MASK (0xffff | (1U << 18) | (0x0f << 19))
350 /* check whether the given ctl is already assigned in any path elements */
351 static bool is_ctl_used(struct hda_codec *codec, unsigned int val, int type)
353 struct hda_gen_spec *spec = codec->spec;
354 const struct nid_path *path;
357 val &= AMP_VAL_COMPARE_MASK;
358 snd_array_for_each(&spec->paths, i, path) {
359 if ((path->ctls[type] & AMP_VAL_COMPARE_MASK) == val)
365 /* check whether a control with the given (nid, dir, idx) was assigned */
366 static bool is_ctl_associated(struct hda_codec *codec, hda_nid_t nid,
367 int dir, int idx, int type)
369 unsigned int val = HDA_COMPOSE_AMP_VAL(nid, 3, idx, dir);
370 return is_ctl_used(codec, val, type);
373 static void print_nid_path(struct hda_codec *codec,
374 const char *pfx, struct nid_path *path)
381 for (i = 0; i < path->depth; i++)
382 pos += scnprintf(pos, sizeof(buf) - (pos - buf), "%s%02x",
383 pos != buf ? ":" : "",
386 codec_dbg(codec, "%s path: depth=%d '%s'\n", pfx, path->depth, buf);
389 /* called recursively */
390 static bool __parse_nid_path(struct hda_codec *codec,
391 hda_nid_t from_nid, hda_nid_t to_nid,
392 int anchor_nid, struct nid_path *path,
395 const hda_nid_t *conn;
398 if (to_nid == anchor_nid)
399 anchor_nid = 0; /* anchor passed */
400 else if (to_nid == (hda_nid_t)(-anchor_nid))
401 return false; /* hit the exclusive nid */
403 nums = snd_hda_get_conn_list(codec, to_nid, &conn);
404 for (i = 0; i < nums; i++) {
405 if (conn[i] != from_nid) {
406 /* special case: when from_nid is 0,
407 * try to find an empty DAC
410 get_wcaps_type(get_wcaps(codec, conn[i])) != AC_WID_AUD_OUT ||
411 is_dac_already_used(codec, conn[i]))
414 /* anchor is not requested or already passed? */
418 if (depth >= MAX_NID_PATH_DEPTH)
420 for (i = 0; i < nums; i++) {
422 type = get_wcaps_type(get_wcaps(codec, conn[i]));
423 if (type == AC_WID_AUD_OUT || type == AC_WID_AUD_IN ||
426 if (__parse_nid_path(codec, from_nid, conn[i],
427 anchor_nid, path, depth + 1))
433 path->path[path->depth] = conn[i];
434 path->idx[path->depth + 1] = i;
435 if (nums > 1 && get_wcaps_type(get_wcaps(codec, to_nid)) != AC_WID_AUD_MIX)
436 path->multi[path->depth + 1] = 1;
442 * snd_hda_parse_nid_path - parse the widget path from the given nid to
444 * @codec: the HDA codec
445 * @from_nid: the NID where the path start from
446 * @to_nid: the NID where the path ends at
447 * @anchor_nid: the anchor indication
448 * @path: the path object to store the result
450 * Returns true if a matching path is found.
452 * The parsing behavior depends on parameters:
453 * when @from_nid is 0, try to find an empty DAC;
454 * when @anchor_nid is set to a positive value, only paths through the widget
455 * with the given value are evaluated.
456 * when @anchor_nid is set to a negative value, paths through the widget
457 * with the negative of given value are excluded, only other paths are chosen.
458 * when @anchor_nid is zero, no special handling about path selection.
460 static bool snd_hda_parse_nid_path(struct hda_codec *codec, hda_nid_t from_nid,
461 hda_nid_t to_nid, int anchor_nid,
462 struct nid_path *path)
464 if (__parse_nid_path(codec, from_nid, to_nid, anchor_nid, path, 1)) {
465 path->path[path->depth] = to_nid;
473 * snd_hda_add_new_path - parse the path between the given NIDs and
474 * add to the path list
475 * @codec: the HDA codec
476 * @from_nid: the NID where the path start from
477 * @to_nid: the NID where the path ends at
478 * @anchor_nid: the anchor indication, see snd_hda_parse_nid_path()
480 * If no valid path is found, returns NULL.
483 snd_hda_add_new_path(struct hda_codec *codec, hda_nid_t from_nid,
484 hda_nid_t to_nid, int anchor_nid)
486 struct hda_gen_spec *spec = codec->spec;
487 struct nid_path *path;
489 if (from_nid && to_nid && !is_reachable_path(codec, from_nid, to_nid))
492 /* check whether the path has been already added */
493 path = get_nid_path(codec, from_nid, to_nid, anchor_nid);
497 path = snd_array_new(&spec->paths);
500 memset(path, 0, sizeof(*path));
501 if (snd_hda_parse_nid_path(codec, from_nid, to_nid, anchor_nid, path))
507 EXPORT_SYMBOL_GPL(snd_hda_add_new_path);
509 /* clear the given path as invalid so that it won't be picked up later */
510 static void invalidate_nid_path(struct hda_codec *codec, int idx)
512 struct nid_path *path = snd_hda_get_path_from_idx(codec, idx);
515 memset(path, 0, sizeof(*path));
518 /* return a DAC if paired to the given pin by codec driver */
519 static hda_nid_t get_preferred_dac(struct hda_codec *codec, hda_nid_t pin)
521 struct hda_gen_spec *spec = codec->spec;
522 const hda_nid_t *list = spec->preferred_dacs;
526 for (; *list; list += 2)
532 /* look for an empty DAC slot */
533 static hda_nid_t look_for_dac(struct hda_codec *codec, hda_nid_t pin,
536 struct hda_gen_spec *spec = codec->spec;
540 for (i = 0; i < spec->num_all_dacs; i++) {
541 hda_nid_t nid = spec->all_dacs[i];
542 if (!nid || is_dac_already_used(codec, nid))
544 cap_digital = !!(get_wcaps(codec, nid) & AC_WCAP_DIGITAL);
545 if (is_digital != cap_digital)
547 if (is_reachable_path(codec, nid, pin))
553 /* replace the channels in the composed amp value with the given number */
554 static unsigned int amp_val_replace_channels(unsigned int val, unsigned int chs)
556 val &= ~(0x3U << 16);
561 static bool same_amp_caps(struct hda_codec *codec, hda_nid_t nid1,
562 hda_nid_t nid2, int dir)
564 if (!(get_wcaps(codec, nid1) & (1 << (dir + 1))))
565 return !(get_wcaps(codec, nid2) & (1 << (dir + 1)));
566 return (query_amp_caps(codec, nid1, dir) ==
567 query_amp_caps(codec, nid2, dir));
570 /* look for a widget suitable for assigning a mute switch in the path */
571 static hda_nid_t look_for_out_mute_nid(struct hda_codec *codec,
572 struct nid_path *path)
576 for (i = path->depth - 1; i >= 0; i--) {
577 if (nid_has_mute(codec, path->path[i], HDA_OUTPUT))
578 return path->path[i];
579 if (i != path->depth - 1 && i != 0 &&
580 nid_has_mute(codec, path->path[i], HDA_INPUT))
581 return path->path[i];
586 /* look for a widget suitable for assigning a volume ctl in the path */
587 static hda_nid_t look_for_out_vol_nid(struct hda_codec *codec,
588 struct nid_path *path)
590 struct hda_gen_spec *spec = codec->spec;
593 for (i = path->depth - 1; i >= 0; i--) {
594 hda_nid_t nid = path->path[i];
595 if ((spec->out_vol_mask >> nid) & 1)
597 if (nid_has_volume(codec, nid, HDA_OUTPUT))
604 * path activation / deactivation
607 /* can have the amp-in capability? */
608 static bool has_amp_in(struct hda_codec *codec, struct nid_path *path, int idx)
610 hda_nid_t nid = path->path[idx];
611 unsigned int caps = get_wcaps(codec, nid);
612 unsigned int type = get_wcaps_type(caps);
614 if (!(caps & AC_WCAP_IN_AMP))
616 if (type == AC_WID_PIN && idx > 0) /* only for input pins */
621 /* can have the amp-out capability? */
622 static bool has_amp_out(struct hda_codec *codec, struct nid_path *path, int idx)
624 hda_nid_t nid = path->path[idx];
625 unsigned int caps = get_wcaps(codec, nid);
626 unsigned int type = get_wcaps_type(caps);
628 if (!(caps & AC_WCAP_OUT_AMP))
630 if (type == AC_WID_PIN && !idx) /* only for output pins */
635 /* check whether the given (nid,dir,idx) is active */
636 static bool is_active_nid(struct hda_codec *codec, hda_nid_t nid,
637 unsigned int dir, unsigned int idx)
639 struct hda_gen_spec *spec = codec->spec;
640 int type = get_wcaps_type(get_wcaps(codec, nid));
641 const struct nid_path *path;
644 if (nid == codec->core.afg)
647 snd_array_for_each(&spec->paths, n, path) {
650 if (codec->power_save_node) {
651 if (!path->stream_enabled)
653 /* ignore unplugged paths except for DAC/ADC */
654 if (!(path->pin_enabled || path->pin_fixed) &&
655 type != AC_WID_AUD_OUT && type != AC_WID_AUD_IN)
658 for (i = 0; i < path->depth; i++) {
659 if (path->path[i] == nid) {
660 if (dir == HDA_OUTPUT || idx == -1 ||
670 /* check whether the NID is referred by any active paths */
671 #define is_active_nid_for_any(codec, nid) \
672 is_active_nid(codec, nid, HDA_OUTPUT, -1)
674 /* get the default amp value for the target state */
675 static int get_amp_val_to_activate(struct hda_codec *codec, hda_nid_t nid,
676 int dir, unsigned int caps, bool enable)
678 unsigned int val = 0;
680 if (caps & AC_AMPCAP_NUM_STEPS) {
683 val = (caps & AC_AMPCAP_OFFSET) >> AC_AMPCAP_OFFSET_SHIFT;
685 if (caps & (AC_AMPCAP_MUTE | AC_AMPCAP_MIN_MUTE)) {
692 /* is this a stereo widget or a stereo-to-mono mix? */
693 static bool is_stereo_amps(struct hda_codec *codec, hda_nid_t nid, int dir)
695 unsigned int wcaps = get_wcaps(codec, nid);
698 if (wcaps & AC_WCAP_STEREO)
700 if (dir != HDA_INPUT || get_wcaps_type(wcaps) != AC_WID_AUD_MIX)
702 if (snd_hda_get_num_conns(codec, nid) != 1)
704 if (snd_hda_get_connections(codec, nid, &conn, 1) < 0)
706 return !!(get_wcaps(codec, conn) & AC_WCAP_STEREO);
709 /* initialize the amp value (only at the first time) */
710 static void init_amp(struct hda_codec *codec, hda_nid_t nid, int dir, int idx)
712 unsigned int caps = query_amp_caps(codec, nid, dir);
713 int val = get_amp_val_to_activate(codec, nid, dir, caps, false);
715 if (is_stereo_amps(codec, nid, dir))
716 snd_hda_codec_amp_init_stereo(codec, nid, dir, idx, 0xff, val);
718 snd_hda_codec_amp_init(codec, nid, 0, dir, idx, 0xff, val);
721 /* update the amp, doing in stereo or mono depending on NID */
722 static int update_amp(struct hda_codec *codec, hda_nid_t nid, int dir, int idx,
723 unsigned int mask, unsigned int val)
725 if (is_stereo_amps(codec, nid, dir))
726 return snd_hda_codec_amp_stereo(codec, nid, dir, idx,
729 return snd_hda_codec_amp_update(codec, nid, 0, dir, idx,
733 /* calculate amp value mask we can modify;
734 * if the given amp is controlled by mixers, don't touch it
736 static unsigned int get_amp_mask_to_modify(struct hda_codec *codec,
737 hda_nid_t nid, int dir, int idx,
740 unsigned int mask = 0xff;
742 if (caps & (AC_AMPCAP_MUTE | AC_AMPCAP_MIN_MUTE)) {
743 if (is_ctl_associated(codec, nid, dir, idx, NID_PATH_MUTE_CTL))
746 if (caps & AC_AMPCAP_NUM_STEPS) {
747 if (is_ctl_associated(codec, nid, dir, idx, NID_PATH_VOL_CTL) ||
748 is_ctl_associated(codec, nid, dir, idx, NID_PATH_BOOST_CTL))
754 static void activate_amp(struct hda_codec *codec, hda_nid_t nid, int dir,
755 int idx, int idx_to_check, bool enable)
758 unsigned int mask, val;
760 caps = query_amp_caps(codec, nid, dir);
761 val = get_amp_val_to_activate(codec, nid, dir, caps, enable);
762 mask = get_amp_mask_to_modify(codec, nid, dir, idx_to_check, caps);
767 update_amp(codec, nid, dir, idx, mask, val);
770 static void check_and_activate_amp(struct hda_codec *codec, hda_nid_t nid,
771 int dir, int idx, int idx_to_check,
774 /* check whether the given amp is still used by others */
775 if (!enable && is_active_nid(codec, nid, dir, idx_to_check))
777 activate_amp(codec, nid, dir, idx, idx_to_check, enable);
780 static void activate_amp_out(struct hda_codec *codec, struct nid_path *path,
783 hda_nid_t nid = path->path[i];
784 init_amp(codec, nid, HDA_OUTPUT, 0);
785 check_and_activate_amp(codec, nid, HDA_OUTPUT, 0, 0, enable);
788 static void activate_amp_in(struct hda_codec *codec, struct nid_path *path,
789 int i, bool enable, bool add_aamix)
791 struct hda_gen_spec *spec = codec->spec;
792 const hda_nid_t *conn;
795 hda_nid_t nid = path->path[i];
797 nums = snd_hda_get_conn_list(codec, nid, &conn);
800 type = get_wcaps_type(get_wcaps(codec, nid));
801 if (type == AC_WID_PIN ||
802 (type == AC_WID_AUD_IN && codec->single_adc_amp)) {
808 for (n = 0; n < nums; n++)
809 init_amp(codec, nid, HDA_INPUT, n);
811 /* here is a little bit tricky in comparison with activate_amp_out();
812 * when aa-mixer is available, we need to enable the path as well
814 for (n = 0; n < nums; n++) {
816 if (conn[n] != spec->mixer_merge_nid)
818 /* when aamix is disabled, force to off */
820 activate_amp(codec, nid, HDA_INPUT, n, n, false);
824 check_and_activate_amp(codec, nid, HDA_INPUT, n, idx, enable);
828 /* sync power of each widget in the given path */
829 static hda_nid_t path_power_update(struct hda_codec *codec,
830 struct nid_path *path,
831 bool allow_powerdown)
833 hda_nid_t nid, changed = 0;
836 for (i = 0; i < path->depth; i++) {
838 if (!(get_wcaps(codec, nid) & AC_WCAP_POWER))
840 if (nid == codec->core.afg)
842 if (!allow_powerdown || is_active_nid_for_any(codec, nid))
846 power = snd_hda_codec_read(codec, nid, 0,
847 AC_VERB_GET_POWER_STATE, 0);
848 if (power != (state | (state << 4))) {
849 snd_hda_codec_write(codec, nid, 0,
850 AC_VERB_SET_POWER_STATE, state);
852 /* all known codecs seem to be capable to handl
853 * widgets state even in D3, so far.
854 * if any new codecs need to restore the widget
855 * states after D0 transition, call the function
859 if (state == AC_PWRST_D0)
860 snd_hdac_regmap_sync_node(&codec->core, nid);
867 /* do sync with the last power state change */
868 static void sync_power_state_change(struct hda_codec *codec, hda_nid_t nid)
872 snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_POWER_STATE, 0);
877 * snd_hda_activate_path - activate or deactivate the given path
878 * @codec: the HDA codec
879 * @path: the path to activate/deactivate
880 * @enable: flag to activate or not
881 * @add_aamix: enable the input from aamix NID
883 * If @add_aamix is set, enable the input from aa-mix NID as well (if any).
885 void snd_hda_activate_path(struct hda_codec *codec, struct nid_path *path,
886 bool enable, bool add_aamix)
888 struct hda_gen_spec *spec = codec->spec;
891 path->active = enable;
893 /* make sure the widget is powered up */
894 if (enable && (spec->power_down_unused || codec->power_save_node))
895 path_power_update(codec, path, codec->power_save_node);
897 for (i = path->depth - 1; i >= 0; i--) {
898 hda_nid_t nid = path->path[i];
900 if (enable && path->multi[i])
901 snd_hda_codec_write_cache(codec, nid, 0,
902 AC_VERB_SET_CONNECT_SEL,
904 if (has_amp_in(codec, path, i))
905 activate_amp_in(codec, path, i, enable, add_aamix);
906 if (has_amp_out(codec, path, i))
907 activate_amp_out(codec, path, i, enable);
910 EXPORT_SYMBOL_GPL(snd_hda_activate_path);
912 /* if the given path is inactive, put widgets into D3 (only if suitable) */
913 static void path_power_down_sync(struct hda_codec *codec, struct nid_path *path)
915 struct hda_gen_spec *spec = codec->spec;
917 if (!(spec->power_down_unused || codec->power_save_node) || path->active)
919 sync_power_state_change(codec, path_power_update(codec, path, true));
922 /* turn on/off EAPD on the given pin */
923 static void set_pin_eapd(struct hda_codec *codec, hda_nid_t pin, bool enable)
925 struct hda_gen_spec *spec = codec->spec;
926 if (spec->own_eapd_ctl ||
927 !(snd_hda_query_pin_caps(codec, pin) & AC_PINCAP_EAPD))
929 if (spec->keep_eapd_on && !enable)
933 snd_hda_codec_write_cache(codec, pin, 0,
934 AC_VERB_SET_EAPD_BTLENABLE,
935 enable ? 0x02 : 0x00);
938 /* re-initialize the path specified by the given path index */
939 static void resume_path_from_idx(struct hda_codec *codec, int path_idx)
941 struct nid_path *path = snd_hda_get_path_from_idx(codec, path_idx);
943 snd_hda_activate_path(codec, path, path->active, false);
948 * Helper functions for creating mixer ctl elements
951 static int hda_gen_mixer_mute_put(struct snd_kcontrol *kcontrol,
952 struct snd_ctl_elem_value *ucontrol);
953 static int hda_gen_bind_mute_get(struct snd_kcontrol *kcontrol,
954 struct snd_ctl_elem_value *ucontrol);
955 static int hda_gen_bind_mute_put(struct snd_kcontrol *kcontrol,
956 struct snd_ctl_elem_value *ucontrol);
963 static const struct snd_kcontrol_new control_templates[] = {
964 HDA_CODEC_VOLUME(NULL, 0, 0, 0),
965 /* only the put callback is replaced for handling the special mute */
967 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
968 .subdevice = HDA_SUBDEV_AMP_FLAG,
969 .info = snd_hda_mixer_amp_switch_info,
970 .get = snd_hda_mixer_amp_switch_get,
971 .put = hda_gen_mixer_mute_put, /* replaced */
972 .private_value = HDA_COMPOSE_AMP_VAL(0, 3, 0, 0),
975 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
976 .info = snd_hda_mixer_amp_switch_info,
977 .get = hda_gen_bind_mute_get,
978 .put = hda_gen_bind_mute_put, /* replaced */
979 .private_value = HDA_COMPOSE_AMP_VAL(0, 3, 0, 0),
983 /* add dynamic controls from template */
984 static struct snd_kcontrol_new *
985 add_control(struct hda_gen_spec *spec, int type, const char *name,
986 int cidx, unsigned long val)
988 struct snd_kcontrol_new *knew;
990 knew = snd_hda_gen_add_kctl(spec, name, &control_templates[type]);
994 if (get_amp_nid_(val))
995 knew->subdevice = HDA_SUBDEV_AMP_FLAG;
996 knew->private_value = val;
1000 static int add_control_with_pfx(struct hda_gen_spec *spec, int type,
1001 const char *pfx, const char *dir,
1002 const char *sfx, int cidx, unsigned long val)
1004 char name[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];
1005 snprintf(name, sizeof(name), "%s %s %s", pfx, dir, sfx);
1006 if (!add_control(spec, type, name, cidx, val))
1011 #define add_pb_vol_ctrl(spec, type, pfx, val) \
1012 add_control_with_pfx(spec, type, pfx, "Playback", "Volume", 0, val)
1013 #define add_pb_sw_ctrl(spec, type, pfx, val) \
1014 add_control_with_pfx(spec, type, pfx, "Playback", "Switch", 0, val)
1015 #define __add_pb_vol_ctrl(spec, type, pfx, cidx, val) \
1016 add_control_with_pfx(spec, type, pfx, "Playback", "Volume", cidx, val)
1017 #define __add_pb_sw_ctrl(spec, type, pfx, cidx, val) \
1018 add_control_with_pfx(spec, type, pfx, "Playback", "Switch", cidx, val)
1020 static int add_vol_ctl(struct hda_codec *codec, const char *pfx, int cidx,
1021 unsigned int chs, struct nid_path *path)
1026 val = path->ctls[NID_PATH_VOL_CTL];
1029 val = amp_val_replace_channels(val, chs);
1030 return __add_pb_vol_ctrl(codec->spec, HDA_CTL_WIDGET_VOL, pfx, cidx, val);
1033 /* return the channel bits suitable for the given path->ctls[] */
1034 static int get_default_ch_nums(struct hda_codec *codec, struct nid_path *path,
1037 int chs = 1; /* mono (left only) */
1039 hda_nid_t nid = get_amp_nid_(path->ctls[type]);
1040 if (nid && (get_wcaps(codec, nid) & AC_WCAP_STEREO))
1041 chs = 3; /* stereo */
1046 static int add_stereo_vol(struct hda_codec *codec, const char *pfx, int cidx,
1047 struct nid_path *path)
1049 int chs = get_default_ch_nums(codec, path, NID_PATH_VOL_CTL);
1050 return add_vol_ctl(codec, pfx, cidx, chs, path);
1053 /* create a mute-switch for the given mixer widget;
1054 * if it has multiple sources (e.g. DAC and loopback), create a bind-mute
1056 static int add_sw_ctl(struct hda_codec *codec, const char *pfx, int cidx,
1057 unsigned int chs, struct nid_path *path)
1060 int type = HDA_CTL_WIDGET_MUTE;
1064 val = path->ctls[NID_PATH_MUTE_CTL];
1067 val = amp_val_replace_channels(val, chs);
1068 if (get_amp_direction_(val) == HDA_INPUT) {
1069 hda_nid_t nid = get_amp_nid_(val);
1070 int nums = snd_hda_get_num_conns(codec, nid);
1072 type = HDA_CTL_BIND_MUTE;
1076 return __add_pb_sw_ctrl(codec->spec, type, pfx, cidx, val);
1079 static int add_stereo_sw(struct hda_codec *codec, const char *pfx,
1080 int cidx, struct nid_path *path)
1082 int chs = get_default_ch_nums(codec, path, NID_PATH_MUTE_CTL);
1083 return add_sw_ctl(codec, pfx, cidx, chs, path);
1086 /* playback mute control with the software mute bit check */
1087 static void sync_auto_mute_bits(struct snd_kcontrol *kcontrol,
1088 struct snd_ctl_elem_value *ucontrol)
1090 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1091 struct hda_gen_spec *spec = codec->spec;
1093 if (spec->auto_mute_via_amp) {
1094 hda_nid_t nid = get_amp_nid(kcontrol);
1095 bool enabled = !((spec->mute_bits >> nid) & 1);
1096 ucontrol->value.integer.value[0] &= enabled;
1097 ucontrol->value.integer.value[1] &= enabled;
1101 static int hda_gen_mixer_mute_put(struct snd_kcontrol *kcontrol,
1102 struct snd_ctl_elem_value *ucontrol)
1104 sync_auto_mute_bits(kcontrol, ucontrol);
1105 return snd_hda_mixer_amp_switch_put(kcontrol, ucontrol);
1109 * Bound mute controls
1111 #define AMP_VAL_IDX_SHIFT 19
1112 #define AMP_VAL_IDX_MASK (0x0f<<19)
1114 static int hda_gen_bind_mute_get(struct snd_kcontrol *kcontrol,
1115 struct snd_ctl_elem_value *ucontrol)
1117 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1121 mutex_lock(&codec->control_mutex);
1122 pval = kcontrol->private_value;
1123 kcontrol->private_value = pval & ~AMP_VAL_IDX_MASK; /* index 0 */
1124 err = snd_hda_mixer_amp_switch_get(kcontrol, ucontrol);
1125 kcontrol->private_value = pval;
1126 mutex_unlock(&codec->control_mutex);
1130 static int hda_gen_bind_mute_put(struct snd_kcontrol *kcontrol,
1131 struct snd_ctl_elem_value *ucontrol)
1133 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1135 int i, indices, err = 0, change = 0;
1137 sync_auto_mute_bits(kcontrol, ucontrol);
1139 mutex_lock(&codec->control_mutex);
1140 pval = kcontrol->private_value;
1141 indices = (pval & AMP_VAL_IDX_MASK) >> AMP_VAL_IDX_SHIFT;
1142 for (i = 0; i < indices; i++) {
1143 kcontrol->private_value = (pval & ~AMP_VAL_IDX_MASK) |
1144 (i << AMP_VAL_IDX_SHIFT);
1145 err = snd_hda_mixer_amp_switch_put(kcontrol, ucontrol);
1150 kcontrol->private_value = pval;
1151 mutex_unlock(&codec->control_mutex);
1152 return err < 0 ? err : change;
1155 /* any ctl assigned to the path with the given index? */
1156 static bool path_has_mixer(struct hda_codec *codec, int path_idx, int ctl_type)
1158 struct nid_path *path = snd_hda_get_path_from_idx(codec, path_idx);
1159 return path && path->ctls[ctl_type];
1162 static const char * const channel_name[] = {
1163 "Front", "Surround", "CLFE", "Side", "Back",
1166 /* give some appropriate ctl name prefix for the given line out channel */
1167 static const char *get_line_out_pfx(struct hda_codec *codec, int ch,
1168 int *index, int ctl_type)
1170 struct hda_gen_spec *spec = codec->spec;
1171 struct auto_pin_cfg *cfg = &spec->autocfg;
1174 if (cfg->line_outs == 1 && !spec->multi_ios &&
1175 !codec->force_pin_prefix &&
1176 !cfg->hp_outs && !cfg->speaker_outs)
1177 return spec->vmaster_mute.hook ? "PCM" : "Master";
1179 /* if there is really a single DAC used in the whole output paths,
1180 * use it master (or "PCM" if a vmaster hook is present)
1182 if (spec->multiout.num_dacs == 1 && !spec->mixer_nid &&
1183 !codec->force_pin_prefix &&
1184 !spec->multiout.hp_out_nid[0] && !spec->multiout.extra_out_nid[0])
1185 return spec->vmaster_mute.hook ? "PCM" : "Master";
1187 /* multi-io channels */
1188 if (ch >= cfg->line_outs)
1191 switch (cfg->line_out_type) {
1192 case AUTO_PIN_SPEAKER_OUT:
1193 /* if the primary channel vol/mute is shared with HP volume,
1194 * don't name it as Speaker
1196 if (!ch && cfg->hp_outs &&
1197 !path_has_mixer(codec, spec->hp_paths[0], ctl_type))
1199 if (cfg->line_outs == 1)
1201 if (cfg->line_outs == 2)
1202 return ch ? "Bass Speaker" : "Speaker";
1204 case AUTO_PIN_HP_OUT:
1205 /* if the primary channel vol/mute is shared with spk volume,
1206 * don't name it as Headphone
1208 if (!ch && cfg->speaker_outs &&
1209 !path_has_mixer(codec, spec->speaker_paths[0], ctl_type))
1211 /* for multi-io case, only the primary out */
1212 if (ch && spec->multi_ios)
1216 case AUTO_PIN_LINE_OUT:
1217 /* This deals with the case where one HP or one Speaker or
1218 * one HP + one Speaker need to share the DAC with LO
1221 bool hp_lo_shared = false, spk_lo_shared = false;
1223 if (cfg->speaker_outs)
1224 spk_lo_shared = !path_has_mixer(codec,
1225 spec->speaker_paths[0], ctl_type);
1227 hp_lo_shared = !path_has_mixer(codec, spec->hp_paths[0], ctl_type);
1228 if (hp_lo_shared && spk_lo_shared)
1229 return spec->vmaster_mute.hook ? "PCM" : "Master";
1231 return "Headphone+LO";
1233 return "Speaker+LO";
1237 /* for a single channel output, we don't have to name the channel */
1238 if (cfg->line_outs == 1 && !spec->multi_ios)
1242 if (ch >= ARRAY_SIZE(channel_name)) {
1247 return channel_name[ch];
1251 * Parse output paths
1254 /* badness definition */
1256 /* No primary DAC is found for the main output */
1257 BAD_NO_PRIMARY_DAC = 0x10000,
1258 /* No DAC is found for the extra output */
1259 BAD_NO_DAC = 0x4000,
1260 /* No possible multi-ios */
1261 BAD_MULTI_IO = 0x120,
1262 /* No individual DAC for extra output */
1263 BAD_NO_EXTRA_DAC = 0x102,
1264 /* No individual DAC for extra surrounds */
1265 BAD_NO_EXTRA_SURR_DAC = 0x101,
1266 /* Primary DAC shared with main surrounds */
1267 BAD_SHARED_SURROUND = 0x100,
1268 /* No independent HP possible */
1269 BAD_NO_INDEP_HP = 0x10,
1270 /* Primary DAC shared with main CLFE */
1271 BAD_SHARED_CLFE = 0x10,
1272 /* Primary DAC shared with extra surrounds */
1273 BAD_SHARED_EXTRA_SURROUND = 0x10,
1274 /* Volume widget is shared */
1275 BAD_SHARED_VOL = 0x10,
1278 /* look for widgets in the given path which are appropriate for
1279 * volume and mute controls, and assign the values to ctls[].
1281 * When no appropriate widget is found in the path, the badness value
1282 * is incremented depending on the situation. The function returns the
1283 * total badness for both volume and mute controls.
1285 static int assign_out_path_ctls(struct hda_codec *codec, struct nid_path *path)
1287 struct hda_gen_spec *spec = codec->spec;
1293 return BAD_SHARED_VOL * 2;
1295 if (path->ctls[NID_PATH_VOL_CTL] ||
1296 path->ctls[NID_PATH_MUTE_CTL])
1297 return 0; /* already evaluated */
1299 nid = look_for_out_vol_nid(codec, path);
1301 val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
1302 if (spec->dac_min_mute)
1303 val |= HDA_AMP_VAL_MIN_MUTE;
1304 if (is_ctl_used(codec, val, NID_PATH_VOL_CTL))
1305 badness += BAD_SHARED_VOL;
1307 path->ctls[NID_PATH_VOL_CTL] = val;
1309 badness += BAD_SHARED_VOL;
1310 nid = look_for_out_mute_nid(codec, path);
1312 unsigned int wid_type = get_wcaps_type(get_wcaps(codec, nid));
1313 if (wid_type == AC_WID_PIN || wid_type == AC_WID_AUD_OUT ||
1314 nid_has_mute(codec, nid, HDA_OUTPUT))
1315 val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
1317 val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT);
1318 if (is_ctl_used(codec, val, NID_PATH_MUTE_CTL))
1319 badness += BAD_SHARED_VOL;
1321 path->ctls[NID_PATH_MUTE_CTL] = val;
1323 badness += BAD_SHARED_VOL;
1327 const struct badness_table hda_main_out_badness = {
1328 .no_primary_dac = BAD_NO_PRIMARY_DAC,
1329 .no_dac = BAD_NO_DAC,
1330 .shared_primary = BAD_NO_PRIMARY_DAC,
1331 .shared_surr = BAD_SHARED_SURROUND,
1332 .shared_clfe = BAD_SHARED_CLFE,
1333 .shared_surr_main = BAD_SHARED_SURROUND,
1335 EXPORT_SYMBOL_GPL(hda_main_out_badness);
1337 const struct badness_table hda_extra_out_badness = {
1338 .no_primary_dac = BAD_NO_DAC,
1339 .no_dac = BAD_NO_DAC,
1340 .shared_primary = BAD_NO_EXTRA_DAC,
1341 .shared_surr = BAD_SHARED_EXTRA_SURROUND,
1342 .shared_clfe = BAD_SHARED_EXTRA_SURROUND,
1343 .shared_surr_main = BAD_NO_EXTRA_SURR_DAC,
1345 EXPORT_SYMBOL_GPL(hda_extra_out_badness);
1347 /* get the DAC of the primary output corresponding to the given array index */
1348 static hda_nid_t get_primary_out(struct hda_codec *codec, int idx)
1350 struct hda_gen_spec *spec = codec->spec;
1351 struct auto_pin_cfg *cfg = &spec->autocfg;
1353 if (cfg->line_outs > idx)
1354 return spec->private_dac_nids[idx];
1355 idx -= cfg->line_outs;
1356 if (spec->multi_ios > idx)
1357 return spec->multi_io[idx].dac;
1361 /* return the DAC if it's reachable, otherwise zero */
1362 static inline hda_nid_t try_dac(struct hda_codec *codec,
1363 hda_nid_t dac, hda_nid_t pin)
1365 return is_reachable_path(codec, dac, pin) ? dac : 0;
1368 /* try to assign DACs to pins and return the resultant badness */
1369 static int try_assign_dacs(struct hda_codec *codec, int num_outs,
1370 const hda_nid_t *pins, hda_nid_t *dacs,
1372 const struct badness_table *bad)
1374 struct hda_gen_spec *spec = codec->spec;
1382 for (i = 0; i < num_outs; i++) {
1383 struct nid_path *path;
1384 hda_nid_t pin = pins[i];
1386 if (!spec->obey_preferred_dacs) {
1387 path = snd_hda_get_path_from_idx(codec, path_idx[i]);
1389 badness += assign_out_path_ctls(codec, path);
1394 dacs[i] = get_preferred_dac(codec, pin);
1396 if (is_dac_already_used(codec, dacs[i]))
1397 badness += bad->shared_primary;
1398 } else if (spec->obey_preferred_dacs) {
1399 badness += BAD_NO_PRIMARY_DAC;
1403 dacs[i] = look_for_dac(codec, pin, false);
1404 if (!dacs[i] && !i) {
1405 /* try to steal the DAC of surrounds for the front */
1406 for (j = 1; j < num_outs; j++) {
1407 if (is_reachable_path(codec, dacs[j], pin)) {
1410 invalidate_nid_path(codec, path_idx[j]);
1419 dac = try_dac(codec, get_primary_out(codec, i), pin);
1421 dac = try_dac(codec, dacs[0], pin);
1423 dac = try_dac(codec, get_primary_out(codec, i), pin);
1426 badness += bad->shared_primary;
1428 badness += bad->shared_surr;
1430 badness += bad->shared_clfe;
1431 } else if (is_reachable_path(codec, spec->private_dac_nids[0], pin)) {
1432 dac = spec->private_dac_nids[0];
1433 badness += bad->shared_surr_main;
1435 badness += bad->no_primary_dac;
1437 badness += bad->no_dac;
1441 path = snd_hda_add_new_path(codec, dac, pin, -spec->mixer_nid);
1442 if (!path && !i && spec->mixer_nid) {
1443 /* try with aamix */
1444 path = snd_hda_add_new_path(codec, dac, pin, 0);
1448 badness += bad->no_dac;
1450 /* print_nid_path(codec, "output", path); */
1451 path->active = true;
1452 path_idx[i] = snd_hda_get_path_idx(codec, path);
1453 badness += assign_out_path_ctls(codec, path);
1460 /* return NID if the given pin has only a single connection to a certain DAC */
1461 static hda_nid_t get_dac_if_single(struct hda_codec *codec, hda_nid_t pin)
1463 struct hda_gen_spec *spec = codec->spec;
1465 hda_nid_t nid_found = 0;
1467 for (i = 0; i < spec->num_all_dacs; i++) {
1468 hda_nid_t nid = spec->all_dacs[i];
1469 if (!nid || is_dac_already_used(codec, nid))
1471 if (is_reachable_path(codec, nid, pin)) {
1480 /* check whether the given pin can be a multi-io pin */
1481 static bool can_be_multiio_pin(struct hda_codec *codec,
1482 unsigned int location, hda_nid_t nid)
1484 unsigned int defcfg, caps;
1486 defcfg = snd_hda_codec_get_pincfg(codec, nid);
1487 if (get_defcfg_connect(defcfg) != AC_JACK_PORT_COMPLEX)
1489 if (location && get_defcfg_location(defcfg) != location)
1491 caps = snd_hda_query_pin_caps(codec, nid);
1492 if (!(caps & AC_PINCAP_OUT))
1497 /* count the number of input pins that are capable to be multi-io */
1498 static int count_multiio_pins(struct hda_codec *codec, hda_nid_t reference_pin)
1500 struct hda_gen_spec *spec = codec->spec;
1501 struct auto_pin_cfg *cfg = &spec->autocfg;
1502 unsigned int defcfg = snd_hda_codec_get_pincfg(codec, reference_pin);
1503 unsigned int location = get_defcfg_location(defcfg);
1507 for (type = AUTO_PIN_LINE_IN; type >= AUTO_PIN_MIC; type--) {
1508 for (i = 0; i < cfg->num_inputs; i++) {
1509 if (cfg->inputs[i].type != type)
1511 if (can_be_multiio_pin(codec, location,
1512 cfg->inputs[i].pin))
1522 * When hardwired is set, try to fill ony hardwired pins, and returns
1523 * zero if any pins are filled, non-zero if nothing found.
1524 * When hardwired is off, try to fill possible input pins, and returns
1525 * the badness value.
1527 static int fill_multi_ios(struct hda_codec *codec,
1528 hda_nid_t reference_pin,
1531 struct hda_gen_spec *spec = codec->spec;
1532 struct auto_pin_cfg *cfg = &spec->autocfg;
1533 int type, i, j, num_pins, old_pins;
1534 unsigned int defcfg = snd_hda_codec_get_pincfg(codec, reference_pin);
1535 unsigned int location = get_defcfg_location(defcfg);
1537 struct nid_path *path;
1539 old_pins = spec->multi_ios;
1543 num_pins = count_multiio_pins(codec, reference_pin);
1547 for (type = AUTO_PIN_LINE_IN; type >= AUTO_PIN_MIC; type--) {
1548 for (i = 0; i < cfg->num_inputs; i++) {
1549 hda_nid_t nid = cfg->inputs[i].pin;
1552 if (cfg->inputs[i].type != type)
1554 if (!can_be_multiio_pin(codec, location, nid))
1556 for (j = 0; j < spec->multi_ios; j++) {
1557 if (nid == spec->multi_io[j].pin)
1560 if (j < spec->multi_ios)
1564 dac = get_dac_if_single(codec, nid);
1566 dac = look_for_dac(codec, nid, false);
1571 path = snd_hda_add_new_path(codec, dac, nid,
1577 /* print_nid_path(codec, "multiio", path); */
1578 spec->multi_io[spec->multi_ios].pin = nid;
1579 spec->multi_io[spec->multi_ios].dac = dac;
1580 spec->out_paths[cfg->line_outs + spec->multi_ios] =
1581 snd_hda_get_path_idx(codec, path);
1583 if (spec->multi_ios >= 2)
1589 badness = BAD_MULTI_IO;
1590 if (old_pins == spec->multi_ios) {
1592 return 1; /* nothing found */
1594 return badness; /* no badness if nothing found */
1596 if (!hardwired && spec->multi_ios < 2) {
1597 /* cancel newly assigned paths */
1598 spec->paths.used -= spec->multi_ios - old_pins;
1599 spec->multi_ios = old_pins;
1603 /* assign volume and mute controls */
1604 for (i = old_pins; i < spec->multi_ios; i++) {
1605 path = snd_hda_get_path_from_idx(codec, spec->out_paths[cfg->line_outs + i]);
1606 badness += assign_out_path_ctls(codec, path);
1612 /* map DACs for all pins in the list if they are single connections */
1613 static bool map_singles(struct hda_codec *codec, int outs,
1614 const hda_nid_t *pins, hda_nid_t *dacs, int *path_idx)
1616 struct hda_gen_spec *spec = codec->spec;
1619 for (i = 0; i < outs; i++) {
1620 struct nid_path *path;
1624 dac = get_dac_if_single(codec, pins[i]);
1627 path = snd_hda_add_new_path(codec, dac, pins[i],
1629 if (!path && !i && spec->mixer_nid)
1630 path = snd_hda_add_new_path(codec, dac, pins[i], 0);
1634 /* print_nid_path(codec, "output", path); */
1635 path->active = true;
1636 path_idx[i] = snd_hda_get_path_idx(codec, path);
1642 static inline bool has_aamix_out_paths(struct hda_gen_spec *spec)
1644 return spec->aamix_out_paths[0] || spec->aamix_out_paths[1] ||
1645 spec->aamix_out_paths[2];
1648 /* create a new path including aamix if available, and return its index */
1649 static int check_aamix_out_path(struct hda_codec *codec, int path_idx)
1651 struct hda_gen_spec *spec = codec->spec;
1652 struct nid_path *path;
1653 hda_nid_t path_dac, dac, pin;
1655 path = snd_hda_get_path_from_idx(codec, path_idx);
1656 if (!path || !path->depth ||
1657 is_nid_contained(path, spec->mixer_nid))
1659 path_dac = path->path[0];
1660 dac = spec->private_dac_nids[0];
1661 pin = path->path[path->depth - 1];
1662 path = snd_hda_add_new_path(codec, dac, pin, spec->mixer_nid);
1664 if (dac != path_dac)
1666 else if (spec->multiout.hp_out_nid[0])
1667 dac = spec->multiout.hp_out_nid[0];
1668 else if (spec->multiout.extra_out_nid[0])
1669 dac = spec->multiout.extra_out_nid[0];
1673 path = snd_hda_add_new_path(codec, dac, pin,
1678 /* print_nid_path(codec, "output-aamix", path); */
1679 path->active = false; /* unused as default */
1680 path->pin_fixed = true; /* static route */
1681 return snd_hda_get_path_idx(codec, path);
1684 /* check whether the independent HP is available with the current config */
1685 static bool indep_hp_possible(struct hda_codec *codec)
1687 struct hda_gen_spec *spec = codec->spec;
1688 struct auto_pin_cfg *cfg = &spec->autocfg;
1689 struct nid_path *path;
1692 if (cfg->line_out_type == AUTO_PIN_HP_OUT)
1693 idx = spec->out_paths[0];
1695 idx = spec->hp_paths[0];
1696 path = snd_hda_get_path_from_idx(codec, idx);
1700 /* assume no path conflicts unless aamix is involved */
1701 if (!spec->mixer_nid || !is_nid_contained(path, spec->mixer_nid))
1704 /* check whether output paths contain aamix */
1705 for (i = 0; i < cfg->line_outs; i++) {
1706 if (spec->out_paths[i] == idx)
1708 path = snd_hda_get_path_from_idx(codec, spec->out_paths[i]);
1709 if (path && is_nid_contained(path, spec->mixer_nid))
1712 for (i = 0; i < cfg->speaker_outs; i++) {
1713 path = snd_hda_get_path_from_idx(codec, spec->speaker_paths[i]);
1714 if (path && is_nid_contained(path, spec->mixer_nid))
1721 /* fill the empty entries in the dac array for speaker/hp with the
1722 * shared dac pointed by the paths
1724 static void refill_shared_dacs(struct hda_codec *codec, int num_outs,
1725 hda_nid_t *dacs, int *path_idx)
1727 struct nid_path *path;
1730 for (i = 0; i < num_outs; i++) {
1733 path = snd_hda_get_path_from_idx(codec, path_idx[i]);
1736 dacs[i] = path->path[0];
1740 /* fill in the dac_nids table from the parsed pin configuration */
1741 static int fill_and_eval_dacs(struct hda_codec *codec,
1742 bool fill_hardwired,
1743 bool fill_mio_first)
1745 struct hda_gen_spec *spec = codec->spec;
1746 struct auto_pin_cfg *cfg = &spec->autocfg;
1747 int i, err, badness;
1749 /* set num_dacs once to full for look_for_dac() */
1750 spec->multiout.num_dacs = cfg->line_outs;
1751 spec->multiout.dac_nids = spec->private_dac_nids;
1752 memset(spec->private_dac_nids, 0, sizeof(spec->private_dac_nids));
1753 memset(spec->multiout.hp_out_nid, 0, sizeof(spec->multiout.hp_out_nid));
1754 memset(spec->multiout.extra_out_nid, 0, sizeof(spec->multiout.extra_out_nid));
1755 spec->multi_ios = 0;
1756 snd_array_free(&spec->paths);
1758 /* clear path indices */
1759 memset(spec->out_paths, 0, sizeof(spec->out_paths));
1760 memset(spec->hp_paths, 0, sizeof(spec->hp_paths));
1761 memset(spec->speaker_paths, 0, sizeof(spec->speaker_paths));
1762 memset(spec->aamix_out_paths, 0, sizeof(spec->aamix_out_paths));
1763 memset(spec->digout_paths, 0, sizeof(spec->digout_paths));
1764 memset(spec->input_paths, 0, sizeof(spec->input_paths));
1765 memset(spec->loopback_paths, 0, sizeof(spec->loopback_paths));
1766 memset(&spec->digin_path, 0, sizeof(spec->digin_path));
1770 /* fill hard-wired DACs first */
1771 if (fill_hardwired) {
1774 mapped = map_singles(codec, cfg->line_outs,
1776 spec->private_dac_nids,
1778 mapped |= map_singles(codec, cfg->hp_outs,
1780 spec->multiout.hp_out_nid,
1782 mapped |= map_singles(codec, cfg->speaker_outs,
1784 spec->multiout.extra_out_nid,
1785 spec->speaker_paths);
1786 if (!spec->no_multi_io &&
1787 fill_mio_first && cfg->line_outs == 1 &&
1788 cfg->line_out_type != AUTO_PIN_SPEAKER_OUT) {
1789 err = fill_multi_ios(codec, cfg->line_out_pins[0], true);
1796 badness += try_assign_dacs(codec, cfg->line_outs, cfg->line_out_pins,
1797 spec->private_dac_nids, spec->out_paths,
1798 spec->main_out_badness);
1800 if (!spec->no_multi_io && fill_mio_first &&
1801 cfg->line_outs == 1 && cfg->line_out_type != AUTO_PIN_SPEAKER_OUT) {
1802 /* try to fill multi-io first */
1803 err = fill_multi_ios(codec, cfg->line_out_pins[0], false);
1806 /* we don't count badness at this stage yet */
1809 if (cfg->line_out_type != AUTO_PIN_HP_OUT) {
1810 err = try_assign_dacs(codec, cfg->hp_outs, cfg->hp_pins,
1811 spec->multiout.hp_out_nid,
1813 spec->extra_out_badness);
1818 if (cfg->line_out_type != AUTO_PIN_SPEAKER_OUT) {
1819 err = try_assign_dacs(codec, cfg->speaker_outs,
1821 spec->multiout.extra_out_nid,
1822 spec->speaker_paths,
1823 spec->extra_out_badness);
1828 if (!spec->no_multi_io &&
1829 cfg->line_outs == 1 && cfg->line_out_type != AUTO_PIN_SPEAKER_OUT) {
1830 err = fill_multi_ios(codec, cfg->line_out_pins[0], false);
1836 if (spec->mixer_nid) {
1837 spec->aamix_out_paths[0] =
1838 check_aamix_out_path(codec, spec->out_paths[0]);
1839 if (cfg->line_out_type != AUTO_PIN_HP_OUT)
1840 spec->aamix_out_paths[1] =
1841 check_aamix_out_path(codec, spec->hp_paths[0]);
1842 if (cfg->line_out_type != AUTO_PIN_SPEAKER_OUT)
1843 spec->aamix_out_paths[2] =
1844 check_aamix_out_path(codec, spec->speaker_paths[0]);
1847 if (!spec->no_multi_io &&
1848 cfg->hp_outs && cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
1849 if (count_multiio_pins(codec, cfg->hp_pins[0]) >= 2)
1850 spec->multi_ios = 1; /* give badness */
1852 /* re-count num_dacs and squash invalid entries */
1853 spec->multiout.num_dacs = 0;
1854 for (i = 0; i < cfg->line_outs; i++) {
1855 if (spec->private_dac_nids[i])
1856 spec->multiout.num_dacs++;
1858 memmove(spec->private_dac_nids + i,
1859 spec->private_dac_nids + i + 1,
1860 sizeof(hda_nid_t) * (cfg->line_outs - i - 1));
1861 spec->private_dac_nids[cfg->line_outs - 1] = 0;
1865 spec->ext_channel_count = spec->min_channel_count =
1866 spec->multiout.num_dacs * 2;
1868 if (spec->multi_ios == 2) {
1869 for (i = 0; i < 2; i++)
1870 spec->private_dac_nids[spec->multiout.num_dacs++] =
1871 spec->multi_io[i].dac;
1872 } else if (spec->multi_ios) {
1873 spec->multi_ios = 0;
1874 badness += BAD_MULTI_IO;
1877 if (spec->indep_hp && !indep_hp_possible(codec))
1878 badness += BAD_NO_INDEP_HP;
1880 /* re-fill the shared DAC for speaker / headphone */
1881 if (cfg->line_out_type != AUTO_PIN_HP_OUT)
1882 refill_shared_dacs(codec, cfg->hp_outs,
1883 spec->multiout.hp_out_nid,
1885 if (cfg->line_out_type != AUTO_PIN_SPEAKER_OUT)
1886 refill_shared_dacs(codec, cfg->speaker_outs,
1887 spec->multiout.extra_out_nid,
1888 spec->speaker_paths);
1893 #define DEBUG_BADNESS
1895 #ifdef DEBUG_BADNESS
1896 #define debug_badness(fmt, ...) \
1897 codec_dbg(codec, fmt, ##__VA_ARGS__)
1899 #define debug_badness(fmt, ...) \
1900 do { if (0) codec_dbg(codec, fmt, ##__VA_ARGS__); } while (0)
1903 #ifdef DEBUG_BADNESS
1904 static inline void print_nid_path_idx(struct hda_codec *codec,
1905 const char *pfx, int idx)
1907 struct nid_path *path;
1909 path = snd_hda_get_path_from_idx(codec, idx);
1911 print_nid_path(codec, pfx, path);
1914 static void debug_show_configs(struct hda_codec *codec,
1915 struct auto_pin_cfg *cfg)
1917 struct hda_gen_spec *spec = codec->spec;
1918 static const char * const lo_type[3] = { "LO", "SP", "HP" };
1921 debug_badness("multi_outs = %x/%x/%x/%x : %x/%x/%x/%x (type %s)\n",
1922 cfg->line_out_pins[0], cfg->line_out_pins[1],
1923 cfg->line_out_pins[2], cfg->line_out_pins[3],
1924 spec->multiout.dac_nids[0],
1925 spec->multiout.dac_nids[1],
1926 spec->multiout.dac_nids[2],
1927 spec->multiout.dac_nids[3],
1928 lo_type[cfg->line_out_type]);
1929 for (i = 0; i < cfg->line_outs; i++)
1930 print_nid_path_idx(codec, " out", spec->out_paths[i]);
1931 if (spec->multi_ios > 0)
1932 debug_badness("multi_ios(%d) = %x/%x : %x/%x\n",
1934 spec->multi_io[0].pin, spec->multi_io[1].pin,
1935 spec->multi_io[0].dac, spec->multi_io[1].dac);
1936 for (i = 0; i < spec->multi_ios; i++)
1937 print_nid_path_idx(codec, " mio",
1938 spec->out_paths[cfg->line_outs + i]);
1940 debug_badness("hp_outs = %x/%x/%x/%x : %x/%x/%x/%x\n",
1941 cfg->hp_pins[0], cfg->hp_pins[1],
1942 cfg->hp_pins[2], cfg->hp_pins[3],
1943 spec->multiout.hp_out_nid[0],
1944 spec->multiout.hp_out_nid[1],
1945 spec->multiout.hp_out_nid[2],
1946 spec->multiout.hp_out_nid[3]);
1947 for (i = 0; i < cfg->hp_outs; i++)
1948 print_nid_path_idx(codec, " hp ", spec->hp_paths[i]);
1949 if (cfg->speaker_outs)
1950 debug_badness("spk_outs = %x/%x/%x/%x : %x/%x/%x/%x\n",
1951 cfg->speaker_pins[0], cfg->speaker_pins[1],
1952 cfg->speaker_pins[2], cfg->speaker_pins[3],
1953 spec->multiout.extra_out_nid[0],
1954 spec->multiout.extra_out_nid[1],
1955 spec->multiout.extra_out_nid[2],
1956 spec->multiout.extra_out_nid[3]);
1957 for (i = 0; i < cfg->speaker_outs; i++)
1958 print_nid_path_idx(codec, " spk", spec->speaker_paths[i]);
1959 for (i = 0; i < 3; i++)
1960 print_nid_path_idx(codec, " mix", spec->aamix_out_paths[i]);
1963 #define debug_show_configs(codec, cfg) /* NOP */
1966 /* find all available DACs of the codec */
1967 static void fill_all_dac_nids(struct hda_codec *codec)
1969 struct hda_gen_spec *spec = codec->spec;
1972 spec->num_all_dacs = 0;
1973 memset(spec->all_dacs, 0, sizeof(spec->all_dacs));
1974 for_each_hda_codec_node(nid, codec) {
1975 if (get_wcaps_type(get_wcaps(codec, nid)) != AC_WID_AUD_OUT)
1977 if (spec->num_all_dacs >= ARRAY_SIZE(spec->all_dacs)) {
1978 codec_err(codec, "Too many DACs!\n");
1981 spec->all_dacs[spec->num_all_dacs++] = nid;
1985 static int parse_output_paths(struct hda_codec *codec)
1987 struct hda_gen_spec *spec = codec->spec;
1988 struct auto_pin_cfg *cfg = &spec->autocfg;
1989 struct auto_pin_cfg *best_cfg;
1991 int best_badness = INT_MAX;
1993 bool fill_hardwired = true, fill_mio_first = true;
1994 bool best_wired = true, best_mio = true;
1995 bool hp_spk_swapped = false;
1997 best_cfg = kmalloc(sizeof(*best_cfg), GFP_KERNEL);
2003 badness = fill_and_eval_dacs(codec, fill_hardwired,
2009 debug_badness("==> lo_type=%d, wired=%d, mio=%d, badness=0x%x\n",
2010 cfg->line_out_type, fill_hardwired, fill_mio_first,
2012 debug_show_configs(codec, cfg);
2013 if (badness < best_badness) {
2014 best_badness = badness;
2016 best_wired = fill_hardwired;
2017 best_mio = fill_mio_first;
2021 fill_mio_first = !fill_mio_first;
2022 if (!fill_mio_first)
2024 fill_hardwired = !fill_hardwired;
2025 if (!fill_hardwired)
2029 hp_spk_swapped = true;
2030 if (cfg->speaker_outs > 0 &&
2031 cfg->line_out_type == AUTO_PIN_HP_OUT) {
2032 cfg->hp_outs = cfg->line_outs;
2033 memcpy(cfg->hp_pins, cfg->line_out_pins,
2034 sizeof(cfg->hp_pins));
2035 cfg->line_outs = cfg->speaker_outs;
2036 memcpy(cfg->line_out_pins, cfg->speaker_pins,
2037 sizeof(cfg->speaker_pins));
2038 cfg->speaker_outs = 0;
2039 memset(cfg->speaker_pins, 0, sizeof(cfg->speaker_pins));
2040 cfg->line_out_type = AUTO_PIN_SPEAKER_OUT;
2041 fill_hardwired = true;
2044 if (cfg->hp_outs > 0 &&
2045 cfg->line_out_type == AUTO_PIN_SPEAKER_OUT) {
2046 cfg->speaker_outs = cfg->line_outs;
2047 memcpy(cfg->speaker_pins, cfg->line_out_pins,
2048 sizeof(cfg->speaker_pins));
2049 cfg->line_outs = cfg->hp_outs;
2050 memcpy(cfg->line_out_pins, cfg->hp_pins,
2051 sizeof(cfg->hp_pins));
2053 memset(cfg->hp_pins, 0, sizeof(cfg->hp_pins));
2054 cfg->line_out_type = AUTO_PIN_HP_OUT;
2055 fill_hardwired = true;
2062 debug_badness("==> restoring best_cfg\n");
2064 fill_and_eval_dacs(codec, best_wired, best_mio);
2066 debug_badness("==> Best config: lo_type=%d, wired=%d, mio=%d\n",
2067 cfg->line_out_type, best_wired, best_mio);
2068 debug_show_configs(codec, cfg);
2070 if (cfg->line_out_pins[0]) {
2071 struct nid_path *path;
2072 path = snd_hda_get_path_from_idx(codec, spec->out_paths[0]);
2074 spec->vmaster_nid = look_for_out_vol_nid(codec, path);
2075 if (spec->vmaster_nid) {
2076 snd_hda_set_vmaster_tlv(codec, spec->vmaster_nid,
2077 HDA_OUTPUT, spec->vmaster_tlv);
2078 if (spec->dac_min_mute)
2079 spec->vmaster_tlv[SNDRV_CTL_TLVO_DB_SCALE_MUTE_AND_STEP] |= TLV_DB_SCALE_MUTE;
2083 /* set initial pinctl targets */
2084 if (spec->prefer_hp_amp || cfg->line_out_type == AUTO_PIN_HP_OUT)
2088 set_pin_targets(codec, cfg->line_outs, cfg->line_out_pins, val);
2089 if (cfg->line_out_type != AUTO_PIN_HP_OUT)
2090 set_pin_targets(codec, cfg->hp_outs, cfg->hp_pins, PIN_HP);
2091 if (cfg->line_out_type != AUTO_PIN_SPEAKER_OUT) {
2092 val = spec->prefer_hp_amp ? PIN_HP : PIN_OUT;
2093 set_pin_targets(codec, cfg->speaker_outs,
2094 cfg->speaker_pins, val);
2097 /* clear indep_hp flag if not available */
2098 if (spec->indep_hp && !indep_hp_possible(codec))
2105 /* add playback controls from the parsed DAC table */
2106 static int create_multi_out_ctls(struct hda_codec *codec,
2107 const struct auto_pin_cfg *cfg)
2109 struct hda_gen_spec *spec = codec->spec;
2110 int i, err, noutputs;
2112 noutputs = cfg->line_outs;
2113 if (spec->multi_ios > 0 && cfg->line_outs < 3)
2114 noutputs += spec->multi_ios;
2116 for (i = 0; i < noutputs; i++) {
2119 struct nid_path *path;
2121 path = snd_hda_get_path_from_idx(codec, spec->out_paths[i]);
2125 name = get_line_out_pfx(codec, i, &index, NID_PATH_VOL_CTL);
2126 if (!name || !strcmp(name, "CLFE")) {
2128 err = add_vol_ctl(codec, "Center", 0, 1, path);
2131 err = add_vol_ctl(codec, "LFE", 0, 2, path);
2135 err = add_stereo_vol(codec, name, index, path);
2140 name = get_line_out_pfx(codec, i, &index, NID_PATH_MUTE_CTL);
2141 if (!name || !strcmp(name, "CLFE")) {
2142 err = add_sw_ctl(codec, "Center", 0, 1, path);
2145 err = add_sw_ctl(codec, "LFE", 0, 2, path);
2149 err = add_stereo_sw(codec, name, index, path);
2157 static int create_extra_out(struct hda_codec *codec, int path_idx,
2158 const char *pfx, int cidx)
2160 struct nid_path *path;
2163 path = snd_hda_get_path_from_idx(codec, path_idx);
2166 err = add_stereo_vol(codec, pfx, cidx, path);
2169 err = add_stereo_sw(codec, pfx, cidx, path);
2175 /* add playback controls for speaker and HP outputs */
2176 static int create_extra_outs(struct hda_codec *codec, int num_pins,
2177 const int *paths, const char *pfx)
2181 for (i = 0; i < num_pins; i++) {
2183 char tmp[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];
2186 if (num_pins == 2 && i == 1 && !strcmp(pfx, "Speaker"))
2187 name = "Bass Speaker";
2188 else if (num_pins >= 3) {
2189 snprintf(tmp, sizeof(tmp), "%s %s",
2190 pfx, channel_name[i]);
2196 err = create_extra_out(codec, paths[i], name, idx);
2203 static int create_hp_out_ctls(struct hda_codec *codec)
2205 struct hda_gen_spec *spec = codec->spec;
2206 return create_extra_outs(codec, spec->autocfg.hp_outs,
2211 static int create_speaker_out_ctls(struct hda_codec *codec)
2213 struct hda_gen_spec *spec = codec->spec;
2214 return create_extra_outs(codec, spec->autocfg.speaker_outs,
2215 spec->speaker_paths,
2220 * independent HP controls
2223 static void call_hp_automute(struct hda_codec *codec,
2224 struct hda_jack_callback *jack);
2225 static int indep_hp_info(struct snd_kcontrol *kcontrol,
2226 struct snd_ctl_elem_info *uinfo)
2228 return snd_hda_enum_bool_helper_info(kcontrol, uinfo);
2231 static int indep_hp_get(struct snd_kcontrol *kcontrol,
2232 struct snd_ctl_elem_value *ucontrol)
2234 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2235 struct hda_gen_spec *spec = codec->spec;
2236 ucontrol->value.enumerated.item[0] = spec->indep_hp_enabled;
2240 static void update_aamix_paths(struct hda_codec *codec, bool do_mix,
2241 int nomix_path_idx, int mix_path_idx,
2244 static int indep_hp_put(struct snd_kcontrol *kcontrol,
2245 struct snd_ctl_elem_value *ucontrol)
2247 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2248 struct hda_gen_spec *spec = codec->spec;
2249 unsigned int select = ucontrol->value.enumerated.item[0];
2252 mutex_lock(&spec->pcm_mutex);
2253 if (spec->active_streams) {
2258 if (spec->indep_hp_enabled != select) {
2260 if (spec->autocfg.line_out_type == AUTO_PIN_HP_OUT)
2261 dacp = &spec->private_dac_nids[0];
2263 dacp = &spec->multiout.hp_out_nid[0];
2265 /* update HP aamix paths in case it conflicts with indep HP */
2266 if (spec->have_aamix_ctl) {
2267 if (spec->autocfg.line_out_type == AUTO_PIN_HP_OUT)
2268 update_aamix_paths(codec, spec->aamix_mode,
2270 spec->aamix_out_paths[0],
2271 spec->autocfg.line_out_type);
2273 update_aamix_paths(codec, spec->aamix_mode,
2275 spec->aamix_out_paths[1],
2279 spec->indep_hp_enabled = select;
2280 if (spec->indep_hp_enabled)
2283 *dacp = spec->alt_dac_nid;
2285 call_hp_automute(codec, NULL);
2289 mutex_unlock(&spec->pcm_mutex);
2293 static const struct snd_kcontrol_new indep_hp_ctl = {
2294 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2295 .name = "Independent HP",
2296 .info = indep_hp_info,
2297 .get = indep_hp_get,
2298 .put = indep_hp_put,
2302 static int create_indep_hp_ctls(struct hda_codec *codec)
2304 struct hda_gen_spec *spec = codec->spec;
2307 if (!spec->indep_hp)
2309 if (spec->autocfg.line_out_type == AUTO_PIN_HP_OUT)
2310 dac = spec->multiout.dac_nids[0];
2312 dac = spec->multiout.hp_out_nid[0];
2318 spec->indep_hp_enabled = false;
2319 spec->alt_dac_nid = dac;
2320 if (!snd_hda_gen_add_kctl(spec, NULL, &indep_hp_ctl))
2326 * channel mode enum control
2329 static int ch_mode_info(struct snd_kcontrol *kcontrol,
2330 struct snd_ctl_elem_info *uinfo)
2332 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2333 struct hda_gen_spec *spec = codec->spec;
2336 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
2338 uinfo->value.enumerated.items = spec->multi_ios + 1;
2339 if (uinfo->value.enumerated.item > spec->multi_ios)
2340 uinfo->value.enumerated.item = spec->multi_ios;
2341 chs = uinfo->value.enumerated.item * 2 + spec->min_channel_count;
2342 sprintf(uinfo->value.enumerated.name, "%dch", chs);
2346 static int ch_mode_get(struct snd_kcontrol *kcontrol,
2347 struct snd_ctl_elem_value *ucontrol)
2349 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2350 struct hda_gen_spec *spec = codec->spec;
2351 ucontrol->value.enumerated.item[0] =
2352 (spec->ext_channel_count - spec->min_channel_count) / 2;
2356 static inline struct nid_path *
2357 get_multiio_path(struct hda_codec *codec, int idx)
2359 struct hda_gen_spec *spec = codec->spec;
2360 return snd_hda_get_path_from_idx(codec,
2361 spec->out_paths[spec->autocfg.line_outs + idx]);
2364 static void update_automute_all(struct hda_codec *codec);
2366 /* Default value to be passed as aamix argument for snd_hda_activate_path();
2367 * used for output paths
2369 static bool aamix_default(struct hda_gen_spec *spec)
2371 return !spec->have_aamix_ctl || spec->aamix_mode;
2374 static int set_multi_io(struct hda_codec *codec, int idx, bool output)
2376 struct hda_gen_spec *spec = codec->spec;
2377 hda_nid_t nid = spec->multi_io[idx].pin;
2378 struct nid_path *path;
2380 path = get_multiio_path(codec, idx);
2384 if (path->active == output)
2388 set_pin_target(codec, nid, PIN_OUT, true);
2389 snd_hda_activate_path(codec, path, true, aamix_default(spec));
2390 set_pin_eapd(codec, nid, true);
2392 set_pin_eapd(codec, nid, false);
2393 snd_hda_activate_path(codec, path, false, aamix_default(spec));
2394 set_pin_target(codec, nid, spec->multi_io[idx].ctl_in, true);
2395 path_power_down_sync(codec, path);
2398 /* update jack retasking in case it modifies any of them */
2399 update_automute_all(codec);
2404 static int ch_mode_put(struct snd_kcontrol *kcontrol,
2405 struct snd_ctl_elem_value *ucontrol)
2407 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2408 struct hda_gen_spec *spec = codec->spec;
2411 ch = ucontrol->value.enumerated.item[0];
2412 if (ch < 0 || ch > spec->multi_ios)
2414 if (ch == (spec->ext_channel_count - spec->min_channel_count) / 2)
2416 spec->ext_channel_count = ch * 2 + spec->min_channel_count;
2417 for (i = 0; i < spec->multi_ios; i++)
2418 set_multi_io(codec, i, i < ch);
2419 spec->multiout.max_channels = max(spec->ext_channel_count,
2420 spec->const_channel_count);
2421 if (spec->need_dac_fix)
2422 spec->multiout.num_dacs = spec->multiout.max_channels / 2;
2426 static const struct snd_kcontrol_new channel_mode_enum = {
2427 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2428 .name = "Channel Mode",
2429 .info = ch_mode_info,
2434 static int create_multi_channel_mode(struct hda_codec *codec)
2436 struct hda_gen_spec *spec = codec->spec;
2438 if (spec->multi_ios > 0) {
2439 if (!snd_hda_gen_add_kctl(spec, NULL, &channel_mode_enum))
2446 * aamix loopback enable/disable switch
2449 #define loopback_mixing_info indep_hp_info
2451 static int loopback_mixing_get(struct snd_kcontrol *kcontrol,
2452 struct snd_ctl_elem_value *ucontrol)
2454 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2455 struct hda_gen_spec *spec = codec->spec;
2456 ucontrol->value.enumerated.item[0] = spec->aamix_mode;
2460 static void update_aamix_paths(struct hda_codec *codec, bool do_mix,
2461 int nomix_path_idx, int mix_path_idx,
2464 struct hda_gen_spec *spec = codec->spec;
2465 struct nid_path *nomix_path, *mix_path;
2467 nomix_path = snd_hda_get_path_from_idx(codec, nomix_path_idx);
2468 mix_path = snd_hda_get_path_from_idx(codec, mix_path_idx);
2469 if (!nomix_path || !mix_path)
2472 /* if HP aamix path is driven from a different DAC and the
2473 * independent HP mode is ON, can't turn on aamix path
2475 if (out_type == AUTO_PIN_HP_OUT && spec->indep_hp_enabled &&
2476 mix_path->path[0] != spec->alt_dac_nid)
2480 snd_hda_activate_path(codec, nomix_path, false, true);
2481 snd_hda_activate_path(codec, mix_path, true, true);
2482 path_power_down_sync(codec, nomix_path);
2484 snd_hda_activate_path(codec, mix_path, false, false);
2485 snd_hda_activate_path(codec, nomix_path, true, false);
2486 path_power_down_sync(codec, mix_path);
2490 /* re-initialize the output paths; only called from loopback_mixing_put() */
2491 static void update_output_paths(struct hda_codec *codec, int num_outs,
2494 struct hda_gen_spec *spec = codec->spec;
2495 struct nid_path *path;
2498 for (i = 0; i < num_outs; i++) {
2499 path = snd_hda_get_path_from_idx(codec, paths[i]);
2501 snd_hda_activate_path(codec, path, path->active,
2506 static int loopback_mixing_put(struct snd_kcontrol *kcontrol,
2507 struct snd_ctl_elem_value *ucontrol)
2509 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2510 struct hda_gen_spec *spec = codec->spec;
2511 const struct auto_pin_cfg *cfg = &spec->autocfg;
2512 unsigned int val = ucontrol->value.enumerated.item[0];
2514 if (val == spec->aamix_mode)
2516 spec->aamix_mode = val;
2517 if (has_aamix_out_paths(spec)) {
2518 update_aamix_paths(codec, val, spec->out_paths[0],
2519 spec->aamix_out_paths[0],
2520 cfg->line_out_type);
2521 update_aamix_paths(codec, val, spec->hp_paths[0],
2522 spec->aamix_out_paths[1],
2524 update_aamix_paths(codec, val, spec->speaker_paths[0],
2525 spec->aamix_out_paths[2],
2526 AUTO_PIN_SPEAKER_OUT);
2528 update_output_paths(codec, cfg->line_outs, spec->out_paths);
2529 if (cfg->line_out_type != AUTO_PIN_HP_OUT)
2530 update_output_paths(codec, cfg->hp_outs, spec->hp_paths);
2531 if (cfg->line_out_type != AUTO_PIN_SPEAKER_OUT)
2532 update_output_paths(codec, cfg->speaker_outs,
2533 spec->speaker_paths);
2538 static const struct snd_kcontrol_new loopback_mixing_enum = {
2539 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2540 .name = "Loopback Mixing",
2541 .info = loopback_mixing_info,
2542 .get = loopback_mixing_get,
2543 .put = loopback_mixing_put,
2546 static int create_loopback_mixing_ctl(struct hda_codec *codec)
2548 struct hda_gen_spec *spec = codec->spec;
2550 if (!spec->mixer_nid)
2552 if (!snd_hda_gen_add_kctl(spec, NULL, &loopback_mixing_enum))
2554 spec->have_aamix_ctl = 1;
2559 * shared headphone/mic handling
2562 static void call_update_outputs(struct hda_codec *codec);
2564 /* for shared I/O, change the pin-control accordingly */
2565 static void update_hp_mic(struct hda_codec *codec, int adc_mux, bool force)
2567 struct hda_gen_spec *spec = codec->spec;
2572 pin = spec->hp_mic_pin;
2573 as_mic = spec->cur_mux[adc_mux] == spec->hp_mic_mux_idx;
2576 val = snd_hda_codec_get_pin_target(codec, pin);
2586 val = snd_hda_get_default_vref(codec, pin);
2587 /* if the HP pin doesn't support VREF and the codec driver gives an
2588 * alternative pin, set up the VREF on that pin instead
2590 if (val == AC_PINCTL_VREF_HIZ && spec->shared_mic_vref_pin) {
2591 const hda_nid_t vref_pin = spec->shared_mic_vref_pin;
2592 unsigned int vref_val = snd_hda_get_default_vref(codec, vref_pin);
2593 if (vref_val != AC_PINCTL_VREF_HIZ)
2594 snd_hda_set_pin_ctl_cache(codec, vref_pin,
2595 PIN_IN | (as_mic ? vref_val : 0));
2598 if (!spec->hp_mic_jack_modes) {
2603 set_pin_target(codec, pin, val, true);
2604 call_hp_automute(codec, NULL);
2608 /* create a shared input with the headphone out */
2609 static int create_hp_mic(struct hda_codec *codec)
2611 struct hda_gen_spec *spec = codec->spec;
2612 struct auto_pin_cfg *cfg = &spec->autocfg;
2613 unsigned int defcfg;
2616 if (!spec->hp_mic) {
2617 if (spec->suppress_hp_mic_detect)
2619 /* automatic detection: only if no input or a single internal
2620 * input pin is found, try to detect the shared hp/mic
2622 if (cfg->num_inputs > 1)
2624 else if (cfg->num_inputs == 1) {
2625 defcfg = snd_hda_codec_get_pincfg(codec, cfg->inputs[0].pin);
2626 if (snd_hda_get_input_pin_attr(defcfg) != INPUT_PIN_ATTR_INT)
2631 spec->hp_mic = 0; /* clear once */
2632 if (cfg->num_inputs >= AUTO_CFG_MAX_INS)
2636 if (cfg->line_out_type == AUTO_PIN_HP_OUT && cfg->line_outs > 0)
2637 nid = cfg->line_out_pins[0];
2638 else if (cfg->hp_outs > 0)
2639 nid = cfg->hp_pins[0];
2643 if (!(snd_hda_query_pin_caps(codec, nid) & AC_PINCAP_IN))
2644 return 0; /* no input */
2646 cfg->inputs[cfg->num_inputs].pin = nid;
2647 cfg->inputs[cfg->num_inputs].type = AUTO_PIN_MIC;
2648 cfg->inputs[cfg->num_inputs].is_headphone_mic = 1;
2651 spec->hp_mic_pin = nid;
2652 /* we can't handle auto-mic together with HP-mic */
2653 spec->suppress_auto_mic = 1;
2654 codec_dbg(codec, "Enable shared I/O jack on NID 0x%x\n", nid);
2662 static int create_hp_mic_jack_mode(struct hda_codec *codec, hda_nid_t pin);
2664 static const char * const out_jack_texts[] = {
2665 "Line Out", "Headphone Out",
2668 static int out_jack_mode_info(struct snd_kcontrol *kcontrol,
2669 struct snd_ctl_elem_info *uinfo)
2671 return snd_hda_enum_helper_info(kcontrol, uinfo, 2, out_jack_texts);
2674 static int out_jack_mode_get(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;
2679 if (snd_hda_codec_get_pin_target(codec, nid) == PIN_HP)
2680 ucontrol->value.enumerated.item[0] = 1;
2682 ucontrol->value.enumerated.item[0] = 0;
2686 static int out_jack_mode_put(struct snd_kcontrol *kcontrol,
2687 struct snd_ctl_elem_value *ucontrol)
2689 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2690 hda_nid_t nid = kcontrol->private_value;
2693 val = ucontrol->value.enumerated.item[0] ? PIN_HP : PIN_OUT;
2694 if (snd_hda_codec_get_pin_target(codec, nid) == val)
2696 snd_hda_set_pin_ctl_cache(codec, nid, val);
2700 static const struct snd_kcontrol_new out_jack_mode_enum = {
2701 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2702 .info = out_jack_mode_info,
2703 .get = out_jack_mode_get,
2704 .put = out_jack_mode_put,
2707 static bool find_kctl_name(struct hda_codec *codec, const char *name, int idx)
2709 struct hda_gen_spec *spec = codec->spec;
2710 const struct snd_kcontrol_new *kctl;
2713 snd_array_for_each(&spec->kctls, i, kctl) {
2714 if (!strcmp(kctl->name, name) && kctl->index == idx)
2720 static void get_jack_mode_name(struct hda_codec *codec, hda_nid_t pin,
2721 char *name, size_t name_len)
2723 struct hda_gen_spec *spec = codec->spec;
2726 snd_hda_get_pin_label(codec, pin, &spec->autocfg, name, name_len, &idx);
2727 strlcat(name, " Jack Mode", name_len);
2729 for (; find_kctl_name(codec, name, idx); idx++)
2733 static int get_out_jack_num_items(struct hda_codec *codec, hda_nid_t pin)
2735 struct hda_gen_spec *spec = codec->spec;
2736 if (spec->add_jack_modes) {
2737 unsigned int pincap = snd_hda_query_pin_caps(codec, pin);
2738 if ((pincap & AC_PINCAP_OUT) && (pincap & AC_PINCAP_HP_DRV))
2744 static int create_out_jack_modes(struct hda_codec *codec, int num_pins,
2747 struct hda_gen_spec *spec = codec->spec;
2750 for (i = 0; i < num_pins; i++) {
2751 hda_nid_t pin = pins[i];
2752 if (pin == spec->hp_mic_pin)
2754 if (get_out_jack_num_items(codec, pin) > 1) {
2755 struct snd_kcontrol_new *knew;
2756 char name[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];
2757 get_jack_mode_name(codec, pin, name, sizeof(name));
2758 knew = snd_hda_gen_add_kctl(spec, name,
2759 &out_jack_mode_enum);
2762 knew->private_value = pin;
2773 /* from AC_PINCTL_VREF_HIZ to AC_PINCTL_VREF_100 */
2776 static const char * const vref_texts[NUM_VREFS] = {
2777 "Line In", "Mic 50pc Bias", "Mic 0V Bias",
2778 "", "Mic 80pc Bias", "Mic 100pc Bias"
2781 static unsigned int get_vref_caps(struct hda_codec *codec, hda_nid_t pin)
2783 unsigned int pincap;
2785 pincap = snd_hda_query_pin_caps(codec, pin);
2786 pincap = (pincap & AC_PINCAP_VREF) >> AC_PINCAP_VREF_SHIFT;
2787 /* filter out unusual vrefs */
2788 pincap &= ~(AC_PINCAP_VREF_GRD | AC_PINCAP_VREF_100);
2792 /* convert from the enum item index to the vref ctl index (0=HIZ, 1=50%...) */
2793 static int get_vref_idx(unsigned int vref_caps, unsigned int item_idx)
2795 unsigned int i, n = 0;
2797 for (i = 0; i < NUM_VREFS; i++) {
2798 if (vref_caps & (1 << i)) {
2807 /* convert back from the vref ctl index to the enum item index */
2808 static int cvt_from_vref_idx(unsigned int vref_caps, unsigned int idx)
2810 unsigned int i, n = 0;
2812 for (i = 0; i < NUM_VREFS; i++) {
2815 if (vref_caps & (1 << i))
2821 static int in_jack_mode_info(struct snd_kcontrol *kcontrol,
2822 struct snd_ctl_elem_info *uinfo)
2824 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2825 hda_nid_t nid = kcontrol->private_value;
2826 unsigned int vref_caps = get_vref_caps(codec, nid);
2828 snd_hda_enum_helper_info(kcontrol, uinfo, hweight32(vref_caps),
2830 /* set the right text */
2831 strcpy(uinfo->value.enumerated.name,
2832 vref_texts[get_vref_idx(vref_caps, uinfo->value.enumerated.item)]);
2836 static int in_jack_mode_get(struct snd_kcontrol *kcontrol,
2837 struct snd_ctl_elem_value *ucontrol)
2839 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2840 hda_nid_t nid = kcontrol->private_value;
2841 unsigned int vref_caps = get_vref_caps(codec, nid);
2844 idx = snd_hda_codec_get_pin_target(codec, nid) & AC_PINCTL_VREFEN;
2845 ucontrol->value.enumerated.item[0] = cvt_from_vref_idx(vref_caps, idx);
2849 static int in_jack_mode_put(struct snd_kcontrol *kcontrol,
2850 struct snd_ctl_elem_value *ucontrol)
2852 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2853 hda_nid_t nid = kcontrol->private_value;
2854 unsigned int vref_caps = get_vref_caps(codec, nid);
2855 unsigned int val, idx;
2857 val = snd_hda_codec_get_pin_target(codec, nid);
2858 idx = cvt_from_vref_idx(vref_caps, val & AC_PINCTL_VREFEN);
2859 if (idx == ucontrol->value.enumerated.item[0])
2862 val &= ~AC_PINCTL_VREFEN;
2863 val |= get_vref_idx(vref_caps, ucontrol->value.enumerated.item[0]);
2864 snd_hda_set_pin_ctl_cache(codec, nid, val);
2868 static const struct snd_kcontrol_new in_jack_mode_enum = {
2869 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2870 .info = in_jack_mode_info,
2871 .get = in_jack_mode_get,
2872 .put = in_jack_mode_put,
2875 static int get_in_jack_num_items(struct hda_codec *codec, hda_nid_t pin)
2877 struct hda_gen_spec *spec = codec->spec;
2879 if (spec->add_jack_modes)
2880 nitems = hweight32(get_vref_caps(codec, pin));
2881 return nitems ? nitems : 1;
2884 static int create_in_jack_mode(struct hda_codec *codec, hda_nid_t pin)
2886 struct hda_gen_spec *spec = codec->spec;
2887 struct snd_kcontrol_new *knew;
2888 char name[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];
2889 unsigned int defcfg;
2891 if (pin == spec->hp_mic_pin)
2892 return 0; /* already done in create_out_jack_mode() */
2894 /* no jack mode for fixed pins */
2895 defcfg = snd_hda_codec_get_pincfg(codec, pin);
2896 if (snd_hda_get_input_pin_attr(defcfg) == INPUT_PIN_ATTR_INT)
2899 /* no multiple vref caps? */
2900 if (get_in_jack_num_items(codec, pin) <= 1)
2903 get_jack_mode_name(codec, pin, name, sizeof(name));
2904 knew = snd_hda_gen_add_kctl(spec, name, &in_jack_mode_enum);
2907 knew->private_value = pin;
2912 * HP/mic shared jack mode
2914 static int hp_mic_jack_mode_info(struct snd_kcontrol *kcontrol,
2915 struct snd_ctl_elem_info *uinfo)
2917 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2918 hda_nid_t nid = kcontrol->private_value;
2919 int out_jacks = get_out_jack_num_items(codec, nid);
2920 int in_jacks = get_in_jack_num_items(codec, nid);
2921 const char *text = NULL;
2924 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
2926 uinfo->value.enumerated.items = out_jacks + in_jacks;
2927 if (uinfo->value.enumerated.item >= uinfo->value.enumerated.items)
2928 uinfo->value.enumerated.item = uinfo->value.enumerated.items - 1;
2929 idx = uinfo->value.enumerated.item;
2930 if (idx < out_jacks) {
2932 text = out_jack_texts[idx];
2934 text = "Headphone Out";
2938 unsigned int vref_caps = get_vref_caps(codec, nid);
2939 text = vref_texts[get_vref_idx(vref_caps, idx)];
2944 strcpy(uinfo->value.enumerated.name, text);
2948 static int get_cur_hp_mic_jack_mode(struct hda_codec *codec, hda_nid_t nid)
2950 int out_jacks = get_out_jack_num_items(codec, nid);
2951 int in_jacks = get_in_jack_num_items(codec, nid);
2952 unsigned int val = snd_hda_codec_get_pin_target(codec, nid);
2955 if (val & PIN_OUT) {
2956 if (out_jacks > 1 && val == PIN_HP)
2958 } else if (val & PIN_IN) {
2961 unsigned int vref_caps = get_vref_caps(codec, nid);
2962 val &= AC_PINCTL_VREFEN;
2963 idx += cvt_from_vref_idx(vref_caps, val);
2969 static int hp_mic_jack_mode_get(struct snd_kcontrol *kcontrol,
2970 struct snd_ctl_elem_value *ucontrol)
2972 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2973 hda_nid_t nid = kcontrol->private_value;
2974 ucontrol->value.enumerated.item[0] =
2975 get_cur_hp_mic_jack_mode(codec, nid);
2979 static int hp_mic_jack_mode_put(struct snd_kcontrol *kcontrol,
2980 struct snd_ctl_elem_value *ucontrol)
2982 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2983 hda_nid_t nid = kcontrol->private_value;
2984 int out_jacks = get_out_jack_num_items(codec, nid);
2985 int in_jacks = get_in_jack_num_items(codec, nid);
2986 unsigned int val, oldval, idx;
2988 oldval = get_cur_hp_mic_jack_mode(codec, nid);
2989 idx = ucontrol->value.enumerated.item[0];
2993 if (idx < out_jacks) {
2995 val = idx ? PIN_HP : PIN_OUT;
3001 unsigned int vref_caps = get_vref_caps(codec, nid);
3002 val = snd_hda_codec_get_pin_target(codec, nid);
3003 val &= ~(AC_PINCTL_VREFEN | PIN_HP);
3004 val |= get_vref_idx(vref_caps, idx) | PIN_IN;
3006 val = snd_hda_get_default_vref(codec, nid) | PIN_IN;
3008 snd_hda_set_pin_ctl_cache(codec, nid, val);
3009 call_hp_automute(codec, NULL);
3014 static const struct snd_kcontrol_new hp_mic_jack_mode_enum = {
3015 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3016 .info = hp_mic_jack_mode_info,
3017 .get = hp_mic_jack_mode_get,
3018 .put = hp_mic_jack_mode_put,
3021 static int create_hp_mic_jack_mode(struct hda_codec *codec, hda_nid_t pin)
3023 struct hda_gen_spec *spec = codec->spec;
3024 struct snd_kcontrol_new *knew;
3026 knew = snd_hda_gen_add_kctl(spec, "Headphone Mic Jack Mode",
3027 &hp_mic_jack_mode_enum);
3030 knew->private_value = pin;
3031 spec->hp_mic_jack_modes = 1;
3039 /* add the powersave loopback-list entry */
3040 static int add_loopback_list(struct hda_gen_spec *spec, hda_nid_t mix, int idx)
3042 struct hda_amp_list *list;
3044 list = snd_array_new(&spec->loopback_list);
3048 list->dir = HDA_INPUT;
3050 spec->loopback.amplist = spec->loopback_list.list;
3054 /* return true if either a volume or a mute amp is found for the given
3055 * aamix path; the amp has to be either in the mixer node or its direct leaf
3057 static bool look_for_mix_leaf_ctls(struct hda_codec *codec, hda_nid_t mix_nid,
3058 hda_nid_t pin, unsigned int *mix_val,
3059 unsigned int *mute_val)
3062 const hda_nid_t *list;
3065 idx = snd_hda_get_conn_index(codec, mix_nid, pin, true);
3069 *mix_val = *mute_val = 0;
3070 if (nid_has_volume(codec, mix_nid, HDA_INPUT))
3071 *mix_val = HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT);
3072 if (nid_has_mute(codec, mix_nid, HDA_INPUT))
3073 *mute_val = HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT);
3074 if (*mix_val && *mute_val)
3077 /* check leaf node */
3078 num_conns = snd_hda_get_conn_list(codec, mix_nid, &list);
3079 if (num_conns < idx)
3082 if (!*mix_val && nid_has_volume(codec, nid, HDA_OUTPUT) &&
3083 !is_ctl_associated(codec, nid, HDA_OUTPUT, 0, NID_PATH_VOL_CTL))
3084 *mix_val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
3085 if (!*mute_val && nid_has_mute(codec, nid, HDA_OUTPUT) &&
3086 !is_ctl_associated(codec, nid, HDA_OUTPUT, 0, NID_PATH_MUTE_CTL))
3087 *mute_val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
3089 return *mix_val || *mute_val;
3092 /* create input playback/capture controls for the given pin */
3093 static int new_analog_input(struct hda_codec *codec, int input_idx,
3094 hda_nid_t pin, const char *ctlname, int ctlidx,
3097 struct hda_gen_spec *spec = codec->spec;
3098 struct nid_path *path;
3099 unsigned int mix_val, mute_val;
3102 if (!look_for_mix_leaf_ctls(codec, mix_nid, pin, &mix_val, &mute_val))
3105 path = snd_hda_add_new_path(codec, pin, mix_nid, 0);
3108 print_nid_path(codec, "loopback", path);
3109 spec->loopback_paths[input_idx] = snd_hda_get_path_idx(codec, path);
3111 idx = path->idx[path->depth - 1];
3113 err = __add_pb_vol_ctrl(spec, HDA_CTL_WIDGET_VOL, ctlname, ctlidx, mix_val);
3116 path->ctls[NID_PATH_VOL_CTL] = mix_val;
3120 err = __add_pb_sw_ctrl(spec, HDA_CTL_WIDGET_MUTE, ctlname, ctlidx, mute_val);
3123 path->ctls[NID_PATH_MUTE_CTL] = mute_val;
3126 path->active = true;
3127 path->stream_enabled = true; /* no DAC/ADC involved */
3128 err = add_loopback_list(spec, mix_nid, idx);
3132 if (spec->mixer_nid != spec->mixer_merge_nid &&
3133 !spec->loopback_merge_path) {
3134 path = snd_hda_add_new_path(codec, spec->mixer_nid,
3135 spec->mixer_merge_nid, 0);
3137 print_nid_path(codec, "loopback-merge", path);
3138 path->active = true;
3139 path->pin_fixed = true; /* static route */
3140 path->stream_enabled = true; /* no DAC/ADC involved */
3141 spec->loopback_merge_path =
3142 snd_hda_get_path_idx(codec, path);
3149 static int is_input_pin(struct hda_codec *codec, hda_nid_t nid)
3151 unsigned int pincap = snd_hda_query_pin_caps(codec, nid);
3152 return (pincap & AC_PINCAP_IN) != 0;
3155 /* Parse the codec tree and retrieve ADCs */
3156 static int fill_adc_nids(struct hda_codec *codec)
3158 struct hda_gen_spec *spec = codec->spec;
3160 hda_nid_t *adc_nids = spec->adc_nids;
3161 int max_nums = ARRAY_SIZE(spec->adc_nids);
3164 for_each_hda_codec_node(nid, codec) {
3165 unsigned int caps = get_wcaps(codec, nid);
3166 int type = get_wcaps_type(caps);
3168 if (type != AC_WID_AUD_IN || (caps & AC_WCAP_DIGITAL))
3170 adc_nids[nums] = nid;
3171 if (++nums >= max_nums)
3174 spec->num_adc_nids = nums;
3176 /* copy the detected ADCs to all_adcs[] */
3177 spec->num_all_adcs = nums;
3178 memcpy(spec->all_adcs, spec->adc_nids, nums * sizeof(hda_nid_t));
3183 /* filter out invalid adc_nids that don't give all active input pins;
3184 * if needed, check whether dynamic ADC-switching is available
3186 static int check_dyn_adc_switch(struct hda_codec *codec)
3188 struct hda_gen_spec *spec = codec->spec;
3189 struct hda_input_mux *imux = &spec->input_mux;
3190 unsigned int ok_bits;
3195 for (n = 0; n < spec->num_adc_nids; n++) {
3196 for (i = 0; i < imux->num_items; i++) {
3197 if (!spec->input_paths[i][n])
3200 if (i >= imux->num_items) {
3201 ok_bits |= (1 << n);
3207 /* check whether ADC-switch is possible */
3208 for (i = 0; i < imux->num_items; i++) {
3209 for (n = 0; n < spec->num_adc_nids; n++) {
3210 if (spec->input_paths[i][n]) {
3211 spec->dyn_adc_idx[i] = n;
3217 codec_dbg(codec, "enabling ADC switching\n");
3218 spec->dyn_adc_switch = 1;
3219 } else if (nums != spec->num_adc_nids) {
3220 /* shrink the invalid adcs and input paths */
3222 for (n = 0; n < spec->num_adc_nids; n++) {
3223 if (!(ok_bits & (1 << n)))
3226 spec->adc_nids[nums] = spec->adc_nids[n];
3227 for (i = 0; i < imux->num_items; i++) {
3228 invalidate_nid_path(codec,
3229 spec->input_paths[i][nums]);
3230 spec->input_paths[i][nums] =
3231 spec->input_paths[i][n];
3232 spec->input_paths[i][n] = 0;
3237 spec->num_adc_nids = nums;
3240 if (imux->num_items == 1 ||
3241 (imux->num_items == 2 && spec->hp_mic)) {
3242 codec_dbg(codec, "reducing to a single ADC\n");
3243 spec->num_adc_nids = 1; /* reduce to a single ADC */
3246 /* single index for individual volumes ctls */
3247 if (!spec->dyn_adc_switch && spec->multi_cap_vol)
3248 spec->num_adc_nids = 1;
3253 /* parse capture source paths from the given pin and create imux items */
3254 static int parse_capture_source(struct hda_codec *codec, hda_nid_t pin,
3255 int cfg_idx, int num_adcs,
3256 const char *label, int anchor)
3258 struct hda_gen_spec *spec = codec->spec;
3259 struct hda_input_mux *imux = &spec->input_mux;
3260 int imux_idx = imux->num_items;
3261 bool imux_added = false;
3264 for (c = 0; c < num_adcs; c++) {
3265 struct nid_path *path;
3266 hda_nid_t adc = spec->adc_nids[c];
3268 if (!is_reachable_path(codec, pin, adc))
3270 path = snd_hda_add_new_path(codec, pin, adc, anchor);
3273 print_nid_path(codec, "input", path);
3274 spec->input_paths[imux_idx][c] =
3275 snd_hda_get_path_idx(codec, path);
3278 if (spec->hp_mic_pin == pin)
3279 spec->hp_mic_mux_idx = imux->num_items;
3280 spec->imux_pins[imux->num_items] = pin;
3281 snd_hda_add_imux_item(codec, imux, label, cfg_idx, NULL);
3283 if (spec->dyn_adc_switch)
3284 spec->dyn_adc_idx[imux_idx] = c;
3292 * create playback/capture controls for input pins
3295 /* fill the label for each input at first */
3296 static int fill_input_pin_labels(struct hda_codec *codec)
3298 struct hda_gen_spec *spec = codec->spec;
3299 const struct auto_pin_cfg *cfg = &spec->autocfg;
3302 for (i = 0; i < cfg->num_inputs; i++) {
3303 hda_nid_t pin = cfg->inputs[i].pin;
3307 if (!is_input_pin(codec, pin))
3310 label = hda_get_autocfg_input_label(codec, cfg, i);
3312 for (j = i - 1; j >= 0; j--) {
3313 if (spec->input_labels[j] &&
3314 !strcmp(spec->input_labels[j], label)) {
3315 idx = spec->input_label_idxs[j] + 1;
3320 spec->input_labels[i] = label;
3321 spec->input_label_idxs[i] = idx;
3327 #define CFG_IDX_MIX 99 /* a dummy cfg->input idx for stereo mix */
3329 static int create_input_ctls(struct hda_codec *codec)
3331 struct hda_gen_spec *spec = codec->spec;
3332 const struct auto_pin_cfg *cfg = &spec->autocfg;
3333 hda_nid_t mixer = spec->mixer_nid;
3338 num_adcs = fill_adc_nids(codec);
3342 err = fill_input_pin_labels(codec);
3346 for (i = 0; i < cfg->num_inputs; i++) {
3349 pin = cfg->inputs[i].pin;
3350 if (!is_input_pin(codec, pin))
3354 if (cfg->inputs[i].type == AUTO_PIN_MIC)
3355 val |= snd_hda_get_default_vref(codec, pin);
3356 if (pin != spec->hp_mic_pin &&
3357 !snd_hda_codec_get_pin_target(codec, pin))
3358 set_pin_target(codec, pin, val, false);
3361 if (is_reachable_path(codec, pin, mixer)) {
3362 err = new_analog_input(codec, i, pin,
3363 spec->input_labels[i],
3364 spec->input_label_idxs[i],
3371 err = parse_capture_source(codec, pin, i, num_adcs,
3372 spec->input_labels[i], -mixer);
3376 if (spec->add_jack_modes) {
3377 err = create_in_jack_mode(codec, pin);
3383 /* add stereo mix when explicitly enabled via hint */
3384 if (mixer && spec->add_stereo_mix_input == HDA_HINT_STEREO_MIX_ENABLE) {
3385 err = parse_capture_source(codec, mixer, CFG_IDX_MIX, num_adcs,
3390 spec->suppress_auto_mic = 1;
3401 /* get the input path specified by the given adc and imux indices */
3402 static struct nid_path *get_input_path(struct hda_codec *codec, int adc_idx, int imux_idx)
3404 struct hda_gen_spec *spec = codec->spec;
3405 if (imux_idx < 0 || imux_idx >= HDA_MAX_NUM_INPUTS) {
3409 if (spec->dyn_adc_switch)
3410 adc_idx = spec->dyn_adc_idx[imux_idx];
3411 if (adc_idx < 0 || adc_idx >= AUTO_CFG_MAX_INS) {
3415 return snd_hda_get_path_from_idx(codec, spec->input_paths[imux_idx][adc_idx]);
3418 static int mux_select(struct hda_codec *codec, unsigned int adc_idx,
3421 static int mux_enum_info(struct snd_kcontrol *kcontrol,
3422 struct snd_ctl_elem_info *uinfo)
3424 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3425 struct hda_gen_spec *spec = codec->spec;
3426 return snd_hda_input_mux_info(&spec->input_mux, uinfo);
3429 static int mux_enum_get(struct snd_kcontrol *kcontrol,
3430 struct snd_ctl_elem_value *ucontrol)
3432 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3433 struct hda_gen_spec *spec = codec->spec;
3434 /* the ctls are created at once with multiple counts */
3435 unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
3437 ucontrol->value.enumerated.item[0] = spec->cur_mux[adc_idx];
3441 static int mux_enum_put(struct snd_kcontrol *kcontrol,
3442 struct snd_ctl_elem_value *ucontrol)
3444 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3445 unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
3446 return mux_select(codec, adc_idx,
3447 ucontrol->value.enumerated.item[0]);
3450 static const struct snd_kcontrol_new cap_src_temp = {
3451 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3452 .name = "Input Source",
3453 .info = mux_enum_info,
3454 .get = mux_enum_get,
3455 .put = mux_enum_put,
3459 * capture volume and capture switch ctls
3462 typedef int (*put_call_t)(struct snd_kcontrol *kcontrol,
3463 struct snd_ctl_elem_value *ucontrol);
3465 /* call the given amp update function for all amps in the imux list at once */
3466 static int cap_put_caller(struct snd_kcontrol *kcontrol,
3467 struct snd_ctl_elem_value *ucontrol,
3468 put_call_t func, int type)
3470 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3471 struct hda_gen_spec *spec = codec->spec;
3472 const struct hda_input_mux *imux;
3473 struct nid_path *path;
3474 int i, adc_idx, ret, err = 0;
3476 imux = &spec->input_mux;
3477 adc_idx = kcontrol->id.index;
3478 mutex_lock(&codec->control_mutex);
3479 for (i = 0; i < imux->num_items; i++) {
3480 path = get_input_path(codec, adc_idx, i);
3481 if (!path || !path->ctls[type])
3483 kcontrol->private_value = path->ctls[type];
3484 ret = func(kcontrol, ucontrol);
3492 mutex_unlock(&codec->control_mutex);
3493 if (err >= 0 && spec->cap_sync_hook)
3494 spec->cap_sync_hook(codec, kcontrol, ucontrol);
3498 /* capture volume ctl callbacks */
3499 #define cap_vol_info snd_hda_mixer_amp_volume_info
3500 #define cap_vol_get snd_hda_mixer_amp_volume_get
3501 #define cap_vol_tlv snd_hda_mixer_amp_tlv
3503 static int cap_vol_put(struct snd_kcontrol *kcontrol,
3504 struct snd_ctl_elem_value *ucontrol)
3506 return cap_put_caller(kcontrol, ucontrol,
3507 snd_hda_mixer_amp_volume_put,
3511 static const struct snd_kcontrol_new cap_vol_temp = {
3512 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3513 .name = "Capture Volume",
3514 .access = (SNDRV_CTL_ELEM_ACCESS_READWRITE |
3515 SNDRV_CTL_ELEM_ACCESS_TLV_READ |
3516 SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK),
3517 .info = cap_vol_info,
3520 .tlv = { .c = cap_vol_tlv },
3523 /* capture switch ctl callbacks */
3524 #define cap_sw_info snd_ctl_boolean_stereo_info
3525 #define cap_sw_get snd_hda_mixer_amp_switch_get
3527 static int cap_sw_put(struct snd_kcontrol *kcontrol,
3528 struct snd_ctl_elem_value *ucontrol)
3530 return cap_put_caller(kcontrol, ucontrol,
3531 snd_hda_mixer_amp_switch_put,
3535 static const struct snd_kcontrol_new cap_sw_temp = {
3536 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3537 .name = "Capture Switch",
3538 .info = cap_sw_info,
3543 static int parse_capvol_in_path(struct hda_codec *codec, struct nid_path *path)
3548 path->ctls[NID_PATH_VOL_CTL] = path->ctls[NID_PATH_MUTE_CTL] = 0;
3549 for (depth = 0; depth < 3; depth++) {
3550 if (depth >= path->depth)
3552 i = path->depth - depth - 1;
3553 nid = path->path[i];
3554 if (!path->ctls[NID_PATH_VOL_CTL]) {
3555 if (nid_has_volume(codec, nid, HDA_OUTPUT))
3556 path->ctls[NID_PATH_VOL_CTL] =
3557 HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
3558 else if (nid_has_volume(codec, nid, HDA_INPUT)) {
3559 int idx = path->idx[i];
3560 if (!depth && codec->single_adc_amp)
3562 path->ctls[NID_PATH_VOL_CTL] =
3563 HDA_COMPOSE_AMP_VAL(nid, 3, idx, HDA_INPUT);
3566 if (!path->ctls[NID_PATH_MUTE_CTL]) {
3567 if (nid_has_mute(codec, nid, HDA_OUTPUT))
3568 path->ctls[NID_PATH_MUTE_CTL] =
3569 HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
3570 else if (nid_has_mute(codec, nid, HDA_INPUT)) {
3571 int idx = path->idx[i];
3572 if (!depth && codec->single_adc_amp)
3574 path->ctls[NID_PATH_MUTE_CTL] =
3575 HDA_COMPOSE_AMP_VAL(nid, 3, idx, HDA_INPUT);
3582 static bool is_inv_dmic_pin(struct hda_codec *codec, hda_nid_t nid)
3584 struct hda_gen_spec *spec = codec->spec;
3585 struct auto_pin_cfg *cfg = &spec->autocfg;
3589 if (!spec->inv_dmic_split)
3591 for (i = 0; i < cfg->num_inputs; i++) {
3592 if (cfg->inputs[i].pin != nid)
3594 if (cfg->inputs[i].type != AUTO_PIN_MIC)
3596 val = snd_hda_codec_get_pincfg(codec, nid);
3597 return snd_hda_get_input_pin_attr(val) == INPUT_PIN_ATTR_INT;
3602 /* capture switch put callback for a single control with hook call */
3603 static int cap_single_sw_put(struct snd_kcontrol *kcontrol,
3604 struct snd_ctl_elem_value *ucontrol)
3606 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3607 struct hda_gen_spec *spec = codec->spec;
3610 ret = snd_hda_mixer_amp_switch_put(kcontrol, ucontrol);
3614 if (spec->cap_sync_hook)
3615 spec->cap_sync_hook(codec, kcontrol, ucontrol);
3620 static int add_single_cap_ctl(struct hda_codec *codec, const char *label,
3621 int idx, bool is_switch, unsigned int ctl,
3624 struct hda_gen_spec *spec = codec->spec;
3625 char tmpname[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];
3626 int type = is_switch ? HDA_CTL_WIDGET_MUTE : HDA_CTL_WIDGET_VOL;
3627 const char *sfx = is_switch ? "Switch" : "Volume";
3628 unsigned int chs = inv_dmic ? 1 : 3;
3629 struct snd_kcontrol_new *knew;
3635 snprintf(tmpname, sizeof(tmpname),
3636 "%s Capture %s", label, sfx);
3638 snprintf(tmpname, sizeof(tmpname),
3640 knew = add_control(spec, type, tmpname, idx,
3641 amp_val_replace_channels(ctl, chs));
3645 knew->put = cap_single_sw_put;
3649 /* Make independent right kcontrol */
3651 snprintf(tmpname, sizeof(tmpname),
3652 "Inverted %s Capture %s", label, sfx);
3654 snprintf(tmpname, sizeof(tmpname),
3655 "Inverted Capture %s", sfx);
3656 knew = add_control(spec, type, tmpname, idx,
3657 amp_val_replace_channels(ctl, 2));
3661 knew->put = cap_single_sw_put;
3665 /* create single (and simple) capture volume and switch controls */
3666 static int create_single_cap_vol_ctl(struct hda_codec *codec, int idx,
3667 unsigned int vol_ctl, unsigned int sw_ctl,
3671 err = add_single_cap_ctl(codec, NULL, idx, false, vol_ctl, inv_dmic);
3674 err = add_single_cap_ctl(codec, NULL, idx, true, sw_ctl, inv_dmic);
3680 /* create bound capture volume and switch controls */
3681 static int create_bind_cap_vol_ctl(struct hda_codec *codec, int idx,
3682 unsigned int vol_ctl, unsigned int sw_ctl)
3684 struct hda_gen_spec *spec = codec->spec;
3685 struct snd_kcontrol_new *knew;
3688 knew = snd_hda_gen_add_kctl(spec, NULL, &cap_vol_temp);
3692 knew->private_value = vol_ctl;
3693 knew->subdevice = HDA_SUBDEV_AMP_FLAG;
3696 knew = snd_hda_gen_add_kctl(spec, NULL, &cap_sw_temp);
3700 knew->private_value = sw_ctl;
3701 knew->subdevice = HDA_SUBDEV_AMP_FLAG;
3706 /* return the vol ctl when used first in the imux list */
3707 static unsigned int get_first_cap_ctl(struct hda_codec *codec, int idx, int type)
3709 struct nid_path *path;
3713 path = get_input_path(codec, 0, idx);
3716 ctl = path->ctls[type];
3719 for (i = 0; i < idx - 1; i++) {
3720 path = get_input_path(codec, 0, i);
3721 if (path && path->ctls[type] == ctl)
3727 /* create individual capture volume and switch controls per input */
3728 static int create_multi_cap_vol_ctl(struct hda_codec *codec)
3730 struct hda_gen_spec *spec = codec->spec;
3731 struct hda_input_mux *imux = &spec->input_mux;
3734 for (i = 0; i < imux->num_items; i++) {
3738 idx = imux->items[i].index;
3739 if (idx >= spec->autocfg.num_inputs)
3741 inv_dmic = is_inv_dmic_pin(codec, spec->imux_pins[i]);
3743 for (type = 0; type < 2; type++) {
3744 err = add_single_cap_ctl(codec,
3745 spec->input_labels[idx],
3746 spec->input_label_idxs[idx],
3748 get_first_cap_ctl(codec, i, type),
3757 static int create_capture_mixers(struct hda_codec *codec)
3759 struct hda_gen_spec *spec = codec->spec;
3760 struct hda_input_mux *imux = &spec->input_mux;
3761 int i, n, nums, err;
3763 if (spec->dyn_adc_switch)
3766 nums = spec->num_adc_nids;
3768 if (!spec->auto_mic && imux->num_items > 1) {
3769 struct snd_kcontrol_new *knew;
3771 name = nums > 1 ? "Input Source" : "Capture Source";
3772 knew = snd_hda_gen_add_kctl(spec, name, &cap_src_temp);
3778 for (n = 0; n < nums; n++) {
3780 bool multi_cap_vol = spec->multi_cap_vol;
3781 bool inv_dmic = false;
3785 for (i = 0; i < imux->num_items; i++) {
3786 struct nid_path *path;
3787 path = get_input_path(codec, n, i);
3790 parse_capvol_in_path(codec, path);
3792 vol = path->ctls[NID_PATH_VOL_CTL];
3793 else if (vol != path->ctls[NID_PATH_VOL_CTL]) {
3795 if (!same_amp_caps(codec, vol,
3796 path->ctls[NID_PATH_VOL_CTL], HDA_INPUT))
3797 multi_cap_vol = true;
3800 sw = path->ctls[NID_PATH_MUTE_CTL];
3801 else if (sw != path->ctls[NID_PATH_MUTE_CTL]) {
3803 if (!same_amp_caps(codec, sw,
3804 path->ctls[NID_PATH_MUTE_CTL], HDA_INPUT))
3805 multi_cap_vol = true;
3807 if (is_inv_dmic_pin(codec, spec->imux_pins[i]))
3812 err = create_single_cap_vol_ctl(codec, n, vol, sw,
3814 else if (!multi_cap_vol && !inv_dmic)
3815 err = create_bind_cap_vol_ctl(codec, n, vol, sw);
3817 err = create_multi_cap_vol_ctl(codec);
3826 * add mic boosts if needed
3829 /* check whether the given amp is feasible as a boost volume */
3830 static bool check_boost_vol(struct hda_codec *codec, hda_nid_t nid,
3835 if (!nid_has_volume(codec, nid, dir) ||
3836 is_ctl_associated(codec, nid, dir, idx, NID_PATH_VOL_CTL) ||
3837 is_ctl_associated(codec, nid, dir, idx, NID_PATH_BOOST_CTL))
3840 step = (query_amp_caps(codec, nid, dir) & AC_AMPCAP_STEP_SIZE)
3841 >> AC_AMPCAP_STEP_SIZE_SHIFT;
3847 /* look for a boost amp in a widget close to the pin */
3848 static unsigned int look_for_boost_amp(struct hda_codec *codec,
3849 struct nid_path *path)
3851 unsigned int val = 0;
3855 for (depth = 0; depth < 3; depth++) {
3856 if (depth >= path->depth - 1)
3858 nid = path->path[depth];
3859 if (depth && check_boost_vol(codec, nid, HDA_OUTPUT, 0)) {
3860 val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
3862 } else if (check_boost_vol(codec, nid, HDA_INPUT,
3863 path->idx[depth])) {
3864 val = HDA_COMPOSE_AMP_VAL(nid, 3, path->idx[depth],
3873 static int parse_mic_boost(struct hda_codec *codec)
3875 struct hda_gen_spec *spec = codec->spec;
3876 struct auto_pin_cfg *cfg = &spec->autocfg;
3877 struct hda_input_mux *imux = &spec->input_mux;
3880 if (!spec->num_adc_nids)
3883 for (i = 0; i < imux->num_items; i++) {
3884 struct nid_path *path;
3887 char boost_label[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];
3889 idx = imux->items[i].index;
3890 if (idx >= imux->num_items)
3893 /* check only line-in and mic pins */
3894 if (cfg->inputs[idx].type > AUTO_PIN_LINE_IN)
3897 path = get_input_path(codec, 0, i);
3901 val = look_for_boost_amp(codec, path);
3905 /* create a boost control */
3906 snprintf(boost_label, sizeof(boost_label),
3907 "%s Boost Volume", spec->input_labels[idx]);
3908 if (!add_control(spec, HDA_CTL_WIDGET_VOL, boost_label,
3909 spec->input_label_idxs[idx], val))
3912 path->ctls[NID_PATH_BOOST_CTL] = val;
3918 * mic mute LED hook helpers
3923 MICMUTE_LED_FOLLOW_CAPTURE,
3924 MICMUTE_LED_FOLLOW_MUTE,
3927 static void call_micmute_led_update(struct hda_codec *codec)
3929 struct hda_gen_spec *spec = codec->spec;
3932 switch (spec->micmute_led.led_mode) {
3933 case MICMUTE_LED_ON:
3936 case MICMUTE_LED_OFF:
3939 case MICMUTE_LED_FOLLOW_CAPTURE:
3940 val = !!spec->micmute_led.capture;
3942 case MICMUTE_LED_FOLLOW_MUTE:
3944 val = !spec->micmute_led.capture;
3948 if (val == spec->micmute_led.led_value)
3950 spec->micmute_led.led_value = val;
3951 if (spec->micmute_led.update)
3952 spec->micmute_led.update(codec);
3955 static void update_micmute_led(struct hda_codec *codec,
3956 struct snd_kcontrol *kcontrol,
3957 struct snd_ctl_elem_value *ucontrol)
3959 struct hda_gen_spec *spec = codec->spec;
3962 if (spec->micmute_led.old_hook)
3963 spec->micmute_led.old_hook(codec, kcontrol, ucontrol);
3967 mask = 1U << snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
3968 if (!strcmp("Capture Switch", ucontrol->id.name)) {
3969 /* TODO: How do I verify if it's a mono or stereo here? */
3970 if (ucontrol->value.integer.value[0] ||
3971 ucontrol->value.integer.value[1])
3972 spec->micmute_led.capture |= mask;
3974 spec->micmute_led.capture &= ~mask;
3975 call_micmute_led_update(codec);
3979 static int micmute_led_mode_info(struct snd_kcontrol *kcontrol,
3980 struct snd_ctl_elem_info *uinfo)
3982 static const char * const texts[] = {
3983 "On", "Off", "Follow Capture", "Follow Mute",
3986 return snd_ctl_enum_info(uinfo, 1, ARRAY_SIZE(texts), texts);
3989 static int micmute_led_mode_get(struct snd_kcontrol *kcontrol,
3990 struct snd_ctl_elem_value *ucontrol)
3992 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3993 struct hda_gen_spec *spec = codec->spec;
3995 ucontrol->value.enumerated.item[0] = spec->micmute_led.led_mode;
3999 static int micmute_led_mode_put(struct snd_kcontrol *kcontrol,
4000 struct snd_ctl_elem_value *ucontrol)
4002 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
4003 struct hda_gen_spec *spec = codec->spec;
4006 mode = ucontrol->value.enumerated.item[0];
4007 if (mode > MICMUTE_LED_FOLLOW_MUTE)
4008 mode = MICMUTE_LED_FOLLOW_MUTE;
4009 if (mode == spec->micmute_led.led_mode)
4011 spec->micmute_led.led_mode = mode;
4012 call_micmute_led_update(codec);
4016 static const struct snd_kcontrol_new micmute_led_mode_ctl = {
4017 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
4018 .name = "Mic Mute-LED Mode",
4019 .info = micmute_led_mode_info,
4020 .get = micmute_led_mode_get,
4021 .put = micmute_led_mode_put,
4025 * snd_hda_gen_add_micmute_led - helper for setting up mic mute LED hook
4026 * @codec: the HDA codec
4027 * @hook: the callback for updating LED
4029 * Called from the codec drivers for offering the mic mute LED controls.
4030 * When established, it sets up cap_sync_hook and triggers the callback at
4031 * each time when the capture mixer switch changes. The callback is supposed
4032 * to update the LED accordingly.
4034 * Returns 0 if the hook is established or a negative error code.
4036 int snd_hda_gen_add_micmute_led(struct hda_codec *codec,
4037 void (*hook)(struct hda_codec *))
4039 struct hda_gen_spec *spec = codec->spec;
4041 spec->micmute_led.led_mode = MICMUTE_LED_FOLLOW_MUTE;
4042 spec->micmute_led.capture = 0;
4043 spec->micmute_led.led_value = -1;
4044 spec->micmute_led.old_hook = spec->cap_sync_hook;
4045 spec->micmute_led.update = hook;
4046 spec->cap_sync_hook = update_micmute_led;
4047 if (!snd_hda_gen_add_kctl(spec, NULL, &micmute_led_mode_ctl))
4051 EXPORT_SYMBOL_GPL(snd_hda_gen_add_micmute_led);
4054 * parse digital I/Os and set up NIDs in BIOS auto-parse mode
4056 static void parse_digital(struct hda_codec *codec)
4058 struct hda_gen_spec *spec = codec->spec;
4059 struct nid_path *path;
4061 hda_nid_t dig_nid, pin;
4063 /* support multiple SPDIFs; the secondary is set up as a slave */
4065 for (i = 0; i < spec->autocfg.dig_outs; i++) {
4066 pin = spec->autocfg.dig_out_pins[i];
4067 dig_nid = look_for_dac(codec, pin, true);
4070 path = snd_hda_add_new_path(codec, dig_nid, pin, 0);
4073 print_nid_path(codec, "digout", path);
4074 path->active = true;
4075 path->pin_fixed = true; /* no jack detection */
4076 spec->digout_paths[i] = snd_hda_get_path_idx(codec, path);
4077 set_pin_target(codec, pin, PIN_OUT, false);
4079 spec->multiout.dig_out_nid = dig_nid;
4080 spec->dig_out_type = spec->autocfg.dig_out_type[0];
4082 spec->multiout.slave_dig_outs = spec->slave_dig_outs;
4083 if (nums >= ARRAY_SIZE(spec->slave_dig_outs) - 1)
4085 spec->slave_dig_outs[nums - 1] = dig_nid;
4090 if (spec->autocfg.dig_in_pin) {
4091 pin = spec->autocfg.dig_in_pin;
4092 for_each_hda_codec_node(dig_nid, codec) {
4093 unsigned int wcaps = get_wcaps(codec, dig_nid);
4094 if (get_wcaps_type(wcaps) != AC_WID_AUD_IN)
4096 if (!(wcaps & AC_WCAP_DIGITAL))
4098 path = snd_hda_add_new_path(codec, pin, dig_nid, 0);
4100 print_nid_path(codec, "digin", path);
4101 path->active = true;
4102 path->pin_fixed = true; /* no jack */
4103 spec->dig_in_nid = dig_nid;
4104 spec->digin_path = snd_hda_get_path_idx(codec, path);
4105 set_pin_target(codec, pin, PIN_IN, false);
4114 * input MUX handling
4117 static bool dyn_adc_pcm_resetup(struct hda_codec *codec, int cur);
4119 /* select the given imux item; either unmute exclusively or select the route */
4120 static int mux_select(struct hda_codec *codec, unsigned int adc_idx,
4123 struct hda_gen_spec *spec = codec->spec;
4124 const struct hda_input_mux *imux;
4125 struct nid_path *old_path, *path;
4127 imux = &spec->input_mux;
4128 if (!imux->num_items)
4131 if (idx >= imux->num_items)
4132 idx = imux->num_items - 1;
4133 if (spec->cur_mux[adc_idx] == idx)
4136 old_path = get_input_path(codec, adc_idx, spec->cur_mux[adc_idx]);
4139 if (old_path->active)
4140 snd_hda_activate_path(codec, old_path, false, false);
4142 spec->cur_mux[adc_idx] = idx;
4145 update_hp_mic(codec, adc_idx, false);
4147 if (spec->dyn_adc_switch)
4148 dyn_adc_pcm_resetup(codec, idx);
4150 path = get_input_path(codec, adc_idx, idx);
4155 snd_hda_activate_path(codec, path, true, false);
4156 if (spec->cap_sync_hook)
4157 spec->cap_sync_hook(codec, NULL, NULL);
4158 path_power_down_sync(codec, old_path);
4162 /* power up/down widgets in the all paths that match with the given NID
4163 * as terminals (either start- or endpoint)
4165 * returns the last changed NID, or zero if unchanged.
4167 static hda_nid_t set_path_power(struct hda_codec *codec, hda_nid_t nid,
4168 int pin_state, int stream_state)
4170 struct hda_gen_spec *spec = codec->spec;
4171 hda_nid_t last, changed = 0;
4172 struct nid_path *path;
4175 snd_array_for_each(&spec->paths, n, path) {
4178 if (path->path[0] == nid ||
4179 path->path[path->depth - 1] == nid) {
4180 bool pin_old = path->pin_enabled;
4181 bool stream_old = path->stream_enabled;
4184 path->pin_enabled = pin_state;
4185 if (stream_state >= 0)
4186 path->stream_enabled = stream_state;
4187 if ((!path->pin_fixed && path->pin_enabled != pin_old)
4188 || path->stream_enabled != stream_old) {
4189 last = path_power_update(codec, path, true);
4198 /* check the jack status for power control */
4199 static bool detect_pin_state(struct hda_codec *codec, hda_nid_t pin)
4201 if (!is_jack_detectable(codec, pin))
4203 return snd_hda_jack_detect_state(codec, pin) != HDA_JACK_NOT_PRESENT;
4206 /* power up/down the paths of the given pin according to the jack state;
4207 * power = 0/1 : only power up/down if it matches with the jack state,
4208 * < 0 : force power up/down to follow the jack sate
4210 * returns the last changed NID, or zero if unchanged.
4212 static hda_nid_t set_pin_power_jack(struct hda_codec *codec, hda_nid_t pin,
4217 if (!codec->power_save_node)
4220 on = detect_pin_state(codec, pin);
4222 if (power >= 0 && on != power)
4224 return set_path_power(codec, pin, on, -1);
4227 static void pin_power_callback(struct hda_codec *codec,
4228 struct hda_jack_callback *jack,
4231 if (jack && jack->nid)
4232 sync_power_state_change(codec,
4233 set_pin_power_jack(codec, jack->nid, on));
4236 /* callback only doing power up -- called at first */
4237 static void pin_power_up_callback(struct hda_codec *codec,
4238 struct hda_jack_callback *jack)
4240 pin_power_callback(codec, jack, true);
4243 /* callback only doing power down -- called at last */
4244 static void pin_power_down_callback(struct hda_codec *codec,
4245 struct hda_jack_callback *jack)
4247 pin_power_callback(codec, jack, false);
4250 /* set up the power up/down callbacks */
4251 static void add_pin_power_ctls(struct hda_codec *codec, int num_pins,
4252 const hda_nid_t *pins, bool on)
4255 hda_jack_callback_fn cb =
4256 on ? pin_power_up_callback : pin_power_down_callback;
4258 for (i = 0; i < num_pins && pins[i]; i++) {
4259 if (is_jack_detectable(codec, pins[i]))
4260 snd_hda_jack_detect_enable_callback(codec, pins[i], cb);
4262 set_path_power(codec, pins[i], true, -1);
4266 /* enabled power callback to each available I/O pin with jack detections;
4267 * the digital I/O pins are excluded because of the unreliable detectsion
4269 static void add_all_pin_power_ctls(struct hda_codec *codec, bool on)
4271 struct hda_gen_spec *spec = codec->spec;
4272 struct auto_pin_cfg *cfg = &spec->autocfg;
4275 if (!codec->power_save_node)
4277 add_pin_power_ctls(codec, cfg->line_outs, cfg->line_out_pins, on);
4278 if (cfg->line_out_type != AUTO_PIN_HP_OUT)
4279 add_pin_power_ctls(codec, cfg->hp_outs, cfg->hp_pins, on);
4280 if (cfg->line_out_type != AUTO_PIN_SPEAKER_OUT)
4281 add_pin_power_ctls(codec, cfg->speaker_outs, cfg->speaker_pins, on);
4282 for (i = 0; i < cfg->num_inputs; i++)
4283 add_pin_power_ctls(codec, 1, &cfg->inputs[i].pin, on);
4286 /* sync path power up/down with the jack states of given pins */
4287 static void sync_pin_power_ctls(struct hda_codec *codec, int num_pins,
4288 const hda_nid_t *pins)
4292 for (i = 0; i < num_pins && pins[i]; i++)
4293 if (is_jack_detectable(codec, pins[i]))
4294 set_pin_power_jack(codec, pins[i], -1);
4297 /* sync path power up/down with pins; called at init and resume */
4298 static void sync_all_pin_power_ctls(struct hda_codec *codec)
4300 struct hda_gen_spec *spec = codec->spec;
4301 struct auto_pin_cfg *cfg = &spec->autocfg;
4304 if (!codec->power_save_node)
4306 sync_pin_power_ctls(codec, cfg->line_outs, cfg->line_out_pins);
4307 if (cfg->line_out_type != AUTO_PIN_HP_OUT)
4308 sync_pin_power_ctls(codec, cfg->hp_outs, cfg->hp_pins);
4309 if (cfg->line_out_type != AUTO_PIN_SPEAKER_OUT)
4310 sync_pin_power_ctls(codec, cfg->speaker_outs, cfg->speaker_pins);
4311 for (i = 0; i < cfg->num_inputs; i++)
4312 sync_pin_power_ctls(codec, 1, &cfg->inputs[i].pin);
4315 /* add fake paths if not present yet */
4316 static int add_fake_paths(struct hda_codec *codec, hda_nid_t nid,
4317 int num_pins, const hda_nid_t *pins)
4319 struct hda_gen_spec *spec = codec->spec;
4320 struct nid_path *path;
4323 for (i = 0; i < num_pins; i++) {
4326 if (get_nid_path(codec, nid, pins[i], 0))
4328 path = snd_array_new(&spec->paths);
4331 memset(path, 0, sizeof(*path));
4333 path->path[0] = nid;
4334 path->path[1] = pins[i];
4335 path->active = true;
4340 /* create fake paths to all outputs from beep */
4341 static int add_fake_beep_paths(struct hda_codec *codec)
4343 struct hda_gen_spec *spec = codec->spec;
4344 struct auto_pin_cfg *cfg = &spec->autocfg;
4345 hda_nid_t nid = spec->beep_nid;
4348 if (!codec->power_save_node || !nid)
4350 err = add_fake_paths(codec, nid, cfg->line_outs, cfg->line_out_pins);
4353 if (cfg->line_out_type != AUTO_PIN_HP_OUT) {
4354 err = add_fake_paths(codec, nid, cfg->hp_outs, cfg->hp_pins);
4358 if (cfg->line_out_type != AUTO_PIN_SPEAKER_OUT) {
4359 err = add_fake_paths(codec, nid, cfg->speaker_outs,
4367 /* power up/down beep widget and its output paths */
4368 static void beep_power_hook(struct hda_beep *beep, bool on)
4370 set_path_power(beep->codec, beep->nid, -1, on);
4374 * snd_hda_gen_fix_pin_power - Fix the power of the given pin widget to D0
4375 * @codec: the HDA codec
4376 * @pin: NID of pin to fix
4378 int snd_hda_gen_fix_pin_power(struct hda_codec *codec, hda_nid_t pin)
4380 struct hda_gen_spec *spec = codec->spec;
4381 struct nid_path *path;
4383 path = snd_array_new(&spec->paths);
4386 memset(path, 0, sizeof(*path));
4388 path->path[0] = pin;
4389 path->active = true;
4390 path->pin_fixed = true;
4391 path->stream_enabled = true;
4394 EXPORT_SYMBOL_GPL(snd_hda_gen_fix_pin_power);
4397 * Jack detections for HP auto-mute and mic-switch
4400 /* check each pin in the given array; returns true if any of them is plugged */
4401 static bool detect_jacks(struct hda_codec *codec, int num_pins, hda_nid_t *pins)
4404 bool present = false;
4406 for (i = 0; i < num_pins; i++) {
4407 hda_nid_t nid = pins[i];
4410 /* don't detect pins retasked as inputs */
4411 if (snd_hda_codec_get_pin_target(codec, nid) & AC_PINCTL_IN_EN)
4413 if (snd_hda_jack_detect_state(codec, nid) == HDA_JACK_PRESENT)
4419 /* standard HP/line-out auto-mute helper */
4420 static void do_automute(struct hda_codec *codec, int num_pins, hda_nid_t *pins,
4421 int *paths, bool mute)
4423 struct hda_gen_spec *spec = codec->spec;
4426 for (i = 0; i < num_pins; i++) {
4427 hda_nid_t nid = pins[i];
4428 unsigned int val, oldval;
4432 oldval = snd_hda_codec_get_pin_target(codec, nid);
4433 if (oldval & PIN_IN)
4434 continue; /* no mute for inputs */
4436 if (spec->auto_mute_via_amp) {
4437 struct nid_path *path;
4440 path = snd_hda_get_path_from_idx(codec, paths[i]);
4443 mute_nid = get_amp_nid_(path->ctls[NID_PATH_MUTE_CTL]);
4447 spec->mute_bits |= (1ULL << mute_nid);
4449 spec->mute_bits &= ~(1ULL << mute_nid);
4452 /* don't reset VREF value in case it's controlling
4453 * the amp (see alc861_fixup_asus_amp_vref_0f())
4455 if (spec->keep_vref_in_automute)
4456 val = oldval & ~PIN_HP;
4461 /* here we call update_pin_ctl() so that the pinctl is
4462 * changed without changing the pinctl target value;
4463 * the original target value will be still referred at
4464 * the init / resume again
4466 update_pin_ctl(codec, nid, val);
4469 set_pin_eapd(codec, nid, !mute);
4470 if (codec->power_save_node) {
4473 on = detect_pin_state(codec, nid);
4474 set_path_power(codec, nid, on, -1);
4480 * snd_hda_gen_update_outputs - Toggle outputs muting
4481 * @codec: the HDA codec
4483 * Update the mute status of all outputs based on the current jack states.
4485 void snd_hda_gen_update_outputs(struct hda_codec *codec)
4487 struct hda_gen_spec *spec = codec->spec;
4491 /* Control HP pins/amps depending on master_mute state;
4492 * in general, HP pins/amps control should be enabled in all cases,
4493 * but currently set only for master_mute, just to be safe
4495 if (spec->autocfg.line_out_type == AUTO_PIN_HP_OUT)
4496 paths = spec->out_paths;
4498 paths = spec->hp_paths;
4499 do_automute(codec, ARRAY_SIZE(spec->autocfg.hp_pins),
4500 spec->autocfg.hp_pins, paths, spec->master_mute);
4502 if (!spec->automute_speaker)
4505 on = spec->hp_jack_present | spec->line_jack_present;
4506 on |= spec->master_mute;
4507 spec->speaker_muted = on;
4508 if (spec->autocfg.line_out_type == AUTO_PIN_SPEAKER_OUT)
4509 paths = spec->out_paths;
4511 paths = spec->speaker_paths;
4512 do_automute(codec, ARRAY_SIZE(spec->autocfg.speaker_pins),
4513 spec->autocfg.speaker_pins, paths, on);
4515 /* toggle line-out mutes if needed, too */
4516 /* if LO is a copy of either HP or Speaker, don't need to handle it */
4517 if (spec->autocfg.line_out_pins[0] == spec->autocfg.hp_pins[0] ||
4518 spec->autocfg.line_out_pins[0] == spec->autocfg.speaker_pins[0])
4520 if (!spec->automute_lo)
4523 on = spec->hp_jack_present;
4524 on |= spec->master_mute;
4525 spec->line_out_muted = on;
4526 paths = spec->out_paths;
4527 do_automute(codec, ARRAY_SIZE(spec->autocfg.line_out_pins),
4528 spec->autocfg.line_out_pins, paths, on);
4530 EXPORT_SYMBOL_GPL(snd_hda_gen_update_outputs);
4532 static void call_update_outputs(struct hda_codec *codec)
4534 struct hda_gen_spec *spec = codec->spec;
4535 if (spec->automute_hook)
4536 spec->automute_hook(codec);
4538 snd_hda_gen_update_outputs(codec);
4540 /* sync the whole vmaster slaves to reflect the new auto-mute status */
4541 if (spec->auto_mute_via_amp && !codec->bus->shutdown)
4542 snd_ctl_sync_vmaster(spec->vmaster_mute.sw_kctl, false);
4546 * snd_hda_gen_hp_automute - standard HP-automute helper
4547 * @codec: the HDA codec
4548 * @jack: jack object, NULL for the whole
4550 void snd_hda_gen_hp_automute(struct hda_codec *codec,
4551 struct hda_jack_callback *jack)
4553 struct hda_gen_spec *spec = codec->spec;
4554 hda_nid_t *pins = spec->autocfg.hp_pins;
4555 int num_pins = ARRAY_SIZE(spec->autocfg.hp_pins);
4557 /* No detection for the first HP jack during indep-HP mode */
4558 if (spec->indep_hp_enabled) {
4563 spec->hp_jack_present = detect_jacks(codec, num_pins, pins);
4564 if (!spec->detect_hp || (!spec->automute_speaker && !spec->automute_lo))
4566 call_update_outputs(codec);
4568 EXPORT_SYMBOL_GPL(snd_hda_gen_hp_automute);
4571 * snd_hda_gen_line_automute - standard line-out-automute helper
4572 * @codec: the HDA codec
4573 * @jack: jack object, NULL for the whole
4575 void snd_hda_gen_line_automute(struct hda_codec *codec,
4576 struct hda_jack_callback *jack)
4578 struct hda_gen_spec *spec = codec->spec;
4580 if (spec->autocfg.line_out_type == AUTO_PIN_SPEAKER_OUT)
4582 /* check LO jack only when it's different from HP */
4583 if (spec->autocfg.line_out_pins[0] == spec->autocfg.hp_pins[0])
4586 spec->line_jack_present =
4587 detect_jacks(codec, ARRAY_SIZE(spec->autocfg.line_out_pins),
4588 spec->autocfg.line_out_pins);
4589 if (!spec->automute_speaker || !spec->detect_lo)
4591 call_update_outputs(codec);
4593 EXPORT_SYMBOL_GPL(snd_hda_gen_line_automute);
4596 * snd_hda_gen_mic_autoswitch - standard mic auto-switch helper
4597 * @codec: the HDA codec
4598 * @jack: jack object, NULL for the whole
4600 void snd_hda_gen_mic_autoswitch(struct hda_codec *codec,
4601 struct hda_jack_callback *jack)
4603 struct hda_gen_spec *spec = codec->spec;
4606 if (!spec->auto_mic)
4609 for (i = spec->am_num_entries - 1; i > 0; i--) {
4610 hda_nid_t pin = spec->am_entry[i].pin;
4611 /* don't detect pins retasked as outputs */
4612 if (snd_hda_codec_get_pin_target(codec, pin) & AC_PINCTL_OUT_EN)
4614 if (snd_hda_jack_detect_state(codec, pin) == HDA_JACK_PRESENT) {
4615 mux_select(codec, 0, spec->am_entry[i].idx);
4619 mux_select(codec, 0, spec->am_entry[0].idx);
4621 EXPORT_SYMBOL_GPL(snd_hda_gen_mic_autoswitch);
4623 /* call appropriate hooks */
4624 static void call_hp_automute(struct hda_codec *codec,
4625 struct hda_jack_callback *jack)
4627 struct hda_gen_spec *spec = codec->spec;
4628 if (spec->hp_automute_hook)
4629 spec->hp_automute_hook(codec, jack);
4631 snd_hda_gen_hp_automute(codec, jack);
4634 static void call_line_automute(struct hda_codec *codec,
4635 struct hda_jack_callback *jack)
4637 struct hda_gen_spec *spec = codec->spec;
4638 if (spec->line_automute_hook)
4639 spec->line_automute_hook(codec, jack);
4641 snd_hda_gen_line_automute(codec, jack);
4644 static void call_mic_autoswitch(struct hda_codec *codec,
4645 struct hda_jack_callback *jack)
4647 struct hda_gen_spec *spec = codec->spec;
4648 if (spec->mic_autoswitch_hook)
4649 spec->mic_autoswitch_hook(codec, jack);
4651 snd_hda_gen_mic_autoswitch(codec, jack);
4654 /* update jack retasking */
4655 static void update_automute_all(struct hda_codec *codec)
4657 call_hp_automute(codec, NULL);
4658 call_line_automute(codec, NULL);
4659 call_mic_autoswitch(codec, NULL);
4663 * Auto-Mute mode mixer enum support
4665 static int automute_mode_info(struct snd_kcontrol *kcontrol,
4666 struct snd_ctl_elem_info *uinfo)
4668 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
4669 struct hda_gen_spec *spec = codec->spec;
4670 static const char * const texts3[] = {
4671 "Disabled", "Speaker Only", "Line Out+Speaker"
4674 if (spec->automute_speaker_possible && spec->automute_lo_possible)
4675 return snd_hda_enum_helper_info(kcontrol, uinfo, 3, texts3);
4676 return snd_hda_enum_bool_helper_info(kcontrol, uinfo);
4679 static int automute_mode_get(struct snd_kcontrol *kcontrol,
4680 struct snd_ctl_elem_value *ucontrol)
4682 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
4683 struct hda_gen_spec *spec = codec->spec;
4684 unsigned int val = 0;
4685 if (spec->automute_speaker)
4687 if (spec->automute_lo)
4690 ucontrol->value.enumerated.item[0] = val;
4694 static int automute_mode_put(struct snd_kcontrol *kcontrol,
4695 struct snd_ctl_elem_value *ucontrol)
4697 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
4698 struct hda_gen_spec *spec = codec->spec;
4700 switch (ucontrol->value.enumerated.item[0]) {
4702 if (!spec->automute_speaker && !spec->automute_lo)
4704 spec->automute_speaker = 0;
4705 spec->automute_lo = 0;
4708 if (spec->automute_speaker_possible) {
4709 if (!spec->automute_lo && spec->automute_speaker)
4711 spec->automute_speaker = 1;
4712 spec->automute_lo = 0;
4713 } else if (spec->automute_lo_possible) {
4714 if (spec->automute_lo)
4716 spec->automute_lo = 1;
4721 if (!spec->automute_lo_possible || !spec->automute_speaker_possible)
4723 if (spec->automute_speaker && spec->automute_lo)
4725 spec->automute_speaker = 1;
4726 spec->automute_lo = 1;
4731 call_update_outputs(codec);
4735 static const struct snd_kcontrol_new automute_mode_enum = {
4736 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
4737 .name = "Auto-Mute Mode",
4738 .info = automute_mode_info,
4739 .get = automute_mode_get,
4740 .put = automute_mode_put,
4743 static int add_automute_mode_enum(struct hda_codec *codec)
4745 struct hda_gen_spec *spec = codec->spec;
4747 if (!snd_hda_gen_add_kctl(spec, NULL, &automute_mode_enum))
4753 * Check the availability of HP/line-out auto-mute;
4754 * Set up appropriately if really supported
4756 static int check_auto_mute_availability(struct hda_codec *codec)
4758 struct hda_gen_spec *spec = codec->spec;
4759 struct auto_pin_cfg *cfg = &spec->autocfg;
4763 if (spec->suppress_auto_mute)
4766 if (cfg->hp_pins[0])
4768 if (cfg->line_out_pins[0])
4770 if (cfg->speaker_pins[0])
4772 if (present < 2) /* need two different output types */
4775 if (!cfg->speaker_pins[0] &&
4776 cfg->line_out_type == AUTO_PIN_SPEAKER_OUT) {
4777 memcpy(cfg->speaker_pins, cfg->line_out_pins,
4778 sizeof(cfg->speaker_pins));
4779 cfg->speaker_outs = cfg->line_outs;
4782 if (!cfg->hp_pins[0] &&
4783 cfg->line_out_type == AUTO_PIN_HP_OUT) {
4784 memcpy(cfg->hp_pins, cfg->line_out_pins,
4785 sizeof(cfg->hp_pins));
4786 cfg->hp_outs = cfg->line_outs;
4789 for (i = 0; i < cfg->hp_outs; i++) {
4790 hda_nid_t nid = cfg->hp_pins[i];
4791 if (!is_jack_detectable(codec, nid))
4793 codec_dbg(codec, "Enable HP auto-muting on NID 0x%x\n", nid);
4794 snd_hda_jack_detect_enable_callback(codec, nid,
4796 spec->detect_hp = 1;
4799 if (cfg->line_out_type == AUTO_PIN_LINE_OUT && cfg->line_outs) {
4800 if (cfg->speaker_outs)
4801 for (i = 0; i < cfg->line_outs; i++) {
4802 hda_nid_t nid = cfg->line_out_pins[i];
4803 if (!is_jack_detectable(codec, nid))
4805 codec_dbg(codec, "Enable Line-Out auto-muting on NID 0x%x\n", nid);
4806 snd_hda_jack_detect_enable_callback(codec, nid,
4807 call_line_automute);
4808 spec->detect_lo = 1;
4810 spec->automute_lo_possible = spec->detect_hp;
4813 spec->automute_speaker_possible = cfg->speaker_outs &&
4814 (spec->detect_hp || spec->detect_lo);
4816 spec->automute_lo = spec->automute_lo_possible;
4817 spec->automute_speaker = spec->automute_speaker_possible;
4819 if (spec->automute_speaker_possible || spec->automute_lo_possible) {
4820 /* create a control for automute mode */
4821 err = add_automute_mode_enum(codec);
4828 /* check whether all auto-mic pins are valid; setup indices if OK */
4829 static bool auto_mic_check_imux(struct hda_codec *codec)
4831 struct hda_gen_spec *spec = codec->spec;
4832 const struct hda_input_mux *imux;
4835 imux = &spec->input_mux;
4836 for (i = 0; i < spec->am_num_entries; i++) {
4837 spec->am_entry[i].idx =
4838 find_idx_in_nid_list(spec->am_entry[i].pin,
4839 spec->imux_pins, imux->num_items);
4840 if (spec->am_entry[i].idx < 0)
4841 return false; /* no corresponding imux */
4844 /* we don't need the jack detection for the first pin */
4845 for (i = 1; i < spec->am_num_entries; i++)
4846 snd_hda_jack_detect_enable_callback(codec,
4847 spec->am_entry[i].pin,
4848 call_mic_autoswitch);
4852 static int compare_attr(const void *ap, const void *bp)
4854 const struct automic_entry *a = ap;
4855 const struct automic_entry *b = bp;
4856 return (int)(a->attr - b->attr);
4860 * Check the availability of auto-mic switch;
4861 * Set up if really supported
4863 static int check_auto_mic_availability(struct hda_codec *codec)
4865 struct hda_gen_spec *spec = codec->spec;
4866 struct auto_pin_cfg *cfg = &spec->autocfg;
4870 if (spec->suppress_auto_mic)
4875 for (i = 0; i < cfg->num_inputs; i++) {
4876 hda_nid_t nid = cfg->inputs[i].pin;
4878 attr = snd_hda_codec_get_pincfg(codec, nid);
4879 attr = snd_hda_get_input_pin_attr(attr);
4880 if (types & (1 << attr))
4881 return 0; /* already occupied */
4883 case INPUT_PIN_ATTR_INT:
4884 if (cfg->inputs[i].type != AUTO_PIN_MIC)
4885 return 0; /* invalid type */
4887 case INPUT_PIN_ATTR_UNUSED:
4888 return 0; /* invalid entry */
4890 if (cfg->inputs[i].type > AUTO_PIN_LINE_IN)
4891 return 0; /* invalid type */
4892 if (!spec->line_in_auto_switch &&
4893 cfg->inputs[i].type != AUTO_PIN_MIC)
4894 return 0; /* only mic is allowed */
4895 if (!is_jack_detectable(codec, nid))
4896 return 0; /* no unsol support */
4899 if (num_pins >= MAX_AUTO_MIC_PINS)
4901 types |= (1 << attr);
4902 spec->am_entry[num_pins].pin = nid;
4903 spec->am_entry[num_pins].attr = attr;
4910 spec->am_num_entries = num_pins;
4911 /* sort the am_entry in the order of attr so that the pin with a
4912 * higher attr will be selected when the jack is plugged.
4914 sort(spec->am_entry, num_pins, sizeof(spec->am_entry[0]),
4915 compare_attr, NULL);
4917 if (!auto_mic_check_imux(codec))
4921 spec->num_adc_nids = 1;
4922 spec->cur_mux[0] = spec->am_entry[0].idx;
4923 codec_dbg(codec, "Enable auto-mic switch on NID 0x%x/0x%x/0x%x\n",
4924 spec->am_entry[0].pin,
4925 spec->am_entry[1].pin,
4926 spec->am_entry[2].pin);
4932 * snd_hda_gen_path_power_filter - power_filter hook to make inactive widgets
4934 * @codec: the HDA codec
4935 * @nid: NID to evalute
4936 * @power_state: target power state
4938 unsigned int snd_hda_gen_path_power_filter(struct hda_codec *codec,
4940 unsigned int power_state)
4942 struct hda_gen_spec *spec = codec->spec;
4944 if (!spec->power_down_unused && !codec->power_save_node)
4946 if (power_state != AC_PWRST_D0 || nid == codec->core.afg)
4948 if (get_wcaps_type(get_wcaps(codec, nid)) >= AC_WID_POWER)
4950 if (is_active_nid_for_any(codec, nid))
4954 EXPORT_SYMBOL_GPL(snd_hda_gen_path_power_filter);
4956 /* mute all aamix inputs initially; parse up to the first leaves */
4957 static void mute_all_mixer_nid(struct hda_codec *codec, hda_nid_t mix)
4960 const hda_nid_t *conn;
4963 nums = snd_hda_get_conn_list(codec, mix, &conn);
4964 has_amp = nid_has_mute(codec, mix, HDA_INPUT);
4965 for (i = 0; i < nums; i++) {
4967 update_amp(codec, mix, HDA_INPUT, i,
4968 0xff, HDA_AMP_MUTE);
4969 else if (nid_has_volume(codec, conn[i], HDA_OUTPUT))
4970 update_amp(codec, conn[i], HDA_OUTPUT, 0,
4971 0xff, HDA_AMP_MUTE);
4976 * snd_hda_gen_stream_pm - Stream power management callback
4977 * @codec: the HDA codec
4978 * @nid: audio widget
4979 * @on: power on/off flag
4981 * Set this in patch_ops.stream_pm. Only valid with power_save_node flag.
4983 void snd_hda_gen_stream_pm(struct hda_codec *codec, hda_nid_t nid, bool on)
4985 if (codec->power_save_node)
4986 set_path_power(codec, nid, -1, on);
4988 EXPORT_SYMBOL_GPL(snd_hda_gen_stream_pm);
4991 * snd_hda_gen_parse_auto_config - Parse the given BIOS configuration and
4992 * set up the hda_gen_spec
4993 * @codec: the HDA codec
4994 * @cfg: Parsed pin configuration
4996 * return 1 if successful, 0 if the proper config is not found,
4997 * or a negative error code
4999 int snd_hda_gen_parse_auto_config(struct hda_codec *codec,
5000 struct auto_pin_cfg *cfg)
5002 struct hda_gen_spec *spec = codec->spec;
5005 parse_user_hints(codec);
5007 if (spec->mixer_nid && !spec->mixer_merge_nid)
5008 spec->mixer_merge_nid = spec->mixer_nid;
5010 if (cfg != &spec->autocfg) {
5011 spec->autocfg = *cfg;
5012 cfg = &spec->autocfg;
5015 if (!spec->main_out_badness)
5016 spec->main_out_badness = &hda_main_out_badness;
5017 if (!spec->extra_out_badness)
5018 spec->extra_out_badness = &hda_extra_out_badness;
5020 fill_all_dac_nids(codec);
5022 if (!cfg->line_outs) {
5023 if (cfg->dig_outs || cfg->dig_in_pin) {
5024 spec->multiout.max_channels = 2;
5025 spec->no_analog = 1;
5028 if (!cfg->num_inputs && !cfg->dig_in_pin)
5029 return 0; /* can't find valid BIOS pin config */
5032 if (!spec->no_primary_hp &&
5033 cfg->line_out_type == AUTO_PIN_SPEAKER_OUT &&
5034 cfg->line_outs <= cfg->hp_outs) {
5035 /* use HP as primary out */
5036 cfg->speaker_outs = cfg->line_outs;
5037 memcpy(cfg->speaker_pins, cfg->line_out_pins,
5038 sizeof(cfg->speaker_pins));
5039 cfg->line_outs = cfg->hp_outs;
5040 memcpy(cfg->line_out_pins, cfg->hp_pins, sizeof(cfg->hp_pins));
5042 memset(cfg->hp_pins, 0, sizeof(cfg->hp_pins));
5043 cfg->line_out_type = AUTO_PIN_HP_OUT;
5046 err = parse_output_paths(codec);
5049 err = create_multi_channel_mode(codec);
5052 err = create_multi_out_ctls(codec, cfg);
5055 err = create_hp_out_ctls(codec);
5058 err = create_speaker_out_ctls(codec);
5061 err = create_indep_hp_ctls(codec);
5064 err = create_loopback_mixing_ctl(codec);
5067 err = create_hp_mic(codec);
5070 err = create_input_ctls(codec);
5074 /* add power-down pin callbacks at first */
5075 add_all_pin_power_ctls(codec, false);
5077 spec->const_channel_count = spec->ext_channel_count;
5078 /* check the multiple speaker and headphone pins */
5079 if (cfg->line_out_type != AUTO_PIN_SPEAKER_OUT)
5080 spec->const_channel_count = max(spec->const_channel_count,
5081 cfg->speaker_outs * 2);
5082 if (cfg->line_out_type != AUTO_PIN_HP_OUT)
5083 spec->const_channel_count = max(spec->const_channel_count,
5085 spec->multiout.max_channels = max(spec->ext_channel_count,
5086 spec->const_channel_count);
5088 err = check_auto_mute_availability(codec);
5092 err = check_dyn_adc_switch(codec);
5096 err = check_auto_mic_availability(codec);
5100 /* add stereo mix if available and not enabled yet */
5101 if (!spec->auto_mic && spec->mixer_nid &&
5102 spec->add_stereo_mix_input == HDA_HINT_STEREO_MIX_AUTO &&
5103 spec->input_mux.num_items > 1) {
5104 err = parse_capture_source(codec, spec->mixer_nid,
5105 CFG_IDX_MIX, spec->num_all_adcs,
5112 err = create_capture_mixers(codec);
5116 err = parse_mic_boost(codec);
5120 /* create "Headphone Mic Jack Mode" if no input selection is
5121 * available (or user specifies add_jack_modes hint)
5123 if (spec->hp_mic_pin &&
5124 (spec->auto_mic || spec->input_mux.num_items == 1 ||
5125 spec->add_jack_modes)) {
5126 err = create_hp_mic_jack_mode(codec, spec->hp_mic_pin);
5131 if (spec->add_jack_modes) {
5132 if (cfg->line_out_type != AUTO_PIN_SPEAKER_OUT) {
5133 err = create_out_jack_modes(codec, cfg->line_outs,
5134 cfg->line_out_pins);
5138 if (cfg->line_out_type != AUTO_PIN_HP_OUT) {
5139 err = create_out_jack_modes(codec, cfg->hp_outs,
5146 /* add power-up pin callbacks at last */
5147 add_all_pin_power_ctls(codec, true);
5149 /* mute all aamix input initially */
5150 if (spec->mixer_nid)
5151 mute_all_mixer_nid(codec, spec->mixer_nid);
5154 parse_digital(codec);
5156 if (spec->power_down_unused || codec->power_save_node) {
5157 if (!codec->power_filter)
5158 codec->power_filter = snd_hda_gen_path_power_filter;
5159 if (!codec->patch_ops.stream_pm)
5160 codec->patch_ops.stream_pm = snd_hda_gen_stream_pm;
5163 if (!spec->no_analog && spec->beep_nid) {
5164 err = snd_hda_attach_beep_device(codec, spec->beep_nid);
5167 if (codec->beep && codec->power_save_node) {
5168 err = add_fake_beep_paths(codec);
5171 codec->beep->power_hook = beep_power_hook;
5177 EXPORT_SYMBOL_GPL(snd_hda_gen_parse_auto_config);
5181 * Build control elements
5184 /* slave controls for virtual master */
5185 static const char * const slave_pfxs[] = {
5186 "Front", "Surround", "Center", "LFE", "Side",
5187 "Headphone", "Speaker", "Mono", "Line Out",
5188 "CLFE", "Bass Speaker", "PCM",
5189 "Speaker Front", "Speaker Surround", "Speaker CLFE", "Speaker Side",
5190 "Headphone Front", "Headphone Surround", "Headphone CLFE",
5191 "Headphone Side", "Headphone+LO", "Speaker+LO",
5196 * snd_hda_gen_build_controls - Build controls from the parsed results
5197 * @codec: the HDA codec
5199 * Pass this to build_controls patch_ops.
5201 int snd_hda_gen_build_controls(struct hda_codec *codec)
5203 struct hda_gen_spec *spec = codec->spec;
5206 if (spec->kctls.used) {
5207 err = snd_hda_add_new_ctls(codec, spec->kctls.list);
5212 if (spec->multiout.dig_out_nid) {
5213 err = snd_hda_create_dig_out_ctls(codec,
5214 spec->multiout.dig_out_nid,
5215 spec->multiout.dig_out_nid,
5216 spec->pcm_rec[1]->pcm_type);
5219 if (!spec->no_analog) {
5220 err = snd_hda_create_spdif_share_sw(codec,
5224 spec->multiout.share_spdif = 1;
5227 if (spec->dig_in_nid) {
5228 err = snd_hda_create_spdif_in_ctls(codec, spec->dig_in_nid);
5233 /* if we have no master control, let's create it */
5234 if (!spec->no_analog && !spec->suppress_vmaster &&
5235 !snd_hda_find_mixer_ctl(codec, "Master Playback Volume")) {
5236 err = snd_hda_add_vmaster(codec, "Master Playback Volume",
5237 spec->vmaster_tlv, slave_pfxs,
5242 if (!spec->no_analog && !spec->suppress_vmaster &&
5243 !snd_hda_find_mixer_ctl(codec, "Master Playback Switch")) {
5244 err = __snd_hda_add_vmaster(codec, "Master Playback Switch",
5247 true, &spec->vmaster_mute.sw_kctl);
5250 if (spec->vmaster_mute.hook) {
5251 snd_hda_add_vmaster_hook(codec, &spec->vmaster_mute,
5252 spec->vmaster_mute_enum);
5253 snd_hda_sync_vmaster_hook(&spec->vmaster_mute);
5257 free_kctls(spec); /* no longer needed */
5259 err = snd_hda_jack_add_kctls(codec, &spec->autocfg);
5265 EXPORT_SYMBOL_GPL(snd_hda_gen_build_controls);
5272 static void call_pcm_playback_hook(struct hda_pcm_stream *hinfo,
5273 struct hda_codec *codec,
5274 struct snd_pcm_substream *substream,
5277 struct hda_gen_spec *spec = codec->spec;
5278 if (spec->pcm_playback_hook)
5279 spec->pcm_playback_hook(hinfo, codec, substream, action);
5282 static void call_pcm_capture_hook(struct hda_pcm_stream *hinfo,
5283 struct hda_codec *codec,
5284 struct snd_pcm_substream *substream,
5287 struct hda_gen_spec *spec = codec->spec;
5288 if (spec->pcm_capture_hook)
5289 spec->pcm_capture_hook(hinfo, codec, substream, action);
5293 * Analog playback callbacks
5295 static int playback_pcm_open(struct hda_pcm_stream *hinfo,
5296 struct hda_codec *codec,
5297 struct snd_pcm_substream *substream)
5299 struct hda_gen_spec *spec = codec->spec;
5302 mutex_lock(&spec->pcm_mutex);
5303 err = snd_hda_multi_out_analog_open(codec,
5304 &spec->multiout, substream,
5307 spec->active_streams |= 1 << STREAM_MULTI_OUT;
5308 call_pcm_playback_hook(hinfo, codec, substream,
5309 HDA_GEN_PCM_ACT_OPEN);
5311 mutex_unlock(&spec->pcm_mutex);
5315 static int playback_pcm_prepare(struct hda_pcm_stream *hinfo,
5316 struct hda_codec *codec,
5317 unsigned int stream_tag,
5318 unsigned int format,
5319 struct snd_pcm_substream *substream)
5321 struct hda_gen_spec *spec = codec->spec;
5324 err = snd_hda_multi_out_analog_prepare(codec, &spec->multiout,
5325 stream_tag, format, substream);
5327 call_pcm_playback_hook(hinfo, codec, substream,
5328 HDA_GEN_PCM_ACT_PREPARE);
5332 static int playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
5333 struct hda_codec *codec,
5334 struct snd_pcm_substream *substream)
5336 struct hda_gen_spec *spec = codec->spec;
5339 err = snd_hda_multi_out_analog_cleanup(codec, &spec->multiout);
5341 call_pcm_playback_hook(hinfo, codec, substream,
5342 HDA_GEN_PCM_ACT_CLEANUP);
5346 static int playback_pcm_close(struct hda_pcm_stream *hinfo,
5347 struct hda_codec *codec,
5348 struct snd_pcm_substream *substream)
5350 struct hda_gen_spec *spec = codec->spec;
5351 mutex_lock(&spec->pcm_mutex);
5352 spec->active_streams &= ~(1 << STREAM_MULTI_OUT);
5353 call_pcm_playback_hook(hinfo, codec, substream,
5354 HDA_GEN_PCM_ACT_CLOSE);
5355 mutex_unlock(&spec->pcm_mutex);
5359 static int capture_pcm_open(struct hda_pcm_stream *hinfo,
5360 struct hda_codec *codec,
5361 struct snd_pcm_substream *substream)
5363 call_pcm_capture_hook(hinfo, codec, substream, HDA_GEN_PCM_ACT_OPEN);
5367 static int capture_pcm_prepare(struct hda_pcm_stream *hinfo,
5368 struct hda_codec *codec,
5369 unsigned int stream_tag,
5370 unsigned int format,
5371 struct snd_pcm_substream *substream)
5373 snd_hda_codec_setup_stream(codec, hinfo->nid, stream_tag, 0, format);
5374 call_pcm_capture_hook(hinfo, codec, substream,
5375 HDA_GEN_PCM_ACT_PREPARE);
5379 static int capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
5380 struct hda_codec *codec,
5381 struct snd_pcm_substream *substream)
5383 snd_hda_codec_cleanup_stream(codec, hinfo->nid);
5384 call_pcm_capture_hook(hinfo, codec, substream,
5385 HDA_GEN_PCM_ACT_CLEANUP);
5389 static int capture_pcm_close(struct hda_pcm_stream *hinfo,
5390 struct hda_codec *codec,
5391 struct snd_pcm_substream *substream)
5393 call_pcm_capture_hook(hinfo, codec, substream, HDA_GEN_PCM_ACT_CLOSE);
5397 static int alt_playback_pcm_open(struct hda_pcm_stream *hinfo,
5398 struct hda_codec *codec,
5399 struct snd_pcm_substream *substream)
5401 struct hda_gen_spec *spec = codec->spec;
5404 mutex_lock(&spec->pcm_mutex);
5405 if (spec->indep_hp && !spec->indep_hp_enabled)
5408 spec->active_streams |= 1 << STREAM_INDEP_HP;
5409 call_pcm_playback_hook(hinfo, codec, substream,
5410 HDA_GEN_PCM_ACT_OPEN);
5411 mutex_unlock(&spec->pcm_mutex);
5415 static int alt_playback_pcm_close(struct hda_pcm_stream *hinfo,
5416 struct hda_codec *codec,
5417 struct snd_pcm_substream *substream)
5419 struct hda_gen_spec *spec = codec->spec;
5420 mutex_lock(&spec->pcm_mutex);
5421 spec->active_streams &= ~(1 << STREAM_INDEP_HP);
5422 call_pcm_playback_hook(hinfo, codec, substream,
5423 HDA_GEN_PCM_ACT_CLOSE);
5424 mutex_unlock(&spec->pcm_mutex);
5428 static int alt_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
5429 struct hda_codec *codec,
5430 unsigned int stream_tag,
5431 unsigned int format,
5432 struct snd_pcm_substream *substream)
5434 snd_hda_codec_setup_stream(codec, hinfo->nid, stream_tag, 0, format);
5435 call_pcm_playback_hook(hinfo, codec, substream,
5436 HDA_GEN_PCM_ACT_PREPARE);
5440 static int alt_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
5441 struct hda_codec *codec,
5442 struct snd_pcm_substream *substream)
5444 snd_hda_codec_cleanup_stream(codec, hinfo->nid);
5445 call_pcm_playback_hook(hinfo, codec, substream,
5446 HDA_GEN_PCM_ACT_CLEANUP);
5453 static int dig_playback_pcm_open(struct hda_pcm_stream *hinfo,
5454 struct hda_codec *codec,
5455 struct snd_pcm_substream *substream)
5457 struct hda_gen_spec *spec = codec->spec;
5458 return snd_hda_multi_out_dig_open(codec, &spec->multiout);
5461 static int dig_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
5462 struct hda_codec *codec,
5463 unsigned int stream_tag,
5464 unsigned int format,
5465 struct snd_pcm_substream *substream)
5467 struct hda_gen_spec *spec = codec->spec;
5468 return snd_hda_multi_out_dig_prepare(codec, &spec->multiout,
5469 stream_tag, format, substream);
5472 static int dig_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
5473 struct hda_codec *codec,
5474 struct snd_pcm_substream *substream)
5476 struct hda_gen_spec *spec = codec->spec;
5477 return snd_hda_multi_out_dig_cleanup(codec, &spec->multiout);
5480 static int dig_playback_pcm_close(struct hda_pcm_stream *hinfo,
5481 struct hda_codec *codec,
5482 struct snd_pcm_substream *substream)
5484 struct hda_gen_spec *spec = codec->spec;
5485 return snd_hda_multi_out_dig_close(codec, &spec->multiout);
5491 #define alt_capture_pcm_open capture_pcm_open
5492 #define alt_capture_pcm_close capture_pcm_close
5494 static int alt_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
5495 struct hda_codec *codec,
5496 unsigned int stream_tag,
5497 unsigned int format,
5498 struct snd_pcm_substream *substream)
5500 struct hda_gen_spec *spec = codec->spec;
5502 snd_hda_codec_setup_stream(codec, spec->adc_nids[substream->number + 1],
5503 stream_tag, 0, format);
5504 call_pcm_capture_hook(hinfo, codec, substream,
5505 HDA_GEN_PCM_ACT_PREPARE);
5509 static int alt_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
5510 struct hda_codec *codec,
5511 struct snd_pcm_substream *substream)
5513 struct hda_gen_spec *spec = codec->spec;
5515 snd_hda_codec_cleanup_stream(codec,
5516 spec->adc_nids[substream->number + 1]);
5517 call_pcm_capture_hook(hinfo, codec, substream,
5518 HDA_GEN_PCM_ACT_CLEANUP);
5524 static const struct hda_pcm_stream pcm_analog_playback = {
5528 /* NID is set in build_pcms */
5530 .open = playback_pcm_open,
5531 .close = playback_pcm_close,
5532 .prepare = playback_pcm_prepare,
5533 .cleanup = playback_pcm_cleanup
5537 static const struct hda_pcm_stream pcm_analog_capture = {
5541 /* NID is set in build_pcms */
5543 .open = capture_pcm_open,
5544 .close = capture_pcm_close,
5545 .prepare = capture_pcm_prepare,
5546 .cleanup = capture_pcm_cleanup
5550 static const struct hda_pcm_stream pcm_analog_alt_playback = {
5554 /* NID is set in build_pcms */
5556 .open = alt_playback_pcm_open,
5557 .close = alt_playback_pcm_close,
5558 .prepare = alt_playback_pcm_prepare,
5559 .cleanup = alt_playback_pcm_cleanup
5563 static const struct hda_pcm_stream pcm_analog_alt_capture = {
5564 .substreams = 2, /* can be overridden */
5567 /* NID is set in build_pcms */
5569 .open = alt_capture_pcm_open,
5570 .close = alt_capture_pcm_close,
5571 .prepare = alt_capture_pcm_prepare,
5572 .cleanup = alt_capture_pcm_cleanup
5576 static const struct hda_pcm_stream pcm_digital_playback = {
5580 /* NID is set in build_pcms */
5582 .open = dig_playback_pcm_open,
5583 .close = dig_playback_pcm_close,
5584 .prepare = dig_playback_pcm_prepare,
5585 .cleanup = dig_playback_pcm_cleanup
5589 static const struct hda_pcm_stream pcm_digital_capture = {
5593 /* NID is set in build_pcms */
5596 /* Used by build_pcms to flag that a PCM has no playback stream */
5597 static const struct hda_pcm_stream pcm_null_stream = {
5604 * dynamic changing ADC PCM streams
5606 static bool dyn_adc_pcm_resetup(struct hda_codec *codec, int cur)
5608 struct hda_gen_spec *spec = codec->spec;
5609 hda_nid_t new_adc = spec->adc_nids[spec->dyn_adc_idx[cur]];
5611 if (spec->cur_adc && spec->cur_adc != new_adc) {
5612 /* stream is running, let's swap the current ADC */
5613 __snd_hda_codec_cleanup_stream(codec, spec->cur_adc, 1);
5614 spec->cur_adc = new_adc;
5615 snd_hda_codec_setup_stream(codec, new_adc,
5616 spec->cur_adc_stream_tag, 0,
5617 spec->cur_adc_format);
5623 /* analog capture with dynamic dual-adc changes */
5624 static int dyn_adc_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
5625 struct hda_codec *codec,
5626 unsigned int stream_tag,
5627 unsigned int format,
5628 struct snd_pcm_substream *substream)
5630 struct hda_gen_spec *spec = codec->spec;
5631 spec->cur_adc = spec->adc_nids[spec->dyn_adc_idx[spec->cur_mux[0]]];
5632 spec->cur_adc_stream_tag = stream_tag;
5633 spec->cur_adc_format = format;
5634 snd_hda_codec_setup_stream(codec, spec->cur_adc, stream_tag, 0, format);
5635 call_pcm_capture_hook(hinfo, codec, substream, HDA_GEN_PCM_ACT_PREPARE);
5639 static int dyn_adc_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
5640 struct hda_codec *codec,
5641 struct snd_pcm_substream *substream)
5643 struct hda_gen_spec *spec = codec->spec;
5644 snd_hda_codec_cleanup_stream(codec, spec->cur_adc);
5646 call_pcm_capture_hook(hinfo, codec, substream, HDA_GEN_PCM_ACT_CLEANUP);
5650 static const struct hda_pcm_stream dyn_adc_pcm_analog_capture = {
5654 .nid = 0, /* fill later */
5656 .prepare = dyn_adc_capture_pcm_prepare,
5657 .cleanup = dyn_adc_capture_pcm_cleanup
5661 static void fill_pcm_stream_name(char *str, size_t len, const char *sfx,
5662 const char *chip_name)
5668 strlcpy(str, chip_name, len);
5670 /* drop non-alnum chars after a space */
5671 for (p = strchr(str, ' '); p; p = strchr(p + 1, ' ')) {
5672 if (!isalnum(p[1])) {
5677 strlcat(str, sfx, len);
5680 /* copy PCM stream info from @default_str, and override non-NULL entries
5681 * from @spec_str and @nid
5683 static void setup_pcm_stream(struct hda_pcm_stream *str,
5684 const struct hda_pcm_stream *default_str,
5685 const struct hda_pcm_stream *spec_str,
5688 *str = *default_str;
5692 if (spec_str->substreams)
5693 str->substreams = spec_str->substreams;
5694 if (spec_str->channels_min)
5695 str->channels_min = spec_str->channels_min;
5696 if (spec_str->channels_max)
5697 str->channels_max = spec_str->channels_max;
5698 if (spec_str->rates)
5699 str->rates = spec_str->rates;
5700 if (spec_str->formats)
5701 str->formats = spec_str->formats;
5702 if (spec_str->maxbps)
5703 str->maxbps = spec_str->maxbps;
5708 * snd_hda_gen_build_pcms - build PCM streams based on the parsed results
5709 * @codec: the HDA codec
5711 * Pass this to build_pcms patch_ops.
5713 int snd_hda_gen_build_pcms(struct hda_codec *codec)
5715 struct hda_gen_spec *spec = codec->spec;
5716 struct hda_pcm *info;
5717 bool have_multi_adcs;
5719 if (spec->no_analog)
5722 fill_pcm_stream_name(spec->stream_name_analog,
5723 sizeof(spec->stream_name_analog),
5724 " Analog", codec->core.chip_name);
5725 info = snd_hda_codec_pcm_new(codec, "%s", spec->stream_name_analog);
5728 spec->pcm_rec[0] = info;
5730 if (spec->multiout.num_dacs > 0) {
5731 setup_pcm_stream(&info->stream[SNDRV_PCM_STREAM_PLAYBACK],
5732 &pcm_analog_playback,
5733 spec->stream_analog_playback,
5734 spec->multiout.dac_nids[0]);
5735 info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max =
5736 spec->multiout.max_channels;
5737 if (spec->autocfg.line_out_type == AUTO_PIN_SPEAKER_OUT &&
5738 spec->autocfg.line_outs == 2)
5739 info->stream[SNDRV_PCM_STREAM_PLAYBACK].chmap =
5742 if (spec->num_adc_nids) {
5743 setup_pcm_stream(&info->stream[SNDRV_PCM_STREAM_CAPTURE],
5744 (spec->dyn_adc_switch ?
5745 &dyn_adc_pcm_analog_capture : &pcm_analog_capture),
5746 spec->stream_analog_capture,
5751 /* SPDIF for stream index #1 */
5752 if (spec->multiout.dig_out_nid || spec->dig_in_nid) {
5753 fill_pcm_stream_name(spec->stream_name_digital,
5754 sizeof(spec->stream_name_digital),
5755 " Digital", codec->core.chip_name);
5756 info = snd_hda_codec_pcm_new(codec, "%s",
5757 spec->stream_name_digital);
5760 codec->slave_dig_outs = spec->multiout.slave_dig_outs;
5761 spec->pcm_rec[1] = info;
5762 if (spec->dig_out_type)
5763 info->pcm_type = spec->dig_out_type;
5765 info->pcm_type = HDA_PCM_TYPE_SPDIF;
5766 if (spec->multiout.dig_out_nid)
5767 setup_pcm_stream(&info->stream[SNDRV_PCM_STREAM_PLAYBACK],
5768 &pcm_digital_playback,
5769 spec->stream_digital_playback,
5770 spec->multiout.dig_out_nid);
5771 if (spec->dig_in_nid)
5772 setup_pcm_stream(&info->stream[SNDRV_PCM_STREAM_CAPTURE],
5773 &pcm_digital_capture,
5774 spec->stream_digital_capture,
5778 if (spec->no_analog)
5781 /* If the use of more than one ADC is requested for the current
5782 * model, configure a second analog capture-only PCM.
5784 have_multi_adcs = (spec->num_adc_nids > 1) &&
5785 !spec->dyn_adc_switch && !spec->auto_mic;
5786 /* Additional Analaog capture for index #2 */
5787 if (spec->alt_dac_nid || have_multi_adcs) {
5788 fill_pcm_stream_name(spec->stream_name_alt_analog,
5789 sizeof(spec->stream_name_alt_analog),
5790 " Alt Analog", codec->core.chip_name);
5791 info = snd_hda_codec_pcm_new(codec, "%s",
5792 spec->stream_name_alt_analog);
5795 spec->pcm_rec[2] = info;
5796 if (spec->alt_dac_nid)
5797 setup_pcm_stream(&info->stream[SNDRV_PCM_STREAM_PLAYBACK],
5798 &pcm_analog_alt_playback,
5799 spec->stream_analog_alt_playback,
5802 setup_pcm_stream(&info->stream[SNDRV_PCM_STREAM_PLAYBACK],
5803 &pcm_null_stream, NULL, 0);
5804 if (have_multi_adcs) {
5805 setup_pcm_stream(&info->stream[SNDRV_PCM_STREAM_CAPTURE],
5806 &pcm_analog_alt_capture,
5807 spec->stream_analog_alt_capture,
5809 info->stream[SNDRV_PCM_STREAM_CAPTURE].substreams =
5810 spec->num_adc_nids - 1;
5812 setup_pcm_stream(&info->stream[SNDRV_PCM_STREAM_CAPTURE],
5813 &pcm_null_stream, NULL, 0);
5819 EXPORT_SYMBOL_GPL(snd_hda_gen_build_pcms);
5823 * Standard auto-parser initializations
5826 /* configure the given path as a proper output */
5827 static void set_output_and_unmute(struct hda_codec *codec, int path_idx)
5829 struct nid_path *path;
5832 path = snd_hda_get_path_from_idx(codec, path_idx);
5833 if (!path || !path->depth)
5835 pin = path->path[path->depth - 1];
5836 restore_pin_ctl(codec, pin);
5837 snd_hda_activate_path(codec, path, path->active,
5838 aamix_default(codec->spec));
5839 set_pin_eapd(codec, pin, path->active);
5842 /* initialize primary output paths */
5843 static void init_multi_out(struct hda_codec *codec)
5845 struct hda_gen_spec *spec = codec->spec;
5848 for (i = 0; i < spec->autocfg.line_outs; i++)
5849 set_output_and_unmute(codec, spec->out_paths[i]);
5853 static void __init_extra_out(struct hda_codec *codec, int num_outs, int *paths)
5857 for (i = 0; i < num_outs; i++)
5858 set_output_and_unmute(codec, paths[i]);
5861 /* initialize hp and speaker paths */
5862 static void init_extra_out(struct hda_codec *codec)
5864 struct hda_gen_spec *spec = codec->spec;
5866 if (spec->autocfg.line_out_type != AUTO_PIN_HP_OUT)
5867 __init_extra_out(codec, spec->autocfg.hp_outs, spec->hp_paths);
5868 if (spec->autocfg.line_out_type != AUTO_PIN_SPEAKER_OUT)
5869 __init_extra_out(codec, spec->autocfg.speaker_outs,
5870 spec->speaker_paths);
5873 /* initialize multi-io paths */
5874 static void init_multi_io(struct hda_codec *codec)
5876 struct hda_gen_spec *spec = codec->spec;
5879 for (i = 0; i < spec->multi_ios; i++) {
5880 hda_nid_t pin = spec->multi_io[i].pin;
5881 struct nid_path *path;
5882 path = get_multiio_path(codec, i);
5885 if (!spec->multi_io[i].ctl_in)
5886 spec->multi_io[i].ctl_in =
5887 snd_hda_codec_get_pin_target(codec, pin);
5888 snd_hda_activate_path(codec, path, path->active,
5889 aamix_default(spec));
5893 static void init_aamix_paths(struct hda_codec *codec)
5895 struct hda_gen_spec *spec = codec->spec;
5897 if (!spec->have_aamix_ctl)
5899 if (!has_aamix_out_paths(spec))
5901 update_aamix_paths(codec, spec->aamix_mode, spec->out_paths[0],
5902 spec->aamix_out_paths[0],
5903 spec->autocfg.line_out_type);
5904 update_aamix_paths(codec, spec->aamix_mode, spec->hp_paths[0],
5905 spec->aamix_out_paths[1],
5907 update_aamix_paths(codec, spec->aamix_mode, spec->speaker_paths[0],
5908 spec->aamix_out_paths[2],
5909 AUTO_PIN_SPEAKER_OUT);
5912 /* set up input pins and loopback paths */
5913 static void init_analog_input(struct hda_codec *codec)
5915 struct hda_gen_spec *spec = codec->spec;
5916 struct auto_pin_cfg *cfg = &spec->autocfg;
5919 for (i = 0; i < cfg->num_inputs; i++) {
5920 hda_nid_t nid = cfg->inputs[i].pin;
5921 if (is_input_pin(codec, nid))
5922 restore_pin_ctl(codec, nid);
5924 /* init loopback inputs */
5925 if (spec->mixer_nid) {
5926 resume_path_from_idx(codec, spec->loopback_paths[i]);
5927 resume_path_from_idx(codec, spec->loopback_merge_path);
5932 /* initialize ADC paths */
5933 static void init_input_src(struct hda_codec *codec)
5935 struct hda_gen_spec *spec = codec->spec;
5936 struct hda_input_mux *imux = &spec->input_mux;
5937 struct nid_path *path;
5940 if (spec->dyn_adc_switch)
5943 nums = spec->num_adc_nids;
5945 for (c = 0; c < nums; c++) {
5946 for (i = 0; i < imux->num_items; i++) {
5947 path = get_input_path(codec, c, i);
5949 bool active = path->active;
5950 if (i == spec->cur_mux[c])
5952 snd_hda_activate_path(codec, path, active, false);
5956 update_hp_mic(codec, c, true);
5959 if (spec->cap_sync_hook)
5960 spec->cap_sync_hook(codec, NULL, NULL);
5963 /* set right pin controls for digital I/O */
5964 static void init_digital(struct hda_codec *codec)
5966 struct hda_gen_spec *spec = codec->spec;
5970 for (i = 0; i < spec->autocfg.dig_outs; i++)
5971 set_output_and_unmute(codec, spec->digout_paths[i]);
5972 pin = spec->autocfg.dig_in_pin;
5974 restore_pin_ctl(codec, pin);
5975 resume_path_from_idx(codec, spec->digin_path);
5979 /* clear unsol-event tags on unused pins; Conexant codecs seem to leave
5980 * invalid unsol tags by some reason
5982 static void clear_unsol_on_unused_pins(struct hda_codec *codec)
5984 const struct hda_pincfg *pin;
5987 snd_array_for_each(&codec->init_pins, i, pin) {
5988 hda_nid_t nid = pin->nid;
5989 if (is_jack_detectable(codec, nid) &&
5990 !snd_hda_jack_tbl_get(codec, nid))
5991 snd_hda_codec_write_cache(codec, nid, 0,
5992 AC_VERB_SET_UNSOLICITED_ENABLE, 0);
5997 * snd_hda_gen_init - initialize the generic spec
5998 * @codec: the HDA codec
6000 * This can be put as patch_ops init function.
6002 int snd_hda_gen_init(struct hda_codec *codec)
6004 struct hda_gen_spec *spec = codec->spec;
6006 if (spec->init_hook)
6007 spec->init_hook(codec);
6009 if (!spec->skip_verbs)
6010 snd_hda_apply_verbs(codec);
6012 init_multi_out(codec);
6013 init_extra_out(codec);
6014 init_multi_io(codec);
6015 init_aamix_paths(codec);
6016 init_analog_input(codec);
6017 init_input_src(codec);
6018 init_digital(codec);
6020 clear_unsol_on_unused_pins(codec);
6022 sync_all_pin_power_ctls(codec);
6024 /* call init functions of standard auto-mute helpers */
6025 update_automute_all(codec);
6027 regcache_sync(codec->core.regmap);
6029 if (spec->vmaster_mute.sw_kctl && spec->vmaster_mute.hook)
6030 snd_hda_sync_vmaster_hook(&spec->vmaster_mute);
6032 hda_call_check_power_status(codec, 0x01);
6035 EXPORT_SYMBOL_GPL(snd_hda_gen_init);
6038 * snd_hda_gen_free - free the generic spec
6039 * @codec: the HDA codec
6041 * This can be put as patch_ops free function.
6043 void snd_hda_gen_free(struct hda_codec *codec)
6045 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_FREE);
6046 snd_hda_gen_spec_free(codec->spec);
6050 EXPORT_SYMBOL_GPL(snd_hda_gen_free);
6053 * snd_hda_gen_reboot_notify - Make codec enter D3 before rebooting
6054 * @codec: the HDA codec
6056 * This can be put as patch_ops reboot_notify function.
6058 void snd_hda_gen_reboot_notify(struct hda_codec *codec)
6060 /* Make the codec enter D3 to avoid spurious noises from the internal
6061 * speaker during (and after) reboot
6063 snd_hda_codec_set_power_to_all(codec, codec->core.afg, AC_PWRST_D3);
6064 snd_hda_codec_write(codec, codec->core.afg, 0,
6065 AC_VERB_SET_POWER_STATE, AC_PWRST_D3);
6068 EXPORT_SYMBOL_GPL(snd_hda_gen_reboot_notify);
6072 * snd_hda_gen_check_power_status - check the loopback power save state
6073 * @codec: the HDA codec
6074 * @nid: NID to inspect
6076 * This can be put as patch_ops check_power_status function.
6078 int snd_hda_gen_check_power_status(struct hda_codec *codec, hda_nid_t nid)
6080 struct hda_gen_spec *spec = codec->spec;
6081 return snd_hda_check_amp_list_power(codec, &spec->loopback, nid);
6083 EXPORT_SYMBOL_GPL(snd_hda_gen_check_power_status);
6088 * the generic codec support
6091 static const struct hda_codec_ops generic_patch_ops = {
6092 .build_controls = snd_hda_gen_build_controls,
6093 .build_pcms = snd_hda_gen_build_pcms,
6094 .init = snd_hda_gen_init,
6095 .free = snd_hda_gen_free,
6096 .unsol_event = snd_hda_jack_unsol_event,
6097 .reboot_notify = snd_hda_gen_reboot_notify,
6099 .check_power_status = snd_hda_gen_check_power_status,
6104 * snd_hda_parse_generic_codec - Generic codec parser
6105 * @codec: the HDA codec
6107 static int snd_hda_parse_generic_codec(struct hda_codec *codec)
6109 struct hda_gen_spec *spec;
6112 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
6115 snd_hda_gen_spec_init(spec);
6118 err = snd_hda_parse_pin_defcfg(codec, &spec->autocfg, NULL, 0);
6122 err = snd_hda_gen_parse_auto_config(codec, &spec->autocfg);
6126 codec->patch_ops = generic_patch_ops;
6130 snd_hda_gen_free(codec);
6134 static const struct hda_device_id snd_hda_id_generic[] = {
6135 HDA_CODEC_ENTRY(HDA_CODEC_ID_GENERIC, "Generic", snd_hda_parse_generic_codec),
6138 MODULE_DEVICE_TABLE(hdaudio, snd_hda_id_generic);
6140 static struct hda_codec_driver generic_driver = {
6141 .id = snd_hda_id_generic,
6144 module_hda_codec_driver(generic_driver);
6146 MODULE_LICENSE("GPL");
6147 MODULE_DESCRIPTION("Generic HD-audio codec parser");