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/ctype.h>
28 #include <linux/string.h>
29 #include <sound/core.h>
30 #include <sound/jack.h>
31 #include "hda_codec.h"
32 #include "hda_local.h"
33 #include "hda_auto_parser.h"
35 #include "hda_generic.h"
38 /* initialize hda_gen_spec struct */
39 int snd_hda_gen_spec_init(struct hda_gen_spec *spec)
41 snd_array_init(&spec->kctls, sizeof(struct snd_kcontrol_new), 32);
42 snd_array_init(&spec->paths, sizeof(struct nid_path), 8);
43 mutex_init(&spec->pcm_mutex);
46 EXPORT_SYMBOL_HDA(snd_hda_gen_spec_init);
48 struct snd_kcontrol_new *
49 snd_hda_gen_add_kctl(struct hda_gen_spec *spec, const char *name,
50 const struct snd_kcontrol_new *temp)
52 struct snd_kcontrol_new *knew = snd_array_new(&spec->kctls);
57 knew->name = kstrdup(name, GFP_KERNEL);
59 knew->name = kstrdup(knew->name, GFP_KERNEL);
64 EXPORT_SYMBOL_HDA(snd_hda_gen_add_kctl);
66 static void free_kctls(struct hda_gen_spec *spec)
68 if (spec->kctls.list) {
69 struct snd_kcontrol_new *kctl = spec->kctls.list;
71 for (i = 0; i < spec->kctls.used; i++)
74 snd_array_free(&spec->kctls);
77 void snd_hda_gen_spec_free(struct hda_gen_spec *spec)
82 snd_array_free(&spec->paths);
84 EXPORT_SYMBOL_HDA(snd_hda_gen_spec_free);
89 static void parse_user_hints(struct hda_codec *codec)
91 struct hda_gen_spec *spec = codec->spec;
94 val = snd_hda_get_bool_hint(codec, "jack_detect");
96 codec->no_jack_detect = !val;
97 val = snd_hda_get_bool_hint(codec, "inv_jack_detect");
99 codec->inv_jack_detect = !!val;
100 val = snd_hda_get_bool_hint(codec, "trigger_sense");
102 codec->no_trigger_sense = !val;
103 val = snd_hda_get_bool_hint(codec, "inv_eapd");
105 codec->inv_eapd = !!val;
106 val = snd_hda_get_bool_hint(codec, "pcm_format_first");
108 codec->pcm_format_first = !!val;
109 val = snd_hda_get_bool_hint(codec, "sticky_stream");
111 codec->no_sticky_stream = !val;
112 val = snd_hda_get_bool_hint(codec, "spdif_status_reset");
114 codec->spdif_status_reset = !!val;
115 val = snd_hda_get_bool_hint(codec, "pin_amp_workaround");
117 codec->pin_amp_workaround = !!val;
118 val = snd_hda_get_bool_hint(codec, "single_adc_amp");
120 codec->single_adc_amp = !!val;
122 val = snd_hda_get_bool_hint(codec, "auto_mic");
124 spec->suppress_auto_mic = !val;
125 val = snd_hda_get_bool_hint(codec, "line_in_auto_switch");
127 spec->line_in_auto_switch = !!val;
128 val = snd_hda_get_bool_hint(codec, "need_dac_fix");
130 spec->need_dac_fix = !!val;
131 val = snd_hda_get_bool_hint(codec, "primary_hp");
133 spec->no_primary_hp = !val;
134 val = snd_hda_get_bool_hint(codec, "multi_cap_vol");
136 spec->multi_cap_vol = !!val;
137 val = snd_hda_get_bool_hint(codec, "inv_dmic_split");
139 spec->inv_dmic_split = !!val;
140 val = snd_hda_get_bool_hint(codec, "indep_hp");
142 spec->indep_hp = !!val;
143 val = snd_hda_get_bool_hint(codec, "add_stereo_mix_input");
145 spec->add_stereo_mix_input = !!val;
146 val = snd_hda_get_bool_hint(codec, "add_out_jack_modes");
148 spec->add_out_jack_modes = !!val;
150 if (!snd_hda_get_int_hint(codec, "mixer_nid", &val))
151 spec->mixer_nid = val;
155 * pin control value accesses
158 #define update_pin_ctl(codec, pin, val) \
159 snd_hda_codec_update_cache(codec, pin, 0, \
160 AC_VERB_SET_PIN_WIDGET_CONTROL, val)
162 /* restore the pinctl based on the cached value */
163 static inline void restore_pin_ctl(struct hda_codec *codec, hda_nid_t pin)
165 update_pin_ctl(codec, pin, snd_hda_codec_get_pin_target(codec, pin));
168 /* set the pinctl target value and write it if requested */
169 static void set_pin_target(struct hda_codec *codec, hda_nid_t pin,
170 unsigned int val, bool do_write)
174 val = snd_hda_correct_pin_ctl(codec, pin, val);
175 snd_hda_codec_set_pin_target(codec, pin, val);
177 update_pin_ctl(codec, pin, val);
180 /* set pinctl target values for all given pins */
181 static void set_pin_targets(struct hda_codec *codec, int num_pins,
182 hda_nid_t *pins, unsigned int val)
185 for (i = 0; i < num_pins; i++)
186 set_pin_target(codec, pins[i], val, false);
193 /* return the position of NID in the list, or -1 if not found */
194 static int find_idx_in_nid_list(hda_nid_t nid, const hda_nid_t *list, int nums)
197 for (i = 0; i < nums; i++)
203 /* return true if the given NID is contained in the path */
204 static bool is_nid_contained(struct nid_path *path, hda_nid_t nid)
206 return find_idx_in_nid_list(nid, path->path, path->depth) >= 0;
209 static struct nid_path *get_nid_path(struct hda_codec *codec,
210 hda_nid_t from_nid, hda_nid_t to_nid,
213 struct hda_gen_spec *spec = codec->spec;
216 for (i = 0; i < spec->paths.used; i++) {
217 struct nid_path *path = snd_array_elem(&spec->paths, i);
218 if (path->depth <= 0)
220 if ((!from_nid || path->path[0] == from_nid) &&
221 (!to_nid || path->path[path->depth - 1] == to_nid)) {
223 (anchor_nid > 0 && is_nid_contained(path, anchor_nid)) ||
224 (anchor_nid < 0 && !is_nid_contained(path, anchor_nid)))
231 /* get the path between the given NIDs;
232 * passing 0 to either @pin or @dac behaves as a wildcard
234 struct nid_path *snd_hda_get_nid_path(struct hda_codec *codec,
235 hda_nid_t from_nid, hda_nid_t to_nid)
237 return get_nid_path(codec, from_nid, to_nid, 0);
239 EXPORT_SYMBOL_HDA(snd_hda_get_nid_path);
241 /* get the index number corresponding to the path instance;
242 * the index starts from 1, for easier checking the invalid value
244 int snd_hda_get_path_idx(struct hda_codec *codec, struct nid_path *path)
246 struct hda_gen_spec *spec = codec->spec;
247 struct nid_path *array = spec->paths.list;
250 if (!spec->paths.used)
253 if (idx < 0 || idx >= spec->paths.used)
258 /* get the path instance corresponding to the given index number */
259 struct nid_path *snd_hda_get_path_from_idx(struct hda_codec *codec, int idx)
261 struct hda_gen_spec *spec = codec->spec;
263 if (idx <= 0 || idx > spec->paths.used)
265 return snd_array_elem(&spec->paths, idx - 1);
268 /* check whether the given DAC is already found in any existing paths */
269 static bool is_dac_already_used(struct hda_codec *codec, hda_nid_t nid)
271 struct hda_gen_spec *spec = codec->spec;
274 for (i = 0; i < spec->paths.used; i++) {
275 struct nid_path *path = snd_array_elem(&spec->paths, i);
276 if (path->path[0] == nid)
282 /* check whether the given two widgets can be connected */
283 static bool is_reachable_path(struct hda_codec *codec,
284 hda_nid_t from_nid, hda_nid_t to_nid)
286 if (!from_nid || !to_nid)
288 return snd_hda_get_conn_index(codec, to_nid, from_nid, true) >= 0;
291 /* nid, dir and idx */
292 #define AMP_VAL_COMPARE_MASK (0xffff | (1U << 18) | (0x0f << 19))
294 /* check whether the given ctl is already assigned in any path elements */
295 static bool is_ctl_used(struct hda_codec *codec, unsigned int val, int type)
297 struct hda_gen_spec *spec = codec->spec;
300 val &= AMP_VAL_COMPARE_MASK;
301 for (i = 0; i < spec->paths.used; i++) {
302 struct nid_path *path = snd_array_elem(&spec->paths, i);
303 if ((path->ctls[type] & AMP_VAL_COMPARE_MASK) == val)
309 /* check whether a control with the given (nid, dir, idx) was assigned */
310 static bool is_ctl_associated(struct hda_codec *codec, hda_nid_t nid,
313 unsigned int val = HDA_COMPOSE_AMP_VAL(nid, 3, idx, dir);
314 return is_ctl_used(codec, val, NID_PATH_VOL_CTL) ||
315 is_ctl_used(codec, val, NID_PATH_MUTE_CTL);
318 static void print_nid_path(const char *pfx, struct nid_path *path)
325 for (i = 0; i < path->depth; i++) {
327 sprintf(tmp, ":%02x", path->path[i]);
328 strlcat(buf, tmp, sizeof(buf));
330 snd_printdd("%s path: depth=%d %s\n", pfx, path->depth, buf);
333 /* called recursively */
334 static bool __parse_nid_path(struct hda_codec *codec,
335 hda_nid_t from_nid, hda_nid_t to_nid,
336 int anchor_nid, struct nid_path *path,
339 const hda_nid_t *conn;
342 if (to_nid == anchor_nid)
343 anchor_nid = 0; /* anchor passed */
344 else if (to_nid == (hda_nid_t)(-anchor_nid))
345 return false; /* hit the exclusive nid */
347 nums = snd_hda_get_conn_list(codec, to_nid, &conn);
348 for (i = 0; i < nums; i++) {
349 if (conn[i] != from_nid) {
350 /* special case: when from_nid is 0,
351 * try to find an empty DAC
354 get_wcaps_type(get_wcaps(codec, conn[i])) != AC_WID_AUD_OUT ||
355 is_dac_already_used(codec, conn[i]))
358 /* anchor is not requested or already passed? */
362 if (depth >= MAX_NID_PATH_DEPTH)
364 for (i = 0; i < nums; i++) {
366 type = get_wcaps_type(get_wcaps(codec, conn[i]));
367 if (type == AC_WID_AUD_OUT || type == AC_WID_AUD_IN ||
370 if (__parse_nid_path(codec, from_nid, conn[i],
371 anchor_nid, path, depth + 1))
377 path->path[path->depth] = conn[i];
378 path->idx[path->depth + 1] = i;
379 if (nums > 1 && get_wcaps_type(get_wcaps(codec, to_nid)) != AC_WID_AUD_MIX)
380 path->multi[path->depth + 1] = 1;
385 /* parse the widget path from the given nid to the target nid;
386 * when @from_nid is 0, try to find an empty DAC;
387 * when @anchor_nid is set to a positive value, only paths through the widget
388 * with the given value are evaluated.
389 * when @anchor_nid is set to a negative value, paths through the widget
390 * with the negative of given value are excluded, only other paths are chosen.
391 * when @anchor_nid is zero, no special handling about path selection.
393 bool snd_hda_parse_nid_path(struct hda_codec *codec, hda_nid_t from_nid,
394 hda_nid_t to_nid, int anchor_nid,
395 struct nid_path *path)
397 if (__parse_nid_path(codec, from_nid, to_nid, anchor_nid, path, 1)) {
398 path->path[path->depth] = to_nid;
404 EXPORT_SYMBOL_HDA(snd_hda_parse_nid_path);
407 * parse the path between the given NIDs and add to the path list.
408 * if no valid path is found, return NULL
411 snd_hda_add_new_path(struct hda_codec *codec, hda_nid_t from_nid,
412 hda_nid_t to_nid, int anchor_nid)
414 struct hda_gen_spec *spec = codec->spec;
415 struct nid_path *path;
417 if (from_nid && to_nid && !is_reachable_path(codec, from_nid, to_nid))
420 /* check whether the path has been already added */
421 path = get_nid_path(codec, from_nid, to_nid, anchor_nid);
425 path = snd_array_new(&spec->paths);
428 memset(path, 0, sizeof(*path));
429 if (snd_hda_parse_nid_path(codec, from_nid, to_nid, anchor_nid, path))
435 EXPORT_SYMBOL_HDA(snd_hda_add_new_path);
437 /* clear the given path as invalid so that it won't be picked up later */
438 static void invalidate_nid_path(struct hda_codec *codec, int idx)
440 struct nid_path *path = snd_hda_get_path_from_idx(codec, idx);
443 memset(path, 0, sizeof(*path));
446 /* look for an empty DAC slot */
447 static hda_nid_t look_for_dac(struct hda_codec *codec, hda_nid_t pin,
450 struct hda_gen_spec *spec = codec->spec;
454 for (i = 0; i < spec->num_all_dacs; i++) {
455 hda_nid_t nid = spec->all_dacs[i];
456 if (!nid || is_dac_already_used(codec, nid))
458 cap_digital = !!(get_wcaps(codec, nid) & AC_WCAP_DIGITAL);
459 if (is_digital != cap_digital)
461 if (is_reachable_path(codec, nid, pin))
467 /* replace the channels in the composed amp value with the given number */
468 static unsigned int amp_val_replace_channels(unsigned int val, unsigned int chs)
470 val &= ~(0x3U << 16);
475 /* check whether the widget has the given amp capability for the direction */
476 static bool check_amp_caps(struct hda_codec *codec, hda_nid_t nid,
477 int dir, unsigned int bits)
481 if (get_wcaps(codec, nid) & (1 << (dir + 1)))
482 if (query_amp_caps(codec, nid, dir) & bits)
487 #define nid_has_mute(codec, nid, dir) \
488 check_amp_caps(codec, nid, dir, AC_AMPCAP_MUTE)
489 #define nid_has_volume(codec, nid, dir) \
490 check_amp_caps(codec, nid, dir, AC_AMPCAP_NUM_STEPS)
492 /* look for a widget suitable for assigning a mute switch in the path */
493 static hda_nid_t look_for_out_mute_nid(struct hda_codec *codec,
494 struct nid_path *path)
498 for (i = path->depth - 1; i >= 0; i--) {
499 if (nid_has_mute(codec, path->path[i], HDA_OUTPUT))
500 return path->path[i];
501 if (i != path->depth - 1 && i != 0 &&
502 nid_has_mute(codec, path->path[i], HDA_INPUT))
503 return path->path[i];
508 /* look for a widget suitable for assigning a volume ctl in the path */
509 static hda_nid_t look_for_out_vol_nid(struct hda_codec *codec,
510 struct nid_path *path)
514 for (i = path->depth - 1; i >= 0; i--) {
515 if (nid_has_volume(codec, path->path[i], HDA_OUTPUT))
516 return path->path[i];
522 * path activation / deactivation
525 /* can have the amp-in capability? */
526 static bool has_amp_in(struct hda_codec *codec, struct nid_path *path, int idx)
528 hda_nid_t nid = path->path[idx];
529 unsigned int caps = get_wcaps(codec, nid);
530 unsigned int type = get_wcaps_type(caps);
532 if (!(caps & AC_WCAP_IN_AMP))
534 if (type == AC_WID_PIN && idx > 0) /* only for input pins */
539 /* can have the amp-out capability? */
540 static bool has_amp_out(struct hda_codec *codec, struct nid_path *path, int idx)
542 hda_nid_t nid = path->path[idx];
543 unsigned int caps = get_wcaps(codec, nid);
544 unsigned int type = get_wcaps_type(caps);
546 if (!(caps & AC_WCAP_OUT_AMP))
548 if (type == AC_WID_PIN && !idx) /* only for output pins */
553 /* check whether the given (nid,dir,idx) is active */
554 static bool is_active_nid(struct hda_codec *codec, hda_nid_t nid,
555 unsigned int idx, unsigned int dir)
557 struct hda_gen_spec *spec = codec->spec;
560 for (n = 0; n < spec->paths.used; n++) {
561 struct nid_path *path = snd_array_elem(&spec->paths, n);
564 for (i = 0; i < path->depth; i++) {
565 if (path->path[i] == nid) {
566 if (dir == HDA_OUTPUT || path->idx[i] == idx)
575 /* get the default amp value for the target state */
576 static int get_amp_val_to_activate(struct hda_codec *codec, hda_nid_t nid,
577 int dir, bool enable)
580 unsigned int val = 0;
582 caps = query_amp_caps(codec, nid, dir);
583 if (caps & AC_AMPCAP_NUM_STEPS) {
586 val = (caps & AC_AMPCAP_OFFSET) >> AC_AMPCAP_OFFSET_SHIFT;
588 if (caps & AC_AMPCAP_MUTE) {
595 /* initialize the amp value (only at the first time) */
596 static void init_amp(struct hda_codec *codec, hda_nid_t nid, int dir, int idx)
598 int val = get_amp_val_to_activate(codec, nid, dir, false);
599 snd_hda_codec_amp_init_stereo(codec, nid, dir, idx, 0xff, val);
602 static void activate_amp(struct hda_codec *codec, hda_nid_t nid, int dir,
603 int idx, bool enable)
606 if (is_ctl_associated(codec, nid, dir, idx) ||
607 (!enable && is_active_nid(codec, nid, dir, idx)))
609 val = get_amp_val_to_activate(codec, nid, dir, enable);
610 snd_hda_codec_amp_stereo(codec, nid, dir, idx, 0xff, val);
613 static void activate_amp_out(struct hda_codec *codec, struct nid_path *path,
616 hda_nid_t nid = path->path[i];
617 init_amp(codec, nid, HDA_OUTPUT, 0);
618 activate_amp(codec, nid, HDA_OUTPUT, 0, enable);
621 static void activate_amp_in(struct hda_codec *codec, struct nid_path *path,
622 int i, bool enable, bool add_aamix)
624 struct hda_gen_spec *spec = codec->spec;
625 const hda_nid_t *conn;
628 hda_nid_t nid = path->path[i];
630 nums = snd_hda_get_conn_list(codec, nid, &conn);
631 type = get_wcaps_type(get_wcaps(codec, nid));
632 if (type == AC_WID_PIN ||
633 (type == AC_WID_AUD_IN && codec->single_adc_amp)) {
639 for (n = 0; n < nums; n++)
640 init_amp(codec, nid, HDA_INPUT, n);
642 if (is_ctl_associated(codec, nid, HDA_INPUT, idx))
645 /* here is a little bit tricky in comparison with activate_amp_out();
646 * when aa-mixer is available, we need to enable the path as well
648 for (n = 0; n < nums; n++) {
649 if (n != idx && (!add_aamix || conn[n] != spec->mixer_nid))
651 activate_amp(codec, nid, HDA_INPUT, n, enable);
655 /* activate or deactivate the given path
656 * if @add_aamix is set, enable the input from aa-mix NID as well (if any)
658 void snd_hda_activate_path(struct hda_codec *codec, struct nid_path *path,
659 bool enable, bool add_aamix)
664 path->active = false;
666 for (i = path->depth - 1; i >= 0; i--) {
667 if (enable && path->multi[i])
668 snd_hda_codec_write_cache(codec, path->path[i], 0,
669 AC_VERB_SET_CONNECT_SEL,
671 if (has_amp_in(codec, path, i))
672 activate_amp_in(codec, path, i, enable, add_aamix);
673 if (has_amp_out(codec, path, i))
674 activate_amp_out(codec, path, i, enable);
680 EXPORT_SYMBOL_HDA(snd_hda_activate_path);
682 /* turn on/off EAPD on the given pin */
683 static void set_pin_eapd(struct hda_codec *codec, hda_nid_t pin, bool enable)
685 struct hda_gen_spec *spec = codec->spec;
686 if (spec->own_eapd_ctl ||
687 !(snd_hda_query_pin_caps(codec, pin) & AC_PINCAP_EAPD))
691 snd_hda_codec_update_cache(codec, pin, 0,
692 AC_VERB_SET_EAPD_BTLENABLE,
693 enable ? 0x02 : 0x00);
698 * Helper functions for creating mixer ctl elements
706 static const struct snd_kcontrol_new control_templates[] = {
707 HDA_CODEC_VOLUME(NULL, 0, 0, 0),
708 HDA_CODEC_MUTE(NULL, 0, 0, 0),
709 HDA_BIND_MUTE(NULL, 0, 0, 0),
712 /* add dynamic controls from template */
713 static int add_control(struct hda_gen_spec *spec, int type, const char *name,
714 int cidx, unsigned long val)
716 struct snd_kcontrol_new *knew;
718 knew = snd_hda_gen_add_kctl(spec, name, &control_templates[type]);
722 if (get_amp_nid_(val))
723 knew->subdevice = HDA_SUBDEV_AMP_FLAG;
724 knew->private_value = val;
728 static int add_control_with_pfx(struct hda_gen_spec *spec, int type,
729 const char *pfx, const char *dir,
730 const char *sfx, int cidx, unsigned long val)
733 snprintf(name, sizeof(name), "%s %s %s", pfx, dir, sfx);
734 return add_control(spec, type, name, cidx, val);
737 #define add_pb_vol_ctrl(spec, type, pfx, val) \
738 add_control_with_pfx(spec, type, pfx, "Playback", "Volume", 0, val)
739 #define add_pb_sw_ctrl(spec, type, pfx, val) \
740 add_control_with_pfx(spec, type, pfx, "Playback", "Switch", 0, val)
741 #define __add_pb_vol_ctrl(spec, type, pfx, cidx, val) \
742 add_control_with_pfx(spec, type, pfx, "Playback", "Volume", cidx, val)
743 #define __add_pb_sw_ctrl(spec, type, pfx, cidx, val) \
744 add_control_with_pfx(spec, type, pfx, "Playback", "Switch", cidx, val)
746 static int add_vol_ctl(struct hda_codec *codec, const char *pfx, int cidx,
747 unsigned int chs, struct nid_path *path)
752 val = path->ctls[NID_PATH_VOL_CTL];
755 val = amp_val_replace_channels(val, chs);
756 return __add_pb_vol_ctrl(codec->spec, HDA_CTL_WIDGET_VOL, pfx, cidx, val);
759 /* return the channel bits suitable for the given path->ctls[] */
760 static int get_default_ch_nums(struct hda_codec *codec, struct nid_path *path,
763 int chs = 1; /* mono (left only) */
765 hda_nid_t nid = get_amp_nid_(path->ctls[type]);
766 if (nid && (get_wcaps(codec, nid) & AC_WCAP_STEREO))
767 chs = 3; /* stereo */
772 static int add_stereo_vol(struct hda_codec *codec, const char *pfx, int cidx,
773 struct nid_path *path)
775 int chs = get_default_ch_nums(codec, path, NID_PATH_VOL_CTL);
776 return add_vol_ctl(codec, pfx, cidx, chs, path);
779 /* create a mute-switch for the given mixer widget;
780 * if it has multiple sources (e.g. DAC and loopback), create a bind-mute
782 static int add_sw_ctl(struct hda_codec *codec, const char *pfx, int cidx,
783 unsigned int chs, struct nid_path *path)
786 int type = HDA_CTL_WIDGET_MUTE;
790 val = path->ctls[NID_PATH_MUTE_CTL];
793 val = amp_val_replace_channels(val, chs);
794 if (get_amp_direction_(val) == HDA_INPUT) {
795 hda_nid_t nid = get_amp_nid_(val);
796 int nums = snd_hda_get_num_conns(codec, nid);
798 type = HDA_CTL_BIND_MUTE;
802 return __add_pb_sw_ctrl(codec->spec, type, pfx, cidx, val);
805 static int add_stereo_sw(struct hda_codec *codec, const char *pfx,
806 int cidx, struct nid_path *path)
808 int chs = get_default_ch_nums(codec, path, NID_PATH_MUTE_CTL);
809 return add_sw_ctl(codec, pfx, cidx, chs, path);
812 static const char * const channel_name[4] = {
813 "Front", "Surround", "CLFE", "Side"
816 /* give some appropriate ctl name prefix for the given line out channel */
817 static const char *get_line_out_pfx(struct hda_gen_spec *spec, int ch,
818 bool can_be_master, int *index)
820 struct auto_pin_cfg *cfg = &spec->autocfg;
823 if (cfg->line_outs == 1 && !spec->multi_ios &&
824 !cfg->hp_outs && !cfg->speaker_outs && can_be_master)
825 return spec->vmaster_mute.hook ? "PCM" : "Master";
827 /* if there is really a single DAC used in the whole output paths,
828 * use it master (or "PCM" if a vmaster hook is present)
830 if (spec->multiout.num_dacs == 1 && !spec->mixer_nid &&
831 !spec->multiout.hp_out_nid[0] && !spec->multiout.extra_out_nid[0])
832 return spec->vmaster_mute.hook ? "PCM" : "Master";
834 switch (cfg->line_out_type) {
835 case AUTO_PIN_SPEAKER_OUT:
836 if (cfg->line_outs == 1)
838 if (cfg->line_outs == 2)
839 return ch ? "Bass Speaker" : "Speaker";
841 case AUTO_PIN_HP_OUT:
842 /* for multi-io case, only the primary out */
843 if (ch && spec->multi_ios)
848 if (cfg->line_outs == 1 && !spec->multi_ios)
852 if (ch >= ARRAY_SIZE(channel_name)) {
857 return channel_name[ch];
864 /* badness definition */
866 /* No primary DAC is found for the main output */
867 BAD_NO_PRIMARY_DAC = 0x10000,
868 /* No DAC is found for the extra output */
870 /* No possible multi-ios */
871 BAD_MULTI_IO = 0x103,
872 /* No individual DAC for extra output */
873 BAD_NO_EXTRA_DAC = 0x102,
874 /* No individual DAC for extra surrounds */
875 BAD_NO_EXTRA_SURR_DAC = 0x101,
876 /* Primary DAC shared with main surrounds */
877 BAD_SHARED_SURROUND = 0x100,
878 /* Primary DAC shared with main CLFE */
879 BAD_SHARED_CLFE = 0x10,
880 /* Primary DAC shared with extra surrounds */
881 BAD_SHARED_EXTRA_SURROUND = 0x10,
882 /* Volume widget is shared */
883 BAD_SHARED_VOL = 0x10,
886 /* look for widgets in the given path which are appropriate for
887 * volume and mute controls, and assign the values to ctls[].
889 * When no appropriate widget is found in the path, the badness value
890 * is incremented depending on the situation. The function returns the
891 * total badness for both volume and mute controls.
893 static int assign_out_path_ctls(struct hda_codec *codec, struct nid_path *path)
900 return BAD_SHARED_VOL * 2;
902 if (path->ctls[NID_PATH_VOL_CTL] ||
903 path->ctls[NID_PATH_MUTE_CTL])
904 return 0; /* already evaluated */
906 nid = look_for_out_vol_nid(codec, path);
908 val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
909 if (is_ctl_used(codec, val, NID_PATH_VOL_CTL))
910 badness += BAD_SHARED_VOL;
912 path->ctls[NID_PATH_VOL_CTL] = val;
914 badness += BAD_SHARED_VOL;
915 nid = look_for_out_mute_nid(codec, path);
917 unsigned int wid_type = get_wcaps_type(get_wcaps(codec, nid));
918 if (wid_type == AC_WID_PIN || wid_type == AC_WID_AUD_OUT ||
919 nid_has_mute(codec, nid, HDA_OUTPUT))
920 val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
922 val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT);
923 if (is_ctl_used(codec, val, NID_PATH_MUTE_CTL))
924 badness += BAD_SHARED_VOL;
926 path->ctls[NID_PATH_MUTE_CTL] = val;
928 badness += BAD_SHARED_VOL;
932 struct badness_table {
933 int no_primary_dac; /* no primary DAC */
934 int no_dac; /* no secondary DACs */
935 int shared_primary; /* primary DAC is shared with main output */
936 int shared_surr; /* secondary DAC shared with main or primary */
937 int shared_clfe; /* third DAC shared with main or primary */
938 int shared_surr_main; /* secondary DAC sahred with main/DAC0 */
941 static struct badness_table main_out_badness = {
942 .no_primary_dac = BAD_NO_PRIMARY_DAC,
943 .no_dac = BAD_NO_DAC,
944 .shared_primary = BAD_NO_PRIMARY_DAC,
945 .shared_surr = BAD_SHARED_SURROUND,
946 .shared_clfe = BAD_SHARED_CLFE,
947 .shared_surr_main = BAD_SHARED_SURROUND,
950 static struct badness_table extra_out_badness = {
951 .no_primary_dac = BAD_NO_DAC,
952 .no_dac = BAD_NO_DAC,
953 .shared_primary = BAD_NO_EXTRA_DAC,
954 .shared_surr = BAD_SHARED_EXTRA_SURROUND,
955 .shared_clfe = BAD_SHARED_EXTRA_SURROUND,
956 .shared_surr_main = BAD_NO_EXTRA_SURR_DAC,
959 /* get the DAC of the primary output corresponding to the given array index */
960 static hda_nid_t get_primary_out(struct hda_codec *codec, int idx)
962 struct hda_gen_spec *spec = codec->spec;
963 struct auto_pin_cfg *cfg = &spec->autocfg;
965 if (cfg->line_outs > idx)
966 return spec->private_dac_nids[idx];
967 idx -= cfg->line_outs;
968 if (spec->multi_ios > idx)
969 return spec->multi_io[idx].dac;
973 /* return the DAC if it's reachable, otherwise zero */
974 static inline hda_nid_t try_dac(struct hda_codec *codec,
975 hda_nid_t dac, hda_nid_t pin)
977 return is_reachable_path(codec, dac, pin) ? dac : 0;
980 /* try to assign DACs to pins and return the resultant badness */
981 static int try_assign_dacs(struct hda_codec *codec, int num_outs,
982 const hda_nid_t *pins, hda_nid_t *dacs,
984 const struct badness_table *bad)
986 struct hda_gen_spec *spec = codec->spec;
994 for (i = 0; i < num_outs; i++) {
995 struct nid_path *path;
996 hda_nid_t pin = pins[i];
998 path = snd_hda_get_path_from_idx(codec, path_idx[i]);
1000 badness += assign_out_path_ctls(codec, path);
1004 dacs[i] = look_for_dac(codec, pin, false);
1005 if (!dacs[i] && !i) {
1006 /* try to steal the DAC of surrounds for the front */
1007 for (j = 1; j < num_outs; j++) {
1008 if (is_reachable_path(codec, dacs[j], pin)) {
1011 invalidate_nid_path(codec, path_idx[j]);
1020 dac = try_dac(codec, get_primary_out(codec, i), pin);
1022 dac = try_dac(codec, dacs[0], pin);
1024 dac = try_dac(codec, get_primary_out(codec, i), pin);
1027 badness += bad->shared_primary;
1029 badness += bad->shared_surr;
1031 badness += bad->shared_clfe;
1032 } else if (is_reachable_path(codec, spec->private_dac_nids[0], pin)) {
1033 dac = spec->private_dac_nids[0];
1034 badness += bad->shared_surr_main;
1036 badness += bad->no_primary_dac;
1038 badness += bad->no_dac;
1040 path = snd_hda_add_new_path(codec, dac, pin, -spec->mixer_nid);
1041 if (!path && !i && spec->mixer_nid) {
1042 /* try with aamix */
1043 path = snd_hda_add_new_path(codec, dac, pin, 0);
1048 print_nid_path("output", path);
1049 path->active = true;
1050 path_idx[i] = snd_hda_get_path_idx(codec, path);
1051 badness += assign_out_path_ctls(codec, path);
1058 /* return NID if the given pin has only a single connection to a certain DAC */
1059 static hda_nid_t get_dac_if_single(struct hda_codec *codec, hda_nid_t pin)
1061 struct hda_gen_spec *spec = codec->spec;
1063 hda_nid_t nid_found = 0;
1065 for (i = 0; i < spec->num_all_dacs; i++) {
1066 hda_nid_t nid = spec->all_dacs[i];
1067 if (!nid || is_dac_already_used(codec, nid))
1069 if (is_reachable_path(codec, nid, pin)) {
1078 /* check whether the given pin can be a multi-io pin */
1079 static bool can_be_multiio_pin(struct hda_codec *codec,
1080 unsigned int location, hda_nid_t nid)
1082 unsigned int defcfg, caps;
1084 defcfg = snd_hda_codec_get_pincfg(codec, nid);
1085 if (get_defcfg_connect(defcfg) != AC_JACK_PORT_COMPLEX)
1087 if (location && get_defcfg_location(defcfg) != location)
1089 caps = snd_hda_query_pin_caps(codec, nid);
1090 if (!(caps & AC_PINCAP_OUT))
1095 /* count the number of input pins that are capable to be multi-io */
1096 static int count_multiio_pins(struct hda_codec *codec, hda_nid_t reference_pin)
1098 struct hda_gen_spec *spec = codec->spec;
1099 struct auto_pin_cfg *cfg = &spec->autocfg;
1100 unsigned int defcfg = snd_hda_codec_get_pincfg(codec, reference_pin);
1101 unsigned int location = get_defcfg_location(defcfg);
1105 for (type = AUTO_PIN_LINE_IN; type >= AUTO_PIN_MIC; type--) {
1106 for (i = 0; i < cfg->num_inputs; i++) {
1107 if (cfg->inputs[i].type != type)
1109 if (can_be_multiio_pin(codec, location,
1110 cfg->inputs[i].pin))
1120 * When hardwired is set, try to fill ony hardwired pins, and returns
1121 * zero if any pins are filled, non-zero if nothing found.
1122 * When hardwired is off, try to fill possible input pins, and returns
1123 * the badness value.
1125 static int fill_multi_ios(struct hda_codec *codec,
1126 hda_nid_t reference_pin,
1129 struct hda_gen_spec *spec = codec->spec;
1130 struct auto_pin_cfg *cfg = &spec->autocfg;
1131 int type, i, j, num_pins, old_pins;
1132 unsigned int defcfg = snd_hda_codec_get_pincfg(codec, reference_pin);
1133 unsigned int location = get_defcfg_location(defcfg);
1135 struct nid_path *path;
1137 old_pins = spec->multi_ios;
1141 num_pins = count_multiio_pins(codec, reference_pin);
1145 for (type = AUTO_PIN_LINE_IN; type >= AUTO_PIN_MIC; type--) {
1146 for (i = 0; i < cfg->num_inputs; i++) {
1147 hda_nid_t nid = cfg->inputs[i].pin;
1150 if (cfg->inputs[i].type != type)
1152 if (!can_be_multiio_pin(codec, location, nid))
1154 for (j = 0; j < spec->multi_ios; j++) {
1155 if (nid == spec->multi_io[j].pin)
1158 if (j < spec->multi_ios)
1162 dac = get_dac_if_single(codec, nid);
1164 dac = look_for_dac(codec, nid, false);
1169 path = snd_hda_add_new_path(codec, dac, nid,
1175 print_nid_path("multiio", path);
1176 spec->multi_io[spec->multi_ios].pin = nid;
1177 spec->multi_io[spec->multi_ios].dac = dac;
1178 spec->out_paths[cfg->line_outs + spec->multi_ios] =
1179 snd_hda_get_path_idx(codec, path);
1181 if (spec->multi_ios >= 2)
1187 badness = BAD_MULTI_IO;
1188 if (old_pins == spec->multi_ios) {
1190 return 1; /* nothing found */
1192 return badness; /* no badness if nothing found */
1194 if (!hardwired && spec->multi_ios < 2) {
1195 /* cancel newly assigned paths */
1196 spec->paths.used -= spec->multi_ios - old_pins;
1197 spec->multi_ios = old_pins;
1201 /* assign volume and mute controls */
1202 for (i = old_pins; i < spec->multi_ios; i++) {
1203 path = snd_hda_get_path_from_idx(codec, spec->out_paths[cfg->line_outs + i]);
1204 badness += assign_out_path_ctls(codec, path);
1210 /* map DACs for all pins in the list if they are single connections */
1211 static bool map_singles(struct hda_codec *codec, int outs,
1212 const hda_nid_t *pins, hda_nid_t *dacs, int *path_idx)
1214 struct hda_gen_spec *spec = codec->spec;
1217 for (i = 0; i < outs; i++) {
1218 struct nid_path *path;
1222 dac = get_dac_if_single(codec, pins[i]);
1225 path = snd_hda_add_new_path(codec, dac, pins[i],
1227 if (!path && !i && spec->mixer_nid)
1228 path = snd_hda_add_new_path(codec, dac, pins[i], 0);
1232 print_nid_path("output", path);
1233 path->active = true;
1234 path_idx[i] = snd_hda_get_path_idx(codec, path);
1240 /* create a new path including aamix if available, and return its index */
1241 static int check_aamix_out_path(struct hda_codec *codec, int path_idx)
1243 struct hda_gen_spec *spec = codec->spec;
1244 struct nid_path *path;
1246 path = snd_hda_get_path_from_idx(codec, path_idx);
1247 if (!path || !path->depth ||
1248 is_nid_contained(path, spec->mixer_nid))
1250 path = snd_hda_add_new_path(codec, path->path[0],
1251 path->path[path->depth - 1],
1255 print_nid_path("output-aamix", path);
1256 path->active = false; /* unused as default */
1257 return snd_hda_get_path_idx(codec, path);
1260 /* fill the empty entries in the dac array for speaker/hp with the
1261 * shared dac pointed by the paths
1263 static void refill_shared_dacs(struct hda_codec *codec, int num_outs,
1264 hda_nid_t *dacs, int *path_idx)
1266 struct nid_path *path;
1269 for (i = 0; i < num_outs; i++) {
1272 path = snd_hda_get_path_from_idx(codec, path_idx[i]);
1275 dacs[i] = path->path[0];
1279 /* fill in the dac_nids table from the parsed pin configuration */
1280 static int fill_and_eval_dacs(struct hda_codec *codec,
1281 bool fill_hardwired,
1282 bool fill_mio_first)
1284 struct hda_gen_spec *spec = codec->spec;
1285 struct auto_pin_cfg *cfg = &spec->autocfg;
1286 int i, err, badness;
1289 /* set num_dacs once to full for look_for_dac() */
1290 spec->multiout.num_dacs = cfg->line_outs;
1291 spec->multiout.dac_nids = spec->private_dac_nids;
1292 memset(spec->private_dac_nids, 0, sizeof(spec->private_dac_nids));
1293 memset(spec->multiout.hp_out_nid, 0, sizeof(spec->multiout.hp_out_nid));
1294 memset(spec->multiout.extra_out_nid, 0, sizeof(spec->multiout.extra_out_nid));
1295 spec->multi_ios = 0;
1296 snd_array_free(&spec->paths);
1298 /* clear path indices */
1299 memset(spec->out_paths, 0, sizeof(spec->out_paths));
1300 memset(spec->hp_paths, 0, sizeof(spec->hp_paths));
1301 memset(spec->speaker_paths, 0, sizeof(spec->speaker_paths));
1302 memset(spec->aamix_out_paths, 0, sizeof(spec->aamix_out_paths));
1303 memset(spec->digout_paths, 0, sizeof(spec->digout_paths));
1304 memset(spec->input_paths, 0, sizeof(spec->input_paths));
1305 memset(spec->loopback_paths, 0, sizeof(spec->loopback_paths));
1306 memset(&spec->digin_path, 0, sizeof(spec->digin_path));
1310 /* fill hard-wired DACs first */
1311 if (fill_hardwired) {
1314 mapped = map_singles(codec, cfg->line_outs,
1316 spec->private_dac_nids,
1318 mapped |= map_singles(codec, cfg->hp_outs,
1320 spec->multiout.hp_out_nid,
1322 mapped |= map_singles(codec, cfg->speaker_outs,
1324 spec->multiout.extra_out_nid,
1325 spec->speaker_paths);
1326 if (fill_mio_first && cfg->line_outs == 1 &&
1327 cfg->line_out_type != AUTO_PIN_SPEAKER_OUT) {
1328 err = fill_multi_ios(codec, cfg->line_out_pins[0], true);
1335 badness += try_assign_dacs(codec, cfg->line_outs, cfg->line_out_pins,
1336 spec->private_dac_nids, spec->out_paths,
1339 if (fill_mio_first &&
1340 cfg->line_outs == 1 && cfg->line_out_type != AUTO_PIN_SPEAKER_OUT) {
1341 /* try to fill multi-io first */
1342 err = fill_multi_ios(codec, cfg->line_out_pins[0], false);
1345 /* we don't count badness at this stage yet */
1348 if (cfg->line_out_type != AUTO_PIN_HP_OUT) {
1349 err = try_assign_dacs(codec, cfg->hp_outs, cfg->hp_pins,
1350 spec->multiout.hp_out_nid,
1352 &extra_out_badness);
1357 if (cfg->line_out_type != AUTO_PIN_SPEAKER_OUT) {
1358 err = try_assign_dacs(codec, cfg->speaker_outs,
1360 spec->multiout.extra_out_nid,
1361 spec->speaker_paths,
1362 &extra_out_badness);
1367 if (cfg->line_outs == 1 && cfg->line_out_type != AUTO_PIN_SPEAKER_OUT) {
1368 err = fill_multi_ios(codec, cfg->line_out_pins[0], false);
1374 if (spec->mixer_nid) {
1375 spec->aamix_out_paths[0] =
1376 check_aamix_out_path(codec, spec->out_paths[0]);
1377 if (cfg->line_out_type != AUTO_PIN_HP_OUT)
1378 spec->aamix_out_paths[1] =
1379 check_aamix_out_path(codec, spec->hp_paths[0]);
1380 if (cfg->line_out_type != AUTO_PIN_SPEAKER_OUT)
1381 spec->aamix_out_paths[2] =
1382 check_aamix_out_path(codec, spec->speaker_paths[0]);
1385 if (cfg->hp_outs && cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
1386 if (count_multiio_pins(codec, cfg->hp_pins[0]) >= 2)
1387 spec->multi_ios = 1; /* give badness */
1389 /* re-count num_dacs and squash invalid entries */
1390 spec->multiout.num_dacs = 0;
1391 for (i = 0; i < cfg->line_outs; i++) {
1392 if (spec->private_dac_nids[i])
1393 spec->multiout.num_dacs++;
1395 memmove(spec->private_dac_nids + i,
1396 spec->private_dac_nids + i + 1,
1397 sizeof(hda_nid_t) * (cfg->line_outs - i - 1));
1398 spec->private_dac_nids[cfg->line_outs - 1] = 0;
1402 spec->ext_channel_count = spec->min_channel_count =
1403 spec->multiout.num_dacs * 2;
1405 if (spec->multi_ios == 2) {
1406 for (i = 0; i < 2; i++)
1407 spec->private_dac_nids[spec->multiout.num_dacs++] =
1408 spec->multi_io[i].dac;
1409 } else if (spec->multi_ios) {
1410 spec->multi_ios = 0;
1411 badness += BAD_MULTI_IO;
1414 /* re-fill the shared DAC for speaker / headphone */
1415 if (cfg->line_out_type != AUTO_PIN_HP_OUT)
1416 refill_shared_dacs(codec, cfg->hp_outs,
1417 spec->multiout.hp_out_nid,
1419 if (cfg->line_out_type != AUTO_PIN_SPEAKER_OUT)
1420 refill_shared_dacs(codec, cfg->speaker_outs,
1421 spec->multiout.extra_out_nid,
1422 spec->speaker_paths);
1424 /* set initial pinctl targets */
1425 if (spec->prefer_hp_amp || cfg->line_out_type == AUTO_PIN_HP_OUT)
1429 set_pin_targets(codec, cfg->line_outs, cfg->line_out_pins, val);
1430 if (cfg->line_out_type != AUTO_PIN_HP_OUT)
1431 set_pin_targets(codec, cfg->hp_outs, cfg->hp_pins, PIN_HP);
1432 if (cfg->line_out_type != AUTO_PIN_SPEAKER_OUT) {
1433 val = spec->prefer_hp_amp ? PIN_HP : PIN_OUT;
1434 set_pin_targets(codec, cfg->speaker_outs,
1435 cfg->speaker_pins, val);
1441 #define DEBUG_BADNESS
1443 #ifdef DEBUG_BADNESS
1444 #define debug_badness snd_printdd
1446 #define debug_badness(...)
1449 static void debug_show_configs(struct hda_gen_spec *spec, struct auto_pin_cfg *cfg)
1451 debug_badness("multi_outs = %x/%x/%x/%x : %x/%x/%x/%x\n",
1452 cfg->line_out_pins[0], cfg->line_out_pins[1],
1453 cfg->line_out_pins[2], cfg->line_out_pins[3],
1454 spec->multiout.dac_nids[0],
1455 spec->multiout.dac_nids[1],
1456 spec->multiout.dac_nids[2],
1457 spec->multiout.dac_nids[3]);
1458 if (spec->multi_ios > 0)
1459 debug_badness("multi_ios(%d) = %x/%x : %x/%x\n",
1461 spec->multi_io[0].pin, spec->multi_io[1].pin,
1462 spec->multi_io[0].dac, spec->multi_io[1].dac);
1463 debug_badness("hp_outs = %x/%x/%x/%x : %x/%x/%x/%x\n",
1464 cfg->hp_pins[0], cfg->hp_pins[1],
1465 cfg->hp_pins[2], cfg->hp_pins[3],
1466 spec->multiout.hp_out_nid[0],
1467 spec->multiout.hp_out_nid[1],
1468 spec->multiout.hp_out_nid[2],
1469 spec->multiout.hp_out_nid[3]);
1470 debug_badness("spk_outs = %x/%x/%x/%x : %x/%x/%x/%x\n",
1471 cfg->speaker_pins[0], cfg->speaker_pins[1],
1472 cfg->speaker_pins[2], cfg->speaker_pins[3],
1473 spec->multiout.extra_out_nid[0],
1474 spec->multiout.extra_out_nid[1],
1475 spec->multiout.extra_out_nid[2],
1476 spec->multiout.extra_out_nid[3]);
1479 /* find all available DACs of the codec */
1480 static void fill_all_dac_nids(struct hda_codec *codec)
1482 struct hda_gen_spec *spec = codec->spec;
1484 hda_nid_t nid = codec->start_nid;
1486 spec->num_all_dacs = 0;
1487 memset(spec->all_dacs, 0, sizeof(spec->all_dacs));
1488 for (i = 0; i < codec->num_nodes; i++, nid++) {
1489 if (get_wcaps_type(get_wcaps(codec, nid)) != AC_WID_AUD_OUT)
1491 if (spec->num_all_dacs >= ARRAY_SIZE(spec->all_dacs)) {
1492 snd_printk(KERN_ERR "hda: Too many DACs!\n");
1495 spec->all_dacs[spec->num_all_dacs++] = nid;
1499 static int parse_output_paths(struct hda_codec *codec)
1501 struct hda_gen_spec *spec = codec->spec;
1502 struct auto_pin_cfg *cfg = &spec->autocfg;
1503 struct auto_pin_cfg *best_cfg;
1504 int best_badness = INT_MAX;
1506 bool fill_hardwired = true, fill_mio_first = true;
1507 bool best_wired = true, best_mio = true;
1508 bool hp_spk_swapped = false;
1510 fill_all_dac_nids(codec);
1512 best_cfg = kmalloc(sizeof(*best_cfg), GFP_KERNEL);
1518 badness = fill_and_eval_dacs(codec, fill_hardwired,
1524 debug_badness("==> lo_type=%d, wired=%d, mio=%d, badness=0x%x\n",
1525 cfg->line_out_type, fill_hardwired, fill_mio_first,
1527 debug_show_configs(spec, cfg);
1528 if (badness < best_badness) {
1529 best_badness = badness;
1531 best_wired = fill_hardwired;
1532 best_mio = fill_mio_first;
1536 fill_mio_first = !fill_mio_first;
1537 if (!fill_mio_first)
1539 fill_hardwired = !fill_hardwired;
1540 if (!fill_hardwired)
1544 hp_spk_swapped = true;
1545 if (cfg->speaker_outs > 0 &&
1546 cfg->line_out_type == AUTO_PIN_HP_OUT) {
1547 cfg->hp_outs = cfg->line_outs;
1548 memcpy(cfg->hp_pins, cfg->line_out_pins,
1549 sizeof(cfg->hp_pins));
1550 cfg->line_outs = cfg->speaker_outs;
1551 memcpy(cfg->line_out_pins, cfg->speaker_pins,
1552 sizeof(cfg->speaker_pins));
1553 cfg->speaker_outs = 0;
1554 memset(cfg->speaker_pins, 0, sizeof(cfg->speaker_pins));
1555 cfg->line_out_type = AUTO_PIN_SPEAKER_OUT;
1556 fill_hardwired = true;
1559 if (cfg->hp_outs > 0 &&
1560 cfg->line_out_type == AUTO_PIN_SPEAKER_OUT) {
1561 cfg->speaker_outs = cfg->line_outs;
1562 memcpy(cfg->speaker_pins, cfg->line_out_pins,
1563 sizeof(cfg->speaker_pins));
1564 cfg->line_outs = cfg->hp_outs;
1565 memcpy(cfg->line_out_pins, cfg->hp_pins,
1566 sizeof(cfg->hp_pins));
1568 memset(cfg->hp_pins, 0, sizeof(cfg->hp_pins));
1569 cfg->line_out_type = AUTO_PIN_HP_OUT;
1570 fill_hardwired = true;
1577 debug_badness("==> restoring best_cfg\n");
1579 fill_and_eval_dacs(codec, best_wired, best_mio);
1581 debug_badness("==> Best config: lo_type=%d, wired=%d, mio=%d\n",
1582 cfg->line_out_type, best_wired, best_mio);
1583 debug_show_configs(spec, cfg);
1585 if (cfg->line_out_pins[0]) {
1586 struct nid_path *path;
1587 path = snd_hda_get_path_from_idx(codec, spec->out_paths[0]);
1589 spec->vmaster_nid = look_for_out_vol_nid(codec, path);
1596 /* add playback controls from the parsed DAC table */
1597 static int create_multi_out_ctls(struct hda_codec *codec,
1598 const struct auto_pin_cfg *cfg)
1600 struct hda_gen_spec *spec = codec->spec;
1601 int i, err, noutputs;
1603 noutputs = cfg->line_outs;
1604 if (spec->multi_ios > 0 && cfg->line_outs < 3)
1605 noutputs += spec->multi_ios;
1607 for (i = 0; i < noutputs; i++) {
1610 struct nid_path *path;
1612 if (i >= cfg->line_outs) {
1614 name = channel_name[i];
1616 name = get_line_out_pfx(spec, i, true, &index);
1619 path = snd_hda_get_path_from_idx(codec, spec->out_paths[i]);
1622 if (!name || !strcmp(name, "CLFE")) {
1624 err = add_vol_ctl(codec, "Center", 0, 1, path);
1627 err = add_vol_ctl(codec, "LFE", 0, 2, path);
1630 err = add_sw_ctl(codec, "Center", 0, 1, path);
1633 err = add_sw_ctl(codec, "LFE", 0, 2, path);
1637 err = add_stereo_vol(codec, name, index, path);
1640 err = add_stereo_sw(codec, name, index, path);
1648 static int create_extra_out(struct hda_codec *codec, int path_idx,
1649 const char *pfx, int cidx)
1651 struct nid_path *path;
1654 path = snd_hda_get_path_from_idx(codec, path_idx);
1657 err = add_stereo_vol(codec, pfx, cidx, path);
1660 err = add_stereo_sw(codec, pfx, cidx, path);
1666 /* add playback controls for speaker and HP outputs */
1667 static int create_extra_outs(struct hda_codec *codec, int num_pins,
1668 const int *paths, const char *pfx)
1672 for (i = 0; i < num_pins; i++) {
1677 if (num_pins == 2 && i == 1 && !strcmp(pfx, "Speaker"))
1678 name = "Bass Speaker";
1679 else if (num_pins >= 3) {
1680 snprintf(tmp, sizeof(tmp), "%s %s",
1681 pfx, channel_name[i]);
1687 err = create_extra_out(codec, paths[i], name, idx);
1694 static int create_hp_out_ctls(struct hda_codec *codec)
1696 struct hda_gen_spec *spec = codec->spec;
1697 return create_extra_outs(codec, spec->autocfg.hp_outs,
1702 static int create_speaker_out_ctls(struct hda_codec *codec)
1704 struct hda_gen_spec *spec = codec->spec;
1705 return create_extra_outs(codec, spec->autocfg.speaker_outs,
1706 spec->speaker_paths,
1711 * independent HP controls
1714 static int indep_hp_info(struct snd_kcontrol *kcontrol,
1715 struct snd_ctl_elem_info *uinfo)
1717 return snd_hda_enum_bool_helper_info(kcontrol, uinfo);
1720 static int indep_hp_get(struct snd_kcontrol *kcontrol,
1721 struct snd_ctl_elem_value *ucontrol)
1723 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1724 struct hda_gen_spec *spec = codec->spec;
1725 ucontrol->value.enumerated.item[0] = spec->indep_hp_enabled;
1729 static int indep_hp_put(struct snd_kcontrol *kcontrol,
1730 struct snd_ctl_elem_value *ucontrol)
1732 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1733 struct hda_gen_spec *spec = codec->spec;
1734 unsigned int select = ucontrol->value.enumerated.item[0];
1737 mutex_lock(&spec->pcm_mutex);
1738 if (spec->active_streams) {
1743 if (spec->indep_hp_enabled != select) {
1744 spec->indep_hp_enabled = select;
1745 if (spec->indep_hp_enabled)
1746 spec->multiout.hp_out_nid[0] = 0;
1748 spec->multiout.hp_out_nid[0] = spec->alt_dac_nid;
1752 mutex_unlock(&spec->pcm_mutex);
1756 static const struct snd_kcontrol_new indep_hp_ctl = {
1757 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1758 .name = "Independent HP",
1759 .info = indep_hp_info,
1760 .get = indep_hp_get,
1761 .put = indep_hp_put,
1765 static int create_indep_hp_ctls(struct hda_codec *codec)
1767 struct hda_gen_spec *spec = codec->spec;
1769 if (!spec->indep_hp)
1771 if (!spec->multiout.hp_out_nid[0]) {
1776 spec->indep_hp_enabled = false;
1777 spec->alt_dac_nid = spec->multiout.hp_out_nid[0];
1778 if (!snd_hda_gen_add_kctl(spec, NULL, &indep_hp_ctl))
1784 * channel mode enum control
1787 static int ch_mode_info(struct snd_kcontrol *kcontrol,
1788 struct snd_ctl_elem_info *uinfo)
1790 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1791 struct hda_gen_spec *spec = codec->spec;
1794 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
1796 uinfo->value.enumerated.items = spec->multi_ios + 1;
1797 if (uinfo->value.enumerated.item > spec->multi_ios)
1798 uinfo->value.enumerated.item = spec->multi_ios;
1799 chs = uinfo->value.enumerated.item * 2 + spec->min_channel_count;
1800 sprintf(uinfo->value.enumerated.name, "%dch", chs);
1804 static int ch_mode_get(struct snd_kcontrol *kcontrol,
1805 struct snd_ctl_elem_value *ucontrol)
1807 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1808 struct hda_gen_spec *spec = codec->spec;
1809 ucontrol->value.enumerated.item[0] =
1810 (spec->ext_channel_count - spec->min_channel_count) / 2;
1814 static inline struct nid_path *
1815 get_multiio_path(struct hda_codec *codec, int idx)
1817 struct hda_gen_spec *spec = codec->spec;
1818 return snd_hda_get_path_from_idx(codec,
1819 spec->out_paths[spec->autocfg.line_outs + idx]);
1822 static int set_multi_io(struct hda_codec *codec, int idx, bool output)
1824 struct hda_gen_spec *spec = codec->spec;
1825 hda_nid_t nid = spec->multi_io[idx].pin;
1826 struct nid_path *path;
1828 path = get_multiio_path(codec, idx);
1832 if (path->active == output)
1836 set_pin_target(codec, nid, PIN_OUT, true);
1837 snd_hda_activate_path(codec, path, true, true);
1838 set_pin_eapd(codec, nid, true);
1840 set_pin_eapd(codec, nid, false);
1841 snd_hda_activate_path(codec, path, false, true);
1842 set_pin_target(codec, nid, spec->multi_io[idx].ctl_in, true);
1845 /* update jack retasking in case it modifies any of them */
1846 snd_hda_gen_hp_automute(codec, NULL);
1847 snd_hda_gen_line_automute(codec, NULL);
1848 snd_hda_gen_mic_autoswitch(codec, NULL);
1853 static int ch_mode_put(struct snd_kcontrol *kcontrol,
1854 struct snd_ctl_elem_value *ucontrol)
1856 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1857 struct hda_gen_spec *spec = codec->spec;
1860 ch = ucontrol->value.enumerated.item[0];
1861 if (ch < 0 || ch > spec->multi_ios)
1863 if (ch == (spec->ext_channel_count - spec->min_channel_count) / 2)
1865 spec->ext_channel_count = ch * 2 + spec->min_channel_count;
1866 for (i = 0; i < spec->multi_ios; i++)
1867 set_multi_io(codec, i, i < ch);
1868 spec->multiout.max_channels = max(spec->ext_channel_count,
1869 spec->const_channel_count);
1870 if (spec->need_dac_fix)
1871 spec->multiout.num_dacs = spec->multiout.max_channels / 2;
1875 static const struct snd_kcontrol_new channel_mode_enum = {
1876 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1877 .name = "Channel Mode",
1878 .info = ch_mode_info,
1883 static int create_multi_channel_mode(struct hda_codec *codec)
1885 struct hda_gen_spec *spec = codec->spec;
1887 if (spec->multi_ios > 0) {
1888 if (!snd_hda_gen_add_kctl(spec, NULL, &channel_mode_enum))
1895 * aamix loopback enable/disable switch
1898 #define loopback_mixing_info indep_hp_info
1900 static int loopback_mixing_get(struct snd_kcontrol *kcontrol,
1901 struct snd_ctl_elem_value *ucontrol)
1903 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1904 struct hda_gen_spec *spec = codec->spec;
1905 ucontrol->value.enumerated.item[0] = spec->aamix_mode;
1909 static void update_aamix_paths(struct hda_codec *codec, bool do_mix,
1910 int nomix_path_idx, int mix_path_idx)
1912 struct nid_path *nomix_path, *mix_path;
1914 nomix_path = snd_hda_get_path_from_idx(codec, nomix_path_idx);
1915 mix_path = snd_hda_get_path_from_idx(codec, mix_path_idx);
1916 if (!nomix_path || !mix_path)
1919 snd_hda_activate_path(codec, nomix_path, false, true);
1920 snd_hda_activate_path(codec, mix_path, true, true);
1922 snd_hda_activate_path(codec, mix_path, false, true);
1923 snd_hda_activate_path(codec, nomix_path, true, true);
1927 static int loopback_mixing_put(struct snd_kcontrol *kcontrol,
1928 struct snd_ctl_elem_value *ucontrol)
1930 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1931 struct hda_gen_spec *spec = codec->spec;
1932 unsigned int val = ucontrol->value.enumerated.item[0];
1934 if (val == spec->aamix_mode)
1936 spec->aamix_mode = val;
1937 update_aamix_paths(codec, val, spec->out_paths[0],
1938 spec->aamix_out_paths[0]);
1939 update_aamix_paths(codec, val, spec->hp_paths[0],
1940 spec->aamix_out_paths[1]);
1941 update_aamix_paths(codec, val, spec->speaker_paths[0],
1942 spec->aamix_out_paths[2]);
1946 static const struct snd_kcontrol_new loopback_mixing_enum = {
1947 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1948 .name = "Loopback Mixing",
1949 .info = loopback_mixing_info,
1950 .get = loopback_mixing_get,
1951 .put = loopback_mixing_put,
1954 static int create_loopback_mixing_ctl(struct hda_codec *codec)
1956 struct hda_gen_spec *spec = codec->spec;
1958 if (!spec->mixer_nid)
1960 if (!(spec->aamix_out_paths[0] || spec->aamix_out_paths[1] ||
1961 spec->aamix_out_paths[2]))
1963 if (!snd_hda_gen_add_kctl(spec, NULL, &loopback_mixing_enum))
1969 * shared headphone/mic handling
1972 static void call_update_outputs(struct hda_codec *codec);
1974 /* for shared I/O, change the pin-control accordingly */
1975 static void update_shared_mic_hp(struct hda_codec *codec, bool set_as_mic)
1977 struct hda_gen_spec *spec = codec->spec;
1979 hda_nid_t pin = spec->autocfg.inputs[1].pin;
1980 /* NOTE: this assumes that there are only two inputs, the
1981 * first is the real internal mic and the second is HP/mic jack.
1984 val = snd_hda_get_default_vref(codec, pin);
1986 /* This pin does not have vref caps - let's enable vref on pin 0x18
1987 instead, as suggested by Realtek */
1988 if (val == AC_PINCTL_VREF_HIZ && spec->shared_mic_vref_pin) {
1989 const hda_nid_t vref_pin = spec->shared_mic_vref_pin;
1990 unsigned int vref_val = snd_hda_get_default_vref(codec, vref_pin);
1991 if (vref_val != AC_PINCTL_VREF_HIZ)
1992 snd_hda_set_pin_ctl_cache(codec, vref_pin,
1993 PIN_IN | (set_as_mic ? vref_val : 0));
1996 val = set_as_mic ? val | PIN_IN : PIN_HP;
1997 set_pin_target(codec, pin, val, true);
1999 spec->automute_speaker = !set_as_mic;
2000 call_update_outputs(codec);
2003 /* create a shared input with the headphone out */
2004 static int create_shared_input(struct hda_codec *codec)
2006 struct hda_gen_spec *spec = codec->spec;
2007 struct auto_pin_cfg *cfg = &spec->autocfg;
2008 unsigned int defcfg;
2011 /* only one internal input pin? */
2012 if (cfg->num_inputs != 1)
2014 defcfg = snd_hda_codec_get_pincfg(codec, cfg->inputs[0].pin);
2015 if (snd_hda_get_input_pin_attr(defcfg) != INPUT_PIN_ATTR_INT)
2018 if (cfg->hp_outs == 1 && cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
2019 nid = cfg->hp_pins[0]; /* OK, we have a single HP-out */
2020 else if (cfg->line_outs == 1 && cfg->line_out_type == AUTO_PIN_HP_OUT)
2021 nid = cfg->line_out_pins[0]; /* OK, we have a single line-out */
2023 return 0; /* both not available */
2025 if (!(snd_hda_query_pin_caps(codec, nid) & AC_PINCAP_IN))
2026 return 0; /* no input */
2028 cfg->inputs[1].pin = nid;
2029 cfg->inputs[1].type = AUTO_PIN_MIC;
2030 cfg->num_inputs = 2;
2031 spec->shared_mic_hp = 1;
2032 snd_printdd("hda-codec: Enable shared I/O jack on NID 0x%x\n", nid);
2039 static int out_jack_mode_info(struct snd_kcontrol *kcontrol,
2040 struct snd_ctl_elem_info *uinfo)
2042 static const char * const texts[] = {
2043 "Line Out", "Headphone Out",
2045 return snd_hda_enum_helper_info(kcontrol, uinfo, 2, texts);
2048 static int out_jack_mode_get(struct snd_kcontrol *kcontrol,
2049 struct snd_ctl_elem_value *ucontrol)
2051 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2052 hda_nid_t nid = kcontrol->private_value;
2053 if (snd_hda_codec_get_pin_target(codec, nid) == PIN_HP)
2054 ucontrol->value.enumerated.item[0] = 1;
2056 ucontrol->value.enumerated.item[0] = 0;
2060 static int out_jack_mode_put(struct snd_kcontrol *kcontrol,
2061 struct snd_ctl_elem_value *ucontrol)
2063 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2064 hda_nid_t nid = kcontrol->private_value;
2067 val = ucontrol->value.enumerated.item[0] ? PIN_HP : PIN_OUT;
2068 if (snd_hda_codec_get_pin_target(codec, nid) == val)
2070 snd_hda_set_pin_ctl_cache(codec, nid, val);
2074 static const struct snd_kcontrol_new out_jack_mode_enum = {
2075 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2076 .info = out_jack_mode_info,
2077 .get = out_jack_mode_get,
2078 .put = out_jack_mode_put,
2081 static bool find_kctl_name(struct hda_codec *codec, const char *name, int idx)
2083 struct hda_gen_spec *spec = codec->spec;
2086 for (i = 0; i < spec->kctls.used; i++) {
2087 struct snd_kcontrol_new *kctl = snd_array_elem(&spec->kctls, i);
2088 if (!strcmp(kctl->name, name) && kctl->index == idx)
2094 static void get_jack_mode_name(struct hda_codec *codec, hda_nid_t pin,
2095 char *name, size_t name_len)
2097 struct hda_gen_spec *spec = codec->spec;
2100 snd_hda_get_pin_label(codec, pin, &spec->autocfg, name, name_len, &idx);
2101 strlcat(name, " Jack Mode", name_len);
2103 for (; find_kctl_name(codec, name, idx); idx++)
2107 static int create_out_jack_modes(struct hda_codec *codec, int num_pins,
2110 struct hda_gen_spec *spec = codec->spec;
2113 for (i = 0; i < num_pins; i++) {
2114 hda_nid_t pin = pins[i];
2115 unsigned int pincap = snd_hda_query_pin_caps(codec, pin);
2116 if ((pincap & AC_PINCAP_OUT) && (pincap & AC_PINCAP_HP_DRV)) {
2117 struct snd_kcontrol_new *knew;
2119 get_jack_mode_name(codec, pin, name, sizeof(name));
2120 knew = snd_hda_gen_add_kctl(spec, name,
2121 &out_jack_mode_enum);
2124 knew->private_value = pin;
2137 /* add the powersave loopback-list entry */
2138 static void add_loopback_list(struct hda_gen_spec *spec, hda_nid_t mix, int idx)
2140 struct hda_amp_list *list;
2142 if (spec->num_loopbacks >= ARRAY_SIZE(spec->loopback_list) - 1)
2144 list = spec->loopback_list + spec->num_loopbacks;
2146 list->dir = HDA_INPUT;
2148 spec->num_loopbacks++;
2149 spec->loopback.amplist = spec->loopback_list;
2152 #define add_loopback_list(spec, mix, idx) /* NOP */
2155 /* create input playback/capture controls for the given pin */
2156 static int new_analog_input(struct hda_codec *codec, int input_idx,
2157 hda_nid_t pin, const char *ctlname, int ctlidx,
2160 struct hda_gen_spec *spec = codec->spec;
2161 struct nid_path *path;
2165 if (!nid_has_volume(codec, mix_nid, HDA_INPUT) &&
2166 !nid_has_mute(codec, mix_nid, HDA_INPUT))
2167 return 0; /* no need for analog loopback */
2169 path = snd_hda_add_new_path(codec, pin, mix_nid, 0);
2172 print_nid_path("loopback", path);
2173 spec->loopback_paths[input_idx] = snd_hda_get_path_idx(codec, path);
2175 idx = path->idx[path->depth - 1];
2176 if (nid_has_volume(codec, mix_nid, HDA_INPUT)) {
2177 val = HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT);
2178 err = __add_pb_vol_ctrl(spec, HDA_CTL_WIDGET_VOL, ctlname, ctlidx, val);
2181 path->ctls[NID_PATH_VOL_CTL] = val;
2184 if (nid_has_mute(codec, mix_nid, HDA_INPUT)) {
2185 val = HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT);
2186 err = __add_pb_sw_ctrl(spec, HDA_CTL_WIDGET_MUTE, ctlname, ctlidx, val);
2189 path->ctls[NID_PATH_MUTE_CTL] = val;
2192 path->active = true;
2193 add_loopback_list(spec, mix_nid, idx);
2197 static int is_input_pin(struct hda_codec *codec, hda_nid_t nid)
2199 unsigned int pincap = snd_hda_query_pin_caps(codec, nid);
2200 return (pincap & AC_PINCAP_IN) != 0;
2203 /* Parse the codec tree and retrieve ADCs */
2204 static int fill_adc_nids(struct hda_codec *codec)
2206 struct hda_gen_spec *spec = codec->spec;
2208 hda_nid_t *adc_nids = spec->adc_nids;
2209 int max_nums = ARRAY_SIZE(spec->adc_nids);
2212 nid = codec->start_nid;
2213 for (i = 0; i < codec->num_nodes; i++, nid++) {
2214 unsigned int caps = get_wcaps(codec, nid);
2215 int type = get_wcaps_type(caps);
2217 if (type != AC_WID_AUD_IN || (caps & AC_WCAP_DIGITAL))
2219 adc_nids[nums] = nid;
2220 if (++nums >= max_nums)
2223 spec->num_adc_nids = nums;
2227 /* filter out invalid adc_nids that don't give all active input pins;
2228 * if needed, check whether dynamic ADC-switching is available
2230 static int check_dyn_adc_switch(struct hda_codec *codec)
2232 struct hda_gen_spec *spec = codec->spec;
2233 struct hda_input_mux *imux = &spec->input_mux;
2234 unsigned int ok_bits;
2240 for (n = 0; n < spec->num_adc_nids; n++) {
2241 for (i = 0; i < imux->num_items; i++) {
2242 if (!spec->input_paths[i][n])
2245 if (i >= imux->num_items) {
2246 ok_bits |= (1 << n);
2252 if (spec->shared_mic_hp) {
2253 spec->shared_mic_hp = 0;
2254 imux->num_items = 1;
2258 /* check whether ADC-switch is possible */
2259 for (i = 0; i < imux->num_items; i++) {
2260 for (n = 0; n < spec->num_adc_nids; n++) {
2261 if (spec->input_paths[i][n]) {
2262 spec->dyn_adc_idx[i] = n;
2268 snd_printdd("hda-codec: enabling ADC switching\n");
2269 spec->dyn_adc_switch = 1;
2270 } else if (nums != spec->num_adc_nids) {
2271 /* shrink the invalid adcs and input paths */
2273 for (n = 0; n < spec->num_adc_nids; n++) {
2274 if (!(ok_bits & (1 << n)))
2277 spec->adc_nids[nums] = spec->adc_nids[n];
2278 for (i = 0; i < imux->num_items; i++) {
2279 invalidate_nid_path(codec,
2280 spec->input_paths[i][nums]);
2281 spec->input_paths[i][nums] =
2282 spec->input_paths[i][n];
2287 spec->num_adc_nids = nums;
2290 if (imux->num_items == 1 || spec->shared_mic_hp) {
2291 snd_printdd("hda-codec: reducing to a single ADC\n");
2292 spec->num_adc_nids = 1; /* reduce to a single ADC */
2295 /* single index for individual volumes ctls */
2296 if (!spec->dyn_adc_switch && spec->multi_cap_vol)
2297 spec->num_adc_nids = 1;
2302 /* parse capture source paths from the given pin and create imux items */
2303 static int parse_capture_source(struct hda_codec *codec, hda_nid_t pin,
2304 int num_adcs, const char *label, int anchor)
2306 struct hda_gen_spec *spec = codec->spec;
2307 struct hda_input_mux *imux = &spec->input_mux;
2308 int imux_idx = imux->num_items;
2309 bool imux_added = false;
2312 for (c = 0; c < num_adcs; c++) {
2313 struct nid_path *path;
2314 hda_nid_t adc = spec->adc_nids[c];
2316 if (!is_reachable_path(codec, pin, adc))
2318 path = snd_hda_add_new_path(codec, pin, adc, anchor);
2321 print_nid_path("input", path);
2322 spec->input_paths[imux_idx][c] =
2323 snd_hda_get_path_idx(codec, path);
2326 spec->imux_pins[imux->num_items] = pin;
2327 snd_hda_add_imux_item(imux, label,
2328 imux->num_items, NULL);
2337 * create playback/capture controls for input pins
2339 static int create_input_ctls(struct hda_codec *codec)
2341 struct hda_gen_spec *spec = codec->spec;
2342 const struct auto_pin_cfg *cfg = &spec->autocfg;
2343 hda_nid_t mixer = spec->mixer_nid;
2345 int i, err, type_idx = 0;
2346 const char *prev_label = NULL;
2349 num_adcs = fill_adc_nids(codec);
2353 for (i = 0; i < cfg->num_inputs; i++) {
2357 pin = cfg->inputs[i].pin;
2358 if (!is_input_pin(codec, pin))
2361 label = hda_get_autocfg_input_label(codec, cfg, i);
2362 if (prev_label && !strcmp(label, prev_label))
2369 if (cfg->inputs[i].type == AUTO_PIN_MIC)
2370 val |= snd_hda_get_default_vref(codec, pin);
2371 set_pin_target(codec, pin, val, false);
2374 if (is_reachable_path(codec, pin, mixer)) {
2375 err = new_analog_input(codec, i, pin,
2376 label, type_idx, mixer);
2382 err = parse_capture_source(codec, pin, num_adcs, label, -mixer);
2387 if (mixer && spec->add_stereo_mix_input) {
2388 err = parse_capture_source(codec, mixer, num_adcs,
2402 /* get the input path specified by the given adc and imux indices */
2403 static struct nid_path *get_input_path(struct hda_codec *codec, int adc_idx, int imux_idx)
2405 struct hda_gen_spec *spec = codec->spec;
2406 if (imux_idx < 0 || imux_idx >= HDA_MAX_NUM_INPUTS) {
2410 if (spec->dyn_adc_switch)
2411 adc_idx = spec->dyn_adc_idx[imux_idx];
2412 if (adc_idx < 0 || adc_idx >= AUTO_CFG_MAX_OUTS) {
2416 return snd_hda_get_path_from_idx(codec, spec->input_paths[imux_idx][adc_idx]);
2419 static int mux_select(struct hda_codec *codec, unsigned int adc_idx,
2422 static int mux_enum_info(struct snd_kcontrol *kcontrol,
2423 struct snd_ctl_elem_info *uinfo)
2425 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2426 struct hda_gen_spec *spec = codec->spec;
2427 return snd_hda_input_mux_info(&spec->input_mux, uinfo);
2430 static int mux_enum_get(struct snd_kcontrol *kcontrol,
2431 struct snd_ctl_elem_value *ucontrol)
2433 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2434 struct hda_gen_spec *spec = codec->spec;
2435 unsigned int adc_idx = kcontrol->id.index;
2437 ucontrol->value.enumerated.item[0] = spec->cur_mux[adc_idx];
2441 static int mux_enum_put(struct snd_kcontrol *kcontrol,
2442 struct snd_ctl_elem_value *ucontrol)
2444 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2445 unsigned int adc_idx = kcontrol->id.index;
2446 return mux_select(codec, adc_idx,
2447 ucontrol->value.enumerated.item[0]);
2450 static const struct snd_kcontrol_new cap_src_temp = {
2451 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2452 .name = "Input Source",
2453 .info = mux_enum_info,
2454 .get = mux_enum_get,
2455 .put = mux_enum_put,
2459 * capture volume and capture switch ctls
2462 typedef int (*put_call_t)(struct snd_kcontrol *kcontrol,
2463 struct snd_ctl_elem_value *ucontrol);
2465 /* call the given amp update function for all amps in the imux list at once */
2466 static int cap_put_caller(struct snd_kcontrol *kcontrol,
2467 struct snd_ctl_elem_value *ucontrol,
2468 put_call_t func, int type)
2470 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2471 struct hda_gen_spec *spec = codec->spec;
2472 const struct hda_input_mux *imux;
2473 struct nid_path *path;
2474 int i, adc_idx, err = 0;
2476 imux = &spec->input_mux;
2477 adc_idx = kcontrol->id.index;
2478 mutex_lock(&codec->control_mutex);
2479 /* we use the cache-only update at first since multiple input paths
2480 * may shared the same amp; by updating only caches, the redundant
2481 * writes to hardware can be reduced.
2483 codec->cached_write = 1;
2484 for (i = 0; i < imux->num_items; i++) {
2485 path = get_input_path(codec, adc_idx, i);
2486 if (!path || !path->ctls[type])
2488 kcontrol->private_value = path->ctls[type];
2489 err = func(kcontrol, ucontrol);
2494 codec->cached_write = 0;
2495 mutex_unlock(&codec->control_mutex);
2496 snd_hda_codec_flush_amp_cache(codec); /* flush the updates */
2497 if (err >= 0 && spec->cap_sync_hook)
2498 spec->cap_sync_hook(codec);
2502 /* capture volume ctl callbacks */
2503 #define cap_vol_info snd_hda_mixer_amp_volume_info
2504 #define cap_vol_get snd_hda_mixer_amp_volume_get
2505 #define cap_vol_tlv snd_hda_mixer_amp_tlv
2507 static int cap_vol_put(struct snd_kcontrol *kcontrol,
2508 struct snd_ctl_elem_value *ucontrol)
2510 return cap_put_caller(kcontrol, ucontrol,
2511 snd_hda_mixer_amp_volume_put,
2515 static const struct snd_kcontrol_new cap_vol_temp = {
2516 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2517 .name = "Capture Volume",
2518 .access = (SNDRV_CTL_ELEM_ACCESS_READWRITE |
2519 SNDRV_CTL_ELEM_ACCESS_TLV_READ |
2520 SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK),
2521 .info = cap_vol_info,
2524 .tlv = { .c = cap_vol_tlv },
2527 /* capture switch ctl callbacks */
2528 #define cap_sw_info snd_ctl_boolean_stereo_info
2529 #define cap_sw_get snd_hda_mixer_amp_switch_get
2531 static int cap_sw_put(struct snd_kcontrol *kcontrol,
2532 struct snd_ctl_elem_value *ucontrol)
2534 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2535 struct hda_gen_spec *spec = codec->spec;
2538 ret = cap_put_caller(kcontrol, ucontrol,
2539 snd_hda_mixer_amp_switch_put,
2544 if (spec->capture_switch_hook) {
2545 bool enable = (ucontrol->value.integer.value[0] ||
2546 ucontrol->value.integer.value[1]);
2547 spec->capture_switch_hook(codec, enable);
2553 static const struct snd_kcontrol_new cap_sw_temp = {
2554 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2555 .name = "Capture Switch",
2556 .info = cap_sw_info,
2561 static int parse_capvol_in_path(struct hda_codec *codec, struct nid_path *path)
2566 path->ctls[NID_PATH_VOL_CTL] = path->ctls[NID_PATH_MUTE_CTL] = 0;
2567 for (depth = 0; depth < 3; depth++) {
2568 if (depth >= path->depth)
2570 i = path->depth - depth - 1;
2571 nid = path->path[i];
2572 if (!path->ctls[NID_PATH_VOL_CTL]) {
2573 if (nid_has_volume(codec, nid, HDA_OUTPUT))
2574 path->ctls[NID_PATH_VOL_CTL] =
2575 HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
2576 else if (nid_has_volume(codec, nid, HDA_INPUT)) {
2577 int idx = path->idx[i];
2578 if (!depth && codec->single_adc_amp)
2580 path->ctls[NID_PATH_VOL_CTL] =
2581 HDA_COMPOSE_AMP_VAL(nid, 3, idx, HDA_INPUT);
2584 if (!path->ctls[NID_PATH_MUTE_CTL]) {
2585 if (nid_has_mute(codec, nid, HDA_OUTPUT))
2586 path->ctls[NID_PATH_MUTE_CTL] =
2587 HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
2588 else if (nid_has_mute(codec, nid, HDA_INPUT)) {
2589 int idx = path->idx[i];
2590 if (!depth && codec->single_adc_amp)
2592 path->ctls[NID_PATH_MUTE_CTL] =
2593 HDA_COMPOSE_AMP_VAL(nid, 3, idx, HDA_INPUT);
2600 static bool is_inv_dmic_pin(struct hda_codec *codec, hda_nid_t nid)
2602 struct hda_gen_spec *spec = codec->spec;
2603 struct auto_pin_cfg *cfg = &spec->autocfg;
2607 if (!spec->inv_dmic_split)
2609 for (i = 0; i < cfg->num_inputs; i++) {
2610 if (cfg->inputs[i].pin != nid)
2612 if (cfg->inputs[i].type != AUTO_PIN_MIC)
2614 val = snd_hda_codec_get_pincfg(codec, nid);
2615 return snd_hda_get_input_pin_attr(val) == INPUT_PIN_ATTR_INT;
2620 static int add_single_cap_ctl(struct hda_codec *codec, const char *label,
2621 int idx, bool is_switch, unsigned int ctl,
2624 struct hda_gen_spec *spec = codec->spec;
2626 int type = is_switch ? HDA_CTL_WIDGET_MUTE : HDA_CTL_WIDGET_VOL;
2627 const char *sfx = is_switch ? "Switch" : "Volume";
2628 unsigned int chs = inv_dmic ? 1 : 3;
2635 snprintf(tmpname, sizeof(tmpname),
2636 "%s Capture %s", label, sfx);
2638 snprintf(tmpname, sizeof(tmpname),
2640 err = add_control(spec, type, tmpname, idx,
2641 amp_val_replace_channels(ctl, chs));
2642 if (err < 0 || !inv_dmic)
2645 /* Make independent right kcontrol */
2647 snprintf(tmpname, sizeof(tmpname),
2648 "Inverted %s Capture %s", label, sfx);
2650 snprintf(tmpname, sizeof(tmpname),
2651 "Inverted Capture %s", sfx);
2652 return add_control(spec, type, tmpname, idx,
2653 amp_val_replace_channels(ctl, 2));
2656 /* create single (and simple) capture volume and switch controls */
2657 static int create_single_cap_vol_ctl(struct hda_codec *codec, int idx,
2658 unsigned int vol_ctl, unsigned int sw_ctl,
2662 err = add_single_cap_ctl(codec, NULL, idx, false, vol_ctl, inv_dmic);
2665 err = add_single_cap_ctl(codec, NULL, idx, true, sw_ctl, inv_dmic);
2671 /* create bound capture volume and switch controls */
2672 static int create_bind_cap_vol_ctl(struct hda_codec *codec, int idx,
2673 unsigned int vol_ctl, unsigned int sw_ctl)
2675 struct hda_gen_spec *spec = codec->spec;
2676 struct snd_kcontrol_new *knew;
2679 knew = snd_hda_gen_add_kctl(spec, NULL, &cap_vol_temp);
2683 knew->private_value = vol_ctl;
2684 knew->subdevice = HDA_SUBDEV_AMP_FLAG;
2687 knew = snd_hda_gen_add_kctl(spec, NULL, &cap_sw_temp);
2691 knew->private_value = sw_ctl;
2692 knew->subdevice = HDA_SUBDEV_AMP_FLAG;
2697 /* return the vol ctl when used first in the imux list */
2698 static unsigned int get_first_cap_ctl(struct hda_codec *codec, int idx, int type)
2700 struct nid_path *path;
2704 path = get_input_path(codec, 0, idx);
2707 ctl = path->ctls[type];
2710 for (i = 0; i < idx - 1; i++) {
2711 path = get_input_path(codec, 0, i);
2712 if (path && path->ctls[type] == ctl)
2718 /* create individual capture volume and switch controls per input */
2719 static int create_multi_cap_vol_ctl(struct hda_codec *codec)
2721 struct hda_gen_spec *spec = codec->spec;
2722 struct hda_input_mux *imux = &spec->input_mux;
2723 int i, err, type, type_idx = 0;
2724 const char *prev_label = NULL;
2726 for (i = 0; i < imux->num_items; i++) {
2729 label = hda_get_autocfg_input_label(codec, &spec->autocfg, i);
2730 if (prev_label && !strcmp(label, prev_label))
2735 inv_dmic = is_inv_dmic_pin(codec, spec->imux_pins[i]);
2737 for (type = 0; type < 2; type++) {
2738 err = add_single_cap_ctl(codec, label, type_idx, type,
2739 get_first_cap_ctl(codec, i, type),
2748 static int create_capture_mixers(struct hda_codec *codec)
2750 struct hda_gen_spec *spec = codec->spec;
2751 struct hda_input_mux *imux = &spec->input_mux;
2752 int i, n, nums, err;
2754 if (spec->dyn_adc_switch)
2757 nums = spec->num_adc_nids;
2759 if (!spec->auto_mic && imux->num_items > 1) {
2760 struct snd_kcontrol_new *knew;
2762 name = nums > 1 ? "Input Source" : "Capture Source";
2763 knew = snd_hda_gen_add_kctl(spec, name, &cap_src_temp);
2769 for (n = 0; n < nums; n++) {
2771 bool inv_dmic = false;
2775 for (i = 0; i < imux->num_items; i++) {
2776 struct nid_path *path;
2777 path = get_input_path(codec, n, i);
2780 parse_capvol_in_path(codec, path);
2782 vol = path->ctls[NID_PATH_VOL_CTL];
2783 else if (vol != path->ctls[NID_PATH_VOL_CTL])
2786 sw = path->ctls[NID_PATH_MUTE_CTL];
2787 else if (sw != path->ctls[NID_PATH_MUTE_CTL])
2789 if (is_inv_dmic_pin(codec, spec->imux_pins[i]))
2794 err = create_single_cap_vol_ctl(codec, n, vol, sw,
2796 else if (!spec->multi_cap_vol)
2797 err = create_bind_cap_vol_ctl(codec, n, vol, sw);
2799 err = create_multi_cap_vol_ctl(codec);
2808 * add mic boosts if needed
2810 static int parse_mic_boost(struct hda_codec *codec)
2812 struct hda_gen_spec *spec = codec->spec;
2813 struct auto_pin_cfg *cfg = &spec->autocfg;
2817 const char *prev_label = NULL;
2819 for (i = 0; i < cfg->num_inputs; i++) {
2820 if (cfg->inputs[i].type > AUTO_PIN_MIC)
2822 nid = cfg->inputs[i].pin;
2823 if (get_wcaps(codec, nid) & AC_WCAP_IN_AMP) {
2825 char boost_label[44];
2826 struct nid_path *path;
2829 if (!nid_has_volume(codec, nid, HDA_INPUT))
2832 label = hda_get_autocfg_input_label(codec, cfg, i);
2833 if (prev_label && !strcmp(label, prev_label))
2839 snprintf(boost_label, sizeof(boost_label),
2840 "%s Boost Volume", label);
2841 val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT);
2842 err = add_control(spec, HDA_CTL_WIDGET_VOL,
2843 boost_label, type_idx, val);
2847 path = snd_hda_get_nid_path(codec, nid, 0);
2849 path->ctls[NID_PATH_BOOST_CTL] = val;
2856 * parse digital I/Os and set up NIDs in BIOS auto-parse mode
2858 static void parse_digital(struct hda_codec *codec)
2860 struct hda_gen_spec *spec = codec->spec;
2861 struct nid_path *path;
2863 hda_nid_t dig_nid, pin;
2865 /* support multiple SPDIFs; the secondary is set up as a slave */
2867 for (i = 0; i < spec->autocfg.dig_outs; i++) {
2868 pin = spec->autocfg.dig_out_pins[i];
2869 dig_nid = look_for_dac(codec, pin, true);
2872 path = snd_hda_add_new_path(codec, dig_nid, pin, 0);
2875 print_nid_path("digout", path);
2876 path->active = true;
2877 spec->digout_paths[i] = snd_hda_get_path_idx(codec, path);
2878 set_pin_target(codec, pin, PIN_OUT, false);
2880 spec->multiout.dig_out_nid = dig_nid;
2881 spec->dig_out_type = spec->autocfg.dig_out_type[0];
2883 spec->multiout.slave_dig_outs = spec->slave_dig_outs;
2884 if (nums >= ARRAY_SIZE(spec->slave_dig_outs) - 1)
2886 spec->slave_dig_outs[nums - 1] = dig_nid;
2891 if (spec->autocfg.dig_in_pin) {
2892 pin = spec->autocfg.dig_in_pin;
2893 dig_nid = codec->start_nid;
2894 for (i = 0; i < codec->num_nodes; i++, dig_nid++) {
2895 unsigned int wcaps = get_wcaps(codec, dig_nid);
2896 if (get_wcaps_type(wcaps) != AC_WID_AUD_IN)
2898 if (!(wcaps & AC_WCAP_DIGITAL))
2900 path = snd_hda_add_new_path(codec, pin, dig_nid, 0);
2902 print_nid_path("digin", path);
2903 path->active = true;
2904 spec->dig_in_nid = dig_nid;
2905 spec->digin_path = snd_hda_get_path_idx(codec, path);
2906 set_pin_target(codec, pin, PIN_IN, false);
2915 * input MUX handling
2918 static bool dyn_adc_pcm_resetup(struct hda_codec *codec, int cur);
2920 /* select the given imux item; either unmute exclusively or select the route */
2921 static int mux_select(struct hda_codec *codec, unsigned int adc_idx,
2924 struct hda_gen_spec *spec = codec->spec;
2925 const struct hda_input_mux *imux;
2926 struct nid_path *path;
2928 imux = &spec->input_mux;
2929 if (!imux->num_items)
2932 if (idx >= imux->num_items)
2933 idx = imux->num_items - 1;
2934 if (spec->cur_mux[adc_idx] == idx)
2937 path = get_input_path(codec, adc_idx, spec->cur_mux[adc_idx]);
2941 snd_hda_activate_path(codec, path, false, false);
2943 spec->cur_mux[adc_idx] = idx;
2945 if (spec->shared_mic_hp)
2946 update_shared_mic_hp(codec, spec->cur_mux[adc_idx]);
2948 if (spec->dyn_adc_switch)
2949 dyn_adc_pcm_resetup(codec, idx);
2951 path = get_input_path(codec, adc_idx, idx);
2956 snd_hda_activate_path(codec, path, true, false);
2957 if (spec->cap_sync_hook)
2958 spec->cap_sync_hook(codec);
2964 * Jack detections for HP auto-mute and mic-switch
2967 /* check each pin in the given array; returns true if any of them is plugged */
2968 static bool detect_jacks(struct hda_codec *codec, int num_pins, hda_nid_t *pins)
2972 for (i = 0; i < num_pins; i++) {
2973 hda_nid_t nid = pins[i];
2976 /* don't detect pins retasked as inputs */
2977 if (snd_hda_codec_get_pin_target(codec, nid) & AC_PINCTL_IN_EN)
2979 present |= snd_hda_jack_detect(codec, nid);
2984 /* standard HP/line-out auto-mute helper */
2985 static void do_automute(struct hda_codec *codec, int num_pins, hda_nid_t *pins,
2988 struct hda_gen_spec *spec = codec->spec;
2991 for (i = 0; i < num_pins; i++) {
2992 hda_nid_t nid = pins[i];
2996 /* don't reset VREF value in case it's controlling
2997 * the amp (see alc861_fixup_asus_amp_vref_0f())
2999 if (spec->keep_vref_in_automute)
3000 val = snd_hda_codec_get_pin_target(codec, nid) & ~PIN_HP;
3004 val |= snd_hda_codec_get_pin_target(codec, nid);
3005 /* here we call update_pin_ctl() so that the pinctl is changed
3006 * without changing the pinctl target value;
3007 * the original target value will be still referred at the
3008 * init / resume again
3010 update_pin_ctl(codec, nid, val);
3011 set_pin_eapd(codec, nid, !mute);
3015 /* Toggle outputs muting */
3016 void snd_hda_gen_update_outputs(struct hda_codec *codec)
3018 struct hda_gen_spec *spec = codec->spec;
3021 /* Control HP pins/amps depending on master_mute state;
3022 * in general, HP pins/amps control should be enabled in all cases,
3023 * but currently set only for master_mute, just to be safe
3025 if (!spec->shared_mic_hp) /* don't change HP-pin when shared with mic */
3026 do_automute(codec, ARRAY_SIZE(spec->autocfg.hp_pins),
3027 spec->autocfg.hp_pins, spec->master_mute);
3029 if (!spec->automute_speaker)
3032 on = spec->hp_jack_present | spec->line_jack_present;
3033 on |= spec->master_mute;
3034 do_automute(codec, ARRAY_SIZE(spec->autocfg.speaker_pins),
3035 spec->autocfg.speaker_pins, on);
3037 /* toggle line-out mutes if needed, too */
3038 /* if LO is a copy of either HP or Speaker, don't need to handle it */
3039 if (spec->autocfg.line_out_pins[0] == spec->autocfg.hp_pins[0] ||
3040 spec->autocfg.line_out_pins[0] == spec->autocfg.speaker_pins[0])
3042 if (!spec->automute_lo)
3045 on = spec->hp_jack_present;
3046 on |= spec->master_mute;
3047 do_automute(codec, ARRAY_SIZE(spec->autocfg.line_out_pins),
3048 spec->autocfg.line_out_pins, on);
3050 EXPORT_SYMBOL_HDA(snd_hda_gen_update_outputs);
3052 static void call_update_outputs(struct hda_codec *codec)
3054 struct hda_gen_spec *spec = codec->spec;
3055 if (spec->automute_hook)
3056 spec->automute_hook(codec);
3058 snd_hda_gen_update_outputs(codec);
3061 /* standard HP-automute helper */
3062 void snd_hda_gen_hp_automute(struct hda_codec *codec, struct hda_jack_tbl *jack)
3064 struct hda_gen_spec *spec = codec->spec;
3066 spec->hp_jack_present =
3067 detect_jacks(codec, ARRAY_SIZE(spec->autocfg.hp_pins),
3068 spec->autocfg.hp_pins);
3069 if (!spec->detect_hp || (!spec->automute_speaker && !spec->automute_lo))
3071 call_update_outputs(codec);
3073 EXPORT_SYMBOL_HDA(snd_hda_gen_hp_automute);
3075 /* standard line-out-automute helper */
3076 void snd_hda_gen_line_automute(struct hda_codec *codec, struct hda_jack_tbl *jack)
3078 struct hda_gen_spec *spec = codec->spec;
3080 if (spec->autocfg.line_out_type == AUTO_PIN_SPEAKER_OUT)
3082 /* check LO jack only when it's different from HP */
3083 if (spec->autocfg.line_out_pins[0] == spec->autocfg.hp_pins[0])
3086 spec->line_jack_present =
3087 detect_jacks(codec, ARRAY_SIZE(spec->autocfg.line_out_pins),
3088 spec->autocfg.line_out_pins);
3089 if (!spec->automute_speaker || !spec->detect_lo)
3091 call_update_outputs(codec);
3093 EXPORT_SYMBOL_HDA(snd_hda_gen_line_automute);
3095 /* standard mic auto-switch helper */
3096 void snd_hda_gen_mic_autoswitch(struct hda_codec *codec, struct hda_jack_tbl *jack)
3098 struct hda_gen_spec *spec = codec->spec;
3101 if (!spec->auto_mic)
3104 for (i = spec->am_num_entries - 1; i > 0; i--) {
3105 hda_nid_t pin = spec->am_entry[i].pin;
3106 /* don't detect pins retasked as outputs */
3107 if (snd_hda_codec_get_pin_target(codec, pin) & AC_PINCTL_OUT_EN)
3109 if (snd_hda_jack_detect(codec, pin)) {
3110 mux_select(codec, 0, spec->am_entry[i].idx);
3114 mux_select(codec, 0, spec->am_entry[0].idx);
3116 EXPORT_SYMBOL_HDA(snd_hda_gen_mic_autoswitch);
3119 * Auto-Mute mode mixer enum support
3121 static int automute_mode_info(struct snd_kcontrol *kcontrol,
3122 struct snd_ctl_elem_info *uinfo)
3124 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3125 struct hda_gen_spec *spec = codec->spec;
3126 static const char * const texts3[] = {
3127 "Disabled", "Speaker Only", "Line Out+Speaker"
3130 if (spec->automute_speaker_possible && spec->automute_lo_possible)
3131 return snd_hda_enum_helper_info(kcontrol, uinfo, 3, texts3);
3132 return snd_hda_enum_bool_helper_info(kcontrol, uinfo);
3135 static int automute_mode_get(struct snd_kcontrol *kcontrol,
3136 struct snd_ctl_elem_value *ucontrol)
3138 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3139 struct hda_gen_spec *spec = codec->spec;
3140 unsigned int val = 0;
3141 if (spec->automute_speaker)
3143 if (spec->automute_lo)
3146 ucontrol->value.enumerated.item[0] = val;
3150 static int automute_mode_put(struct snd_kcontrol *kcontrol,
3151 struct snd_ctl_elem_value *ucontrol)
3153 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3154 struct hda_gen_spec *spec = codec->spec;
3156 switch (ucontrol->value.enumerated.item[0]) {
3158 if (!spec->automute_speaker && !spec->automute_lo)
3160 spec->automute_speaker = 0;
3161 spec->automute_lo = 0;
3164 if (spec->automute_speaker_possible) {
3165 if (!spec->automute_lo && spec->automute_speaker)
3167 spec->automute_speaker = 1;
3168 spec->automute_lo = 0;
3169 } else if (spec->automute_lo_possible) {
3170 if (spec->automute_lo)
3172 spec->automute_lo = 1;
3177 if (!spec->automute_lo_possible || !spec->automute_speaker_possible)
3179 if (spec->automute_speaker && spec->automute_lo)
3181 spec->automute_speaker = 1;
3182 spec->automute_lo = 1;
3187 call_update_outputs(codec);
3191 static const struct snd_kcontrol_new automute_mode_enum = {
3192 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3193 .name = "Auto-Mute Mode",
3194 .info = automute_mode_info,
3195 .get = automute_mode_get,
3196 .put = automute_mode_put,
3199 static int add_automute_mode_enum(struct hda_codec *codec)
3201 struct hda_gen_spec *spec = codec->spec;
3203 if (!snd_hda_gen_add_kctl(spec, NULL, &automute_mode_enum))
3209 * Check the availability of HP/line-out auto-mute;
3210 * Set up appropriately if really supported
3212 static int check_auto_mute_availability(struct hda_codec *codec)
3214 struct hda_gen_spec *spec = codec->spec;
3215 struct auto_pin_cfg *cfg = &spec->autocfg;
3219 if (cfg->hp_pins[0])
3221 if (cfg->line_out_pins[0])
3223 if (cfg->speaker_pins[0])
3225 if (present < 2) /* need two different output types */
3228 if (!cfg->speaker_pins[0] &&
3229 cfg->line_out_type == AUTO_PIN_SPEAKER_OUT) {
3230 memcpy(cfg->speaker_pins, cfg->line_out_pins,
3231 sizeof(cfg->speaker_pins));
3232 cfg->speaker_outs = cfg->line_outs;
3235 if (!cfg->hp_pins[0] &&
3236 cfg->line_out_type == AUTO_PIN_HP_OUT) {
3237 memcpy(cfg->hp_pins, cfg->line_out_pins,
3238 sizeof(cfg->hp_pins));
3239 cfg->hp_outs = cfg->line_outs;
3242 for (i = 0; i < cfg->hp_outs; i++) {
3243 hda_nid_t nid = cfg->hp_pins[i];
3244 if (!is_jack_detectable(codec, nid))
3246 snd_printdd("hda-codec: Enable HP auto-muting on NID 0x%x\n",
3248 snd_hda_jack_detect_enable_callback(codec, nid, HDA_GEN_HP_EVENT,
3249 spec->hp_automute_hook ?
3250 spec->hp_automute_hook :
3251 snd_hda_gen_hp_automute);
3252 spec->detect_hp = 1;
3255 if (cfg->line_out_type == AUTO_PIN_LINE_OUT && cfg->line_outs) {
3256 if (cfg->speaker_outs)
3257 for (i = 0; i < cfg->line_outs; i++) {
3258 hda_nid_t nid = cfg->line_out_pins[i];
3259 if (!is_jack_detectable(codec, nid))
3261 snd_printdd("hda-codec: Enable Line-Out auto-muting on NID 0x%x\n", nid);
3262 snd_hda_jack_detect_enable_callback(codec, nid,
3263 HDA_GEN_FRONT_EVENT,
3264 spec->line_automute_hook ?
3265 spec->line_automute_hook :
3266 snd_hda_gen_line_automute);
3267 spec->detect_lo = 1;
3269 spec->automute_lo_possible = spec->detect_hp;
3272 spec->automute_speaker_possible = cfg->speaker_outs &&
3273 (spec->detect_hp || spec->detect_lo);
3275 spec->automute_lo = spec->automute_lo_possible;
3276 spec->automute_speaker = spec->automute_speaker_possible;
3278 if (spec->automute_speaker_possible || spec->automute_lo_possible) {
3279 /* create a control for automute mode */
3280 err = add_automute_mode_enum(codec);
3287 /* check whether all auto-mic pins are valid; setup indices if OK */
3288 static bool auto_mic_check_imux(struct hda_codec *codec)
3290 struct hda_gen_spec *spec = codec->spec;
3291 const struct hda_input_mux *imux;
3294 imux = &spec->input_mux;
3295 for (i = 0; i < spec->am_num_entries; i++) {
3296 spec->am_entry[i].idx =
3297 find_idx_in_nid_list(spec->am_entry[i].pin,
3298 spec->imux_pins, imux->num_items);
3299 if (spec->am_entry[i].idx < 0)
3300 return false; /* no corresponding imux */
3303 /* we don't need the jack detection for the first pin */
3304 for (i = 1; i < spec->am_num_entries; i++)
3305 snd_hda_jack_detect_enable_callback(codec,
3306 spec->am_entry[i].pin,
3308 spec->mic_autoswitch_hook ?
3309 spec->mic_autoswitch_hook :
3310 snd_hda_gen_mic_autoswitch);
3314 static int compare_attr(const void *ap, const void *bp)
3316 const struct automic_entry *a = ap;
3317 const struct automic_entry *b = bp;
3318 return (int)(a->attr - b->attr);
3322 * Check the availability of auto-mic switch;
3323 * Set up if really supported
3325 static int check_auto_mic_availability(struct hda_codec *codec)
3327 struct hda_gen_spec *spec = codec->spec;
3328 struct auto_pin_cfg *cfg = &spec->autocfg;
3332 if (spec->suppress_auto_mic)
3337 for (i = 0; i < cfg->num_inputs; i++) {
3338 hda_nid_t nid = cfg->inputs[i].pin;
3340 attr = snd_hda_codec_get_pincfg(codec, nid);
3341 attr = snd_hda_get_input_pin_attr(attr);
3342 if (types & (1 << attr))
3343 return 0; /* already occupied */
3345 case INPUT_PIN_ATTR_INT:
3346 if (cfg->inputs[i].type != AUTO_PIN_MIC)
3347 return 0; /* invalid type */
3349 case INPUT_PIN_ATTR_UNUSED:
3350 return 0; /* invalid entry */
3352 if (cfg->inputs[i].type > AUTO_PIN_LINE_IN)
3353 return 0; /* invalid type */
3354 if (!spec->line_in_auto_switch &&
3355 cfg->inputs[i].type != AUTO_PIN_MIC)
3356 return 0; /* only mic is allowed */
3357 if (!is_jack_detectable(codec, nid))
3358 return 0; /* no unsol support */
3361 if (num_pins >= MAX_AUTO_MIC_PINS)
3363 types |= (1 << attr);
3364 spec->am_entry[num_pins].pin = nid;
3365 spec->am_entry[num_pins].attr = attr;
3372 spec->am_num_entries = num_pins;
3373 /* sort the am_entry in the order of attr so that the pin with a
3374 * higher attr will be selected when the jack is plugged.
3376 sort(spec->am_entry, num_pins, sizeof(spec->am_entry[0]),
3377 compare_attr, NULL);
3379 if (!auto_mic_check_imux(codec))
3383 spec->num_adc_nids = 1;
3384 spec->cur_mux[0] = spec->am_entry[0].idx;
3385 snd_printdd("hda-codec: Enable auto-mic switch on NID 0x%x/0x%x/0x%x\n",
3386 spec->am_entry[0].pin,
3387 spec->am_entry[1].pin,
3388 spec->am_entry[2].pin);
3395 * Parse the given BIOS configuration and set up the hda_gen_spec
3397 * return 1 if successful, 0 if the proper config is not found,
3398 * or a negative error code
3400 int snd_hda_gen_parse_auto_config(struct hda_codec *codec,
3401 struct auto_pin_cfg *cfg)
3403 struct hda_gen_spec *spec = codec->spec;
3406 parse_user_hints(codec);
3408 if (cfg != &spec->autocfg) {
3409 spec->autocfg = *cfg;
3410 cfg = &spec->autocfg;
3413 if (!cfg->line_outs) {
3414 if (cfg->dig_outs || cfg->dig_in_pin) {
3415 spec->multiout.max_channels = 2;
3416 spec->no_analog = 1;
3419 return 0; /* can't find valid BIOS pin config */
3422 if (!spec->no_primary_hp &&
3423 cfg->line_out_type == AUTO_PIN_SPEAKER_OUT &&
3424 cfg->line_outs <= cfg->hp_outs) {
3425 /* use HP as primary out */
3426 cfg->speaker_outs = cfg->line_outs;
3427 memcpy(cfg->speaker_pins, cfg->line_out_pins,
3428 sizeof(cfg->speaker_pins));
3429 cfg->line_outs = cfg->hp_outs;
3430 memcpy(cfg->line_out_pins, cfg->hp_pins, sizeof(cfg->hp_pins));
3432 memset(cfg->hp_pins, 0, sizeof(cfg->hp_pins));
3433 cfg->line_out_type = AUTO_PIN_HP_OUT;
3436 err = parse_output_paths(codec);
3439 err = create_multi_channel_mode(codec);
3442 err = create_multi_out_ctls(codec, cfg);
3445 err = create_hp_out_ctls(codec);
3448 err = create_speaker_out_ctls(codec);
3451 err = create_indep_hp_ctls(codec);
3454 err = create_loopback_mixing_ctl(codec);
3457 err = create_shared_input(codec);
3460 err = create_input_ctls(codec);
3464 spec->const_channel_count = spec->ext_channel_count;
3465 /* check the multiple speaker and headphone pins */
3466 if (cfg->line_out_type != AUTO_PIN_SPEAKER_OUT)
3467 spec->const_channel_count = max(spec->const_channel_count,
3468 cfg->speaker_outs * 2);
3469 if (cfg->line_out_type != AUTO_PIN_HP_OUT)
3470 spec->const_channel_count = max(spec->const_channel_count,
3472 spec->multiout.max_channels = max(spec->ext_channel_count,
3473 spec->const_channel_count);
3475 err = check_auto_mute_availability(codec);
3479 err = check_dyn_adc_switch(codec);
3483 if (!spec->shared_mic_hp) {
3484 err = check_auto_mic_availability(codec);
3489 err = create_capture_mixers(codec);
3493 err = parse_mic_boost(codec);
3497 if (spec->add_out_jack_modes) {
3498 if (cfg->line_out_type != AUTO_PIN_SPEAKER_OUT) {
3499 err = create_out_jack_modes(codec, cfg->line_outs,
3500 cfg->line_out_pins);
3504 if (cfg->line_out_type != AUTO_PIN_HP_OUT) {
3505 err = create_out_jack_modes(codec, cfg->hp_outs,
3513 parse_digital(codec);
3517 EXPORT_SYMBOL_HDA(snd_hda_gen_parse_auto_config);
3521 * Build control elements
3524 /* slave controls for virtual master */
3525 static const char * const slave_pfxs[] = {
3526 "Front", "Surround", "Center", "LFE", "Side",
3527 "Headphone", "Speaker", "Mono", "Line Out",
3528 "CLFE", "Bass Speaker", "PCM",
3529 "Speaker Front", "Speaker Surround", "Speaker CLFE", "Speaker Side",
3530 "Headphone Front", "Headphone Surround", "Headphone CLFE",
3535 int snd_hda_gen_build_controls(struct hda_codec *codec)
3537 struct hda_gen_spec *spec = codec->spec;
3540 if (spec->kctls.used) {
3541 err = snd_hda_add_new_ctls(codec, spec->kctls.list);
3546 if (spec->multiout.dig_out_nid) {
3547 err = snd_hda_create_dig_out_ctls(codec,
3548 spec->multiout.dig_out_nid,
3549 spec->multiout.dig_out_nid,
3550 spec->pcm_rec[1].pcm_type);
3553 if (!spec->no_analog) {
3554 err = snd_hda_create_spdif_share_sw(codec,
3558 spec->multiout.share_spdif = 1;
3561 if (spec->dig_in_nid) {
3562 err = snd_hda_create_spdif_in_ctls(codec, spec->dig_in_nid);
3567 /* if we have no master control, let's create it */
3568 if (!spec->no_analog &&
3569 !snd_hda_find_mixer_ctl(codec, "Master Playback Volume")) {
3570 unsigned int vmaster_tlv[4];
3571 snd_hda_set_vmaster_tlv(codec, spec->vmaster_nid,
3572 HDA_OUTPUT, vmaster_tlv);
3573 err = snd_hda_add_vmaster(codec, "Master Playback Volume",
3574 vmaster_tlv, slave_pfxs,
3579 if (!spec->no_analog &&
3580 !snd_hda_find_mixer_ctl(codec, "Master Playback Switch")) {
3581 err = __snd_hda_add_vmaster(codec, "Master Playback Switch",
3584 true, &spec->vmaster_mute.sw_kctl);
3587 if (spec->vmaster_mute.hook)
3588 snd_hda_add_vmaster_hook(codec, &spec->vmaster_mute,
3589 spec->vmaster_mute_enum);
3592 free_kctls(spec); /* no longer needed */
3594 if (spec->shared_mic_hp) {
3596 int nid = spec->autocfg.inputs[1].pin;
3597 err = snd_hda_jack_add_kctl(codec, nid, "Headphone Mic", 0);
3600 err = snd_hda_jack_detect_enable(codec, nid, 0);
3605 err = snd_hda_jack_add_kctls(codec, &spec->autocfg);
3611 EXPORT_SYMBOL_HDA(snd_hda_gen_build_controls);
3618 static void call_pcm_playback_hook(struct hda_pcm_stream *hinfo,
3619 struct hda_codec *codec,
3620 struct snd_pcm_substream *substream,
3623 struct hda_gen_spec *spec = codec->spec;
3624 if (spec->pcm_playback_hook)
3625 spec->pcm_playback_hook(hinfo, codec, substream, action);
3629 * Analog playback callbacks
3631 static int playback_pcm_open(struct hda_pcm_stream *hinfo,
3632 struct hda_codec *codec,
3633 struct snd_pcm_substream *substream)
3635 struct hda_gen_spec *spec = codec->spec;
3638 mutex_lock(&spec->pcm_mutex);
3639 err = snd_hda_multi_out_analog_open(codec,
3640 &spec->multiout, substream,
3643 spec->active_streams |= 1 << STREAM_MULTI_OUT;
3644 call_pcm_playback_hook(hinfo, codec, substream,
3645 HDA_GEN_PCM_ACT_OPEN);
3647 mutex_unlock(&spec->pcm_mutex);
3651 static int playback_pcm_prepare(struct hda_pcm_stream *hinfo,
3652 struct hda_codec *codec,
3653 unsigned int stream_tag,
3654 unsigned int format,
3655 struct snd_pcm_substream *substream)
3657 struct hda_gen_spec *spec = codec->spec;
3660 err = snd_hda_multi_out_analog_prepare(codec, &spec->multiout,
3661 stream_tag, format, substream);
3663 call_pcm_playback_hook(hinfo, codec, substream,
3664 HDA_GEN_PCM_ACT_PREPARE);
3668 static int playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
3669 struct hda_codec *codec,
3670 struct snd_pcm_substream *substream)
3672 struct hda_gen_spec *spec = codec->spec;
3675 err = snd_hda_multi_out_analog_cleanup(codec, &spec->multiout);
3677 call_pcm_playback_hook(hinfo, codec, substream,
3678 HDA_GEN_PCM_ACT_CLEANUP);
3682 static int playback_pcm_close(struct hda_pcm_stream *hinfo,
3683 struct hda_codec *codec,
3684 struct snd_pcm_substream *substream)
3686 struct hda_gen_spec *spec = codec->spec;
3687 mutex_lock(&spec->pcm_mutex);
3688 spec->active_streams &= ~(1 << STREAM_MULTI_OUT);
3689 call_pcm_playback_hook(hinfo, codec, substream,
3690 HDA_GEN_PCM_ACT_CLOSE);
3691 mutex_unlock(&spec->pcm_mutex);
3695 static int alt_playback_pcm_open(struct hda_pcm_stream *hinfo,
3696 struct hda_codec *codec,
3697 struct snd_pcm_substream *substream)
3699 struct hda_gen_spec *spec = codec->spec;
3702 mutex_lock(&spec->pcm_mutex);
3703 if (!spec->indep_hp_enabled)
3706 spec->active_streams |= 1 << STREAM_INDEP_HP;
3707 call_pcm_playback_hook(hinfo, codec, substream,
3708 HDA_GEN_PCM_ACT_OPEN);
3709 mutex_unlock(&spec->pcm_mutex);
3713 static int alt_playback_pcm_close(struct hda_pcm_stream *hinfo,
3714 struct hda_codec *codec,
3715 struct snd_pcm_substream *substream)
3717 struct hda_gen_spec *spec = codec->spec;
3718 mutex_lock(&spec->pcm_mutex);
3719 spec->active_streams &= ~(1 << STREAM_INDEP_HP);
3720 call_pcm_playback_hook(hinfo, codec, substream,
3721 HDA_GEN_PCM_ACT_CLOSE);
3722 mutex_unlock(&spec->pcm_mutex);
3726 static int alt_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
3727 struct hda_codec *codec,
3728 unsigned int stream_tag,
3729 unsigned int format,
3730 struct snd_pcm_substream *substream)
3732 snd_hda_codec_setup_stream(codec, hinfo->nid, stream_tag, 0, format);
3733 call_pcm_playback_hook(hinfo, codec, substream,
3734 HDA_GEN_PCM_ACT_PREPARE);
3738 static int alt_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
3739 struct hda_codec *codec,
3740 struct snd_pcm_substream *substream)
3742 snd_hda_codec_cleanup_stream(codec, hinfo->nid);
3743 call_pcm_playback_hook(hinfo, codec, substream,
3744 HDA_GEN_PCM_ACT_CLEANUP);
3751 static int dig_playback_pcm_open(struct hda_pcm_stream *hinfo,
3752 struct hda_codec *codec,
3753 struct snd_pcm_substream *substream)
3755 struct hda_gen_spec *spec = codec->spec;
3756 return snd_hda_multi_out_dig_open(codec, &spec->multiout);
3759 static int dig_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
3760 struct hda_codec *codec,
3761 unsigned int stream_tag,
3762 unsigned int format,
3763 struct snd_pcm_substream *substream)
3765 struct hda_gen_spec *spec = codec->spec;
3766 return snd_hda_multi_out_dig_prepare(codec, &spec->multiout,
3767 stream_tag, format, substream);
3770 static int dig_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
3771 struct hda_codec *codec,
3772 struct snd_pcm_substream *substream)
3774 struct hda_gen_spec *spec = codec->spec;
3775 return snd_hda_multi_out_dig_cleanup(codec, &spec->multiout);
3778 static int dig_playback_pcm_close(struct hda_pcm_stream *hinfo,
3779 struct hda_codec *codec,
3780 struct snd_pcm_substream *substream)
3782 struct hda_gen_spec *spec = codec->spec;
3783 return snd_hda_multi_out_dig_close(codec, &spec->multiout);
3789 static int alt_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
3790 struct hda_codec *codec,
3791 unsigned int stream_tag,
3792 unsigned int format,
3793 struct snd_pcm_substream *substream)
3795 struct hda_gen_spec *spec = codec->spec;
3797 snd_hda_codec_setup_stream(codec, spec->adc_nids[substream->number + 1],
3798 stream_tag, 0, format);
3802 static int alt_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
3803 struct hda_codec *codec,
3804 struct snd_pcm_substream *substream)
3806 struct hda_gen_spec *spec = codec->spec;
3808 snd_hda_codec_cleanup_stream(codec,
3809 spec->adc_nids[substream->number + 1]);
3815 static const struct hda_pcm_stream pcm_analog_playback = {
3819 /* NID is set in build_pcms */
3821 .open = playback_pcm_open,
3822 .close = playback_pcm_close,
3823 .prepare = playback_pcm_prepare,
3824 .cleanup = playback_pcm_cleanup
3828 static const struct hda_pcm_stream pcm_analog_capture = {
3832 /* NID is set in build_pcms */
3835 static const struct hda_pcm_stream pcm_analog_alt_playback = {
3839 /* NID is set in build_pcms */
3841 .open = alt_playback_pcm_open,
3842 .close = alt_playback_pcm_close,
3843 .prepare = alt_playback_pcm_prepare,
3844 .cleanup = alt_playback_pcm_cleanup
3848 static const struct hda_pcm_stream pcm_analog_alt_capture = {
3849 .substreams = 2, /* can be overridden */
3852 /* NID is set in build_pcms */
3854 .prepare = alt_capture_pcm_prepare,
3855 .cleanup = alt_capture_pcm_cleanup
3859 static const struct hda_pcm_stream pcm_digital_playback = {
3863 /* NID is set in build_pcms */
3865 .open = dig_playback_pcm_open,
3866 .close = dig_playback_pcm_close,
3867 .prepare = dig_playback_pcm_prepare,
3868 .cleanup = dig_playback_pcm_cleanup
3872 static const struct hda_pcm_stream pcm_digital_capture = {
3876 /* NID is set in build_pcms */
3879 /* Used by build_pcms to flag that a PCM has no playback stream */
3880 static const struct hda_pcm_stream pcm_null_stream = {
3887 * dynamic changing ADC PCM streams
3889 static bool dyn_adc_pcm_resetup(struct hda_codec *codec, int cur)
3891 struct hda_gen_spec *spec = codec->spec;
3892 hda_nid_t new_adc = spec->adc_nids[spec->dyn_adc_idx[cur]];
3894 if (spec->cur_adc && spec->cur_adc != new_adc) {
3895 /* stream is running, let's swap the current ADC */
3896 __snd_hda_codec_cleanup_stream(codec, spec->cur_adc, 1);
3897 spec->cur_adc = new_adc;
3898 snd_hda_codec_setup_stream(codec, new_adc,
3899 spec->cur_adc_stream_tag, 0,
3900 spec->cur_adc_format);
3906 /* analog capture with dynamic dual-adc changes */
3907 static int dyn_adc_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
3908 struct hda_codec *codec,
3909 unsigned int stream_tag,
3910 unsigned int format,
3911 struct snd_pcm_substream *substream)
3913 struct hda_gen_spec *spec = codec->spec;
3914 spec->cur_adc = spec->adc_nids[spec->dyn_adc_idx[spec->cur_mux[0]]];
3915 spec->cur_adc_stream_tag = stream_tag;
3916 spec->cur_adc_format = format;
3917 snd_hda_codec_setup_stream(codec, spec->cur_adc, stream_tag, 0, format);
3921 static int dyn_adc_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
3922 struct hda_codec *codec,
3923 struct snd_pcm_substream *substream)
3925 struct hda_gen_spec *spec = codec->spec;
3926 snd_hda_codec_cleanup_stream(codec, spec->cur_adc);
3931 static const struct hda_pcm_stream dyn_adc_pcm_analog_capture = {
3935 .nid = 0, /* fill later */
3937 .prepare = dyn_adc_capture_pcm_prepare,
3938 .cleanup = dyn_adc_capture_pcm_cleanup
3942 static void fill_pcm_stream_name(char *str, size_t len, const char *sfx,
3943 const char *chip_name)
3949 strlcpy(str, chip_name, len);
3951 /* drop non-alnum chars after a space */
3952 for (p = strchr(str, ' '); p; p = strchr(p + 1, ' ')) {
3953 if (!isalnum(p[1])) {
3958 strlcat(str, sfx, len);
3961 /* build PCM streams based on the parsed results */
3962 int snd_hda_gen_build_pcms(struct hda_codec *codec)
3964 struct hda_gen_spec *spec = codec->spec;
3965 struct hda_pcm *info = spec->pcm_rec;
3966 const struct hda_pcm_stream *p;
3967 bool have_multi_adcs;
3969 codec->num_pcms = 1;
3970 codec->pcm_info = info;
3972 if (spec->no_analog)
3975 fill_pcm_stream_name(spec->stream_name_analog,
3976 sizeof(spec->stream_name_analog),
3977 " Analog", codec->chip_name);
3978 info->name = spec->stream_name_analog;
3980 if (spec->multiout.num_dacs > 0) {
3981 p = spec->stream_analog_playback;
3983 p = &pcm_analog_playback;
3984 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *p;
3985 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dac_nids[0];
3986 info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max =
3987 spec->multiout.max_channels;
3988 if (spec->autocfg.line_out_type == AUTO_PIN_SPEAKER_OUT &&
3989 spec->autocfg.line_outs == 2)
3990 info->stream[SNDRV_PCM_STREAM_PLAYBACK].chmap =
3993 if (spec->num_adc_nids) {
3994 p = spec->stream_analog_capture;
3996 if (spec->dyn_adc_switch)
3997 p = &dyn_adc_pcm_analog_capture;
3999 p = &pcm_analog_capture;
4001 info->stream[SNDRV_PCM_STREAM_CAPTURE] = *p;
4002 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adc_nids[0];
4006 /* SPDIF for stream index #1 */
4007 if (spec->multiout.dig_out_nid || spec->dig_in_nid) {
4008 fill_pcm_stream_name(spec->stream_name_digital,
4009 sizeof(spec->stream_name_digital),
4010 " Digital", codec->chip_name);
4011 codec->num_pcms = 2;
4012 codec->slave_dig_outs = spec->multiout.slave_dig_outs;
4013 info = spec->pcm_rec + 1;
4014 info->name = spec->stream_name_digital;
4015 if (spec->dig_out_type)
4016 info->pcm_type = spec->dig_out_type;
4018 info->pcm_type = HDA_PCM_TYPE_SPDIF;
4019 if (spec->multiout.dig_out_nid) {
4020 p = spec->stream_digital_playback;
4022 p = &pcm_digital_playback;
4023 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *p;
4024 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dig_out_nid;
4026 if (spec->dig_in_nid) {
4027 p = spec->stream_digital_capture;
4029 p = &pcm_digital_capture;
4030 info->stream[SNDRV_PCM_STREAM_CAPTURE] = *p;
4031 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->dig_in_nid;
4035 if (spec->no_analog)
4038 /* If the use of more than one ADC is requested for the current
4039 * model, configure a second analog capture-only PCM.
4041 have_multi_adcs = (spec->num_adc_nids > 1) &&
4042 !spec->dyn_adc_switch && !spec->auto_mic;
4043 /* Additional Analaog capture for index #2 */
4044 if (spec->alt_dac_nid || have_multi_adcs) {
4045 codec->num_pcms = 3;
4046 info = spec->pcm_rec + 2;
4047 info->name = spec->stream_name_analog;
4048 if (spec->alt_dac_nid) {
4049 p = spec->stream_analog_alt_playback;
4051 p = &pcm_analog_alt_playback;
4052 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *p;
4053 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid =
4056 info->stream[SNDRV_PCM_STREAM_PLAYBACK] =
4058 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = 0;
4060 if (have_multi_adcs) {
4061 p = spec->stream_analog_alt_capture;
4063 p = &pcm_analog_alt_capture;
4064 info->stream[SNDRV_PCM_STREAM_CAPTURE] = *p;
4065 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid =
4067 info->stream[SNDRV_PCM_STREAM_CAPTURE].substreams =
4068 spec->num_adc_nids - 1;
4070 info->stream[SNDRV_PCM_STREAM_CAPTURE] =
4072 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = 0;
4078 EXPORT_SYMBOL_HDA(snd_hda_gen_build_pcms);
4082 * Standard auto-parser initializations
4085 /* configure the given path as a proper output */
4086 static void set_output_and_unmute(struct hda_codec *codec, int path_idx)
4088 struct nid_path *path;
4091 path = snd_hda_get_path_from_idx(codec, path_idx);
4092 if (!path || !path->depth)
4094 pin = path->path[path->depth - 1];
4095 restore_pin_ctl(codec, pin);
4096 snd_hda_activate_path(codec, path, path->active, true);
4097 set_pin_eapd(codec, pin, path->active);
4100 /* initialize primary output paths */
4101 static void init_multi_out(struct hda_codec *codec)
4103 struct hda_gen_spec *spec = codec->spec;
4106 for (i = 0; i < spec->autocfg.line_outs; i++)
4107 set_output_and_unmute(codec, spec->out_paths[i]);
4111 static void __init_extra_out(struct hda_codec *codec, int num_outs, int *paths)
4115 for (i = 0; i < num_outs; i++)
4116 set_output_and_unmute(codec, paths[i]);
4119 /* initialize hp and speaker paths */
4120 static void init_extra_out(struct hda_codec *codec)
4122 struct hda_gen_spec *spec = codec->spec;
4124 if (spec->autocfg.line_out_type != AUTO_PIN_HP_OUT)
4125 __init_extra_out(codec, spec->autocfg.hp_outs, spec->hp_paths);
4126 if (spec->autocfg.line_out_type != AUTO_PIN_SPEAKER_OUT)
4127 __init_extra_out(codec, spec->autocfg.speaker_outs,
4128 spec->speaker_paths);
4131 /* initialize multi-io paths */
4132 static void init_multi_io(struct hda_codec *codec)
4134 struct hda_gen_spec *spec = codec->spec;
4137 for (i = 0; i < spec->multi_ios; i++) {
4138 hda_nid_t pin = spec->multi_io[i].pin;
4139 struct nid_path *path;
4140 path = get_multiio_path(codec, i);
4143 if (!spec->multi_io[i].ctl_in)
4144 spec->multi_io[i].ctl_in =
4145 snd_hda_codec_get_pin_target(codec, pin);
4146 snd_hda_activate_path(codec, path, path->active, true);
4150 /* set up input pins and loopback paths */
4151 static void init_analog_input(struct hda_codec *codec)
4153 struct hda_gen_spec *spec = codec->spec;
4154 struct auto_pin_cfg *cfg = &spec->autocfg;
4157 for (i = 0; i < cfg->num_inputs; i++) {
4158 hda_nid_t nid = cfg->inputs[i].pin;
4159 if (is_input_pin(codec, nid))
4160 restore_pin_ctl(codec, nid);
4162 /* init loopback inputs */
4163 if (spec->mixer_nid) {
4164 struct nid_path *path;
4165 path = snd_hda_get_path_from_idx(codec, spec->loopback_paths[i]);
4167 snd_hda_activate_path(codec, path,
4168 path->active, false);
4173 /* initialize ADC paths */
4174 static void init_input_src(struct hda_codec *codec)
4176 struct hda_gen_spec *spec = codec->spec;
4177 struct hda_input_mux *imux = &spec->input_mux;
4178 struct nid_path *path;
4181 if (spec->dyn_adc_switch)
4184 nums = spec->num_adc_nids;
4186 for (c = 0; c < nums; c++) {
4187 for (i = 0; i < imux->num_items; i++) {
4188 path = get_input_path(codec, c, i);
4190 bool active = path->active;
4191 if (i == spec->cur_mux[c])
4193 snd_hda_activate_path(codec, path, active, false);
4198 if (spec->shared_mic_hp)
4199 update_shared_mic_hp(codec, spec->cur_mux[0]);
4201 if (spec->cap_sync_hook)
4202 spec->cap_sync_hook(codec);
4205 /* set right pin controls for digital I/O */
4206 static void init_digital(struct hda_codec *codec)
4208 struct hda_gen_spec *spec = codec->spec;
4212 for (i = 0; i < spec->autocfg.dig_outs; i++)
4213 set_output_and_unmute(codec, spec->digout_paths[i]);
4214 pin = spec->autocfg.dig_in_pin;
4216 struct nid_path *path;
4217 restore_pin_ctl(codec, pin);
4218 path = snd_hda_get_path_from_idx(codec, spec->digin_path);
4220 snd_hda_activate_path(codec, path, path->active, false);
4224 /* clear unsol-event tags on unused pins; Conexant codecs seem to leave
4225 * invalid unsol tags by some reason
4227 static void clear_unsol_on_unused_pins(struct hda_codec *codec)
4231 for (i = 0; i < codec->init_pins.used; i++) {
4232 struct hda_pincfg *pin = snd_array_elem(&codec->init_pins, i);
4233 hda_nid_t nid = pin->nid;
4234 if (is_jack_detectable(codec, nid) &&
4235 !snd_hda_jack_tbl_get(codec, nid))
4236 snd_hda_codec_update_cache(codec, nid, 0,
4237 AC_VERB_SET_UNSOLICITED_ENABLE, 0);
4242 * initialize the generic spec;
4243 * this can be put as patch_ops.init function
4245 int snd_hda_gen_init(struct hda_codec *codec)
4247 struct hda_gen_spec *spec = codec->spec;
4249 if (spec->init_hook)
4250 spec->init_hook(codec);
4252 snd_hda_apply_verbs(codec);
4254 codec->cached_write = 1;
4256 init_multi_out(codec);
4257 init_extra_out(codec);
4258 init_multi_io(codec);
4259 init_analog_input(codec);
4260 init_input_src(codec);
4261 init_digital(codec);
4263 clear_unsol_on_unused_pins(codec);
4265 /* call init functions of standard auto-mute helpers */
4266 snd_hda_gen_hp_automute(codec, NULL);
4267 snd_hda_gen_line_automute(codec, NULL);
4268 snd_hda_gen_mic_autoswitch(codec, NULL);
4270 snd_hda_codec_flush_amp_cache(codec);
4271 snd_hda_codec_flush_cmd_cache(codec);
4273 if (spec->vmaster_mute.sw_kctl && spec->vmaster_mute.hook)
4274 snd_hda_sync_vmaster_hook(&spec->vmaster_mute);
4276 hda_call_check_power_status(codec, 0x01);
4279 EXPORT_SYMBOL_HDA(snd_hda_gen_init);
4282 * free the generic spec;
4283 * this can be put as patch_ops.free function
4285 void snd_hda_gen_free(struct hda_codec *codec)
4287 snd_hda_gen_spec_free(codec->spec);
4291 EXPORT_SYMBOL_HDA(snd_hda_gen_free);
4295 * check the loopback power save state;
4296 * this can be put as patch_ops.check_power_status function
4298 int snd_hda_gen_check_power_status(struct hda_codec *codec, hda_nid_t nid)
4300 struct hda_gen_spec *spec = codec->spec;
4301 return snd_hda_check_amp_list_power(codec, &spec->loopback, nid);
4303 EXPORT_SYMBOL_HDA(snd_hda_gen_check_power_status);
4308 * the generic codec support
4311 static const struct hda_codec_ops generic_patch_ops = {
4312 .build_controls = snd_hda_gen_build_controls,
4313 .build_pcms = snd_hda_gen_build_pcms,
4314 .init = snd_hda_gen_init,
4315 .free = snd_hda_gen_free,
4316 .unsol_event = snd_hda_jack_unsol_event,
4318 .check_power_status = snd_hda_gen_check_power_status,
4322 int snd_hda_parse_generic_codec(struct hda_codec *codec)
4324 struct hda_gen_spec *spec;
4327 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
4330 snd_hda_gen_spec_init(spec);
4333 err = snd_hda_parse_pin_defcfg(codec, &spec->autocfg, NULL, 0);
4337 err = snd_hda_gen_parse_auto_config(codec, &spec->autocfg);
4341 codec->patch_ops = generic_patch_ops;
4345 snd_hda_gen_free(codec);
4348 EXPORT_SYMBOL_HDA(snd_hda_parse_generic_codec);