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 <sound/core.h>
32 #include <sound/jack.h>
33 #include "hda_codec.h"
34 #include "hda_local.h"
35 #include "hda_auto_parser.h"
37 #include "hda_generic.h"
40 /* initialize hda_gen_spec struct */
41 int snd_hda_gen_spec_init(struct hda_gen_spec *spec)
43 snd_array_init(&spec->kctls, sizeof(struct snd_kcontrol_new), 32);
44 snd_array_init(&spec->paths, sizeof(struct nid_path), 8);
45 snd_array_init(&spec->loopback_list, sizeof(struct hda_amp_list), 8);
46 mutex_init(&spec->pcm_mutex);
49 EXPORT_SYMBOL_HDA(snd_hda_gen_spec_init);
51 struct snd_kcontrol_new *
52 snd_hda_gen_add_kctl(struct hda_gen_spec *spec, const char *name,
53 const struct snd_kcontrol_new *temp)
55 struct snd_kcontrol_new *knew = snd_array_new(&spec->kctls);
60 knew->name = kstrdup(name, GFP_KERNEL);
62 knew->name = kstrdup(knew->name, GFP_KERNEL);
67 EXPORT_SYMBOL_HDA(snd_hda_gen_add_kctl);
69 static void free_kctls(struct hda_gen_spec *spec)
71 if (spec->kctls.list) {
72 struct snd_kcontrol_new *kctl = spec->kctls.list;
74 for (i = 0; i < spec->kctls.used; i++)
77 snd_array_free(&spec->kctls);
80 void snd_hda_gen_spec_free(struct hda_gen_spec *spec)
85 snd_array_free(&spec->paths);
86 snd_array_free(&spec->loopback_list);
88 EXPORT_SYMBOL_HDA(snd_hda_gen_spec_free);
93 static void parse_user_hints(struct hda_codec *codec)
95 struct hda_gen_spec *spec = codec->spec;
98 val = snd_hda_get_bool_hint(codec, "jack_detect");
100 codec->no_jack_detect = !val;
101 val = snd_hda_get_bool_hint(codec, "inv_jack_detect");
103 codec->inv_jack_detect = !!val;
104 val = snd_hda_get_bool_hint(codec, "trigger_sense");
106 codec->no_trigger_sense = !val;
107 val = snd_hda_get_bool_hint(codec, "inv_eapd");
109 codec->inv_eapd = !!val;
110 val = snd_hda_get_bool_hint(codec, "pcm_format_first");
112 codec->pcm_format_first = !!val;
113 val = snd_hda_get_bool_hint(codec, "sticky_stream");
115 codec->no_sticky_stream = !val;
116 val = snd_hda_get_bool_hint(codec, "spdif_status_reset");
118 codec->spdif_status_reset = !!val;
119 val = snd_hda_get_bool_hint(codec, "pin_amp_workaround");
121 codec->pin_amp_workaround = !!val;
122 val = snd_hda_get_bool_hint(codec, "single_adc_amp");
124 codec->single_adc_amp = !!val;
126 val = snd_hda_get_bool_hint(codec, "auto_mute");
128 spec->suppress_auto_mute = !val;
129 val = snd_hda_get_bool_hint(codec, "auto_mic");
131 spec->suppress_auto_mic = !val;
132 val = snd_hda_get_bool_hint(codec, "line_in_auto_switch");
134 spec->line_in_auto_switch = !!val;
135 val = snd_hda_get_bool_hint(codec, "need_dac_fix");
137 spec->need_dac_fix = !!val;
138 val = snd_hda_get_bool_hint(codec, "primary_hp");
140 spec->no_primary_hp = !val;
141 val = snd_hda_get_bool_hint(codec, "multi_cap_vol");
143 spec->multi_cap_vol = !!val;
144 val = snd_hda_get_bool_hint(codec, "inv_dmic_split");
146 spec->inv_dmic_split = !!val;
147 val = snd_hda_get_bool_hint(codec, "indep_hp");
149 spec->indep_hp = !!val;
150 val = snd_hda_get_bool_hint(codec, "add_stereo_mix_input");
152 spec->add_stereo_mix_input = !!val;
153 val = snd_hda_get_bool_hint(codec, "add_out_jack_modes");
155 spec->add_out_jack_modes = !!val;
156 val = snd_hda_get_bool_hint(codec, "add_in_jack_modes");
158 spec->add_in_jack_modes = !!val;
159 val = snd_hda_get_bool_hint(codec, "power_down_unused");
161 spec->power_down_unused = !!val;
163 if (!snd_hda_get_int_hint(codec, "mixer_nid", &val))
164 spec->mixer_nid = val;
168 * pin control value accesses
171 #define update_pin_ctl(codec, pin, val) \
172 snd_hda_codec_update_cache(codec, pin, 0, \
173 AC_VERB_SET_PIN_WIDGET_CONTROL, val)
175 /* restore the pinctl based on the cached value */
176 static inline void restore_pin_ctl(struct hda_codec *codec, hda_nid_t pin)
178 update_pin_ctl(codec, pin, snd_hda_codec_get_pin_target(codec, pin));
181 /* set the pinctl target value and write it if requested */
182 static void set_pin_target(struct hda_codec *codec, hda_nid_t pin,
183 unsigned int val, bool do_write)
187 val = snd_hda_correct_pin_ctl(codec, pin, val);
188 snd_hda_codec_set_pin_target(codec, pin, val);
190 update_pin_ctl(codec, pin, val);
193 /* set pinctl target values for all given pins */
194 static void set_pin_targets(struct hda_codec *codec, int num_pins,
195 hda_nid_t *pins, unsigned int val)
198 for (i = 0; i < num_pins; i++)
199 set_pin_target(codec, pins[i], val, false);
206 /* return the position of NID in the list, or -1 if not found */
207 static int find_idx_in_nid_list(hda_nid_t nid, const hda_nid_t *list, int nums)
210 for (i = 0; i < nums; i++)
216 /* return true if the given NID is contained in the path */
217 static bool is_nid_contained(struct nid_path *path, hda_nid_t nid)
219 return find_idx_in_nid_list(nid, path->path, path->depth) >= 0;
222 static struct nid_path *get_nid_path(struct hda_codec *codec,
223 hda_nid_t from_nid, hda_nid_t to_nid,
226 struct hda_gen_spec *spec = codec->spec;
229 for (i = 0; i < spec->paths.used; i++) {
230 struct nid_path *path = snd_array_elem(&spec->paths, i);
231 if (path->depth <= 0)
233 if ((!from_nid || path->path[0] == from_nid) &&
234 (!to_nid || path->path[path->depth - 1] == to_nid)) {
236 (anchor_nid > 0 && is_nid_contained(path, anchor_nid)) ||
237 (anchor_nid < 0 && !is_nid_contained(path, anchor_nid)))
244 /* get the path between the given NIDs;
245 * passing 0 to either @pin or @dac behaves as a wildcard
247 struct nid_path *snd_hda_get_nid_path(struct hda_codec *codec,
248 hda_nid_t from_nid, hda_nid_t to_nid)
250 return get_nid_path(codec, from_nid, to_nid, 0);
252 EXPORT_SYMBOL_HDA(snd_hda_get_nid_path);
254 /* get the index number corresponding to the path instance;
255 * the index starts from 1, for easier checking the invalid value
257 int snd_hda_get_path_idx(struct hda_codec *codec, struct nid_path *path)
259 struct hda_gen_spec *spec = codec->spec;
260 struct nid_path *array = spec->paths.list;
263 if (!spec->paths.used)
266 if (idx < 0 || idx >= spec->paths.used)
270 EXPORT_SYMBOL_HDA(snd_hda_get_path_idx);
272 /* get the path instance corresponding to the given index number */
273 struct nid_path *snd_hda_get_path_from_idx(struct hda_codec *codec, int idx)
275 struct hda_gen_spec *spec = codec->spec;
277 if (idx <= 0 || idx > spec->paths.used)
279 return snd_array_elem(&spec->paths, idx - 1);
281 EXPORT_SYMBOL_HDA(snd_hda_get_path_from_idx);
283 /* check whether the given DAC is already found in any existing paths */
284 static bool is_dac_already_used(struct hda_codec *codec, hda_nid_t nid)
286 struct hda_gen_spec *spec = codec->spec;
289 for (i = 0; i < spec->paths.used; i++) {
290 struct nid_path *path = snd_array_elem(&spec->paths, i);
291 if (path->path[0] == nid)
297 /* check whether the given two widgets can be connected */
298 static bool is_reachable_path(struct hda_codec *codec,
299 hda_nid_t from_nid, hda_nid_t to_nid)
301 if (!from_nid || !to_nid)
303 return snd_hda_get_conn_index(codec, to_nid, from_nid, true) >= 0;
306 /* nid, dir and idx */
307 #define AMP_VAL_COMPARE_MASK (0xffff | (1U << 18) | (0x0f << 19))
309 /* check whether the given ctl is already assigned in any path elements */
310 static bool is_ctl_used(struct hda_codec *codec, unsigned int val, int type)
312 struct hda_gen_spec *spec = codec->spec;
315 val &= AMP_VAL_COMPARE_MASK;
316 for (i = 0; i < spec->paths.used; i++) {
317 struct nid_path *path = snd_array_elem(&spec->paths, i);
318 if ((path->ctls[type] & AMP_VAL_COMPARE_MASK) == val)
324 /* check whether a control with the given (nid, dir, idx) was assigned */
325 static bool is_ctl_associated(struct hda_codec *codec, hda_nid_t nid,
326 int dir, int idx, int type)
328 unsigned int val = HDA_COMPOSE_AMP_VAL(nid, 3, idx, dir);
329 return is_ctl_used(codec, val, type);
332 static void print_nid_path(const char *pfx, struct nid_path *path)
339 for (i = 0; i < path->depth; i++) {
341 sprintf(tmp, ":%02x", path->path[i]);
342 strlcat(buf, tmp, sizeof(buf));
344 snd_printdd("%s path: depth=%d %s\n", pfx, path->depth, buf);
347 /* called recursively */
348 static bool __parse_nid_path(struct hda_codec *codec,
349 hda_nid_t from_nid, hda_nid_t to_nid,
350 int anchor_nid, struct nid_path *path,
353 const hda_nid_t *conn;
356 if (to_nid == anchor_nid)
357 anchor_nid = 0; /* anchor passed */
358 else if (to_nid == (hda_nid_t)(-anchor_nid))
359 return false; /* hit the exclusive nid */
361 nums = snd_hda_get_conn_list(codec, to_nid, &conn);
362 for (i = 0; i < nums; i++) {
363 if (conn[i] != from_nid) {
364 /* special case: when from_nid is 0,
365 * try to find an empty DAC
368 get_wcaps_type(get_wcaps(codec, conn[i])) != AC_WID_AUD_OUT ||
369 is_dac_already_used(codec, conn[i]))
372 /* anchor is not requested or already passed? */
376 if (depth >= MAX_NID_PATH_DEPTH)
378 for (i = 0; i < nums; i++) {
380 type = get_wcaps_type(get_wcaps(codec, conn[i]));
381 if (type == AC_WID_AUD_OUT || type == AC_WID_AUD_IN ||
384 if (__parse_nid_path(codec, from_nid, conn[i],
385 anchor_nid, path, depth + 1))
391 path->path[path->depth] = conn[i];
392 path->idx[path->depth + 1] = i;
393 if (nums > 1 && get_wcaps_type(get_wcaps(codec, to_nid)) != AC_WID_AUD_MIX)
394 path->multi[path->depth + 1] = 1;
399 /* parse the widget path from the given nid to the target nid;
400 * when @from_nid is 0, try to find an empty DAC;
401 * when @anchor_nid is set to a positive value, only paths through the widget
402 * with the given value are evaluated.
403 * when @anchor_nid is set to a negative value, paths through the widget
404 * with the negative of given value are excluded, only other paths are chosen.
405 * when @anchor_nid is zero, no special handling about path selection.
407 bool snd_hda_parse_nid_path(struct hda_codec *codec, hda_nid_t from_nid,
408 hda_nid_t to_nid, int anchor_nid,
409 struct nid_path *path)
411 if (__parse_nid_path(codec, from_nid, to_nid, anchor_nid, path, 1)) {
412 path->path[path->depth] = to_nid;
418 EXPORT_SYMBOL_HDA(snd_hda_parse_nid_path);
421 * parse the path between the given NIDs and add to the path list.
422 * if no valid path is found, return NULL
425 snd_hda_add_new_path(struct hda_codec *codec, hda_nid_t from_nid,
426 hda_nid_t to_nid, int anchor_nid)
428 struct hda_gen_spec *spec = codec->spec;
429 struct nid_path *path;
431 if (from_nid && to_nid && !is_reachable_path(codec, from_nid, to_nid))
434 /* check whether the path has been already added */
435 path = get_nid_path(codec, from_nid, to_nid, anchor_nid);
439 path = snd_array_new(&spec->paths);
442 memset(path, 0, sizeof(*path));
443 if (snd_hda_parse_nid_path(codec, from_nid, to_nid, anchor_nid, path))
449 EXPORT_SYMBOL_HDA(snd_hda_add_new_path);
451 /* clear the given path as invalid so that it won't be picked up later */
452 static void invalidate_nid_path(struct hda_codec *codec, int idx)
454 struct nid_path *path = snd_hda_get_path_from_idx(codec, idx);
457 memset(path, 0, sizeof(*path));
460 /* look for an empty DAC slot */
461 static hda_nid_t look_for_dac(struct hda_codec *codec, hda_nid_t pin,
464 struct hda_gen_spec *spec = codec->spec;
468 for (i = 0; i < spec->num_all_dacs; i++) {
469 hda_nid_t nid = spec->all_dacs[i];
470 if (!nid || is_dac_already_used(codec, nid))
472 cap_digital = !!(get_wcaps(codec, nid) & AC_WCAP_DIGITAL);
473 if (is_digital != cap_digital)
475 if (is_reachable_path(codec, nid, pin))
481 /* replace the channels in the composed amp value with the given number */
482 static unsigned int amp_val_replace_channels(unsigned int val, unsigned int chs)
484 val &= ~(0x3U << 16);
489 /* check whether the widget has the given amp capability for the direction */
490 static bool check_amp_caps(struct hda_codec *codec, hda_nid_t nid,
491 int dir, unsigned int bits)
495 if (get_wcaps(codec, nid) & (1 << (dir + 1)))
496 if (query_amp_caps(codec, nid, dir) & bits)
501 static bool same_amp_caps(struct hda_codec *codec, hda_nid_t nid1,
502 hda_nid_t nid2, int dir)
504 if (!(get_wcaps(codec, nid1) & (1 << (dir + 1))))
505 return !(get_wcaps(codec, nid2) & (1 << (dir + 1)));
506 return (query_amp_caps(codec, nid1, dir) ==
507 query_amp_caps(codec, nid2, dir));
510 #define nid_has_mute(codec, nid, dir) \
511 check_amp_caps(codec, nid, dir, AC_AMPCAP_MUTE)
512 #define nid_has_volume(codec, nid, dir) \
513 check_amp_caps(codec, nid, dir, AC_AMPCAP_NUM_STEPS)
515 /* look for a widget suitable for assigning a mute switch in the path */
516 static hda_nid_t look_for_out_mute_nid(struct hda_codec *codec,
517 struct nid_path *path)
521 for (i = path->depth - 1; i >= 0; i--) {
522 if (nid_has_mute(codec, path->path[i], HDA_OUTPUT))
523 return path->path[i];
524 if (i != path->depth - 1 && i != 0 &&
525 nid_has_mute(codec, path->path[i], HDA_INPUT))
526 return path->path[i];
531 /* look for a widget suitable for assigning a volume ctl in the path */
532 static hda_nid_t look_for_out_vol_nid(struct hda_codec *codec,
533 struct nid_path *path)
537 for (i = path->depth - 1; i >= 0; i--) {
538 if (nid_has_volume(codec, path->path[i], HDA_OUTPUT))
539 return path->path[i];
545 * path activation / deactivation
548 /* can have the amp-in capability? */
549 static bool has_amp_in(struct hda_codec *codec, struct nid_path *path, int idx)
551 hda_nid_t nid = path->path[idx];
552 unsigned int caps = get_wcaps(codec, nid);
553 unsigned int type = get_wcaps_type(caps);
555 if (!(caps & AC_WCAP_IN_AMP))
557 if (type == AC_WID_PIN && idx > 0) /* only for input pins */
562 /* can have the amp-out capability? */
563 static bool has_amp_out(struct hda_codec *codec, struct nid_path *path, int idx)
565 hda_nid_t nid = path->path[idx];
566 unsigned int caps = get_wcaps(codec, nid);
567 unsigned int type = get_wcaps_type(caps);
569 if (!(caps & AC_WCAP_OUT_AMP))
571 if (type == AC_WID_PIN && !idx) /* only for output pins */
576 /* check whether the given (nid,dir,idx) is active */
577 static bool is_active_nid(struct hda_codec *codec, hda_nid_t nid,
578 unsigned int dir, unsigned int idx)
580 struct hda_gen_spec *spec = codec->spec;
583 for (n = 0; n < spec->paths.used; n++) {
584 struct nid_path *path = snd_array_elem(&spec->paths, n);
587 for (i = 0; i < path->depth; i++) {
588 if (path->path[i] == nid) {
589 if (dir == HDA_OUTPUT || path->idx[i] == idx)
598 /* get the default amp value for the target state */
599 static int get_amp_val_to_activate(struct hda_codec *codec, hda_nid_t nid,
600 int dir, unsigned int caps, bool enable)
602 unsigned int val = 0;
604 if (caps & AC_AMPCAP_NUM_STEPS) {
607 val = (caps & AC_AMPCAP_OFFSET) >> AC_AMPCAP_OFFSET_SHIFT;
609 if (caps & AC_AMPCAP_MUTE) {
616 /* initialize the amp value (only at the first time) */
617 static void init_amp(struct hda_codec *codec, hda_nid_t nid, int dir, int idx)
619 unsigned int caps = query_amp_caps(codec, nid, dir);
620 int val = get_amp_val_to_activate(codec, nid, dir, caps, false);
621 snd_hda_codec_amp_init_stereo(codec, nid, dir, idx, 0xff, val);
624 /* calculate amp value mask we can modify;
625 * if the given amp is controlled by mixers, don't touch it
627 static unsigned int get_amp_mask_to_modify(struct hda_codec *codec,
628 hda_nid_t nid, int dir, int idx,
631 unsigned int mask = 0xff;
633 if (caps & AC_AMPCAP_MUTE) {
634 if (is_ctl_associated(codec, nid, dir, idx, NID_PATH_MUTE_CTL))
637 if (caps & AC_AMPCAP_NUM_STEPS) {
638 if (is_ctl_associated(codec, nid, dir, idx, NID_PATH_VOL_CTL) ||
639 is_ctl_associated(codec, nid, dir, idx, NID_PATH_BOOST_CTL))
645 static void activate_amp(struct hda_codec *codec, hda_nid_t nid, int dir,
646 int idx, int idx_to_check, bool enable)
649 unsigned int mask, val;
651 if (!enable && is_active_nid(codec, nid, dir, idx_to_check))
654 caps = query_amp_caps(codec, nid, dir);
655 val = get_amp_val_to_activate(codec, nid, dir, caps, enable);
656 mask = get_amp_mask_to_modify(codec, nid, dir, idx_to_check, caps);
661 snd_hda_codec_amp_stereo(codec, nid, dir, idx, mask, val);
664 static void activate_amp_out(struct hda_codec *codec, struct nid_path *path,
667 hda_nid_t nid = path->path[i];
668 init_amp(codec, nid, HDA_OUTPUT, 0);
669 activate_amp(codec, nid, HDA_OUTPUT, 0, 0, enable);
672 static void activate_amp_in(struct hda_codec *codec, struct nid_path *path,
673 int i, bool enable, bool add_aamix)
675 struct hda_gen_spec *spec = codec->spec;
676 const hda_nid_t *conn;
679 hda_nid_t nid = path->path[i];
681 nums = snd_hda_get_conn_list(codec, nid, &conn);
682 type = get_wcaps_type(get_wcaps(codec, nid));
683 if (type == AC_WID_PIN ||
684 (type == AC_WID_AUD_IN && codec->single_adc_amp)) {
690 for (n = 0; n < nums; n++)
691 init_amp(codec, nid, HDA_INPUT, n);
693 /* here is a little bit tricky in comparison with activate_amp_out();
694 * when aa-mixer is available, we need to enable the path as well
696 for (n = 0; n < nums; n++) {
697 if (n != idx && (!add_aamix || conn[n] != spec->mixer_merge_nid))
699 activate_amp(codec, nid, HDA_INPUT, n, idx, enable);
703 /* activate or deactivate the given path
704 * if @add_aamix is set, enable the input from aa-mix NID as well (if any)
706 void snd_hda_activate_path(struct hda_codec *codec, struct nid_path *path,
707 bool enable, bool add_aamix)
709 struct hda_gen_spec *spec = codec->spec;
713 path->active = false;
715 for (i = path->depth - 1; i >= 0; i--) {
716 hda_nid_t nid = path->path[i];
717 if (enable && spec->power_down_unused) {
718 /* make sure the widget is powered up */
719 if (!snd_hda_check_power_state(codec, nid, AC_PWRST_D0))
720 snd_hda_codec_write(codec, nid, 0,
721 AC_VERB_SET_POWER_STATE,
724 if (enable && path->multi[i])
725 snd_hda_codec_write_cache(codec, nid, 0,
726 AC_VERB_SET_CONNECT_SEL,
728 if (has_amp_in(codec, path, i))
729 activate_amp_in(codec, path, i, enable, add_aamix);
730 if (has_amp_out(codec, path, i))
731 activate_amp_out(codec, path, i, enable);
737 EXPORT_SYMBOL_HDA(snd_hda_activate_path);
739 /* if the given path is inactive, put widgets into D3 (only if suitable) */
740 static void path_power_down_sync(struct hda_codec *codec, struct nid_path *path)
742 struct hda_gen_spec *spec = codec->spec;
746 if (!spec->power_down_unused || path->active)
749 for (i = 0; i < path->depth; i++) {
750 hda_nid_t nid = path->path[i];
751 if (!snd_hda_check_power_state(codec, nid, AC_PWRST_D3)) {
752 snd_hda_codec_write(codec, nid, 0,
753 AC_VERB_SET_POWER_STATE,
761 snd_hda_codec_read(codec, path->path[0], 0,
762 AC_VERB_GET_POWER_STATE, 0);
766 /* turn on/off EAPD on the given pin */
767 static void set_pin_eapd(struct hda_codec *codec, hda_nid_t pin, bool enable)
769 struct hda_gen_spec *spec = codec->spec;
770 if (spec->own_eapd_ctl ||
771 !(snd_hda_query_pin_caps(codec, pin) & AC_PINCAP_EAPD))
775 snd_hda_codec_update_cache(codec, pin, 0,
776 AC_VERB_SET_EAPD_BTLENABLE,
777 enable ? 0x02 : 0x00);
780 /* re-initialize the path specified by the given path index */
781 static void resume_path_from_idx(struct hda_codec *codec, int path_idx)
783 struct nid_path *path = snd_hda_get_path_from_idx(codec, path_idx);
785 snd_hda_activate_path(codec, path, path->active, false);
790 * Helper functions for creating mixer ctl elements
798 static const struct snd_kcontrol_new control_templates[] = {
799 HDA_CODEC_VOLUME(NULL, 0, 0, 0),
800 HDA_CODEC_MUTE(NULL, 0, 0, 0),
801 HDA_BIND_MUTE(NULL, 0, 0, 0),
804 /* add dynamic controls from template */
805 static struct snd_kcontrol_new *
806 add_control(struct hda_gen_spec *spec, int type, const char *name,
807 int cidx, unsigned long val)
809 struct snd_kcontrol_new *knew;
811 knew = snd_hda_gen_add_kctl(spec, name, &control_templates[type]);
815 if (get_amp_nid_(val))
816 knew->subdevice = HDA_SUBDEV_AMP_FLAG;
817 knew->private_value = val;
821 static int add_control_with_pfx(struct hda_gen_spec *spec, int type,
822 const char *pfx, const char *dir,
823 const char *sfx, int cidx, unsigned long val)
826 snprintf(name, sizeof(name), "%s %s %s", pfx, dir, sfx);
827 if (!add_control(spec, type, name, cidx, val))
832 #define add_pb_vol_ctrl(spec, type, pfx, val) \
833 add_control_with_pfx(spec, type, pfx, "Playback", "Volume", 0, val)
834 #define add_pb_sw_ctrl(spec, type, pfx, val) \
835 add_control_with_pfx(spec, type, pfx, "Playback", "Switch", 0, val)
836 #define __add_pb_vol_ctrl(spec, type, pfx, cidx, val) \
837 add_control_with_pfx(spec, type, pfx, "Playback", "Volume", cidx, val)
838 #define __add_pb_sw_ctrl(spec, type, pfx, cidx, val) \
839 add_control_with_pfx(spec, type, pfx, "Playback", "Switch", cidx, val)
841 static int add_vol_ctl(struct hda_codec *codec, const char *pfx, int cidx,
842 unsigned int chs, struct nid_path *path)
847 val = path->ctls[NID_PATH_VOL_CTL];
850 val = amp_val_replace_channels(val, chs);
851 return __add_pb_vol_ctrl(codec->spec, HDA_CTL_WIDGET_VOL, pfx, cidx, val);
854 /* return the channel bits suitable for the given path->ctls[] */
855 static int get_default_ch_nums(struct hda_codec *codec, struct nid_path *path,
858 int chs = 1; /* mono (left only) */
860 hda_nid_t nid = get_amp_nid_(path->ctls[type]);
861 if (nid && (get_wcaps(codec, nid) & AC_WCAP_STEREO))
862 chs = 3; /* stereo */
867 static int add_stereo_vol(struct hda_codec *codec, const char *pfx, int cidx,
868 struct nid_path *path)
870 int chs = get_default_ch_nums(codec, path, NID_PATH_VOL_CTL);
871 return add_vol_ctl(codec, pfx, cidx, chs, path);
874 /* create a mute-switch for the given mixer widget;
875 * if it has multiple sources (e.g. DAC and loopback), create a bind-mute
877 static int add_sw_ctl(struct hda_codec *codec, const char *pfx, int cidx,
878 unsigned int chs, struct nid_path *path)
881 int type = HDA_CTL_WIDGET_MUTE;
885 val = path->ctls[NID_PATH_MUTE_CTL];
888 val = amp_val_replace_channels(val, chs);
889 if (get_amp_direction_(val) == HDA_INPUT) {
890 hda_nid_t nid = get_amp_nid_(val);
891 int nums = snd_hda_get_num_conns(codec, nid);
893 type = HDA_CTL_BIND_MUTE;
897 return __add_pb_sw_ctrl(codec->spec, type, pfx, cidx, val);
900 static int add_stereo_sw(struct hda_codec *codec, const char *pfx,
901 int cidx, struct nid_path *path)
903 int chs = get_default_ch_nums(codec, path, NID_PATH_MUTE_CTL);
904 return add_sw_ctl(codec, pfx, cidx, chs, path);
907 /* any ctl assigned to the path with the given index? */
908 static bool path_has_mixer(struct hda_codec *codec, int path_idx, int ctl_type)
910 struct nid_path *path = snd_hda_get_path_from_idx(codec, path_idx);
911 return path && path->ctls[ctl_type];
914 static const char * const channel_name[4] = {
915 "Front", "Surround", "CLFE", "Side"
918 /* give some appropriate ctl name prefix for the given line out channel */
919 static const char *get_line_out_pfx(struct hda_codec *codec, int ch,
920 int *index, int ctl_type)
922 struct hda_gen_spec *spec = codec->spec;
923 struct auto_pin_cfg *cfg = &spec->autocfg;
926 if (cfg->line_outs == 1 && !spec->multi_ios &&
927 !cfg->hp_outs && !cfg->speaker_outs)
928 return spec->vmaster_mute.hook ? "PCM" : "Master";
930 /* if there is really a single DAC used in the whole output paths,
931 * use it master (or "PCM" if a vmaster hook is present)
933 if (spec->multiout.num_dacs == 1 && !spec->mixer_nid &&
934 !spec->multiout.hp_out_nid[0] && !spec->multiout.extra_out_nid[0])
935 return spec->vmaster_mute.hook ? "PCM" : "Master";
937 /* multi-io channels */
938 if (ch >= cfg->line_outs)
939 return channel_name[ch];
941 switch (cfg->line_out_type) {
942 case AUTO_PIN_SPEAKER_OUT:
943 /* if the primary channel vol/mute is shared with HP volume,
944 * don't name it as Speaker
946 if (!ch && cfg->hp_outs &&
947 !path_has_mixer(codec, spec->hp_paths[0], ctl_type))
949 if (cfg->line_outs == 1)
951 if (cfg->line_outs == 2)
952 return ch ? "Bass Speaker" : "Speaker";
954 case AUTO_PIN_HP_OUT:
955 /* if the primary channel vol/mute is shared with spk volume,
956 * don't name it as Headphone
958 if (!ch && cfg->speaker_outs &&
959 !path_has_mixer(codec, spec->speaker_paths[0], ctl_type))
961 /* for multi-io case, only the primary out */
962 if (ch && spec->multi_ios)
968 /* for a single channel output, we don't have to name the channel */
969 if (cfg->line_outs == 1 && !spec->multi_ios)
972 if (ch >= ARRAY_SIZE(channel_name)) {
977 return channel_name[ch];
984 /* badness definition */
986 /* No primary DAC is found for the main output */
987 BAD_NO_PRIMARY_DAC = 0x10000,
988 /* No DAC is found for the extra output */
990 /* No possible multi-ios */
991 BAD_MULTI_IO = 0x120,
992 /* No individual DAC for extra output */
993 BAD_NO_EXTRA_DAC = 0x102,
994 /* No individual DAC for extra surrounds */
995 BAD_NO_EXTRA_SURR_DAC = 0x101,
996 /* Primary DAC shared with main surrounds */
997 BAD_SHARED_SURROUND = 0x100,
998 /* Primary DAC shared with main CLFE */
999 BAD_SHARED_CLFE = 0x10,
1000 /* Primary DAC shared with extra surrounds */
1001 BAD_SHARED_EXTRA_SURROUND = 0x10,
1002 /* Volume widget is shared */
1003 BAD_SHARED_VOL = 0x10,
1006 /* look for widgets in the given path which are appropriate for
1007 * volume and mute controls, and assign the values to ctls[].
1009 * When no appropriate widget is found in the path, the badness value
1010 * is incremented depending on the situation. The function returns the
1011 * total badness for both volume and mute controls.
1013 static int assign_out_path_ctls(struct hda_codec *codec, struct nid_path *path)
1020 return BAD_SHARED_VOL * 2;
1022 if (path->ctls[NID_PATH_VOL_CTL] ||
1023 path->ctls[NID_PATH_MUTE_CTL])
1024 return 0; /* already evaluated */
1026 nid = look_for_out_vol_nid(codec, path);
1028 val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
1029 if (is_ctl_used(codec, val, NID_PATH_VOL_CTL))
1030 badness += BAD_SHARED_VOL;
1032 path->ctls[NID_PATH_VOL_CTL] = val;
1034 badness += BAD_SHARED_VOL;
1035 nid = look_for_out_mute_nid(codec, path);
1037 unsigned int wid_type = get_wcaps_type(get_wcaps(codec, nid));
1038 if (wid_type == AC_WID_PIN || wid_type == AC_WID_AUD_OUT ||
1039 nid_has_mute(codec, nid, HDA_OUTPUT))
1040 val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
1042 val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT);
1043 if (is_ctl_used(codec, val, NID_PATH_MUTE_CTL))
1044 badness += BAD_SHARED_VOL;
1046 path->ctls[NID_PATH_MUTE_CTL] = val;
1048 badness += BAD_SHARED_VOL;
1052 struct badness_table {
1053 int no_primary_dac; /* no primary DAC */
1054 int no_dac; /* no secondary DACs */
1055 int shared_primary; /* primary DAC is shared with main output */
1056 int shared_surr; /* secondary DAC shared with main or primary */
1057 int shared_clfe; /* third DAC shared with main or primary */
1058 int shared_surr_main; /* secondary DAC sahred with main/DAC0 */
1061 static struct badness_table main_out_badness = {
1062 .no_primary_dac = BAD_NO_PRIMARY_DAC,
1063 .no_dac = BAD_NO_DAC,
1064 .shared_primary = BAD_NO_PRIMARY_DAC,
1065 .shared_surr = BAD_SHARED_SURROUND,
1066 .shared_clfe = BAD_SHARED_CLFE,
1067 .shared_surr_main = BAD_SHARED_SURROUND,
1070 static struct badness_table extra_out_badness = {
1071 .no_primary_dac = BAD_NO_DAC,
1072 .no_dac = BAD_NO_DAC,
1073 .shared_primary = BAD_NO_EXTRA_DAC,
1074 .shared_surr = BAD_SHARED_EXTRA_SURROUND,
1075 .shared_clfe = BAD_SHARED_EXTRA_SURROUND,
1076 .shared_surr_main = BAD_NO_EXTRA_SURR_DAC,
1079 /* get the DAC of the primary output corresponding to the given array index */
1080 static hda_nid_t get_primary_out(struct hda_codec *codec, int idx)
1082 struct hda_gen_spec *spec = codec->spec;
1083 struct auto_pin_cfg *cfg = &spec->autocfg;
1085 if (cfg->line_outs > idx)
1086 return spec->private_dac_nids[idx];
1087 idx -= cfg->line_outs;
1088 if (spec->multi_ios > idx)
1089 return spec->multi_io[idx].dac;
1093 /* return the DAC if it's reachable, otherwise zero */
1094 static inline hda_nid_t try_dac(struct hda_codec *codec,
1095 hda_nid_t dac, hda_nid_t pin)
1097 return is_reachable_path(codec, dac, pin) ? dac : 0;
1100 /* try to assign DACs to pins and return the resultant badness */
1101 static int try_assign_dacs(struct hda_codec *codec, int num_outs,
1102 const hda_nid_t *pins, hda_nid_t *dacs,
1104 const struct badness_table *bad)
1106 struct hda_gen_spec *spec = codec->spec;
1114 for (i = 0; i < num_outs; i++) {
1115 struct nid_path *path;
1116 hda_nid_t pin = pins[i];
1118 path = snd_hda_get_path_from_idx(codec, path_idx[i]);
1120 badness += assign_out_path_ctls(codec, path);
1124 dacs[i] = look_for_dac(codec, pin, false);
1125 if (!dacs[i] && !i) {
1126 /* try to steal the DAC of surrounds for the front */
1127 for (j = 1; j < num_outs; j++) {
1128 if (is_reachable_path(codec, dacs[j], pin)) {
1131 invalidate_nid_path(codec, path_idx[j]);
1140 dac = try_dac(codec, get_primary_out(codec, i), pin);
1142 dac = try_dac(codec, dacs[0], pin);
1144 dac = try_dac(codec, get_primary_out(codec, i), pin);
1147 badness += bad->shared_primary;
1149 badness += bad->shared_surr;
1151 badness += bad->shared_clfe;
1152 } else if (is_reachable_path(codec, spec->private_dac_nids[0], pin)) {
1153 dac = spec->private_dac_nids[0];
1154 badness += bad->shared_surr_main;
1156 badness += bad->no_primary_dac;
1158 badness += bad->no_dac;
1162 path = snd_hda_add_new_path(codec, dac, pin, -spec->mixer_nid);
1163 if (!path && !i && spec->mixer_nid) {
1164 /* try with aamix */
1165 path = snd_hda_add_new_path(codec, dac, pin, 0);
1169 badness += bad->no_dac;
1171 /* print_nid_path("output", path); */
1172 path->active = true;
1173 path_idx[i] = snd_hda_get_path_idx(codec, path);
1174 badness += assign_out_path_ctls(codec, path);
1181 /* return NID if the given pin has only a single connection to a certain DAC */
1182 static hda_nid_t get_dac_if_single(struct hda_codec *codec, hda_nid_t pin)
1184 struct hda_gen_spec *spec = codec->spec;
1186 hda_nid_t nid_found = 0;
1188 for (i = 0; i < spec->num_all_dacs; i++) {
1189 hda_nid_t nid = spec->all_dacs[i];
1190 if (!nid || is_dac_already_used(codec, nid))
1192 if (is_reachable_path(codec, nid, pin)) {
1201 /* check whether the given pin can be a multi-io pin */
1202 static bool can_be_multiio_pin(struct hda_codec *codec,
1203 unsigned int location, hda_nid_t nid)
1205 unsigned int defcfg, caps;
1207 defcfg = snd_hda_codec_get_pincfg(codec, nid);
1208 if (get_defcfg_connect(defcfg) != AC_JACK_PORT_COMPLEX)
1210 if (location && get_defcfg_location(defcfg) != location)
1212 caps = snd_hda_query_pin_caps(codec, nid);
1213 if (!(caps & AC_PINCAP_OUT))
1218 /* count the number of input pins that are capable to be multi-io */
1219 static int count_multiio_pins(struct hda_codec *codec, hda_nid_t reference_pin)
1221 struct hda_gen_spec *spec = codec->spec;
1222 struct auto_pin_cfg *cfg = &spec->autocfg;
1223 unsigned int defcfg = snd_hda_codec_get_pincfg(codec, reference_pin);
1224 unsigned int location = get_defcfg_location(defcfg);
1228 for (type = AUTO_PIN_LINE_IN; type >= AUTO_PIN_MIC; type--) {
1229 for (i = 0; i < cfg->num_inputs; i++) {
1230 if (cfg->inputs[i].type != type)
1232 if (can_be_multiio_pin(codec, location,
1233 cfg->inputs[i].pin))
1243 * When hardwired is set, try to fill ony hardwired pins, and returns
1244 * zero if any pins are filled, non-zero if nothing found.
1245 * When hardwired is off, try to fill possible input pins, and returns
1246 * the badness value.
1248 static int fill_multi_ios(struct hda_codec *codec,
1249 hda_nid_t reference_pin,
1252 struct hda_gen_spec *spec = codec->spec;
1253 struct auto_pin_cfg *cfg = &spec->autocfg;
1254 int type, i, j, num_pins, old_pins;
1255 unsigned int defcfg = snd_hda_codec_get_pincfg(codec, reference_pin);
1256 unsigned int location = get_defcfg_location(defcfg);
1258 struct nid_path *path;
1260 old_pins = spec->multi_ios;
1264 num_pins = count_multiio_pins(codec, reference_pin);
1268 for (type = AUTO_PIN_LINE_IN; type >= AUTO_PIN_MIC; type--) {
1269 for (i = 0; i < cfg->num_inputs; i++) {
1270 hda_nid_t nid = cfg->inputs[i].pin;
1273 if (cfg->inputs[i].type != type)
1275 if (!can_be_multiio_pin(codec, location, nid))
1277 for (j = 0; j < spec->multi_ios; j++) {
1278 if (nid == spec->multi_io[j].pin)
1281 if (j < spec->multi_ios)
1285 dac = get_dac_if_single(codec, nid);
1287 dac = look_for_dac(codec, nid, false);
1292 path = snd_hda_add_new_path(codec, dac, nid,
1298 /* print_nid_path("multiio", path); */
1299 spec->multi_io[spec->multi_ios].pin = nid;
1300 spec->multi_io[spec->multi_ios].dac = dac;
1301 spec->out_paths[cfg->line_outs + spec->multi_ios] =
1302 snd_hda_get_path_idx(codec, path);
1304 if (spec->multi_ios >= 2)
1310 badness = BAD_MULTI_IO;
1311 if (old_pins == spec->multi_ios) {
1313 return 1; /* nothing found */
1315 return badness; /* no badness if nothing found */
1317 if (!hardwired && spec->multi_ios < 2) {
1318 /* cancel newly assigned paths */
1319 spec->paths.used -= spec->multi_ios - old_pins;
1320 spec->multi_ios = old_pins;
1324 /* assign volume and mute controls */
1325 for (i = old_pins; i < spec->multi_ios; i++) {
1326 path = snd_hda_get_path_from_idx(codec, spec->out_paths[cfg->line_outs + i]);
1327 badness += assign_out_path_ctls(codec, path);
1333 /* map DACs for all pins in the list if they are single connections */
1334 static bool map_singles(struct hda_codec *codec, int outs,
1335 const hda_nid_t *pins, hda_nid_t *dacs, int *path_idx)
1337 struct hda_gen_spec *spec = codec->spec;
1340 for (i = 0; i < outs; i++) {
1341 struct nid_path *path;
1345 dac = get_dac_if_single(codec, pins[i]);
1348 path = snd_hda_add_new_path(codec, dac, pins[i],
1350 if (!path && !i && spec->mixer_nid)
1351 path = snd_hda_add_new_path(codec, dac, pins[i], 0);
1355 /* print_nid_path("output", path); */
1356 path->active = true;
1357 path_idx[i] = snd_hda_get_path_idx(codec, path);
1363 /* create a new path including aamix if available, and return its index */
1364 static int check_aamix_out_path(struct hda_codec *codec, int path_idx)
1366 struct hda_gen_spec *spec = codec->spec;
1367 struct nid_path *path;
1370 path = snd_hda_get_path_from_idx(codec, path_idx);
1371 if (!path || !path->depth ||
1372 is_nid_contained(path, spec->mixer_nid))
1374 dac = path->path[0];
1375 pin = path->path[path->depth - 1];
1376 path = snd_hda_add_new_path(codec, dac, pin, spec->mixer_nid);
1378 if (dac != spec->multiout.dac_nids[0])
1379 dac = spec->multiout.dac_nids[0];
1380 else if (spec->multiout.hp_out_nid[0])
1381 dac = spec->multiout.hp_out_nid[0];
1382 else if (spec->multiout.extra_out_nid[0])
1383 dac = spec->multiout.extra_out_nid[0];
1385 path = snd_hda_add_new_path(codec, dac, pin,
1390 /* print_nid_path("output-aamix", path); */
1391 path->active = false; /* unused as default */
1392 return snd_hda_get_path_idx(codec, path);
1395 /* fill the empty entries in the dac array for speaker/hp with the
1396 * shared dac pointed by the paths
1398 static void refill_shared_dacs(struct hda_codec *codec, int num_outs,
1399 hda_nid_t *dacs, int *path_idx)
1401 struct nid_path *path;
1404 for (i = 0; i < num_outs; i++) {
1407 path = snd_hda_get_path_from_idx(codec, path_idx[i]);
1410 dacs[i] = path->path[0];
1414 /* fill in the dac_nids table from the parsed pin configuration */
1415 static int fill_and_eval_dacs(struct hda_codec *codec,
1416 bool fill_hardwired,
1417 bool fill_mio_first)
1419 struct hda_gen_spec *spec = codec->spec;
1420 struct auto_pin_cfg *cfg = &spec->autocfg;
1421 int i, err, badness;
1423 /* set num_dacs once to full for look_for_dac() */
1424 spec->multiout.num_dacs = cfg->line_outs;
1425 spec->multiout.dac_nids = spec->private_dac_nids;
1426 memset(spec->private_dac_nids, 0, sizeof(spec->private_dac_nids));
1427 memset(spec->multiout.hp_out_nid, 0, sizeof(spec->multiout.hp_out_nid));
1428 memset(spec->multiout.extra_out_nid, 0, sizeof(spec->multiout.extra_out_nid));
1429 spec->multi_ios = 0;
1430 snd_array_free(&spec->paths);
1432 /* clear path indices */
1433 memset(spec->out_paths, 0, sizeof(spec->out_paths));
1434 memset(spec->hp_paths, 0, sizeof(spec->hp_paths));
1435 memset(spec->speaker_paths, 0, sizeof(spec->speaker_paths));
1436 memset(spec->aamix_out_paths, 0, sizeof(spec->aamix_out_paths));
1437 memset(spec->digout_paths, 0, sizeof(spec->digout_paths));
1438 memset(spec->input_paths, 0, sizeof(spec->input_paths));
1439 memset(spec->loopback_paths, 0, sizeof(spec->loopback_paths));
1440 memset(&spec->digin_path, 0, sizeof(spec->digin_path));
1444 /* fill hard-wired DACs first */
1445 if (fill_hardwired) {
1448 mapped = map_singles(codec, cfg->line_outs,
1450 spec->private_dac_nids,
1452 mapped |= map_singles(codec, cfg->hp_outs,
1454 spec->multiout.hp_out_nid,
1456 mapped |= map_singles(codec, cfg->speaker_outs,
1458 spec->multiout.extra_out_nid,
1459 spec->speaker_paths);
1460 if (fill_mio_first && cfg->line_outs == 1 &&
1461 cfg->line_out_type != AUTO_PIN_SPEAKER_OUT) {
1462 err = fill_multi_ios(codec, cfg->line_out_pins[0], true);
1469 badness += try_assign_dacs(codec, cfg->line_outs, cfg->line_out_pins,
1470 spec->private_dac_nids, spec->out_paths,
1473 if (fill_mio_first &&
1474 cfg->line_outs == 1 && cfg->line_out_type != AUTO_PIN_SPEAKER_OUT) {
1475 /* try to fill multi-io first */
1476 err = fill_multi_ios(codec, cfg->line_out_pins[0], false);
1479 /* we don't count badness at this stage yet */
1482 if (cfg->line_out_type != AUTO_PIN_HP_OUT) {
1483 err = try_assign_dacs(codec, cfg->hp_outs, cfg->hp_pins,
1484 spec->multiout.hp_out_nid,
1486 &extra_out_badness);
1491 if (cfg->line_out_type != AUTO_PIN_SPEAKER_OUT) {
1492 err = try_assign_dacs(codec, cfg->speaker_outs,
1494 spec->multiout.extra_out_nid,
1495 spec->speaker_paths,
1496 &extra_out_badness);
1501 if (cfg->line_outs == 1 && cfg->line_out_type != AUTO_PIN_SPEAKER_OUT) {
1502 err = fill_multi_ios(codec, cfg->line_out_pins[0], false);
1508 if (spec->mixer_nid) {
1509 spec->aamix_out_paths[0] =
1510 check_aamix_out_path(codec, spec->out_paths[0]);
1511 if (cfg->line_out_type != AUTO_PIN_HP_OUT)
1512 spec->aamix_out_paths[1] =
1513 check_aamix_out_path(codec, spec->hp_paths[0]);
1514 if (cfg->line_out_type != AUTO_PIN_SPEAKER_OUT)
1515 spec->aamix_out_paths[2] =
1516 check_aamix_out_path(codec, spec->speaker_paths[0]);
1519 if (cfg->hp_outs && cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
1520 if (count_multiio_pins(codec, cfg->hp_pins[0]) >= 2)
1521 spec->multi_ios = 1; /* give badness */
1523 /* re-count num_dacs and squash invalid entries */
1524 spec->multiout.num_dacs = 0;
1525 for (i = 0; i < cfg->line_outs; i++) {
1526 if (spec->private_dac_nids[i])
1527 spec->multiout.num_dacs++;
1529 memmove(spec->private_dac_nids + i,
1530 spec->private_dac_nids + i + 1,
1531 sizeof(hda_nid_t) * (cfg->line_outs - i - 1));
1532 spec->private_dac_nids[cfg->line_outs - 1] = 0;
1536 spec->ext_channel_count = spec->min_channel_count =
1537 spec->multiout.num_dacs * 2;
1539 if (spec->multi_ios == 2) {
1540 for (i = 0; i < 2; i++)
1541 spec->private_dac_nids[spec->multiout.num_dacs++] =
1542 spec->multi_io[i].dac;
1543 } else if (spec->multi_ios) {
1544 spec->multi_ios = 0;
1545 badness += BAD_MULTI_IO;
1548 /* re-fill the shared DAC for speaker / headphone */
1549 if (cfg->line_out_type != AUTO_PIN_HP_OUT)
1550 refill_shared_dacs(codec, cfg->hp_outs,
1551 spec->multiout.hp_out_nid,
1553 if (cfg->line_out_type != AUTO_PIN_SPEAKER_OUT)
1554 refill_shared_dacs(codec, cfg->speaker_outs,
1555 spec->multiout.extra_out_nid,
1556 spec->speaker_paths);
1561 #define DEBUG_BADNESS
1563 #ifdef DEBUG_BADNESS
1564 #define debug_badness snd_printdd
1566 #define debug_badness(...)
1569 #ifdef DEBUG_BADNESS
1570 static inline void print_nid_path_idx(struct hda_codec *codec,
1571 const char *pfx, int idx)
1573 struct nid_path *path;
1575 path = snd_hda_get_path_from_idx(codec, idx);
1577 print_nid_path(pfx, path);
1580 static void debug_show_configs(struct hda_codec *codec,
1581 struct auto_pin_cfg *cfg)
1583 struct hda_gen_spec *spec = codec->spec;
1584 static const char * const lo_type[3] = { "LO", "SP", "HP" };
1587 debug_badness("multi_outs = %x/%x/%x/%x : %x/%x/%x/%x (type %s)\n",
1588 cfg->line_out_pins[0], cfg->line_out_pins[1],
1589 cfg->line_out_pins[2], cfg->line_out_pins[3],
1590 spec->multiout.dac_nids[0],
1591 spec->multiout.dac_nids[1],
1592 spec->multiout.dac_nids[2],
1593 spec->multiout.dac_nids[3],
1594 lo_type[cfg->line_out_type]);
1595 for (i = 0; i < cfg->line_outs; i++)
1596 print_nid_path_idx(codec, " out", spec->out_paths[i]);
1597 if (spec->multi_ios > 0)
1598 debug_badness("multi_ios(%d) = %x/%x : %x/%x\n",
1600 spec->multi_io[0].pin, spec->multi_io[1].pin,
1601 spec->multi_io[0].dac, spec->multi_io[1].dac);
1602 for (i = 0; i < spec->multi_ios; i++)
1603 print_nid_path_idx(codec, " mio",
1604 spec->out_paths[cfg->line_outs + i]);
1606 debug_badness("hp_outs = %x/%x/%x/%x : %x/%x/%x/%x\n",
1607 cfg->hp_pins[0], cfg->hp_pins[1],
1608 cfg->hp_pins[2], cfg->hp_pins[3],
1609 spec->multiout.hp_out_nid[0],
1610 spec->multiout.hp_out_nid[1],
1611 spec->multiout.hp_out_nid[2],
1612 spec->multiout.hp_out_nid[3]);
1613 for (i = 0; i < cfg->hp_outs; i++)
1614 print_nid_path_idx(codec, " hp ", spec->hp_paths[i]);
1615 if (cfg->speaker_outs)
1616 debug_badness("spk_outs = %x/%x/%x/%x : %x/%x/%x/%x\n",
1617 cfg->speaker_pins[0], cfg->speaker_pins[1],
1618 cfg->speaker_pins[2], cfg->speaker_pins[3],
1619 spec->multiout.extra_out_nid[0],
1620 spec->multiout.extra_out_nid[1],
1621 spec->multiout.extra_out_nid[2],
1622 spec->multiout.extra_out_nid[3]);
1623 for (i = 0; i < cfg->speaker_outs; i++)
1624 print_nid_path_idx(codec, " spk", spec->speaker_paths[i]);
1625 for (i = 0; i < 3; i++)
1626 print_nid_path_idx(codec, " mix", spec->aamix_out_paths[i]);
1629 #define debug_show_configs(codec, cfg) /* NOP */
1632 /* find all available DACs of the codec */
1633 static void fill_all_dac_nids(struct hda_codec *codec)
1635 struct hda_gen_spec *spec = codec->spec;
1637 hda_nid_t nid = codec->start_nid;
1639 spec->num_all_dacs = 0;
1640 memset(spec->all_dacs, 0, sizeof(spec->all_dacs));
1641 for (i = 0; i < codec->num_nodes; i++, nid++) {
1642 if (get_wcaps_type(get_wcaps(codec, nid)) != AC_WID_AUD_OUT)
1644 if (spec->num_all_dacs >= ARRAY_SIZE(spec->all_dacs)) {
1645 snd_printk(KERN_ERR "hda: Too many DACs!\n");
1648 spec->all_dacs[spec->num_all_dacs++] = nid;
1652 static int parse_output_paths(struct hda_codec *codec)
1654 struct hda_gen_spec *spec = codec->spec;
1655 struct auto_pin_cfg *cfg = &spec->autocfg;
1656 struct auto_pin_cfg *best_cfg;
1658 int best_badness = INT_MAX;
1660 bool fill_hardwired = true, fill_mio_first = true;
1661 bool best_wired = true, best_mio = true;
1662 bool hp_spk_swapped = false;
1664 best_cfg = kmalloc(sizeof(*best_cfg), GFP_KERNEL);
1670 badness = fill_and_eval_dacs(codec, fill_hardwired,
1676 debug_badness("==> lo_type=%d, wired=%d, mio=%d, badness=0x%x\n",
1677 cfg->line_out_type, fill_hardwired, fill_mio_first,
1679 debug_show_configs(codec, cfg);
1680 if (badness < best_badness) {
1681 best_badness = badness;
1683 best_wired = fill_hardwired;
1684 best_mio = fill_mio_first;
1688 fill_mio_first = !fill_mio_first;
1689 if (!fill_mio_first)
1691 fill_hardwired = !fill_hardwired;
1692 if (!fill_hardwired)
1696 hp_spk_swapped = true;
1697 if (cfg->speaker_outs > 0 &&
1698 cfg->line_out_type == AUTO_PIN_HP_OUT) {
1699 cfg->hp_outs = cfg->line_outs;
1700 memcpy(cfg->hp_pins, cfg->line_out_pins,
1701 sizeof(cfg->hp_pins));
1702 cfg->line_outs = cfg->speaker_outs;
1703 memcpy(cfg->line_out_pins, cfg->speaker_pins,
1704 sizeof(cfg->speaker_pins));
1705 cfg->speaker_outs = 0;
1706 memset(cfg->speaker_pins, 0, sizeof(cfg->speaker_pins));
1707 cfg->line_out_type = AUTO_PIN_SPEAKER_OUT;
1708 fill_hardwired = true;
1711 if (cfg->hp_outs > 0 &&
1712 cfg->line_out_type == AUTO_PIN_SPEAKER_OUT) {
1713 cfg->speaker_outs = cfg->line_outs;
1714 memcpy(cfg->speaker_pins, cfg->line_out_pins,
1715 sizeof(cfg->speaker_pins));
1716 cfg->line_outs = cfg->hp_outs;
1717 memcpy(cfg->line_out_pins, cfg->hp_pins,
1718 sizeof(cfg->hp_pins));
1720 memset(cfg->hp_pins, 0, sizeof(cfg->hp_pins));
1721 cfg->line_out_type = AUTO_PIN_HP_OUT;
1722 fill_hardwired = true;
1729 debug_badness("==> restoring best_cfg\n");
1731 fill_and_eval_dacs(codec, best_wired, best_mio);
1733 debug_badness("==> Best config: lo_type=%d, wired=%d, mio=%d\n",
1734 cfg->line_out_type, best_wired, best_mio);
1735 debug_show_configs(codec, cfg);
1737 if (cfg->line_out_pins[0]) {
1738 struct nid_path *path;
1739 path = snd_hda_get_path_from_idx(codec, spec->out_paths[0]);
1741 spec->vmaster_nid = look_for_out_vol_nid(codec, path);
1742 if (spec->vmaster_nid)
1743 snd_hda_set_vmaster_tlv(codec, spec->vmaster_nid,
1744 HDA_OUTPUT, spec->vmaster_tlv);
1747 /* set initial pinctl targets */
1748 if (spec->prefer_hp_amp || cfg->line_out_type == AUTO_PIN_HP_OUT)
1752 set_pin_targets(codec, cfg->line_outs, cfg->line_out_pins, val);
1753 if (cfg->line_out_type != AUTO_PIN_HP_OUT)
1754 set_pin_targets(codec, cfg->hp_outs, cfg->hp_pins, PIN_HP);
1755 if (cfg->line_out_type != AUTO_PIN_SPEAKER_OUT) {
1756 val = spec->prefer_hp_amp ? PIN_HP : PIN_OUT;
1757 set_pin_targets(codec, cfg->speaker_outs,
1758 cfg->speaker_pins, val);
1765 /* add playback controls from the parsed DAC table */
1766 static int create_multi_out_ctls(struct hda_codec *codec,
1767 const struct auto_pin_cfg *cfg)
1769 struct hda_gen_spec *spec = codec->spec;
1770 int i, err, noutputs;
1772 noutputs = cfg->line_outs;
1773 if (spec->multi_ios > 0 && cfg->line_outs < 3)
1774 noutputs += spec->multi_ios;
1776 for (i = 0; i < noutputs; i++) {
1779 struct nid_path *path;
1781 path = snd_hda_get_path_from_idx(codec, spec->out_paths[i]);
1785 name = get_line_out_pfx(codec, i, &index, NID_PATH_VOL_CTL);
1786 if (!name || !strcmp(name, "CLFE")) {
1788 err = add_vol_ctl(codec, "Center", 0, 1, path);
1791 err = add_vol_ctl(codec, "LFE", 0, 2, path);
1795 err = add_stereo_vol(codec, name, index, path);
1800 name = get_line_out_pfx(codec, i, &index, NID_PATH_MUTE_CTL);
1801 if (!name || !strcmp(name, "CLFE")) {
1802 err = add_sw_ctl(codec, "Center", 0, 1, path);
1805 err = add_sw_ctl(codec, "LFE", 0, 2, path);
1809 err = add_stereo_sw(codec, name, index, path);
1817 static int create_extra_out(struct hda_codec *codec, int path_idx,
1818 const char *pfx, int cidx)
1820 struct nid_path *path;
1823 path = snd_hda_get_path_from_idx(codec, path_idx);
1826 err = add_stereo_vol(codec, pfx, cidx, path);
1829 err = add_stereo_sw(codec, pfx, cidx, path);
1835 /* add playback controls for speaker and HP outputs */
1836 static int create_extra_outs(struct hda_codec *codec, int num_pins,
1837 const int *paths, const char *pfx)
1841 for (i = 0; i < num_pins; i++) {
1846 if (num_pins == 2 && i == 1 && !strcmp(pfx, "Speaker"))
1847 name = "Bass Speaker";
1848 else if (num_pins >= 3) {
1849 snprintf(tmp, sizeof(tmp), "%s %s",
1850 pfx, channel_name[i]);
1856 err = create_extra_out(codec, paths[i], name, idx);
1863 static int create_hp_out_ctls(struct hda_codec *codec)
1865 struct hda_gen_spec *spec = codec->spec;
1866 return create_extra_outs(codec, spec->autocfg.hp_outs,
1871 static int create_speaker_out_ctls(struct hda_codec *codec)
1873 struct hda_gen_spec *spec = codec->spec;
1874 return create_extra_outs(codec, spec->autocfg.speaker_outs,
1875 spec->speaker_paths,
1880 * independent HP controls
1883 static int indep_hp_info(struct snd_kcontrol *kcontrol,
1884 struct snd_ctl_elem_info *uinfo)
1886 return snd_hda_enum_bool_helper_info(kcontrol, uinfo);
1889 static int indep_hp_get(struct snd_kcontrol *kcontrol,
1890 struct snd_ctl_elem_value *ucontrol)
1892 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1893 struct hda_gen_spec *spec = codec->spec;
1894 ucontrol->value.enumerated.item[0] = spec->indep_hp_enabled;
1898 static void update_aamix_paths(struct hda_codec *codec, bool do_mix,
1899 int nomix_path_idx, int mix_path_idx,
1902 static int indep_hp_put(struct snd_kcontrol *kcontrol,
1903 struct snd_ctl_elem_value *ucontrol)
1905 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1906 struct hda_gen_spec *spec = codec->spec;
1907 unsigned int select = ucontrol->value.enumerated.item[0];
1910 mutex_lock(&spec->pcm_mutex);
1911 if (spec->active_streams) {
1916 if (spec->indep_hp_enabled != select) {
1918 if (spec->autocfg.line_out_type == AUTO_PIN_HP_OUT)
1919 dacp = &spec->private_dac_nids[0];
1921 dacp = &spec->multiout.hp_out_nid[0];
1923 /* update HP aamix paths in case it conflicts with indep HP */
1924 if (spec->have_aamix_ctl) {
1925 if (spec->autocfg.line_out_type == AUTO_PIN_HP_OUT)
1926 update_aamix_paths(codec, spec->aamix_mode,
1928 spec->aamix_out_paths[0],
1929 spec->autocfg.line_out_type);
1931 update_aamix_paths(codec, spec->aamix_mode,
1933 spec->aamix_out_paths[1],
1937 spec->indep_hp_enabled = select;
1938 if (spec->indep_hp_enabled)
1941 *dacp = spec->alt_dac_nid;
1943 /* update HP auto-mute state too */
1944 if (spec->hp_automute_hook)
1945 spec->hp_automute_hook(codec, NULL);
1947 snd_hda_gen_hp_automute(codec, NULL);
1952 mutex_unlock(&spec->pcm_mutex);
1956 static const struct snd_kcontrol_new indep_hp_ctl = {
1957 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1958 .name = "Independent HP",
1959 .info = indep_hp_info,
1960 .get = indep_hp_get,
1961 .put = indep_hp_put,
1965 static int create_indep_hp_ctls(struct hda_codec *codec)
1967 struct hda_gen_spec *spec = codec->spec;
1970 if (!spec->indep_hp)
1972 if (spec->autocfg.line_out_type == AUTO_PIN_HP_OUT)
1973 dac = spec->multiout.dac_nids[0];
1975 dac = spec->multiout.hp_out_nid[0];
1981 spec->indep_hp_enabled = false;
1982 spec->alt_dac_nid = dac;
1983 if (!snd_hda_gen_add_kctl(spec, NULL, &indep_hp_ctl))
1989 * channel mode enum control
1992 static int ch_mode_info(struct snd_kcontrol *kcontrol,
1993 struct snd_ctl_elem_info *uinfo)
1995 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1996 struct hda_gen_spec *spec = codec->spec;
1999 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
2001 uinfo->value.enumerated.items = spec->multi_ios + 1;
2002 if (uinfo->value.enumerated.item > spec->multi_ios)
2003 uinfo->value.enumerated.item = spec->multi_ios;
2004 chs = uinfo->value.enumerated.item * 2 + spec->min_channel_count;
2005 sprintf(uinfo->value.enumerated.name, "%dch", chs);
2009 static int ch_mode_get(struct snd_kcontrol *kcontrol,
2010 struct snd_ctl_elem_value *ucontrol)
2012 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2013 struct hda_gen_spec *spec = codec->spec;
2014 ucontrol->value.enumerated.item[0] =
2015 (spec->ext_channel_count - spec->min_channel_count) / 2;
2019 static inline struct nid_path *
2020 get_multiio_path(struct hda_codec *codec, int idx)
2022 struct hda_gen_spec *spec = codec->spec;
2023 return snd_hda_get_path_from_idx(codec,
2024 spec->out_paths[spec->autocfg.line_outs + idx]);
2027 static void update_automute_all(struct hda_codec *codec);
2029 static int set_multi_io(struct hda_codec *codec, int idx, bool output)
2031 struct hda_gen_spec *spec = codec->spec;
2032 hda_nid_t nid = spec->multi_io[idx].pin;
2033 struct nid_path *path;
2035 path = get_multiio_path(codec, idx);
2039 if (path->active == output)
2043 set_pin_target(codec, nid, PIN_OUT, true);
2044 snd_hda_activate_path(codec, path, true, true);
2045 set_pin_eapd(codec, nid, true);
2047 set_pin_eapd(codec, nid, false);
2048 snd_hda_activate_path(codec, path, false, true);
2049 set_pin_target(codec, nid, spec->multi_io[idx].ctl_in, true);
2050 path_power_down_sync(codec, path);
2053 /* update jack retasking in case it modifies any of them */
2054 update_automute_all(codec);
2059 static int ch_mode_put(struct snd_kcontrol *kcontrol,
2060 struct snd_ctl_elem_value *ucontrol)
2062 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2063 struct hda_gen_spec *spec = codec->spec;
2066 ch = ucontrol->value.enumerated.item[0];
2067 if (ch < 0 || ch > spec->multi_ios)
2069 if (ch == (spec->ext_channel_count - spec->min_channel_count) / 2)
2071 spec->ext_channel_count = ch * 2 + spec->min_channel_count;
2072 for (i = 0; i < spec->multi_ios; i++)
2073 set_multi_io(codec, i, i < ch);
2074 spec->multiout.max_channels = max(spec->ext_channel_count,
2075 spec->const_channel_count);
2076 if (spec->need_dac_fix)
2077 spec->multiout.num_dacs = spec->multiout.max_channels / 2;
2081 static const struct snd_kcontrol_new channel_mode_enum = {
2082 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2083 .name = "Channel Mode",
2084 .info = ch_mode_info,
2089 static int create_multi_channel_mode(struct hda_codec *codec)
2091 struct hda_gen_spec *spec = codec->spec;
2093 if (spec->multi_ios > 0) {
2094 if (!snd_hda_gen_add_kctl(spec, NULL, &channel_mode_enum))
2101 * aamix loopback enable/disable switch
2104 #define loopback_mixing_info indep_hp_info
2106 static int loopback_mixing_get(struct snd_kcontrol *kcontrol,
2107 struct snd_ctl_elem_value *ucontrol)
2109 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2110 struct hda_gen_spec *spec = codec->spec;
2111 ucontrol->value.enumerated.item[0] = spec->aamix_mode;
2115 static void update_aamix_paths(struct hda_codec *codec, bool do_mix,
2116 int nomix_path_idx, int mix_path_idx,
2119 struct hda_gen_spec *spec = codec->spec;
2120 struct nid_path *nomix_path, *mix_path;
2122 nomix_path = snd_hda_get_path_from_idx(codec, nomix_path_idx);
2123 mix_path = snd_hda_get_path_from_idx(codec, mix_path_idx);
2124 if (!nomix_path || !mix_path)
2127 /* if HP aamix path is driven from a different DAC and the
2128 * independent HP mode is ON, can't turn on aamix path
2130 if (out_type == AUTO_PIN_HP_OUT && spec->indep_hp_enabled &&
2131 mix_path->path[0] != spec->alt_dac_nid)
2135 snd_hda_activate_path(codec, nomix_path, false, true);
2136 snd_hda_activate_path(codec, mix_path, true, true);
2137 path_power_down_sync(codec, nomix_path);
2139 snd_hda_activate_path(codec, mix_path, false, true);
2140 snd_hda_activate_path(codec, nomix_path, true, true);
2141 path_power_down_sync(codec, mix_path);
2145 static int loopback_mixing_put(struct snd_kcontrol *kcontrol,
2146 struct snd_ctl_elem_value *ucontrol)
2148 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2149 struct hda_gen_spec *spec = codec->spec;
2150 unsigned int val = ucontrol->value.enumerated.item[0];
2152 if (val == spec->aamix_mode)
2154 spec->aamix_mode = val;
2155 update_aamix_paths(codec, val, spec->out_paths[0],
2156 spec->aamix_out_paths[0],
2157 spec->autocfg.line_out_type);
2158 update_aamix_paths(codec, val, spec->hp_paths[0],
2159 spec->aamix_out_paths[1],
2161 update_aamix_paths(codec, val, spec->speaker_paths[0],
2162 spec->aamix_out_paths[2],
2163 AUTO_PIN_SPEAKER_OUT);
2167 static const struct snd_kcontrol_new loopback_mixing_enum = {
2168 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2169 .name = "Loopback Mixing",
2170 .info = loopback_mixing_info,
2171 .get = loopback_mixing_get,
2172 .put = loopback_mixing_put,
2175 static int create_loopback_mixing_ctl(struct hda_codec *codec)
2177 struct hda_gen_spec *spec = codec->spec;
2179 if (!spec->mixer_nid)
2181 if (!(spec->aamix_out_paths[0] || spec->aamix_out_paths[1] ||
2182 spec->aamix_out_paths[2]))
2184 if (!snd_hda_gen_add_kctl(spec, NULL, &loopback_mixing_enum))
2186 spec->have_aamix_ctl = 1;
2191 * shared headphone/mic handling
2194 static void call_update_outputs(struct hda_codec *codec);
2196 /* for shared I/O, change the pin-control accordingly */
2197 static void update_shared_mic_hp(struct hda_codec *codec, bool set_as_mic)
2199 struct hda_gen_spec *spec = codec->spec;
2201 hda_nid_t pin = spec->autocfg.inputs[1].pin;
2202 /* NOTE: this assumes that there are only two inputs, the
2203 * first is the real internal mic and the second is HP/mic jack.
2206 val = snd_hda_get_default_vref(codec, pin);
2208 /* This pin does not have vref caps - let's enable vref on pin 0x18
2209 instead, as suggested by Realtek */
2210 if (val == AC_PINCTL_VREF_HIZ && spec->shared_mic_vref_pin) {
2211 const hda_nid_t vref_pin = spec->shared_mic_vref_pin;
2212 unsigned int vref_val = snd_hda_get_default_vref(codec, vref_pin);
2213 if (vref_val != AC_PINCTL_VREF_HIZ)
2214 snd_hda_set_pin_ctl_cache(codec, vref_pin,
2215 PIN_IN | (set_as_mic ? vref_val : 0));
2218 val = set_as_mic ? val | PIN_IN : PIN_HP;
2219 set_pin_target(codec, pin, val, true);
2221 spec->automute_speaker = !set_as_mic;
2222 call_update_outputs(codec);
2225 /* create a shared input with the headphone out */
2226 static int create_shared_input(struct hda_codec *codec)
2228 struct hda_gen_spec *spec = codec->spec;
2229 struct auto_pin_cfg *cfg = &spec->autocfg;
2230 unsigned int defcfg;
2233 /* only one internal input pin? */
2234 if (cfg->num_inputs != 1)
2236 defcfg = snd_hda_codec_get_pincfg(codec, cfg->inputs[0].pin);
2237 if (snd_hda_get_input_pin_attr(defcfg) != INPUT_PIN_ATTR_INT)
2240 if (cfg->hp_outs == 1 && cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
2241 nid = cfg->hp_pins[0]; /* OK, we have a single HP-out */
2242 else if (cfg->line_outs == 1 && cfg->line_out_type == AUTO_PIN_HP_OUT)
2243 nid = cfg->line_out_pins[0]; /* OK, we have a single line-out */
2245 return 0; /* both not available */
2247 if (!(snd_hda_query_pin_caps(codec, nid) & AC_PINCAP_IN))
2248 return 0; /* no input */
2250 cfg->inputs[1].pin = nid;
2251 cfg->inputs[1].type = AUTO_PIN_MIC;
2252 cfg->num_inputs = 2;
2253 spec->shared_mic_hp = 1;
2254 snd_printdd("hda-codec: Enable shared I/O jack on NID 0x%x\n", nid);
2261 static int out_jack_mode_info(struct snd_kcontrol *kcontrol,
2262 struct snd_ctl_elem_info *uinfo)
2264 static const char * const texts[] = {
2265 "Line Out", "Headphone Out",
2267 return snd_hda_enum_helper_info(kcontrol, uinfo, 2, texts);
2270 static int out_jack_mode_get(struct snd_kcontrol *kcontrol,
2271 struct snd_ctl_elem_value *ucontrol)
2273 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2274 hda_nid_t nid = kcontrol->private_value;
2275 if (snd_hda_codec_get_pin_target(codec, nid) == PIN_HP)
2276 ucontrol->value.enumerated.item[0] = 1;
2278 ucontrol->value.enumerated.item[0] = 0;
2282 static int out_jack_mode_put(struct snd_kcontrol *kcontrol,
2283 struct snd_ctl_elem_value *ucontrol)
2285 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2286 hda_nid_t nid = kcontrol->private_value;
2289 val = ucontrol->value.enumerated.item[0] ? PIN_HP : PIN_OUT;
2290 if (snd_hda_codec_get_pin_target(codec, nid) == val)
2292 snd_hda_set_pin_ctl_cache(codec, nid, val);
2296 static const struct snd_kcontrol_new out_jack_mode_enum = {
2297 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2298 .info = out_jack_mode_info,
2299 .get = out_jack_mode_get,
2300 .put = out_jack_mode_put,
2303 static bool find_kctl_name(struct hda_codec *codec, const char *name, int idx)
2305 struct hda_gen_spec *spec = codec->spec;
2308 for (i = 0; i < spec->kctls.used; i++) {
2309 struct snd_kcontrol_new *kctl = snd_array_elem(&spec->kctls, i);
2310 if (!strcmp(kctl->name, name) && kctl->index == idx)
2316 static void get_jack_mode_name(struct hda_codec *codec, hda_nid_t pin,
2317 char *name, size_t name_len)
2319 struct hda_gen_spec *spec = codec->spec;
2322 snd_hda_get_pin_label(codec, pin, &spec->autocfg, name, name_len, &idx);
2323 strlcat(name, " Jack Mode", name_len);
2325 for (; find_kctl_name(codec, name, idx); idx++)
2329 static int create_out_jack_modes(struct hda_codec *codec, int num_pins,
2332 struct hda_gen_spec *spec = codec->spec;
2335 for (i = 0; i < num_pins; i++) {
2336 hda_nid_t pin = pins[i];
2337 unsigned int pincap = snd_hda_query_pin_caps(codec, pin);
2338 if ((pincap & AC_PINCAP_OUT) && (pincap & AC_PINCAP_HP_DRV)) {
2339 struct snd_kcontrol_new *knew;
2341 get_jack_mode_name(codec, pin, name, sizeof(name));
2342 knew = snd_hda_gen_add_kctl(spec, name,
2343 &out_jack_mode_enum);
2346 knew->private_value = pin;
2357 /* from AC_PINCTL_VREF_HIZ to AC_PINCTL_VREF_100 */
2360 static const char * const vref_texts[NUM_VREFS] = {
2361 "Line In", "Mic 50pc Bias", "Mic 0V Bias",
2362 "", "Mic 80pc Bias", "Mic 100pc Bias"
2365 static unsigned int get_vref_caps(struct hda_codec *codec, hda_nid_t pin)
2367 unsigned int pincap;
2369 pincap = snd_hda_query_pin_caps(codec, pin);
2370 pincap = (pincap & AC_PINCAP_VREF) >> AC_PINCAP_VREF_SHIFT;
2371 /* filter out unusual vrefs */
2372 pincap &= ~(AC_PINCAP_VREF_GRD | AC_PINCAP_VREF_100);
2376 /* convert from the enum item index to the vref ctl index (0=HIZ, 1=50%...) */
2377 static int get_vref_idx(unsigned int vref_caps, unsigned int item_idx)
2379 unsigned int i, n = 0;
2381 for (i = 0; i < NUM_VREFS; i++) {
2382 if (vref_caps & (1 << i)) {
2391 /* convert back from the vref ctl index to the enum item index */
2392 static int cvt_from_vref_idx(unsigned int vref_caps, unsigned int idx)
2394 unsigned int i, n = 0;
2396 for (i = 0; i < NUM_VREFS; i++) {
2399 if (vref_caps & (1 << i))
2405 static int in_jack_mode_info(struct snd_kcontrol *kcontrol,
2406 struct snd_ctl_elem_info *uinfo)
2408 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2409 hda_nid_t nid = kcontrol->private_value;
2410 unsigned int vref_caps = get_vref_caps(codec, nid);
2412 snd_hda_enum_helper_info(kcontrol, uinfo, hweight32(vref_caps),
2414 /* set the right text */
2415 strcpy(uinfo->value.enumerated.name,
2416 vref_texts[get_vref_idx(vref_caps, uinfo->value.enumerated.item)]);
2420 static int in_jack_mode_get(struct snd_kcontrol *kcontrol,
2421 struct snd_ctl_elem_value *ucontrol)
2423 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2424 hda_nid_t nid = kcontrol->private_value;
2425 unsigned int vref_caps = get_vref_caps(codec, nid);
2428 idx = snd_hda_codec_get_pin_target(codec, nid) & AC_PINCTL_VREFEN;
2429 ucontrol->value.enumerated.item[0] = cvt_from_vref_idx(vref_caps, idx);
2433 static int in_jack_mode_put(struct snd_kcontrol *kcontrol,
2434 struct snd_ctl_elem_value *ucontrol)
2436 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2437 hda_nid_t nid = kcontrol->private_value;
2438 unsigned int vref_caps = get_vref_caps(codec, nid);
2439 unsigned int val, idx;
2441 val = snd_hda_codec_get_pin_target(codec, nid);
2442 idx = cvt_from_vref_idx(vref_caps, val & AC_PINCTL_VREFEN);
2443 if (idx == ucontrol->value.enumerated.item[0])
2446 val &= ~AC_PINCTL_VREFEN;
2447 val |= get_vref_idx(vref_caps, ucontrol->value.enumerated.item[0]);
2448 snd_hda_set_pin_ctl_cache(codec, nid, val);
2452 static const struct snd_kcontrol_new in_jack_mode_enum = {
2453 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2454 .info = in_jack_mode_info,
2455 .get = in_jack_mode_get,
2456 .put = in_jack_mode_put,
2459 static int create_in_jack_mode(struct hda_codec *codec, hda_nid_t pin)
2461 struct hda_gen_spec *spec = codec->spec;
2462 unsigned int defcfg;
2463 struct snd_kcontrol_new *knew;
2466 /* no jack mode for fixed pins */
2467 defcfg = snd_hda_codec_get_pincfg(codec, pin);
2468 if (snd_hda_get_input_pin_attr(defcfg) == INPUT_PIN_ATTR_INT)
2471 /* no multiple vref caps? */
2472 if (hweight32(get_vref_caps(codec, pin)) <= 1)
2475 get_jack_mode_name(codec, pin, name, sizeof(name));
2476 knew = snd_hda_gen_add_kctl(spec, name, &in_jack_mode_enum);
2479 knew->private_value = pin;
2488 /* add the powersave loopback-list entry */
2489 static int add_loopback_list(struct hda_gen_spec *spec, hda_nid_t mix, int idx)
2491 struct hda_amp_list *list;
2493 list = snd_array_new(&spec->loopback_list);
2497 list->dir = HDA_INPUT;
2499 spec->loopback.amplist = spec->loopback_list.list;
2503 /* create input playback/capture controls for the given pin */
2504 static int new_analog_input(struct hda_codec *codec, int input_idx,
2505 hda_nid_t pin, const char *ctlname, int ctlidx,
2508 struct hda_gen_spec *spec = codec->spec;
2509 struct nid_path *path;
2513 if (!nid_has_volume(codec, mix_nid, HDA_INPUT) &&
2514 !nid_has_mute(codec, mix_nid, HDA_INPUT))
2515 return 0; /* no need for analog loopback */
2517 path = snd_hda_add_new_path(codec, pin, mix_nid, 0);
2520 print_nid_path("loopback", path);
2521 spec->loopback_paths[input_idx] = snd_hda_get_path_idx(codec, path);
2523 idx = path->idx[path->depth - 1];
2524 if (nid_has_volume(codec, mix_nid, HDA_INPUT)) {
2525 val = HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT);
2526 err = __add_pb_vol_ctrl(spec, HDA_CTL_WIDGET_VOL, ctlname, ctlidx, val);
2529 path->ctls[NID_PATH_VOL_CTL] = val;
2532 if (nid_has_mute(codec, mix_nid, HDA_INPUT)) {
2533 val = HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT);
2534 err = __add_pb_sw_ctrl(spec, HDA_CTL_WIDGET_MUTE, ctlname, ctlidx, val);
2537 path->ctls[NID_PATH_MUTE_CTL] = val;
2540 path->active = true;
2541 err = add_loopback_list(spec, mix_nid, idx);
2545 if (spec->mixer_nid != spec->mixer_merge_nid &&
2546 !spec->loopback_merge_path) {
2547 path = snd_hda_add_new_path(codec, spec->mixer_nid,
2548 spec->mixer_merge_nid, 0);
2550 print_nid_path("loopback-merge", path);
2551 path->active = true;
2552 spec->loopback_merge_path =
2553 snd_hda_get_path_idx(codec, path);
2560 static int is_input_pin(struct hda_codec *codec, hda_nid_t nid)
2562 unsigned int pincap = snd_hda_query_pin_caps(codec, nid);
2563 return (pincap & AC_PINCAP_IN) != 0;
2566 /* Parse the codec tree and retrieve ADCs */
2567 static int fill_adc_nids(struct hda_codec *codec)
2569 struct hda_gen_spec *spec = codec->spec;
2571 hda_nid_t *adc_nids = spec->adc_nids;
2572 int max_nums = ARRAY_SIZE(spec->adc_nids);
2575 nid = codec->start_nid;
2576 for (i = 0; i < codec->num_nodes; i++, nid++) {
2577 unsigned int caps = get_wcaps(codec, nid);
2578 int type = get_wcaps_type(caps);
2580 if (type != AC_WID_AUD_IN || (caps & AC_WCAP_DIGITAL))
2582 adc_nids[nums] = nid;
2583 if (++nums >= max_nums)
2586 spec->num_adc_nids = nums;
2588 /* copy the detected ADCs to all_adcs[] */
2589 spec->num_all_adcs = nums;
2590 memcpy(spec->all_adcs, spec->adc_nids, nums * sizeof(hda_nid_t));
2595 /* filter out invalid adc_nids that don't give all active input pins;
2596 * if needed, check whether dynamic ADC-switching is available
2598 static int check_dyn_adc_switch(struct hda_codec *codec)
2600 struct hda_gen_spec *spec = codec->spec;
2601 struct hda_input_mux *imux = &spec->input_mux;
2602 unsigned int ok_bits;
2608 for (n = 0; n < spec->num_adc_nids; n++) {
2609 for (i = 0; i < imux->num_items; i++) {
2610 if (!spec->input_paths[i][n])
2613 if (i >= imux->num_items) {
2614 ok_bits |= (1 << n);
2620 if (spec->shared_mic_hp) {
2621 spec->shared_mic_hp = 0;
2622 imux->num_items = 1;
2626 /* check whether ADC-switch is possible */
2627 for (i = 0; i < imux->num_items; i++) {
2628 for (n = 0; n < spec->num_adc_nids; n++) {
2629 if (spec->input_paths[i][n]) {
2630 spec->dyn_adc_idx[i] = n;
2636 snd_printdd("hda-codec: enabling ADC switching\n");
2637 spec->dyn_adc_switch = 1;
2638 } else if (nums != spec->num_adc_nids) {
2639 /* shrink the invalid adcs and input paths */
2641 for (n = 0; n < spec->num_adc_nids; n++) {
2642 if (!(ok_bits & (1 << n)))
2645 spec->adc_nids[nums] = spec->adc_nids[n];
2646 for (i = 0; i < imux->num_items; i++) {
2647 invalidate_nid_path(codec,
2648 spec->input_paths[i][nums]);
2649 spec->input_paths[i][nums] =
2650 spec->input_paths[i][n];
2655 spec->num_adc_nids = nums;
2658 if (imux->num_items == 1 || spec->shared_mic_hp) {
2659 snd_printdd("hda-codec: reducing to a single ADC\n");
2660 spec->num_adc_nids = 1; /* reduce to a single ADC */
2663 /* single index for individual volumes ctls */
2664 if (!spec->dyn_adc_switch && spec->multi_cap_vol)
2665 spec->num_adc_nids = 1;
2670 /* parse capture source paths from the given pin and create imux items */
2671 static int parse_capture_source(struct hda_codec *codec, hda_nid_t pin,
2672 int cfg_idx, int num_adcs,
2673 const char *label, int anchor)
2675 struct hda_gen_spec *spec = codec->spec;
2676 struct hda_input_mux *imux = &spec->input_mux;
2677 int imux_idx = imux->num_items;
2678 bool imux_added = false;
2681 for (c = 0; c < num_adcs; c++) {
2682 struct nid_path *path;
2683 hda_nid_t adc = spec->adc_nids[c];
2685 if (!is_reachable_path(codec, pin, adc))
2687 path = snd_hda_add_new_path(codec, pin, adc, anchor);
2690 print_nid_path("input", path);
2691 spec->input_paths[imux_idx][c] =
2692 snd_hda_get_path_idx(codec, path);
2695 spec->imux_pins[imux->num_items] = pin;
2696 snd_hda_add_imux_item(imux, label, cfg_idx, NULL);
2705 * create playback/capture controls for input pins
2708 /* fill the label for each input at first */
2709 static int fill_input_pin_labels(struct hda_codec *codec)
2711 struct hda_gen_spec *spec = codec->spec;
2712 const struct auto_pin_cfg *cfg = &spec->autocfg;
2715 for (i = 0; i < cfg->num_inputs; i++) {
2716 hda_nid_t pin = cfg->inputs[i].pin;
2720 if (!is_input_pin(codec, pin))
2723 label = hda_get_autocfg_input_label(codec, cfg, i);
2725 for (j = i - 1; j >= 0; j--) {
2726 if (spec->input_labels[j] &&
2727 !strcmp(spec->input_labels[j], label)) {
2728 idx = spec->input_label_idxs[j] + 1;
2733 spec->input_labels[i] = label;
2734 spec->input_label_idxs[i] = idx;
2740 #define CFG_IDX_MIX 99 /* a dummy cfg->input idx for stereo mix */
2742 static int create_input_ctls(struct hda_codec *codec)
2744 struct hda_gen_spec *spec = codec->spec;
2745 const struct auto_pin_cfg *cfg = &spec->autocfg;
2746 hda_nid_t mixer = spec->mixer_nid;
2751 num_adcs = fill_adc_nids(codec);
2755 err = fill_input_pin_labels(codec);
2759 for (i = 0; i < cfg->num_inputs; i++) {
2762 pin = cfg->inputs[i].pin;
2763 if (!is_input_pin(codec, pin))
2767 if (cfg->inputs[i].type == AUTO_PIN_MIC)
2768 val |= snd_hda_get_default_vref(codec, pin);
2769 set_pin_target(codec, pin, val, false);
2772 if (is_reachable_path(codec, pin, mixer)) {
2773 err = new_analog_input(codec, i, pin,
2774 spec->input_labels[i],
2775 spec->input_label_idxs[i],
2782 err = parse_capture_source(codec, pin, i, num_adcs,
2783 spec->input_labels[i], -mixer);
2787 if (spec->add_in_jack_modes) {
2788 err = create_in_jack_mode(codec, pin);
2794 if (mixer && spec->add_stereo_mix_input) {
2795 err = parse_capture_source(codec, mixer, CFG_IDX_MIX, num_adcs,
2809 /* get the input path specified by the given adc and imux indices */
2810 static struct nid_path *get_input_path(struct hda_codec *codec, int adc_idx, int imux_idx)
2812 struct hda_gen_spec *spec = codec->spec;
2813 if (imux_idx < 0 || imux_idx >= HDA_MAX_NUM_INPUTS) {
2817 if (spec->dyn_adc_switch)
2818 adc_idx = spec->dyn_adc_idx[imux_idx];
2819 if (adc_idx < 0 || adc_idx >= AUTO_CFG_MAX_INS) {
2823 return snd_hda_get_path_from_idx(codec, spec->input_paths[imux_idx][adc_idx]);
2826 static int mux_select(struct hda_codec *codec, unsigned int adc_idx,
2829 static int mux_enum_info(struct snd_kcontrol *kcontrol,
2830 struct snd_ctl_elem_info *uinfo)
2832 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2833 struct hda_gen_spec *spec = codec->spec;
2834 return snd_hda_input_mux_info(&spec->input_mux, uinfo);
2837 static int mux_enum_get(struct snd_kcontrol *kcontrol,
2838 struct snd_ctl_elem_value *ucontrol)
2840 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2841 struct hda_gen_spec *spec = codec->spec;
2842 /* the ctls are created at once with multiple counts */
2843 unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
2845 ucontrol->value.enumerated.item[0] = spec->cur_mux[adc_idx];
2849 static int mux_enum_put(struct snd_kcontrol *kcontrol,
2850 struct snd_ctl_elem_value *ucontrol)
2852 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2853 unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
2854 return mux_select(codec, adc_idx,
2855 ucontrol->value.enumerated.item[0]);
2858 static const struct snd_kcontrol_new cap_src_temp = {
2859 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2860 .name = "Input Source",
2861 .info = mux_enum_info,
2862 .get = mux_enum_get,
2863 .put = mux_enum_put,
2867 * capture volume and capture switch ctls
2870 typedef int (*put_call_t)(struct snd_kcontrol *kcontrol,
2871 struct snd_ctl_elem_value *ucontrol);
2873 /* call the given amp update function for all amps in the imux list at once */
2874 static int cap_put_caller(struct snd_kcontrol *kcontrol,
2875 struct snd_ctl_elem_value *ucontrol,
2876 put_call_t func, int type)
2878 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2879 struct hda_gen_spec *spec = codec->spec;
2880 const struct hda_input_mux *imux;
2881 struct nid_path *path;
2882 int i, adc_idx, err = 0;
2884 imux = &spec->input_mux;
2885 adc_idx = kcontrol->id.index;
2886 mutex_lock(&codec->control_mutex);
2887 /* we use the cache-only update at first since multiple input paths
2888 * may shared the same amp; by updating only caches, the redundant
2889 * writes to hardware can be reduced.
2891 codec->cached_write = 1;
2892 for (i = 0; i < imux->num_items; i++) {
2893 path = get_input_path(codec, adc_idx, i);
2894 if (!path || !path->ctls[type])
2896 kcontrol->private_value = path->ctls[type];
2897 err = func(kcontrol, ucontrol);
2902 codec->cached_write = 0;
2903 mutex_unlock(&codec->control_mutex);
2904 snd_hda_codec_flush_cache(codec); /* flush the updates */
2905 if (err >= 0 && spec->cap_sync_hook)
2906 spec->cap_sync_hook(codec, ucontrol);
2910 /* capture volume ctl callbacks */
2911 #define cap_vol_info snd_hda_mixer_amp_volume_info
2912 #define cap_vol_get snd_hda_mixer_amp_volume_get
2913 #define cap_vol_tlv snd_hda_mixer_amp_tlv
2915 static int cap_vol_put(struct snd_kcontrol *kcontrol,
2916 struct snd_ctl_elem_value *ucontrol)
2918 return cap_put_caller(kcontrol, ucontrol,
2919 snd_hda_mixer_amp_volume_put,
2923 static const struct snd_kcontrol_new cap_vol_temp = {
2924 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2925 .name = "Capture Volume",
2926 .access = (SNDRV_CTL_ELEM_ACCESS_READWRITE |
2927 SNDRV_CTL_ELEM_ACCESS_TLV_READ |
2928 SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK),
2929 .info = cap_vol_info,
2932 .tlv = { .c = cap_vol_tlv },
2935 /* capture switch ctl callbacks */
2936 #define cap_sw_info snd_ctl_boolean_stereo_info
2937 #define cap_sw_get snd_hda_mixer_amp_switch_get
2939 static int cap_sw_put(struct snd_kcontrol *kcontrol,
2940 struct snd_ctl_elem_value *ucontrol)
2942 return cap_put_caller(kcontrol, ucontrol,
2943 snd_hda_mixer_amp_switch_put,
2947 static const struct snd_kcontrol_new cap_sw_temp = {
2948 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2949 .name = "Capture Switch",
2950 .info = cap_sw_info,
2955 static int parse_capvol_in_path(struct hda_codec *codec, struct nid_path *path)
2960 path->ctls[NID_PATH_VOL_CTL] = path->ctls[NID_PATH_MUTE_CTL] = 0;
2961 for (depth = 0; depth < 3; depth++) {
2962 if (depth >= path->depth)
2964 i = path->depth - depth - 1;
2965 nid = path->path[i];
2966 if (!path->ctls[NID_PATH_VOL_CTL]) {
2967 if (nid_has_volume(codec, nid, HDA_OUTPUT))
2968 path->ctls[NID_PATH_VOL_CTL] =
2969 HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
2970 else if (nid_has_volume(codec, nid, HDA_INPUT)) {
2971 int idx = path->idx[i];
2972 if (!depth && codec->single_adc_amp)
2974 path->ctls[NID_PATH_VOL_CTL] =
2975 HDA_COMPOSE_AMP_VAL(nid, 3, idx, HDA_INPUT);
2978 if (!path->ctls[NID_PATH_MUTE_CTL]) {
2979 if (nid_has_mute(codec, nid, HDA_OUTPUT))
2980 path->ctls[NID_PATH_MUTE_CTL] =
2981 HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
2982 else if (nid_has_mute(codec, nid, HDA_INPUT)) {
2983 int idx = path->idx[i];
2984 if (!depth && codec->single_adc_amp)
2986 path->ctls[NID_PATH_MUTE_CTL] =
2987 HDA_COMPOSE_AMP_VAL(nid, 3, idx, HDA_INPUT);
2994 static bool is_inv_dmic_pin(struct hda_codec *codec, hda_nid_t nid)
2996 struct hda_gen_spec *spec = codec->spec;
2997 struct auto_pin_cfg *cfg = &spec->autocfg;
3001 if (!spec->inv_dmic_split)
3003 for (i = 0; i < cfg->num_inputs; i++) {
3004 if (cfg->inputs[i].pin != nid)
3006 if (cfg->inputs[i].type != AUTO_PIN_MIC)
3008 val = snd_hda_codec_get_pincfg(codec, nid);
3009 return snd_hda_get_input_pin_attr(val) == INPUT_PIN_ATTR_INT;
3014 /* capture switch put callback for a single control with hook call */
3015 static int cap_single_sw_put(struct snd_kcontrol *kcontrol,
3016 struct snd_ctl_elem_value *ucontrol)
3018 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3019 struct hda_gen_spec *spec = codec->spec;
3022 ret = snd_hda_mixer_amp_switch_put(kcontrol, ucontrol);
3026 if (spec->cap_sync_hook)
3027 spec->cap_sync_hook(codec, ucontrol);
3032 static int add_single_cap_ctl(struct hda_codec *codec, const char *label,
3033 int idx, bool is_switch, unsigned int ctl,
3036 struct hda_gen_spec *spec = codec->spec;
3038 int type = is_switch ? HDA_CTL_WIDGET_MUTE : HDA_CTL_WIDGET_VOL;
3039 const char *sfx = is_switch ? "Switch" : "Volume";
3040 unsigned int chs = inv_dmic ? 1 : 3;
3041 struct snd_kcontrol_new *knew;
3047 snprintf(tmpname, sizeof(tmpname),
3048 "%s Capture %s", label, sfx);
3050 snprintf(tmpname, sizeof(tmpname),
3052 knew = add_control(spec, type, tmpname, idx,
3053 amp_val_replace_channels(ctl, chs));
3057 knew->put = cap_single_sw_put;
3061 /* Make independent right kcontrol */
3063 snprintf(tmpname, sizeof(tmpname),
3064 "Inverted %s Capture %s", label, sfx);
3066 snprintf(tmpname, sizeof(tmpname),
3067 "Inverted Capture %s", sfx);
3068 knew = add_control(spec, type, tmpname, idx,
3069 amp_val_replace_channels(ctl, 2));
3073 knew->put = cap_single_sw_put;
3077 /* create single (and simple) capture volume and switch controls */
3078 static int create_single_cap_vol_ctl(struct hda_codec *codec, int idx,
3079 unsigned int vol_ctl, unsigned int sw_ctl,
3083 err = add_single_cap_ctl(codec, NULL, idx, false, vol_ctl, inv_dmic);
3086 err = add_single_cap_ctl(codec, NULL, idx, true, sw_ctl, inv_dmic);
3092 /* create bound capture volume and switch controls */
3093 static int create_bind_cap_vol_ctl(struct hda_codec *codec, int idx,
3094 unsigned int vol_ctl, unsigned int sw_ctl)
3096 struct hda_gen_spec *spec = codec->spec;
3097 struct snd_kcontrol_new *knew;
3100 knew = snd_hda_gen_add_kctl(spec, NULL, &cap_vol_temp);
3104 knew->private_value = vol_ctl;
3105 knew->subdevice = HDA_SUBDEV_AMP_FLAG;
3108 knew = snd_hda_gen_add_kctl(spec, NULL, &cap_sw_temp);
3112 knew->private_value = sw_ctl;
3113 knew->subdevice = HDA_SUBDEV_AMP_FLAG;
3118 /* return the vol ctl when used first in the imux list */
3119 static unsigned int get_first_cap_ctl(struct hda_codec *codec, int idx, int type)
3121 struct nid_path *path;
3125 path = get_input_path(codec, 0, idx);
3128 ctl = path->ctls[type];
3131 for (i = 0; i < idx - 1; i++) {
3132 path = get_input_path(codec, 0, i);
3133 if (path && path->ctls[type] == ctl)
3139 /* create individual capture volume and switch controls per input */
3140 static int create_multi_cap_vol_ctl(struct hda_codec *codec)
3142 struct hda_gen_spec *spec = codec->spec;
3143 struct hda_input_mux *imux = &spec->input_mux;
3146 for (i = 0; i < imux->num_items; i++) {
3150 idx = imux->items[i].index;
3151 if (idx >= spec->autocfg.num_inputs)
3153 inv_dmic = is_inv_dmic_pin(codec, spec->imux_pins[i]);
3155 for (type = 0; type < 2; type++) {
3156 err = add_single_cap_ctl(codec,
3157 spec->input_labels[idx],
3158 spec->input_label_idxs[idx],
3160 get_first_cap_ctl(codec, i, type),
3169 static int create_capture_mixers(struct hda_codec *codec)
3171 struct hda_gen_spec *spec = codec->spec;
3172 struct hda_input_mux *imux = &spec->input_mux;
3173 int i, n, nums, err;
3175 if (spec->dyn_adc_switch)
3178 nums = spec->num_adc_nids;
3180 if (!spec->auto_mic && imux->num_items > 1) {
3181 struct snd_kcontrol_new *knew;
3183 name = nums > 1 ? "Input Source" : "Capture Source";
3184 knew = snd_hda_gen_add_kctl(spec, name, &cap_src_temp);
3190 for (n = 0; n < nums; n++) {
3192 bool multi_cap_vol = spec->multi_cap_vol;
3193 bool inv_dmic = false;
3197 for (i = 0; i < imux->num_items; i++) {
3198 struct nid_path *path;
3199 path = get_input_path(codec, n, i);
3202 parse_capvol_in_path(codec, path);
3204 vol = path->ctls[NID_PATH_VOL_CTL];
3205 else if (vol != path->ctls[NID_PATH_VOL_CTL]) {
3207 if (!same_amp_caps(codec, vol,
3208 path->ctls[NID_PATH_VOL_CTL], HDA_INPUT))
3209 multi_cap_vol = true;
3212 sw = path->ctls[NID_PATH_MUTE_CTL];
3213 else if (sw != path->ctls[NID_PATH_MUTE_CTL]) {
3215 if (!same_amp_caps(codec, sw,
3216 path->ctls[NID_PATH_MUTE_CTL], HDA_INPUT))
3217 multi_cap_vol = true;
3219 if (is_inv_dmic_pin(codec, spec->imux_pins[i]))
3224 err = create_single_cap_vol_ctl(codec, n, vol, sw,
3226 else if (!multi_cap_vol)
3227 err = create_bind_cap_vol_ctl(codec, n, vol, sw);
3229 err = create_multi_cap_vol_ctl(codec);
3238 * add mic boosts if needed
3241 /* check whether the given amp is feasible as a boost volume */
3242 static bool check_boost_vol(struct hda_codec *codec, hda_nid_t nid,
3247 if (!nid_has_volume(codec, nid, dir) ||
3248 is_ctl_associated(codec, nid, dir, idx, NID_PATH_VOL_CTL) ||
3249 is_ctl_associated(codec, nid, dir, idx, NID_PATH_BOOST_CTL))
3252 step = (query_amp_caps(codec, nid, dir) & AC_AMPCAP_STEP_SIZE)
3253 >> AC_AMPCAP_STEP_SIZE_SHIFT;
3259 /* look for a boost amp in a widget close to the pin */
3260 static unsigned int look_for_boost_amp(struct hda_codec *codec,
3261 struct nid_path *path)
3263 unsigned int val = 0;
3267 for (depth = 0; depth < 3; depth++) {
3268 if (depth >= path->depth - 1)
3270 nid = path->path[depth];
3271 if (depth && check_boost_vol(codec, nid, HDA_OUTPUT, 0)) {
3272 val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
3274 } else if (check_boost_vol(codec, nid, HDA_INPUT,
3275 path->idx[depth])) {
3276 val = HDA_COMPOSE_AMP_VAL(nid, 3, path->idx[depth],
3285 static int parse_mic_boost(struct hda_codec *codec)
3287 struct hda_gen_spec *spec = codec->spec;
3288 struct auto_pin_cfg *cfg = &spec->autocfg;
3289 struct hda_input_mux *imux = &spec->input_mux;
3292 if (!spec->num_adc_nids)
3295 for (i = 0; i < imux->num_items; i++) {
3296 struct nid_path *path;
3299 char boost_label[44];
3301 idx = imux->items[i].index;
3302 if (idx >= imux->num_items)
3305 /* check only line-in and mic pins */
3306 if (cfg->inputs[idx].type > AUTO_PIN_LINE_IN)
3309 path = get_input_path(codec, 0, i);
3313 val = look_for_boost_amp(codec, path);
3317 /* create a boost control */
3318 snprintf(boost_label, sizeof(boost_label),
3319 "%s Boost Volume", spec->input_labels[idx]);
3320 if (!add_control(spec, HDA_CTL_WIDGET_VOL, boost_label,
3321 spec->input_label_idxs[idx], val))
3324 path->ctls[NID_PATH_BOOST_CTL] = val;
3330 * parse digital I/Os and set up NIDs in BIOS auto-parse mode
3332 static void parse_digital(struct hda_codec *codec)
3334 struct hda_gen_spec *spec = codec->spec;
3335 struct nid_path *path;
3337 hda_nid_t dig_nid, pin;
3339 /* support multiple SPDIFs; the secondary is set up as a slave */
3341 for (i = 0; i < spec->autocfg.dig_outs; i++) {
3342 pin = spec->autocfg.dig_out_pins[i];
3343 dig_nid = look_for_dac(codec, pin, true);
3346 path = snd_hda_add_new_path(codec, dig_nid, pin, 0);
3349 print_nid_path("digout", path);
3350 path->active = true;
3351 spec->digout_paths[i] = snd_hda_get_path_idx(codec, path);
3352 set_pin_target(codec, pin, PIN_OUT, false);
3354 spec->multiout.dig_out_nid = dig_nid;
3355 spec->dig_out_type = spec->autocfg.dig_out_type[0];
3357 spec->multiout.slave_dig_outs = spec->slave_dig_outs;
3358 if (nums >= ARRAY_SIZE(spec->slave_dig_outs) - 1)
3360 spec->slave_dig_outs[nums - 1] = dig_nid;
3365 if (spec->autocfg.dig_in_pin) {
3366 pin = spec->autocfg.dig_in_pin;
3367 dig_nid = codec->start_nid;
3368 for (i = 0; i < codec->num_nodes; i++, dig_nid++) {
3369 unsigned int wcaps = get_wcaps(codec, dig_nid);
3370 if (get_wcaps_type(wcaps) != AC_WID_AUD_IN)
3372 if (!(wcaps & AC_WCAP_DIGITAL))
3374 path = snd_hda_add_new_path(codec, pin, dig_nid, 0);
3376 print_nid_path("digin", path);
3377 path->active = true;
3378 spec->dig_in_nid = dig_nid;
3379 spec->digin_path = snd_hda_get_path_idx(codec, path);
3380 set_pin_target(codec, pin, PIN_IN, false);
3389 * input MUX handling
3392 static bool dyn_adc_pcm_resetup(struct hda_codec *codec, int cur);
3394 /* select the given imux item; either unmute exclusively or select the route */
3395 static int mux_select(struct hda_codec *codec, unsigned int adc_idx,
3398 struct hda_gen_spec *spec = codec->spec;
3399 const struct hda_input_mux *imux;
3400 struct nid_path *old_path, *path;
3402 imux = &spec->input_mux;
3403 if (!imux->num_items)
3406 if (idx >= imux->num_items)
3407 idx = imux->num_items - 1;
3408 if (spec->cur_mux[adc_idx] == idx)
3411 old_path = get_input_path(codec, adc_idx, spec->cur_mux[adc_idx]);
3414 if (old_path->active)
3415 snd_hda_activate_path(codec, old_path, false, false);
3417 spec->cur_mux[adc_idx] = idx;
3419 if (spec->shared_mic_hp)
3420 update_shared_mic_hp(codec, spec->cur_mux[adc_idx]);
3422 if (spec->dyn_adc_switch)
3423 dyn_adc_pcm_resetup(codec, idx);
3425 path = get_input_path(codec, adc_idx, idx);
3430 snd_hda_activate_path(codec, path, true, false);
3431 if (spec->cap_sync_hook)
3432 spec->cap_sync_hook(codec, NULL);
3433 path_power_down_sync(codec, old_path);
3439 * Jack detections for HP auto-mute and mic-switch
3442 /* check each pin in the given array; returns true if any of them is plugged */
3443 static bool detect_jacks(struct hda_codec *codec, int num_pins, hda_nid_t *pins)
3447 for (i = 0; i < num_pins; i++) {
3448 hda_nid_t nid = pins[i];
3451 /* don't detect pins retasked as inputs */
3452 if (snd_hda_codec_get_pin_target(codec, nid) & AC_PINCTL_IN_EN)
3454 present |= snd_hda_jack_detect(codec, nid);
3459 /* standard HP/line-out auto-mute helper */
3460 static void do_automute(struct hda_codec *codec, int num_pins, hda_nid_t *pins,
3463 struct hda_gen_spec *spec = codec->spec;
3466 for (i = 0; i < num_pins; i++) {
3467 hda_nid_t nid = pins[i];
3471 /* don't reset VREF value in case it's controlling
3472 * the amp (see alc861_fixup_asus_amp_vref_0f())
3474 if (spec->keep_vref_in_automute)
3475 val = snd_hda_codec_get_pin_target(codec, nid) & ~PIN_HP;
3479 val |= snd_hda_codec_get_pin_target(codec, nid);
3480 /* here we call update_pin_ctl() so that the pinctl is changed
3481 * without changing the pinctl target value;
3482 * the original target value will be still referred at the
3483 * init / resume again
3485 update_pin_ctl(codec, nid, val);
3486 set_pin_eapd(codec, nid, !mute);
3490 /* Toggle outputs muting */
3491 void snd_hda_gen_update_outputs(struct hda_codec *codec)
3493 struct hda_gen_spec *spec = codec->spec;
3496 /* Control HP pins/amps depending on master_mute state;
3497 * in general, HP pins/amps control should be enabled in all cases,
3498 * but currently set only for master_mute, just to be safe
3500 if (!spec->shared_mic_hp) /* don't change HP-pin when shared with mic */
3501 do_automute(codec, ARRAY_SIZE(spec->autocfg.hp_pins),
3502 spec->autocfg.hp_pins, spec->master_mute);
3504 if (!spec->automute_speaker)
3507 on = spec->hp_jack_present | spec->line_jack_present;
3508 on |= spec->master_mute;
3509 spec->speaker_muted = on;
3510 do_automute(codec, ARRAY_SIZE(spec->autocfg.speaker_pins),
3511 spec->autocfg.speaker_pins, on);
3513 /* toggle line-out mutes if needed, too */
3514 /* if LO is a copy of either HP or Speaker, don't need to handle it */
3515 if (spec->autocfg.line_out_pins[0] == spec->autocfg.hp_pins[0] ||
3516 spec->autocfg.line_out_pins[0] == spec->autocfg.speaker_pins[0])
3518 if (!spec->automute_lo)
3521 on = spec->hp_jack_present;
3522 on |= spec->master_mute;
3523 spec->line_out_muted = on;
3524 do_automute(codec, ARRAY_SIZE(spec->autocfg.line_out_pins),
3525 spec->autocfg.line_out_pins, on);
3527 EXPORT_SYMBOL_HDA(snd_hda_gen_update_outputs);
3529 static void call_update_outputs(struct hda_codec *codec)
3531 struct hda_gen_spec *spec = codec->spec;
3532 if (spec->automute_hook)
3533 spec->automute_hook(codec);
3535 snd_hda_gen_update_outputs(codec);
3538 /* standard HP-automute helper */
3539 void snd_hda_gen_hp_automute(struct hda_codec *codec, struct hda_jack_tbl *jack)
3541 struct hda_gen_spec *spec = codec->spec;
3542 hda_nid_t *pins = spec->autocfg.hp_pins;
3543 int num_pins = ARRAY_SIZE(spec->autocfg.hp_pins);
3545 /* No detection for the first HP jack during indep-HP mode */
3546 if (spec->indep_hp_enabled) {
3551 spec->hp_jack_present = detect_jacks(codec, num_pins, pins);
3552 if (!spec->detect_hp || (!spec->automute_speaker && !spec->automute_lo))
3554 call_update_outputs(codec);
3556 EXPORT_SYMBOL_HDA(snd_hda_gen_hp_automute);
3558 /* standard line-out-automute helper */
3559 void snd_hda_gen_line_automute(struct hda_codec *codec, struct hda_jack_tbl *jack)
3561 struct hda_gen_spec *spec = codec->spec;
3563 if (spec->autocfg.line_out_type == AUTO_PIN_SPEAKER_OUT)
3565 /* check LO jack only when it's different from HP */
3566 if (spec->autocfg.line_out_pins[0] == spec->autocfg.hp_pins[0])
3569 spec->line_jack_present =
3570 detect_jacks(codec, ARRAY_SIZE(spec->autocfg.line_out_pins),
3571 spec->autocfg.line_out_pins);
3572 if (!spec->automute_speaker || !spec->detect_lo)
3574 call_update_outputs(codec);
3576 EXPORT_SYMBOL_HDA(snd_hda_gen_line_automute);
3578 /* standard mic auto-switch helper */
3579 void snd_hda_gen_mic_autoswitch(struct hda_codec *codec, struct hda_jack_tbl *jack)
3581 struct hda_gen_spec *spec = codec->spec;
3584 if (!spec->auto_mic)
3587 for (i = spec->am_num_entries - 1; i > 0; i--) {
3588 hda_nid_t pin = spec->am_entry[i].pin;
3589 /* don't detect pins retasked as outputs */
3590 if (snd_hda_codec_get_pin_target(codec, pin) & AC_PINCTL_OUT_EN)
3592 if (snd_hda_jack_detect(codec, pin)) {
3593 mux_select(codec, 0, spec->am_entry[i].idx);
3597 mux_select(codec, 0, spec->am_entry[0].idx);
3599 EXPORT_SYMBOL_HDA(snd_hda_gen_mic_autoswitch);
3601 /* update jack retasking */
3602 static void update_automute_all(struct hda_codec *codec)
3604 struct hda_gen_spec *spec = codec->spec;
3606 if (spec->hp_automute_hook)
3607 spec->hp_automute_hook(codec, NULL);
3609 snd_hda_gen_hp_automute(codec, NULL);
3610 if (spec->line_automute_hook)
3611 spec->line_automute_hook(codec, NULL);
3613 snd_hda_gen_line_automute(codec, NULL);
3614 if (spec->mic_autoswitch_hook)
3615 spec->mic_autoswitch_hook(codec, NULL);
3617 snd_hda_gen_mic_autoswitch(codec, NULL);
3621 * Auto-Mute mode mixer enum support
3623 static int automute_mode_info(struct snd_kcontrol *kcontrol,
3624 struct snd_ctl_elem_info *uinfo)
3626 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3627 struct hda_gen_spec *spec = codec->spec;
3628 static const char * const texts3[] = {
3629 "Disabled", "Speaker Only", "Line Out+Speaker"
3632 if (spec->automute_speaker_possible && spec->automute_lo_possible)
3633 return snd_hda_enum_helper_info(kcontrol, uinfo, 3, texts3);
3634 return snd_hda_enum_bool_helper_info(kcontrol, uinfo);
3637 static int automute_mode_get(struct snd_kcontrol *kcontrol,
3638 struct snd_ctl_elem_value *ucontrol)
3640 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3641 struct hda_gen_spec *spec = codec->spec;
3642 unsigned int val = 0;
3643 if (spec->automute_speaker)
3645 if (spec->automute_lo)
3648 ucontrol->value.enumerated.item[0] = val;
3652 static int automute_mode_put(struct snd_kcontrol *kcontrol,
3653 struct snd_ctl_elem_value *ucontrol)
3655 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3656 struct hda_gen_spec *spec = codec->spec;
3658 switch (ucontrol->value.enumerated.item[0]) {
3660 if (!spec->automute_speaker && !spec->automute_lo)
3662 spec->automute_speaker = 0;
3663 spec->automute_lo = 0;
3666 if (spec->automute_speaker_possible) {
3667 if (!spec->automute_lo && spec->automute_speaker)
3669 spec->automute_speaker = 1;
3670 spec->automute_lo = 0;
3671 } else if (spec->automute_lo_possible) {
3672 if (spec->automute_lo)
3674 spec->automute_lo = 1;
3679 if (!spec->automute_lo_possible || !spec->automute_speaker_possible)
3681 if (spec->automute_speaker && spec->automute_lo)
3683 spec->automute_speaker = 1;
3684 spec->automute_lo = 1;
3689 call_update_outputs(codec);
3693 static const struct snd_kcontrol_new automute_mode_enum = {
3694 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3695 .name = "Auto-Mute Mode",
3696 .info = automute_mode_info,
3697 .get = automute_mode_get,
3698 .put = automute_mode_put,
3701 static int add_automute_mode_enum(struct hda_codec *codec)
3703 struct hda_gen_spec *spec = codec->spec;
3705 if (!snd_hda_gen_add_kctl(spec, NULL, &automute_mode_enum))
3711 * Check the availability of HP/line-out auto-mute;
3712 * Set up appropriately if really supported
3714 static int check_auto_mute_availability(struct hda_codec *codec)
3716 struct hda_gen_spec *spec = codec->spec;
3717 struct auto_pin_cfg *cfg = &spec->autocfg;
3721 if (spec->suppress_auto_mute)
3724 if (cfg->hp_pins[0])
3726 if (cfg->line_out_pins[0])
3728 if (cfg->speaker_pins[0])
3730 if (present < 2) /* need two different output types */
3733 if (!cfg->speaker_pins[0] &&
3734 cfg->line_out_type == AUTO_PIN_SPEAKER_OUT) {
3735 memcpy(cfg->speaker_pins, cfg->line_out_pins,
3736 sizeof(cfg->speaker_pins));
3737 cfg->speaker_outs = cfg->line_outs;
3740 if (!cfg->hp_pins[0] &&
3741 cfg->line_out_type == AUTO_PIN_HP_OUT) {
3742 memcpy(cfg->hp_pins, cfg->line_out_pins,
3743 sizeof(cfg->hp_pins));
3744 cfg->hp_outs = cfg->line_outs;
3747 for (i = 0; i < cfg->hp_outs; i++) {
3748 hda_nid_t nid = cfg->hp_pins[i];
3749 if (!is_jack_detectable(codec, nid))
3751 snd_printdd("hda-codec: Enable HP auto-muting on NID 0x%x\n",
3753 snd_hda_jack_detect_enable_callback(codec, nid, HDA_GEN_HP_EVENT,
3754 spec->hp_automute_hook ?
3755 spec->hp_automute_hook :
3756 snd_hda_gen_hp_automute);
3757 spec->detect_hp = 1;
3760 if (cfg->line_out_type == AUTO_PIN_LINE_OUT && cfg->line_outs) {
3761 if (cfg->speaker_outs)
3762 for (i = 0; i < cfg->line_outs; i++) {
3763 hda_nid_t nid = cfg->line_out_pins[i];
3764 if (!is_jack_detectable(codec, nid))
3766 snd_printdd("hda-codec: Enable Line-Out auto-muting on NID 0x%x\n", nid);
3767 snd_hda_jack_detect_enable_callback(codec, nid,
3768 HDA_GEN_FRONT_EVENT,
3769 spec->line_automute_hook ?
3770 spec->line_automute_hook :
3771 snd_hda_gen_line_automute);
3772 spec->detect_lo = 1;
3774 spec->automute_lo_possible = spec->detect_hp;
3777 spec->automute_speaker_possible = cfg->speaker_outs &&
3778 (spec->detect_hp || spec->detect_lo);
3780 spec->automute_lo = spec->automute_lo_possible;
3781 spec->automute_speaker = spec->automute_speaker_possible;
3783 if (spec->automute_speaker_possible || spec->automute_lo_possible) {
3784 /* create a control for automute mode */
3785 err = add_automute_mode_enum(codec);
3792 /* check whether all auto-mic pins are valid; setup indices if OK */
3793 static bool auto_mic_check_imux(struct hda_codec *codec)
3795 struct hda_gen_spec *spec = codec->spec;
3796 const struct hda_input_mux *imux;
3799 imux = &spec->input_mux;
3800 for (i = 0; i < spec->am_num_entries; i++) {
3801 spec->am_entry[i].idx =
3802 find_idx_in_nid_list(spec->am_entry[i].pin,
3803 spec->imux_pins, imux->num_items);
3804 if (spec->am_entry[i].idx < 0)
3805 return false; /* no corresponding imux */
3808 /* we don't need the jack detection for the first pin */
3809 for (i = 1; i < spec->am_num_entries; i++)
3810 snd_hda_jack_detect_enable_callback(codec,
3811 spec->am_entry[i].pin,
3813 spec->mic_autoswitch_hook ?
3814 spec->mic_autoswitch_hook :
3815 snd_hda_gen_mic_autoswitch);
3819 static int compare_attr(const void *ap, const void *bp)
3821 const struct automic_entry *a = ap;
3822 const struct automic_entry *b = bp;
3823 return (int)(a->attr - b->attr);
3827 * Check the availability of auto-mic switch;
3828 * Set up if really supported
3830 static int check_auto_mic_availability(struct hda_codec *codec)
3832 struct hda_gen_spec *spec = codec->spec;
3833 struct auto_pin_cfg *cfg = &spec->autocfg;
3837 if (spec->suppress_auto_mic)
3842 for (i = 0; i < cfg->num_inputs; i++) {
3843 hda_nid_t nid = cfg->inputs[i].pin;
3845 attr = snd_hda_codec_get_pincfg(codec, nid);
3846 attr = snd_hda_get_input_pin_attr(attr);
3847 if (types & (1 << attr))
3848 return 0; /* already occupied */
3850 case INPUT_PIN_ATTR_INT:
3851 if (cfg->inputs[i].type != AUTO_PIN_MIC)
3852 return 0; /* invalid type */
3854 case INPUT_PIN_ATTR_UNUSED:
3855 return 0; /* invalid entry */
3857 if (cfg->inputs[i].type > AUTO_PIN_LINE_IN)
3858 return 0; /* invalid type */
3859 if (!spec->line_in_auto_switch &&
3860 cfg->inputs[i].type != AUTO_PIN_MIC)
3861 return 0; /* only mic is allowed */
3862 if (!is_jack_detectable(codec, nid))
3863 return 0; /* no unsol support */
3866 if (num_pins >= MAX_AUTO_MIC_PINS)
3868 types |= (1 << attr);
3869 spec->am_entry[num_pins].pin = nid;
3870 spec->am_entry[num_pins].attr = attr;
3877 spec->am_num_entries = num_pins;
3878 /* sort the am_entry in the order of attr so that the pin with a
3879 * higher attr will be selected when the jack is plugged.
3881 sort(spec->am_entry, num_pins, sizeof(spec->am_entry[0]),
3882 compare_attr, NULL);
3884 if (!auto_mic_check_imux(codec))
3888 spec->num_adc_nids = 1;
3889 spec->cur_mux[0] = spec->am_entry[0].idx;
3890 snd_printdd("hda-codec: Enable auto-mic switch on NID 0x%x/0x%x/0x%x\n",
3891 spec->am_entry[0].pin,
3892 spec->am_entry[1].pin,
3893 spec->am_entry[2].pin);
3898 /* power_filter hook; make inactive widgets into power down */
3899 static unsigned int snd_hda_gen_path_power_filter(struct hda_codec *codec,
3901 unsigned int power_state)
3903 if (power_state != AC_PWRST_D0)
3905 if (get_wcaps_type(get_wcaps(codec, nid)) >= AC_WID_POWER)
3907 if (is_active_nid(codec, nid, HDA_OUTPUT, 0))
3914 * Parse the given BIOS configuration and set up the hda_gen_spec
3916 * return 1 if successful, 0 if the proper config is not found,
3917 * or a negative error code
3919 int snd_hda_gen_parse_auto_config(struct hda_codec *codec,
3920 struct auto_pin_cfg *cfg)
3922 struct hda_gen_spec *spec = codec->spec;
3925 parse_user_hints(codec);
3927 if (spec->mixer_nid && !spec->mixer_merge_nid)
3928 spec->mixer_merge_nid = spec->mixer_nid;
3930 if (cfg != &spec->autocfg) {
3931 spec->autocfg = *cfg;
3932 cfg = &spec->autocfg;
3935 fill_all_dac_nids(codec);
3937 if (!cfg->line_outs) {
3938 if (cfg->dig_outs || cfg->dig_in_pin) {
3939 spec->multiout.max_channels = 2;
3940 spec->no_analog = 1;
3943 return 0; /* can't find valid BIOS pin config */
3946 if (!spec->no_primary_hp &&
3947 cfg->line_out_type == AUTO_PIN_SPEAKER_OUT &&
3948 cfg->line_outs <= cfg->hp_outs) {
3949 /* use HP as primary out */
3950 cfg->speaker_outs = cfg->line_outs;
3951 memcpy(cfg->speaker_pins, cfg->line_out_pins,
3952 sizeof(cfg->speaker_pins));
3953 cfg->line_outs = cfg->hp_outs;
3954 memcpy(cfg->line_out_pins, cfg->hp_pins, sizeof(cfg->hp_pins));
3956 memset(cfg->hp_pins, 0, sizeof(cfg->hp_pins));
3957 cfg->line_out_type = AUTO_PIN_HP_OUT;
3960 err = parse_output_paths(codec);
3963 err = create_multi_channel_mode(codec);
3966 err = create_multi_out_ctls(codec, cfg);
3969 err = create_hp_out_ctls(codec);
3972 err = create_speaker_out_ctls(codec);
3975 err = create_indep_hp_ctls(codec);
3978 err = create_loopback_mixing_ctl(codec);
3981 err = create_shared_input(codec);
3984 err = create_input_ctls(codec);
3988 spec->const_channel_count = spec->ext_channel_count;
3989 /* check the multiple speaker and headphone pins */
3990 if (cfg->line_out_type != AUTO_PIN_SPEAKER_OUT)
3991 spec->const_channel_count = max(spec->const_channel_count,
3992 cfg->speaker_outs * 2);
3993 if (cfg->line_out_type != AUTO_PIN_HP_OUT)
3994 spec->const_channel_count = max(spec->const_channel_count,
3996 spec->multiout.max_channels = max(spec->ext_channel_count,
3997 spec->const_channel_count);
3999 err = check_auto_mute_availability(codec);
4003 err = check_dyn_adc_switch(codec);
4007 if (!spec->shared_mic_hp) {
4008 err = check_auto_mic_availability(codec);
4013 err = create_capture_mixers(codec);
4017 err = parse_mic_boost(codec);
4021 if (spec->add_out_jack_modes) {
4022 if (cfg->line_out_type != AUTO_PIN_SPEAKER_OUT) {
4023 err = create_out_jack_modes(codec, cfg->line_outs,
4024 cfg->line_out_pins);
4028 if (cfg->line_out_type != AUTO_PIN_HP_OUT) {
4029 err = create_out_jack_modes(codec, cfg->hp_outs,
4037 parse_digital(codec);
4039 if (spec->power_down_unused)
4040 codec->power_filter = snd_hda_gen_path_power_filter;
4044 EXPORT_SYMBOL_HDA(snd_hda_gen_parse_auto_config);
4048 * Build control elements
4051 /* slave controls for virtual master */
4052 static const char * const slave_pfxs[] = {
4053 "Front", "Surround", "Center", "LFE", "Side",
4054 "Headphone", "Speaker", "Mono", "Line Out",
4055 "CLFE", "Bass Speaker", "PCM",
4056 "Speaker Front", "Speaker Surround", "Speaker CLFE", "Speaker Side",
4057 "Headphone Front", "Headphone Surround", "Headphone CLFE",
4062 int snd_hda_gen_build_controls(struct hda_codec *codec)
4064 struct hda_gen_spec *spec = codec->spec;
4067 if (spec->kctls.used) {
4068 err = snd_hda_add_new_ctls(codec, spec->kctls.list);
4073 if (spec->multiout.dig_out_nid) {
4074 err = snd_hda_create_dig_out_ctls(codec,
4075 spec->multiout.dig_out_nid,
4076 spec->multiout.dig_out_nid,
4077 spec->pcm_rec[1].pcm_type);
4080 if (!spec->no_analog) {
4081 err = snd_hda_create_spdif_share_sw(codec,
4085 spec->multiout.share_spdif = 1;
4088 if (spec->dig_in_nid) {
4089 err = snd_hda_create_spdif_in_ctls(codec, spec->dig_in_nid);
4094 /* if we have no master control, let's create it */
4095 if (!spec->no_analog &&
4096 !snd_hda_find_mixer_ctl(codec, "Master Playback Volume")) {
4097 err = snd_hda_add_vmaster(codec, "Master Playback Volume",
4098 spec->vmaster_tlv, slave_pfxs,
4103 if (!spec->no_analog &&
4104 !snd_hda_find_mixer_ctl(codec, "Master Playback Switch")) {
4105 err = __snd_hda_add_vmaster(codec, "Master Playback Switch",
4108 true, &spec->vmaster_mute.sw_kctl);
4111 if (spec->vmaster_mute.hook)
4112 snd_hda_add_vmaster_hook(codec, &spec->vmaster_mute,
4113 spec->vmaster_mute_enum);
4116 free_kctls(spec); /* no longer needed */
4118 if (spec->shared_mic_hp) {
4120 int nid = spec->autocfg.inputs[1].pin;
4121 err = snd_hda_jack_add_kctl(codec, nid, "Headphone Mic", 0);
4124 err = snd_hda_jack_detect_enable(codec, nid, 0);
4129 err = snd_hda_jack_add_kctls(codec, &spec->autocfg);
4135 EXPORT_SYMBOL_HDA(snd_hda_gen_build_controls);
4142 static void call_pcm_playback_hook(struct hda_pcm_stream *hinfo,
4143 struct hda_codec *codec,
4144 struct snd_pcm_substream *substream,
4147 struct hda_gen_spec *spec = codec->spec;
4148 if (spec->pcm_playback_hook)
4149 spec->pcm_playback_hook(hinfo, codec, substream, action);
4152 static void call_pcm_capture_hook(struct hda_pcm_stream *hinfo,
4153 struct hda_codec *codec,
4154 struct snd_pcm_substream *substream,
4157 struct hda_gen_spec *spec = codec->spec;
4158 if (spec->pcm_capture_hook)
4159 spec->pcm_capture_hook(hinfo, codec, substream, action);
4163 * Analog playback callbacks
4165 static int playback_pcm_open(struct hda_pcm_stream *hinfo,
4166 struct hda_codec *codec,
4167 struct snd_pcm_substream *substream)
4169 struct hda_gen_spec *spec = codec->spec;
4172 mutex_lock(&spec->pcm_mutex);
4173 err = snd_hda_multi_out_analog_open(codec,
4174 &spec->multiout, substream,
4177 spec->active_streams |= 1 << STREAM_MULTI_OUT;
4178 call_pcm_playback_hook(hinfo, codec, substream,
4179 HDA_GEN_PCM_ACT_OPEN);
4181 mutex_unlock(&spec->pcm_mutex);
4185 static int playback_pcm_prepare(struct hda_pcm_stream *hinfo,
4186 struct hda_codec *codec,
4187 unsigned int stream_tag,
4188 unsigned int format,
4189 struct snd_pcm_substream *substream)
4191 struct hda_gen_spec *spec = codec->spec;
4194 err = snd_hda_multi_out_analog_prepare(codec, &spec->multiout,
4195 stream_tag, format, substream);
4197 call_pcm_playback_hook(hinfo, codec, substream,
4198 HDA_GEN_PCM_ACT_PREPARE);
4202 static int playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
4203 struct hda_codec *codec,
4204 struct snd_pcm_substream *substream)
4206 struct hda_gen_spec *spec = codec->spec;
4209 err = snd_hda_multi_out_analog_cleanup(codec, &spec->multiout);
4211 call_pcm_playback_hook(hinfo, codec, substream,
4212 HDA_GEN_PCM_ACT_CLEANUP);
4216 static int playback_pcm_close(struct hda_pcm_stream *hinfo,
4217 struct hda_codec *codec,
4218 struct snd_pcm_substream *substream)
4220 struct hda_gen_spec *spec = codec->spec;
4221 mutex_lock(&spec->pcm_mutex);
4222 spec->active_streams &= ~(1 << STREAM_MULTI_OUT);
4223 call_pcm_playback_hook(hinfo, codec, substream,
4224 HDA_GEN_PCM_ACT_CLOSE);
4225 mutex_unlock(&spec->pcm_mutex);
4229 static int capture_pcm_open(struct hda_pcm_stream *hinfo,
4230 struct hda_codec *codec,
4231 struct snd_pcm_substream *substream)
4233 call_pcm_capture_hook(hinfo, codec, substream, HDA_GEN_PCM_ACT_OPEN);
4237 static int capture_pcm_prepare(struct hda_pcm_stream *hinfo,
4238 struct hda_codec *codec,
4239 unsigned int stream_tag,
4240 unsigned int format,
4241 struct snd_pcm_substream *substream)
4243 snd_hda_codec_setup_stream(codec, hinfo->nid, stream_tag, 0, format);
4244 call_pcm_capture_hook(hinfo, codec, substream,
4245 HDA_GEN_PCM_ACT_PREPARE);
4249 static int capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
4250 struct hda_codec *codec,
4251 struct snd_pcm_substream *substream)
4253 snd_hda_codec_cleanup_stream(codec, hinfo->nid);
4254 call_pcm_capture_hook(hinfo, codec, substream,
4255 HDA_GEN_PCM_ACT_CLEANUP);
4259 static int capture_pcm_close(struct hda_pcm_stream *hinfo,
4260 struct hda_codec *codec,
4261 struct snd_pcm_substream *substream)
4263 call_pcm_capture_hook(hinfo, codec, substream, HDA_GEN_PCM_ACT_CLOSE);
4267 static int alt_playback_pcm_open(struct hda_pcm_stream *hinfo,
4268 struct hda_codec *codec,
4269 struct snd_pcm_substream *substream)
4271 struct hda_gen_spec *spec = codec->spec;
4274 mutex_lock(&spec->pcm_mutex);
4275 if (!spec->indep_hp_enabled)
4278 spec->active_streams |= 1 << STREAM_INDEP_HP;
4279 call_pcm_playback_hook(hinfo, codec, substream,
4280 HDA_GEN_PCM_ACT_OPEN);
4281 mutex_unlock(&spec->pcm_mutex);
4285 static int alt_playback_pcm_close(struct hda_pcm_stream *hinfo,
4286 struct hda_codec *codec,
4287 struct snd_pcm_substream *substream)
4289 struct hda_gen_spec *spec = codec->spec;
4290 mutex_lock(&spec->pcm_mutex);
4291 spec->active_streams &= ~(1 << STREAM_INDEP_HP);
4292 call_pcm_playback_hook(hinfo, codec, substream,
4293 HDA_GEN_PCM_ACT_CLOSE);
4294 mutex_unlock(&spec->pcm_mutex);
4298 static int alt_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
4299 struct hda_codec *codec,
4300 unsigned int stream_tag,
4301 unsigned int format,
4302 struct snd_pcm_substream *substream)
4304 snd_hda_codec_setup_stream(codec, hinfo->nid, stream_tag, 0, format);
4305 call_pcm_playback_hook(hinfo, codec, substream,
4306 HDA_GEN_PCM_ACT_PREPARE);
4310 static int alt_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
4311 struct hda_codec *codec,
4312 struct snd_pcm_substream *substream)
4314 snd_hda_codec_cleanup_stream(codec, hinfo->nid);
4315 call_pcm_playback_hook(hinfo, codec, substream,
4316 HDA_GEN_PCM_ACT_CLEANUP);
4323 static int dig_playback_pcm_open(struct hda_pcm_stream *hinfo,
4324 struct hda_codec *codec,
4325 struct snd_pcm_substream *substream)
4327 struct hda_gen_spec *spec = codec->spec;
4328 return snd_hda_multi_out_dig_open(codec, &spec->multiout);
4331 static int dig_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
4332 struct hda_codec *codec,
4333 unsigned int stream_tag,
4334 unsigned int format,
4335 struct snd_pcm_substream *substream)
4337 struct hda_gen_spec *spec = codec->spec;
4338 return snd_hda_multi_out_dig_prepare(codec, &spec->multiout,
4339 stream_tag, format, substream);
4342 static int dig_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
4343 struct hda_codec *codec,
4344 struct snd_pcm_substream *substream)
4346 struct hda_gen_spec *spec = codec->spec;
4347 return snd_hda_multi_out_dig_cleanup(codec, &spec->multiout);
4350 static int dig_playback_pcm_close(struct hda_pcm_stream *hinfo,
4351 struct hda_codec *codec,
4352 struct snd_pcm_substream *substream)
4354 struct hda_gen_spec *spec = codec->spec;
4355 return snd_hda_multi_out_dig_close(codec, &spec->multiout);
4361 #define alt_capture_pcm_open capture_pcm_open
4362 #define alt_capture_pcm_close capture_pcm_close
4364 static int alt_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
4365 struct hda_codec *codec,
4366 unsigned int stream_tag,
4367 unsigned int format,
4368 struct snd_pcm_substream *substream)
4370 struct hda_gen_spec *spec = codec->spec;
4372 snd_hda_codec_setup_stream(codec, spec->adc_nids[substream->number + 1],
4373 stream_tag, 0, format);
4374 call_pcm_capture_hook(hinfo, codec, substream,
4375 HDA_GEN_PCM_ACT_PREPARE);
4379 static int alt_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
4380 struct hda_codec *codec,
4381 struct snd_pcm_substream *substream)
4383 struct hda_gen_spec *spec = codec->spec;
4385 snd_hda_codec_cleanup_stream(codec,
4386 spec->adc_nids[substream->number + 1]);
4387 call_pcm_capture_hook(hinfo, codec, substream,
4388 HDA_GEN_PCM_ACT_CLEANUP);
4394 static const struct hda_pcm_stream pcm_analog_playback = {
4398 /* NID is set in build_pcms */
4400 .open = playback_pcm_open,
4401 .close = playback_pcm_close,
4402 .prepare = playback_pcm_prepare,
4403 .cleanup = playback_pcm_cleanup
4407 static const struct hda_pcm_stream pcm_analog_capture = {
4411 /* NID is set in build_pcms */
4413 .open = capture_pcm_open,
4414 .close = capture_pcm_close,
4415 .prepare = capture_pcm_prepare,
4416 .cleanup = capture_pcm_cleanup
4420 static const struct hda_pcm_stream pcm_analog_alt_playback = {
4424 /* NID is set in build_pcms */
4426 .open = alt_playback_pcm_open,
4427 .close = alt_playback_pcm_close,
4428 .prepare = alt_playback_pcm_prepare,
4429 .cleanup = alt_playback_pcm_cleanup
4433 static const struct hda_pcm_stream pcm_analog_alt_capture = {
4434 .substreams = 2, /* can be overridden */
4437 /* NID is set in build_pcms */
4439 .open = alt_capture_pcm_open,
4440 .close = alt_capture_pcm_close,
4441 .prepare = alt_capture_pcm_prepare,
4442 .cleanup = alt_capture_pcm_cleanup
4446 static const struct hda_pcm_stream pcm_digital_playback = {
4450 /* NID is set in build_pcms */
4452 .open = dig_playback_pcm_open,
4453 .close = dig_playback_pcm_close,
4454 .prepare = dig_playback_pcm_prepare,
4455 .cleanup = dig_playback_pcm_cleanup
4459 static const struct hda_pcm_stream pcm_digital_capture = {
4463 /* NID is set in build_pcms */
4466 /* Used by build_pcms to flag that a PCM has no playback stream */
4467 static const struct hda_pcm_stream pcm_null_stream = {
4474 * dynamic changing ADC PCM streams
4476 static bool dyn_adc_pcm_resetup(struct hda_codec *codec, int cur)
4478 struct hda_gen_spec *spec = codec->spec;
4479 hda_nid_t new_adc = spec->adc_nids[spec->dyn_adc_idx[cur]];
4481 if (spec->cur_adc && spec->cur_adc != new_adc) {
4482 /* stream is running, let's swap the current ADC */
4483 __snd_hda_codec_cleanup_stream(codec, spec->cur_adc, 1);
4484 spec->cur_adc = new_adc;
4485 snd_hda_codec_setup_stream(codec, new_adc,
4486 spec->cur_adc_stream_tag, 0,
4487 spec->cur_adc_format);
4493 /* analog capture with dynamic dual-adc changes */
4494 static int dyn_adc_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
4495 struct hda_codec *codec,
4496 unsigned int stream_tag,
4497 unsigned int format,
4498 struct snd_pcm_substream *substream)
4500 struct hda_gen_spec *spec = codec->spec;
4501 spec->cur_adc = spec->adc_nids[spec->dyn_adc_idx[spec->cur_mux[0]]];
4502 spec->cur_adc_stream_tag = stream_tag;
4503 spec->cur_adc_format = format;
4504 snd_hda_codec_setup_stream(codec, spec->cur_adc, stream_tag, 0, format);
4508 static int dyn_adc_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
4509 struct hda_codec *codec,
4510 struct snd_pcm_substream *substream)
4512 struct hda_gen_spec *spec = codec->spec;
4513 snd_hda_codec_cleanup_stream(codec, spec->cur_adc);
4518 static const struct hda_pcm_stream dyn_adc_pcm_analog_capture = {
4522 .nid = 0, /* fill later */
4524 .prepare = dyn_adc_capture_pcm_prepare,
4525 .cleanup = dyn_adc_capture_pcm_cleanup
4529 static void fill_pcm_stream_name(char *str, size_t len, const char *sfx,
4530 const char *chip_name)
4536 strlcpy(str, chip_name, len);
4538 /* drop non-alnum chars after a space */
4539 for (p = strchr(str, ' '); p; p = strchr(p + 1, ' ')) {
4540 if (!isalnum(p[1])) {
4545 strlcat(str, sfx, len);
4548 /* build PCM streams based on the parsed results */
4549 int snd_hda_gen_build_pcms(struct hda_codec *codec)
4551 struct hda_gen_spec *spec = codec->spec;
4552 struct hda_pcm *info = spec->pcm_rec;
4553 const struct hda_pcm_stream *p;
4554 bool have_multi_adcs;
4556 codec->num_pcms = 1;
4557 codec->pcm_info = info;
4559 if (spec->no_analog)
4562 fill_pcm_stream_name(spec->stream_name_analog,
4563 sizeof(spec->stream_name_analog),
4564 " Analog", codec->chip_name);
4565 info->name = spec->stream_name_analog;
4567 if (spec->multiout.num_dacs > 0) {
4568 p = spec->stream_analog_playback;
4570 p = &pcm_analog_playback;
4571 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *p;
4572 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dac_nids[0];
4573 info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max =
4574 spec->multiout.max_channels;
4575 if (spec->autocfg.line_out_type == AUTO_PIN_SPEAKER_OUT &&
4576 spec->autocfg.line_outs == 2)
4577 info->stream[SNDRV_PCM_STREAM_PLAYBACK].chmap =
4580 if (spec->num_adc_nids) {
4581 p = spec->stream_analog_capture;
4583 if (spec->dyn_adc_switch)
4584 p = &dyn_adc_pcm_analog_capture;
4586 p = &pcm_analog_capture;
4588 info->stream[SNDRV_PCM_STREAM_CAPTURE] = *p;
4589 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adc_nids[0];
4593 /* SPDIF for stream index #1 */
4594 if (spec->multiout.dig_out_nid || spec->dig_in_nid) {
4595 fill_pcm_stream_name(spec->stream_name_digital,
4596 sizeof(spec->stream_name_digital),
4597 " Digital", codec->chip_name);
4598 codec->num_pcms = 2;
4599 codec->slave_dig_outs = spec->multiout.slave_dig_outs;
4600 info = spec->pcm_rec + 1;
4601 info->name = spec->stream_name_digital;
4602 if (spec->dig_out_type)
4603 info->pcm_type = spec->dig_out_type;
4605 info->pcm_type = HDA_PCM_TYPE_SPDIF;
4606 if (spec->multiout.dig_out_nid) {
4607 p = spec->stream_digital_playback;
4609 p = &pcm_digital_playback;
4610 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *p;
4611 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dig_out_nid;
4613 if (spec->dig_in_nid) {
4614 p = spec->stream_digital_capture;
4616 p = &pcm_digital_capture;
4617 info->stream[SNDRV_PCM_STREAM_CAPTURE] = *p;
4618 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->dig_in_nid;
4622 if (spec->no_analog)
4625 /* If the use of more than one ADC is requested for the current
4626 * model, configure a second analog capture-only PCM.
4628 have_multi_adcs = (spec->num_adc_nids > 1) &&
4629 !spec->dyn_adc_switch && !spec->auto_mic;
4630 /* Additional Analaog capture for index #2 */
4631 if (spec->alt_dac_nid || have_multi_adcs) {
4632 fill_pcm_stream_name(spec->stream_name_alt_analog,
4633 sizeof(spec->stream_name_alt_analog),
4634 " Alt Analog", codec->chip_name);
4635 codec->num_pcms = 3;
4636 info = spec->pcm_rec + 2;
4637 info->name = spec->stream_name_alt_analog;
4638 if (spec->alt_dac_nid) {
4639 p = spec->stream_analog_alt_playback;
4641 p = &pcm_analog_alt_playback;
4642 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *p;
4643 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid =
4646 info->stream[SNDRV_PCM_STREAM_PLAYBACK] =
4648 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = 0;
4650 if (have_multi_adcs) {
4651 p = spec->stream_analog_alt_capture;
4653 p = &pcm_analog_alt_capture;
4654 info->stream[SNDRV_PCM_STREAM_CAPTURE] = *p;
4655 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid =
4657 info->stream[SNDRV_PCM_STREAM_CAPTURE].substreams =
4658 spec->num_adc_nids - 1;
4660 info->stream[SNDRV_PCM_STREAM_CAPTURE] =
4662 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = 0;
4668 EXPORT_SYMBOL_HDA(snd_hda_gen_build_pcms);
4672 * Standard auto-parser initializations
4675 /* configure the given path as a proper output */
4676 static void set_output_and_unmute(struct hda_codec *codec, int path_idx)
4678 struct nid_path *path;
4681 path = snd_hda_get_path_from_idx(codec, path_idx);
4682 if (!path || !path->depth)
4684 pin = path->path[path->depth - 1];
4685 restore_pin_ctl(codec, pin);
4686 snd_hda_activate_path(codec, path, path->active, true);
4687 set_pin_eapd(codec, pin, path->active);
4690 /* initialize primary output paths */
4691 static void init_multi_out(struct hda_codec *codec)
4693 struct hda_gen_spec *spec = codec->spec;
4696 for (i = 0; i < spec->autocfg.line_outs; i++)
4697 set_output_and_unmute(codec, spec->out_paths[i]);
4701 static void __init_extra_out(struct hda_codec *codec, int num_outs, int *paths)
4705 for (i = 0; i < num_outs; i++)
4706 set_output_and_unmute(codec, paths[i]);
4709 /* initialize hp and speaker paths */
4710 static void init_extra_out(struct hda_codec *codec)
4712 struct hda_gen_spec *spec = codec->spec;
4714 if (spec->autocfg.line_out_type != AUTO_PIN_HP_OUT)
4715 __init_extra_out(codec, spec->autocfg.hp_outs, spec->hp_paths);
4716 if (spec->autocfg.line_out_type != AUTO_PIN_SPEAKER_OUT)
4717 __init_extra_out(codec, spec->autocfg.speaker_outs,
4718 spec->speaker_paths);
4721 /* initialize multi-io paths */
4722 static void init_multi_io(struct hda_codec *codec)
4724 struct hda_gen_spec *spec = codec->spec;
4727 for (i = 0; i < spec->multi_ios; i++) {
4728 hda_nid_t pin = spec->multi_io[i].pin;
4729 struct nid_path *path;
4730 path = get_multiio_path(codec, i);
4733 if (!spec->multi_io[i].ctl_in)
4734 spec->multi_io[i].ctl_in =
4735 snd_hda_codec_get_pin_target(codec, pin);
4736 snd_hda_activate_path(codec, path, path->active, true);
4740 /* set up input pins and loopback paths */
4741 static void init_analog_input(struct hda_codec *codec)
4743 struct hda_gen_spec *spec = codec->spec;
4744 struct auto_pin_cfg *cfg = &spec->autocfg;
4747 for (i = 0; i < cfg->num_inputs; i++) {
4748 hda_nid_t nid = cfg->inputs[i].pin;
4749 if (is_input_pin(codec, nid))
4750 restore_pin_ctl(codec, nid);
4752 /* init loopback inputs */
4753 if (spec->mixer_nid) {
4754 resume_path_from_idx(codec, spec->loopback_paths[i]);
4755 resume_path_from_idx(codec, spec->loopback_merge_path);
4760 /* initialize ADC paths */
4761 static void init_input_src(struct hda_codec *codec)
4763 struct hda_gen_spec *spec = codec->spec;
4764 struct hda_input_mux *imux = &spec->input_mux;
4765 struct nid_path *path;
4768 if (spec->dyn_adc_switch)
4771 nums = spec->num_adc_nids;
4773 for (c = 0; c < nums; c++) {
4774 for (i = 0; i < imux->num_items; i++) {
4775 path = get_input_path(codec, c, i);
4777 bool active = path->active;
4778 if (i == spec->cur_mux[c])
4780 snd_hda_activate_path(codec, path, active, false);
4785 if (spec->shared_mic_hp)
4786 update_shared_mic_hp(codec, spec->cur_mux[0]);
4788 if (spec->cap_sync_hook)
4789 spec->cap_sync_hook(codec, NULL);
4792 /* set right pin controls for digital I/O */
4793 static void init_digital(struct hda_codec *codec)
4795 struct hda_gen_spec *spec = codec->spec;
4799 for (i = 0; i < spec->autocfg.dig_outs; i++)
4800 set_output_and_unmute(codec, spec->digout_paths[i]);
4801 pin = spec->autocfg.dig_in_pin;
4803 restore_pin_ctl(codec, pin);
4804 resume_path_from_idx(codec, spec->digin_path);
4808 /* clear unsol-event tags on unused pins; Conexant codecs seem to leave
4809 * invalid unsol tags by some reason
4811 static void clear_unsol_on_unused_pins(struct hda_codec *codec)
4815 for (i = 0; i < codec->init_pins.used; i++) {
4816 struct hda_pincfg *pin = snd_array_elem(&codec->init_pins, i);
4817 hda_nid_t nid = pin->nid;
4818 if (is_jack_detectable(codec, nid) &&
4819 !snd_hda_jack_tbl_get(codec, nid))
4820 snd_hda_codec_update_cache(codec, nid, 0,
4821 AC_VERB_SET_UNSOLICITED_ENABLE, 0);
4826 * initialize the generic spec;
4827 * this can be put as patch_ops.init function
4829 int snd_hda_gen_init(struct hda_codec *codec)
4831 struct hda_gen_spec *spec = codec->spec;
4833 if (spec->init_hook)
4834 spec->init_hook(codec);
4836 snd_hda_apply_verbs(codec);
4838 codec->cached_write = 1;
4840 init_multi_out(codec);
4841 init_extra_out(codec);
4842 init_multi_io(codec);
4843 init_analog_input(codec);
4844 init_input_src(codec);
4845 init_digital(codec);
4847 clear_unsol_on_unused_pins(codec);
4849 /* call init functions of standard auto-mute helpers */
4850 update_automute_all(codec);
4852 snd_hda_codec_flush_cache(codec);
4854 if (spec->vmaster_mute.sw_kctl && spec->vmaster_mute.hook)
4855 snd_hda_sync_vmaster_hook(&spec->vmaster_mute);
4857 hda_call_check_power_status(codec, 0x01);
4860 EXPORT_SYMBOL_HDA(snd_hda_gen_init);
4863 * free the generic spec;
4864 * this can be put as patch_ops.free function
4866 void snd_hda_gen_free(struct hda_codec *codec)
4868 snd_hda_gen_spec_free(codec->spec);
4872 EXPORT_SYMBOL_HDA(snd_hda_gen_free);
4876 * check the loopback power save state;
4877 * this can be put as patch_ops.check_power_status function
4879 int snd_hda_gen_check_power_status(struct hda_codec *codec, hda_nid_t nid)
4881 struct hda_gen_spec *spec = codec->spec;
4882 return snd_hda_check_amp_list_power(codec, &spec->loopback, nid);
4884 EXPORT_SYMBOL_HDA(snd_hda_gen_check_power_status);
4889 * the generic codec support
4892 static const struct hda_codec_ops generic_patch_ops = {
4893 .build_controls = snd_hda_gen_build_controls,
4894 .build_pcms = snd_hda_gen_build_pcms,
4895 .init = snd_hda_gen_init,
4896 .free = snd_hda_gen_free,
4897 .unsol_event = snd_hda_jack_unsol_event,
4899 .check_power_status = snd_hda_gen_check_power_status,
4903 int snd_hda_parse_generic_codec(struct hda_codec *codec)
4905 struct hda_gen_spec *spec;
4908 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
4911 snd_hda_gen_spec_init(spec);
4914 err = snd_hda_parse_pin_defcfg(codec, &spec->autocfg, NULL, 0);
4918 err = snd_hda_gen_parse_auto_config(codec, &spec->autocfg);
4922 codec->patch_ops = generic_patch_ops;
4926 snd_hda_gen_free(codec);
4929 EXPORT_SYMBOL_HDA(snd_hda_parse_generic_codec);