2 * Universal Interface for Intel High Definition Audio Codec
4 * Generic widget tree parser
6 * Copyright (c) 2004 Takashi Iwai <tiwai@suse.de>
8 * This driver is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 2 of the License, or
11 * (at your option) any later version.
13 * This driver is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, write to the Free Software
20 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
23 #include <linux/init.h>
24 #include <linux/slab.h>
25 #include <linux/export.h>
26 #include <linux/sort.h>
27 #include <linux/delay.h>
28 #include <linux/ctype.h>
29 #include <linux/string.h>
30 #include <linux/bitops.h>
31 #include <sound/core.h>
32 #include <sound/jack.h>
33 #include "hda_codec.h"
34 #include "hda_local.h"
35 #include "hda_auto_parser.h"
38 #include "hda_generic.h"
41 /* initialize hda_gen_spec struct */
42 int snd_hda_gen_spec_init(struct hda_gen_spec *spec)
44 snd_array_init(&spec->kctls, sizeof(struct snd_kcontrol_new), 32);
45 snd_array_init(&spec->paths, sizeof(struct nid_path), 8);
46 snd_array_init(&spec->loopback_list, sizeof(struct hda_amp_list), 8);
47 mutex_init(&spec->pcm_mutex);
50 EXPORT_SYMBOL_HDA(snd_hda_gen_spec_init);
52 struct snd_kcontrol_new *
53 snd_hda_gen_add_kctl(struct hda_gen_spec *spec, const char *name,
54 const struct snd_kcontrol_new *temp)
56 struct snd_kcontrol_new *knew = snd_array_new(&spec->kctls);
61 knew->name = kstrdup(name, GFP_KERNEL);
63 knew->name = kstrdup(knew->name, GFP_KERNEL);
68 EXPORT_SYMBOL_HDA(snd_hda_gen_add_kctl);
70 static void free_kctls(struct hda_gen_spec *spec)
72 if (spec->kctls.list) {
73 struct snd_kcontrol_new *kctl = spec->kctls.list;
75 for (i = 0; i < spec->kctls.used; i++)
78 snd_array_free(&spec->kctls);
81 void snd_hda_gen_spec_free(struct hda_gen_spec *spec)
86 snd_array_free(&spec->paths);
87 snd_array_free(&spec->loopback_list);
89 EXPORT_SYMBOL_HDA(snd_hda_gen_spec_free);
94 static void parse_user_hints(struct hda_codec *codec)
96 struct hda_gen_spec *spec = codec->spec;
99 val = snd_hda_get_bool_hint(codec, "jack_detect");
101 codec->no_jack_detect = !val;
102 val = snd_hda_get_bool_hint(codec, "inv_jack_detect");
104 codec->inv_jack_detect = !!val;
105 val = snd_hda_get_bool_hint(codec, "trigger_sense");
107 codec->no_trigger_sense = !val;
108 val = snd_hda_get_bool_hint(codec, "inv_eapd");
110 codec->inv_eapd = !!val;
111 val = snd_hda_get_bool_hint(codec, "pcm_format_first");
113 codec->pcm_format_first = !!val;
114 val = snd_hda_get_bool_hint(codec, "sticky_stream");
116 codec->no_sticky_stream = !val;
117 val = snd_hda_get_bool_hint(codec, "spdif_status_reset");
119 codec->spdif_status_reset = !!val;
120 val = snd_hda_get_bool_hint(codec, "pin_amp_workaround");
122 codec->pin_amp_workaround = !!val;
123 val = snd_hda_get_bool_hint(codec, "single_adc_amp");
125 codec->single_adc_amp = !!val;
127 val = snd_hda_get_bool_hint(codec, "auto_mute");
129 spec->suppress_auto_mute = !val;
130 val = snd_hda_get_bool_hint(codec, "auto_mic");
132 spec->suppress_auto_mic = !val;
133 val = snd_hda_get_bool_hint(codec, "line_in_auto_switch");
135 spec->line_in_auto_switch = !!val;
136 val = snd_hda_get_bool_hint(codec, "need_dac_fix");
138 spec->need_dac_fix = !!val;
139 val = snd_hda_get_bool_hint(codec, "primary_hp");
141 spec->no_primary_hp = !val;
142 val = snd_hda_get_bool_hint(codec, "multi_cap_vol");
144 spec->multi_cap_vol = !!val;
145 val = snd_hda_get_bool_hint(codec, "inv_dmic_split");
147 spec->inv_dmic_split = !!val;
148 val = snd_hda_get_bool_hint(codec, "indep_hp");
150 spec->indep_hp = !!val;
151 val = snd_hda_get_bool_hint(codec, "add_stereo_mix_input");
153 spec->add_stereo_mix_input = !!val;
154 /* the following two are just for compatibility */
155 val = snd_hda_get_bool_hint(codec, "add_out_jack_modes");
157 spec->add_jack_modes = !!val;
158 val = snd_hda_get_bool_hint(codec, "add_in_jack_modes");
160 spec->add_jack_modes = !!val;
161 val = snd_hda_get_bool_hint(codec, "add_jack_modes");
163 spec->add_jack_modes = !!val;
164 val = snd_hda_get_bool_hint(codec, "power_down_unused");
166 spec->power_down_unused = !!val;
167 val = snd_hda_get_bool_hint(codec, "add_hp_mic");
169 spec->hp_mic = !!val;
170 val = snd_hda_get_bool_hint(codec, "hp_mic_detect");
172 spec->suppress_hp_mic_detect = !val;
174 if (!snd_hda_get_int_hint(codec, "mixer_nid", &val))
175 spec->mixer_nid = val;
179 * pin control value accesses
182 #define update_pin_ctl(codec, pin, val) \
183 snd_hda_codec_update_cache(codec, pin, 0, \
184 AC_VERB_SET_PIN_WIDGET_CONTROL, val)
186 /* restore the pinctl based on the cached value */
187 static inline void restore_pin_ctl(struct hda_codec *codec, hda_nid_t pin)
189 update_pin_ctl(codec, pin, snd_hda_codec_get_pin_target(codec, pin));
192 /* set the pinctl target value and write it if requested */
193 static void set_pin_target(struct hda_codec *codec, hda_nid_t pin,
194 unsigned int val, bool do_write)
198 val = snd_hda_correct_pin_ctl(codec, pin, val);
199 snd_hda_codec_set_pin_target(codec, pin, val);
201 update_pin_ctl(codec, pin, val);
204 /* set pinctl target values for all given pins */
205 static void set_pin_targets(struct hda_codec *codec, int num_pins,
206 hda_nid_t *pins, unsigned int val)
209 for (i = 0; i < num_pins; i++)
210 set_pin_target(codec, pins[i], val, false);
217 /* return the position of NID in the list, or -1 if not found */
218 static int find_idx_in_nid_list(hda_nid_t nid, const hda_nid_t *list, int nums)
221 for (i = 0; i < nums; i++)
227 /* return true if the given NID is contained in the path */
228 static bool is_nid_contained(struct nid_path *path, hda_nid_t nid)
230 return find_idx_in_nid_list(nid, path->path, path->depth) >= 0;
233 static struct nid_path *get_nid_path(struct hda_codec *codec,
234 hda_nid_t from_nid, hda_nid_t to_nid,
237 struct hda_gen_spec *spec = codec->spec;
240 for (i = 0; i < spec->paths.used; i++) {
241 struct nid_path *path = snd_array_elem(&spec->paths, i);
242 if (path->depth <= 0)
244 if ((!from_nid || path->path[0] == from_nid) &&
245 (!to_nid || path->path[path->depth - 1] == to_nid)) {
247 (anchor_nid > 0 && is_nid_contained(path, anchor_nid)) ||
248 (anchor_nid < 0 && !is_nid_contained(path, anchor_nid)))
255 /* get the path between the given NIDs;
256 * passing 0 to either @pin or @dac behaves as a wildcard
258 struct nid_path *snd_hda_get_nid_path(struct hda_codec *codec,
259 hda_nid_t from_nid, hda_nid_t to_nid)
261 return get_nid_path(codec, from_nid, to_nid, 0);
263 EXPORT_SYMBOL_HDA(snd_hda_get_nid_path);
265 /* get the index number corresponding to the path instance;
266 * the index starts from 1, for easier checking the invalid value
268 int snd_hda_get_path_idx(struct hda_codec *codec, struct nid_path *path)
270 struct hda_gen_spec *spec = codec->spec;
271 struct nid_path *array = spec->paths.list;
274 if (!spec->paths.used)
277 if (idx < 0 || idx >= spec->paths.used)
281 EXPORT_SYMBOL_HDA(snd_hda_get_path_idx);
283 /* get the path instance corresponding to the given index number */
284 struct nid_path *snd_hda_get_path_from_idx(struct hda_codec *codec, int idx)
286 struct hda_gen_spec *spec = codec->spec;
288 if (idx <= 0 || idx > spec->paths.used)
290 return snd_array_elem(&spec->paths, idx - 1);
292 EXPORT_SYMBOL_HDA(snd_hda_get_path_from_idx);
294 /* check whether the given DAC is already found in any existing paths */
295 static bool is_dac_already_used(struct hda_codec *codec, hda_nid_t nid)
297 struct hda_gen_spec *spec = codec->spec;
300 for (i = 0; i < spec->paths.used; i++) {
301 struct nid_path *path = snd_array_elem(&spec->paths, i);
302 if (path->path[0] == nid)
308 /* check whether the given two widgets can be connected */
309 static bool is_reachable_path(struct hda_codec *codec,
310 hda_nid_t from_nid, hda_nid_t to_nid)
312 if (!from_nid || !to_nid)
314 return snd_hda_get_conn_index(codec, to_nid, from_nid, true) >= 0;
317 /* nid, dir and idx */
318 #define AMP_VAL_COMPARE_MASK (0xffff | (1U << 18) | (0x0f << 19))
320 /* check whether the given ctl is already assigned in any path elements */
321 static bool is_ctl_used(struct hda_codec *codec, unsigned int val, int type)
323 struct hda_gen_spec *spec = codec->spec;
326 val &= AMP_VAL_COMPARE_MASK;
327 for (i = 0; i < spec->paths.used; i++) {
328 struct nid_path *path = snd_array_elem(&spec->paths, i);
329 if ((path->ctls[type] & AMP_VAL_COMPARE_MASK) == val)
335 /* check whether a control with the given (nid, dir, idx) was assigned */
336 static bool is_ctl_associated(struct hda_codec *codec, hda_nid_t nid,
337 int dir, int idx, int type)
339 unsigned int val = HDA_COMPOSE_AMP_VAL(nid, 3, idx, dir);
340 return is_ctl_used(codec, val, type);
343 static void print_nid_path(const char *pfx, struct nid_path *path)
350 for (i = 0; i < path->depth; i++) {
352 sprintf(tmp, ":%02x", path->path[i]);
353 strlcat(buf, tmp, sizeof(buf));
355 snd_printdd("%s path: depth=%d %s\n", pfx, path->depth, buf);
358 /* called recursively */
359 static bool __parse_nid_path(struct hda_codec *codec,
360 hda_nid_t from_nid, hda_nid_t to_nid,
361 int anchor_nid, struct nid_path *path,
364 const hda_nid_t *conn;
367 if (to_nid == anchor_nid)
368 anchor_nid = 0; /* anchor passed */
369 else if (to_nid == (hda_nid_t)(-anchor_nid))
370 return false; /* hit the exclusive nid */
372 nums = snd_hda_get_conn_list(codec, to_nid, &conn);
373 for (i = 0; i < nums; i++) {
374 if (conn[i] != from_nid) {
375 /* special case: when from_nid is 0,
376 * try to find an empty DAC
379 get_wcaps_type(get_wcaps(codec, conn[i])) != AC_WID_AUD_OUT ||
380 is_dac_already_used(codec, conn[i]))
383 /* anchor is not requested or already passed? */
387 if (depth >= MAX_NID_PATH_DEPTH)
389 for (i = 0; i < nums; i++) {
391 type = get_wcaps_type(get_wcaps(codec, conn[i]));
392 if (type == AC_WID_AUD_OUT || type == AC_WID_AUD_IN ||
395 if (__parse_nid_path(codec, from_nid, conn[i],
396 anchor_nid, path, depth + 1))
402 path->path[path->depth] = conn[i];
403 path->idx[path->depth + 1] = i;
404 if (nums > 1 && get_wcaps_type(get_wcaps(codec, to_nid)) != AC_WID_AUD_MIX)
405 path->multi[path->depth + 1] = 1;
410 /* parse the widget path from the given nid to the target nid;
411 * when @from_nid is 0, try to find an empty DAC;
412 * when @anchor_nid is set to a positive value, only paths through the widget
413 * with the given value are evaluated.
414 * when @anchor_nid is set to a negative value, paths through the widget
415 * with the negative of given value are excluded, only other paths are chosen.
416 * when @anchor_nid is zero, no special handling about path selection.
418 bool snd_hda_parse_nid_path(struct hda_codec *codec, hda_nid_t from_nid,
419 hda_nid_t to_nid, int anchor_nid,
420 struct nid_path *path)
422 if (__parse_nid_path(codec, from_nid, to_nid, anchor_nid, path, 1)) {
423 path->path[path->depth] = to_nid;
429 EXPORT_SYMBOL_HDA(snd_hda_parse_nid_path);
432 * parse the path between the given NIDs and add to the path list.
433 * if no valid path is found, return NULL
436 snd_hda_add_new_path(struct hda_codec *codec, hda_nid_t from_nid,
437 hda_nid_t to_nid, int anchor_nid)
439 struct hda_gen_spec *spec = codec->spec;
440 struct nid_path *path;
442 if (from_nid && to_nid && !is_reachable_path(codec, from_nid, to_nid))
445 /* check whether the path has been already added */
446 path = get_nid_path(codec, from_nid, to_nid, anchor_nid);
450 path = snd_array_new(&spec->paths);
453 memset(path, 0, sizeof(*path));
454 if (snd_hda_parse_nid_path(codec, from_nid, to_nid, anchor_nid, path))
460 EXPORT_SYMBOL_HDA(snd_hda_add_new_path);
462 /* clear the given path as invalid so that it won't be picked up later */
463 static void invalidate_nid_path(struct hda_codec *codec, int idx)
465 struct nid_path *path = snd_hda_get_path_from_idx(codec, idx);
468 memset(path, 0, sizeof(*path));
471 /* look for an empty DAC slot */
472 static hda_nid_t look_for_dac(struct hda_codec *codec, hda_nid_t pin,
475 struct hda_gen_spec *spec = codec->spec;
479 for (i = 0; i < spec->num_all_dacs; i++) {
480 hda_nid_t nid = spec->all_dacs[i];
481 if (!nid || is_dac_already_used(codec, nid))
483 cap_digital = !!(get_wcaps(codec, nid) & AC_WCAP_DIGITAL);
484 if (is_digital != cap_digital)
486 if (is_reachable_path(codec, nid, pin))
492 /* replace the channels in the composed amp value with the given number */
493 static unsigned int amp_val_replace_channels(unsigned int val, unsigned int chs)
495 val &= ~(0x3U << 16);
500 /* check whether the widget has the given amp capability for the direction */
501 static bool check_amp_caps(struct hda_codec *codec, hda_nid_t nid,
502 int dir, unsigned int bits)
506 if (get_wcaps(codec, nid) & (1 << (dir + 1)))
507 if (query_amp_caps(codec, nid, dir) & bits)
512 static bool same_amp_caps(struct hda_codec *codec, hda_nid_t nid1,
513 hda_nid_t nid2, int dir)
515 if (!(get_wcaps(codec, nid1) & (1 << (dir + 1))))
516 return !(get_wcaps(codec, nid2) & (1 << (dir + 1)));
517 return (query_amp_caps(codec, nid1, dir) ==
518 query_amp_caps(codec, nid2, dir));
521 #define nid_has_mute(codec, nid, dir) \
522 check_amp_caps(codec, nid, dir, AC_AMPCAP_MUTE)
523 #define nid_has_volume(codec, nid, dir) \
524 check_amp_caps(codec, nid, dir, AC_AMPCAP_NUM_STEPS)
526 /* look for a widget suitable for assigning a mute switch in the path */
527 static hda_nid_t look_for_out_mute_nid(struct hda_codec *codec,
528 struct nid_path *path)
532 for (i = path->depth - 1; i >= 0; i--) {
533 if (nid_has_mute(codec, path->path[i], HDA_OUTPUT))
534 return path->path[i];
535 if (i != path->depth - 1 && i != 0 &&
536 nid_has_mute(codec, path->path[i], HDA_INPUT))
537 return path->path[i];
542 /* look for a widget suitable for assigning a volume ctl in the path */
543 static hda_nid_t look_for_out_vol_nid(struct hda_codec *codec,
544 struct nid_path *path)
548 for (i = path->depth - 1; i >= 0; i--) {
549 if (nid_has_volume(codec, path->path[i], HDA_OUTPUT))
550 return path->path[i];
556 * path activation / deactivation
559 /* can have the amp-in capability? */
560 static bool has_amp_in(struct hda_codec *codec, struct nid_path *path, int idx)
562 hda_nid_t nid = path->path[idx];
563 unsigned int caps = get_wcaps(codec, nid);
564 unsigned int type = get_wcaps_type(caps);
566 if (!(caps & AC_WCAP_IN_AMP))
568 if (type == AC_WID_PIN && idx > 0) /* only for input pins */
573 /* can have the amp-out capability? */
574 static bool has_amp_out(struct hda_codec *codec, struct nid_path *path, int idx)
576 hda_nid_t nid = path->path[idx];
577 unsigned int caps = get_wcaps(codec, nid);
578 unsigned int type = get_wcaps_type(caps);
580 if (!(caps & AC_WCAP_OUT_AMP))
582 if (type == AC_WID_PIN && !idx) /* only for output pins */
587 /* check whether the given (nid,dir,idx) is active */
588 static bool is_active_nid(struct hda_codec *codec, hda_nid_t nid,
589 unsigned int dir, unsigned int idx)
591 struct hda_gen_spec *spec = codec->spec;
594 for (n = 0; n < spec->paths.used; n++) {
595 struct nid_path *path = snd_array_elem(&spec->paths, n);
598 for (i = 0; i < path->depth; i++) {
599 if (path->path[i] == nid) {
600 if (dir == HDA_OUTPUT || path->idx[i] == idx)
609 /* check whether the NID is referred by any active paths */
610 #define is_active_nid_for_any(codec, nid) \
611 is_active_nid(codec, nid, HDA_OUTPUT, 0)
613 /* get the default amp value for the target state */
614 static int get_amp_val_to_activate(struct hda_codec *codec, hda_nid_t nid,
615 int dir, unsigned int caps, bool enable)
617 unsigned int val = 0;
619 if (caps & AC_AMPCAP_NUM_STEPS) {
622 val = (caps & AC_AMPCAP_OFFSET) >> AC_AMPCAP_OFFSET_SHIFT;
624 if (caps & AC_AMPCAP_MUTE) {
631 /* initialize the amp value (only at the first time) */
632 static void init_amp(struct hda_codec *codec, hda_nid_t nid, int dir, int idx)
634 unsigned int caps = query_amp_caps(codec, nid, dir);
635 int val = get_amp_val_to_activate(codec, nid, dir, caps, false);
636 snd_hda_codec_amp_init_stereo(codec, nid, dir, idx, 0xff, val);
639 /* calculate amp value mask we can modify;
640 * if the given amp is controlled by mixers, don't touch it
642 static unsigned int get_amp_mask_to_modify(struct hda_codec *codec,
643 hda_nid_t nid, int dir, int idx,
646 unsigned int mask = 0xff;
648 if (caps & AC_AMPCAP_MUTE) {
649 if (is_ctl_associated(codec, nid, dir, idx, NID_PATH_MUTE_CTL))
652 if (caps & AC_AMPCAP_NUM_STEPS) {
653 if (is_ctl_associated(codec, nid, dir, idx, NID_PATH_VOL_CTL) ||
654 is_ctl_associated(codec, nid, dir, idx, NID_PATH_BOOST_CTL))
660 static void activate_amp(struct hda_codec *codec, hda_nid_t nid, int dir,
661 int idx, int idx_to_check, bool enable)
664 unsigned int mask, val;
666 if (!enable && is_active_nid(codec, nid, dir, idx_to_check))
669 caps = query_amp_caps(codec, nid, dir);
670 val = get_amp_val_to_activate(codec, nid, dir, caps, enable);
671 mask = get_amp_mask_to_modify(codec, nid, dir, idx_to_check, caps);
676 snd_hda_codec_amp_stereo(codec, nid, dir, idx, mask, val);
679 static void activate_amp_out(struct hda_codec *codec, struct nid_path *path,
682 hda_nid_t nid = path->path[i];
683 init_amp(codec, nid, HDA_OUTPUT, 0);
684 activate_amp(codec, nid, HDA_OUTPUT, 0, 0, enable);
687 static void activate_amp_in(struct hda_codec *codec, struct nid_path *path,
688 int i, bool enable, bool add_aamix)
690 struct hda_gen_spec *spec = codec->spec;
691 const hda_nid_t *conn;
694 hda_nid_t nid = path->path[i];
696 nums = snd_hda_get_conn_list(codec, nid, &conn);
697 type = get_wcaps_type(get_wcaps(codec, nid));
698 if (type == AC_WID_PIN ||
699 (type == AC_WID_AUD_IN && codec->single_adc_amp)) {
705 for (n = 0; n < nums; n++)
706 init_amp(codec, nid, HDA_INPUT, n);
708 /* here is a little bit tricky in comparison with activate_amp_out();
709 * when aa-mixer is available, we need to enable the path as well
711 for (n = 0; n < nums; n++) {
712 if (n != idx && (!add_aamix || conn[n] != spec->mixer_merge_nid))
714 activate_amp(codec, nid, HDA_INPUT, n, idx, enable);
718 /* activate or deactivate the given path
719 * if @add_aamix is set, enable the input from aa-mix NID as well (if any)
721 void snd_hda_activate_path(struct hda_codec *codec, struct nid_path *path,
722 bool enable, bool add_aamix)
724 struct hda_gen_spec *spec = codec->spec;
728 path->active = false;
730 for (i = path->depth - 1; i >= 0; i--) {
731 hda_nid_t nid = path->path[i];
732 if (enable && spec->power_down_unused) {
733 /* make sure the widget is powered up */
734 if (!snd_hda_check_power_state(codec, nid, AC_PWRST_D0))
735 snd_hda_codec_write(codec, nid, 0,
736 AC_VERB_SET_POWER_STATE,
739 if (enable && path->multi[i])
740 snd_hda_codec_write_cache(codec, nid, 0,
741 AC_VERB_SET_CONNECT_SEL,
743 if (has_amp_in(codec, path, i))
744 activate_amp_in(codec, path, i, enable, add_aamix);
745 if (has_amp_out(codec, path, i))
746 activate_amp_out(codec, path, i, enable);
752 EXPORT_SYMBOL_HDA(snd_hda_activate_path);
754 /* if the given path is inactive, put widgets into D3 (only if suitable) */
755 static void path_power_down_sync(struct hda_codec *codec, struct nid_path *path)
757 struct hda_gen_spec *spec = codec->spec;
758 bool changed = false;
761 if (!spec->power_down_unused || path->active)
764 for (i = 0; i < path->depth; i++) {
765 hda_nid_t nid = path->path[i];
766 if (!snd_hda_check_power_state(codec, nid, AC_PWRST_D3) &&
767 !is_active_nid_for_any(codec, nid)) {
768 snd_hda_codec_write(codec, nid, 0,
769 AC_VERB_SET_POWER_STATE,
777 snd_hda_codec_read(codec, path->path[0], 0,
778 AC_VERB_GET_POWER_STATE, 0);
782 /* turn on/off EAPD on the given pin */
783 static void set_pin_eapd(struct hda_codec *codec, hda_nid_t pin, bool enable)
785 struct hda_gen_spec *spec = codec->spec;
786 if (spec->own_eapd_ctl ||
787 !(snd_hda_query_pin_caps(codec, pin) & AC_PINCAP_EAPD))
791 if (spec->keep_eapd_on && !enable)
793 snd_hda_codec_update_cache(codec, pin, 0,
794 AC_VERB_SET_EAPD_BTLENABLE,
795 enable ? 0x02 : 0x00);
798 /* re-initialize the path specified by the given path index */
799 static void resume_path_from_idx(struct hda_codec *codec, int path_idx)
801 struct nid_path *path = snd_hda_get_path_from_idx(codec, path_idx);
803 snd_hda_activate_path(codec, path, path->active, false);
808 * Helper functions for creating mixer ctl elements
816 static const struct snd_kcontrol_new control_templates[] = {
817 HDA_CODEC_VOLUME(NULL, 0, 0, 0),
818 HDA_CODEC_MUTE(NULL, 0, 0, 0),
819 HDA_BIND_MUTE(NULL, 0, 0, 0),
822 /* add dynamic controls from template */
823 static struct snd_kcontrol_new *
824 add_control(struct hda_gen_spec *spec, int type, const char *name,
825 int cidx, unsigned long val)
827 struct snd_kcontrol_new *knew;
829 knew = snd_hda_gen_add_kctl(spec, name, &control_templates[type]);
833 if (get_amp_nid_(val))
834 knew->subdevice = HDA_SUBDEV_AMP_FLAG;
835 knew->private_value = val;
839 static int add_control_with_pfx(struct hda_gen_spec *spec, int type,
840 const char *pfx, const char *dir,
841 const char *sfx, int cidx, unsigned long val)
844 snprintf(name, sizeof(name), "%s %s %s", pfx, dir, sfx);
845 if (!add_control(spec, type, name, cidx, val))
850 #define add_pb_vol_ctrl(spec, type, pfx, val) \
851 add_control_with_pfx(spec, type, pfx, "Playback", "Volume", 0, val)
852 #define add_pb_sw_ctrl(spec, type, pfx, val) \
853 add_control_with_pfx(spec, type, pfx, "Playback", "Switch", 0, val)
854 #define __add_pb_vol_ctrl(spec, type, pfx, cidx, val) \
855 add_control_with_pfx(spec, type, pfx, "Playback", "Volume", cidx, val)
856 #define __add_pb_sw_ctrl(spec, type, pfx, cidx, val) \
857 add_control_with_pfx(spec, type, pfx, "Playback", "Switch", cidx, val)
859 static int add_vol_ctl(struct hda_codec *codec, const char *pfx, int cidx,
860 unsigned int chs, struct nid_path *path)
865 val = path->ctls[NID_PATH_VOL_CTL];
868 val = amp_val_replace_channels(val, chs);
869 return __add_pb_vol_ctrl(codec->spec, HDA_CTL_WIDGET_VOL, pfx, cidx, val);
872 /* return the channel bits suitable for the given path->ctls[] */
873 static int get_default_ch_nums(struct hda_codec *codec, struct nid_path *path,
876 int chs = 1; /* mono (left only) */
878 hda_nid_t nid = get_amp_nid_(path->ctls[type]);
879 if (nid && (get_wcaps(codec, nid) & AC_WCAP_STEREO))
880 chs = 3; /* stereo */
885 static int add_stereo_vol(struct hda_codec *codec, const char *pfx, int cidx,
886 struct nid_path *path)
888 int chs = get_default_ch_nums(codec, path, NID_PATH_VOL_CTL);
889 return add_vol_ctl(codec, pfx, cidx, chs, path);
892 /* create a mute-switch for the given mixer widget;
893 * if it has multiple sources (e.g. DAC and loopback), create a bind-mute
895 static int add_sw_ctl(struct hda_codec *codec, const char *pfx, int cidx,
896 unsigned int chs, struct nid_path *path)
899 int type = HDA_CTL_WIDGET_MUTE;
903 val = path->ctls[NID_PATH_MUTE_CTL];
906 val = amp_val_replace_channels(val, chs);
907 if (get_amp_direction_(val) == HDA_INPUT) {
908 hda_nid_t nid = get_amp_nid_(val);
909 int nums = snd_hda_get_num_conns(codec, nid);
911 type = HDA_CTL_BIND_MUTE;
915 return __add_pb_sw_ctrl(codec->spec, type, pfx, cidx, val);
918 static int add_stereo_sw(struct hda_codec *codec, const char *pfx,
919 int cidx, struct nid_path *path)
921 int chs = get_default_ch_nums(codec, path, NID_PATH_MUTE_CTL);
922 return add_sw_ctl(codec, pfx, cidx, chs, path);
925 /* any ctl assigned to the path with the given index? */
926 static bool path_has_mixer(struct hda_codec *codec, int path_idx, int ctl_type)
928 struct nid_path *path = snd_hda_get_path_from_idx(codec, path_idx);
929 return path && path->ctls[ctl_type];
932 static const char * const channel_name[4] = {
933 "Front", "Surround", "CLFE", "Side"
936 /* give some appropriate ctl name prefix for the given line out channel */
937 static const char *get_line_out_pfx(struct hda_codec *codec, int ch,
938 int *index, int ctl_type)
940 struct hda_gen_spec *spec = codec->spec;
941 struct auto_pin_cfg *cfg = &spec->autocfg;
944 if (cfg->line_outs == 1 && !spec->multi_ios &&
945 !cfg->hp_outs && !cfg->speaker_outs)
946 return spec->vmaster_mute.hook ? "PCM" : "Master";
948 /* if there is really a single DAC used in the whole output paths,
949 * use it master (or "PCM" if a vmaster hook is present)
951 if (spec->multiout.num_dacs == 1 && !spec->mixer_nid &&
952 !spec->multiout.hp_out_nid[0] && !spec->multiout.extra_out_nid[0])
953 return spec->vmaster_mute.hook ? "PCM" : "Master";
955 /* multi-io channels */
956 if (ch >= cfg->line_outs)
957 return channel_name[ch];
959 switch (cfg->line_out_type) {
960 case AUTO_PIN_SPEAKER_OUT:
961 /* if the primary channel vol/mute is shared with HP volume,
962 * don't name it as Speaker
964 if (!ch && cfg->hp_outs &&
965 !path_has_mixer(codec, spec->hp_paths[0], ctl_type))
967 if (cfg->line_outs == 1)
969 if (cfg->line_outs == 2)
970 return ch ? "Bass Speaker" : "Speaker";
972 case AUTO_PIN_HP_OUT:
973 /* if the primary channel vol/mute is shared with spk volume,
974 * don't name it as Headphone
976 if (!ch && cfg->speaker_outs &&
977 !path_has_mixer(codec, spec->speaker_paths[0], ctl_type))
979 /* for multi-io case, only the primary out */
980 if (ch && spec->multi_ios)
986 /* for a single channel output, we don't have to name the channel */
987 if (cfg->line_outs == 1 && !spec->multi_ios)
990 if (ch >= ARRAY_SIZE(channel_name)) {
995 return channel_name[ch];
1002 /* badness definition */
1004 /* No primary DAC is found for the main output */
1005 BAD_NO_PRIMARY_DAC = 0x10000,
1006 /* No DAC is found for the extra output */
1007 BAD_NO_DAC = 0x4000,
1008 /* No possible multi-ios */
1009 BAD_MULTI_IO = 0x120,
1010 /* No individual DAC for extra output */
1011 BAD_NO_EXTRA_DAC = 0x102,
1012 /* No individual DAC for extra surrounds */
1013 BAD_NO_EXTRA_SURR_DAC = 0x101,
1014 /* Primary DAC shared with main surrounds */
1015 BAD_SHARED_SURROUND = 0x100,
1016 /* No independent HP possible */
1017 BAD_NO_INDEP_HP = 0x10,
1018 /* Primary DAC shared with main CLFE */
1019 BAD_SHARED_CLFE = 0x10,
1020 /* Primary DAC shared with extra surrounds */
1021 BAD_SHARED_EXTRA_SURROUND = 0x10,
1022 /* Volume widget is shared */
1023 BAD_SHARED_VOL = 0x10,
1026 /* look for widgets in the given path which are appropriate for
1027 * volume and mute controls, and assign the values to ctls[].
1029 * When no appropriate widget is found in the path, the badness value
1030 * is incremented depending on the situation. The function returns the
1031 * total badness for both volume and mute controls.
1033 static int assign_out_path_ctls(struct hda_codec *codec, struct nid_path *path)
1040 return BAD_SHARED_VOL * 2;
1042 if (path->ctls[NID_PATH_VOL_CTL] ||
1043 path->ctls[NID_PATH_MUTE_CTL])
1044 return 0; /* already evaluated */
1046 nid = look_for_out_vol_nid(codec, path);
1048 val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
1049 if (is_ctl_used(codec, val, NID_PATH_VOL_CTL))
1050 badness += BAD_SHARED_VOL;
1052 path->ctls[NID_PATH_VOL_CTL] = val;
1054 badness += BAD_SHARED_VOL;
1055 nid = look_for_out_mute_nid(codec, path);
1057 unsigned int wid_type = get_wcaps_type(get_wcaps(codec, nid));
1058 if (wid_type == AC_WID_PIN || wid_type == AC_WID_AUD_OUT ||
1059 nid_has_mute(codec, nid, HDA_OUTPUT))
1060 val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
1062 val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT);
1063 if (is_ctl_used(codec, val, NID_PATH_MUTE_CTL))
1064 badness += BAD_SHARED_VOL;
1066 path->ctls[NID_PATH_MUTE_CTL] = val;
1068 badness += BAD_SHARED_VOL;
1072 const struct badness_table hda_main_out_badness = {
1073 .no_primary_dac = BAD_NO_PRIMARY_DAC,
1074 .no_dac = BAD_NO_DAC,
1075 .shared_primary = BAD_NO_PRIMARY_DAC,
1076 .shared_surr = BAD_SHARED_SURROUND,
1077 .shared_clfe = BAD_SHARED_CLFE,
1078 .shared_surr_main = BAD_SHARED_SURROUND,
1080 EXPORT_SYMBOL_HDA(hda_main_out_badness);
1082 const struct badness_table hda_extra_out_badness = {
1083 .no_primary_dac = BAD_NO_DAC,
1084 .no_dac = BAD_NO_DAC,
1085 .shared_primary = BAD_NO_EXTRA_DAC,
1086 .shared_surr = BAD_SHARED_EXTRA_SURROUND,
1087 .shared_clfe = BAD_SHARED_EXTRA_SURROUND,
1088 .shared_surr_main = BAD_NO_EXTRA_SURR_DAC,
1090 EXPORT_SYMBOL_HDA(hda_extra_out_badness);
1092 /* get the DAC of the primary output corresponding to the given array index */
1093 static hda_nid_t get_primary_out(struct hda_codec *codec, int idx)
1095 struct hda_gen_spec *spec = codec->spec;
1096 struct auto_pin_cfg *cfg = &spec->autocfg;
1098 if (cfg->line_outs > idx)
1099 return spec->private_dac_nids[idx];
1100 idx -= cfg->line_outs;
1101 if (spec->multi_ios > idx)
1102 return spec->multi_io[idx].dac;
1106 /* return the DAC if it's reachable, otherwise zero */
1107 static inline hda_nid_t try_dac(struct hda_codec *codec,
1108 hda_nid_t dac, hda_nid_t pin)
1110 return is_reachable_path(codec, dac, pin) ? dac : 0;
1113 /* try to assign DACs to pins and return the resultant badness */
1114 static int try_assign_dacs(struct hda_codec *codec, int num_outs,
1115 const hda_nid_t *pins, hda_nid_t *dacs,
1117 const struct badness_table *bad)
1119 struct hda_gen_spec *spec = codec->spec;
1127 for (i = 0; i < num_outs; i++) {
1128 struct nid_path *path;
1129 hda_nid_t pin = pins[i];
1131 path = snd_hda_get_path_from_idx(codec, path_idx[i]);
1133 badness += assign_out_path_ctls(codec, path);
1137 dacs[i] = look_for_dac(codec, pin, false);
1138 if (!dacs[i] && !i) {
1139 /* try to steal the DAC of surrounds for the front */
1140 for (j = 1; j < num_outs; j++) {
1141 if (is_reachable_path(codec, dacs[j], pin)) {
1144 invalidate_nid_path(codec, path_idx[j]);
1153 dac = try_dac(codec, get_primary_out(codec, i), pin);
1155 dac = try_dac(codec, dacs[0], pin);
1157 dac = try_dac(codec, get_primary_out(codec, i), pin);
1160 badness += bad->shared_primary;
1162 badness += bad->shared_surr;
1164 badness += bad->shared_clfe;
1165 } else if (is_reachable_path(codec, spec->private_dac_nids[0], pin)) {
1166 dac = spec->private_dac_nids[0];
1167 badness += bad->shared_surr_main;
1169 badness += bad->no_primary_dac;
1171 badness += bad->no_dac;
1175 path = snd_hda_add_new_path(codec, dac, pin, -spec->mixer_nid);
1176 if (!path && !i && spec->mixer_nid) {
1177 /* try with aamix */
1178 path = snd_hda_add_new_path(codec, dac, pin, 0);
1182 badness += bad->no_dac;
1184 /* print_nid_path("output", path); */
1185 path->active = true;
1186 path_idx[i] = snd_hda_get_path_idx(codec, path);
1187 badness += assign_out_path_ctls(codec, path);
1194 /* return NID if the given pin has only a single connection to a certain DAC */
1195 static hda_nid_t get_dac_if_single(struct hda_codec *codec, hda_nid_t pin)
1197 struct hda_gen_spec *spec = codec->spec;
1199 hda_nid_t nid_found = 0;
1201 for (i = 0; i < spec->num_all_dacs; i++) {
1202 hda_nid_t nid = spec->all_dacs[i];
1203 if (!nid || is_dac_already_used(codec, nid))
1205 if (is_reachable_path(codec, nid, pin)) {
1214 /* check whether the given pin can be a multi-io pin */
1215 static bool can_be_multiio_pin(struct hda_codec *codec,
1216 unsigned int location, hda_nid_t nid)
1218 unsigned int defcfg, caps;
1220 defcfg = snd_hda_codec_get_pincfg(codec, nid);
1221 if (get_defcfg_connect(defcfg) != AC_JACK_PORT_COMPLEX)
1223 if (location && get_defcfg_location(defcfg) != location)
1225 caps = snd_hda_query_pin_caps(codec, nid);
1226 if (!(caps & AC_PINCAP_OUT))
1231 /* count the number of input pins that are capable to be multi-io */
1232 static int count_multiio_pins(struct hda_codec *codec, hda_nid_t reference_pin)
1234 struct hda_gen_spec *spec = codec->spec;
1235 struct auto_pin_cfg *cfg = &spec->autocfg;
1236 unsigned int defcfg = snd_hda_codec_get_pincfg(codec, reference_pin);
1237 unsigned int location = get_defcfg_location(defcfg);
1241 for (type = AUTO_PIN_LINE_IN; type >= AUTO_PIN_MIC; type--) {
1242 for (i = 0; i < cfg->num_inputs; i++) {
1243 if (cfg->inputs[i].type != type)
1245 if (can_be_multiio_pin(codec, location,
1246 cfg->inputs[i].pin))
1256 * When hardwired is set, try to fill ony hardwired pins, and returns
1257 * zero if any pins are filled, non-zero if nothing found.
1258 * When hardwired is off, try to fill possible input pins, and returns
1259 * the badness value.
1261 static int fill_multi_ios(struct hda_codec *codec,
1262 hda_nid_t reference_pin,
1265 struct hda_gen_spec *spec = codec->spec;
1266 struct auto_pin_cfg *cfg = &spec->autocfg;
1267 int type, i, j, num_pins, old_pins;
1268 unsigned int defcfg = snd_hda_codec_get_pincfg(codec, reference_pin);
1269 unsigned int location = get_defcfg_location(defcfg);
1271 struct nid_path *path;
1273 old_pins = spec->multi_ios;
1277 num_pins = count_multiio_pins(codec, reference_pin);
1281 for (type = AUTO_PIN_LINE_IN; type >= AUTO_PIN_MIC; type--) {
1282 for (i = 0; i < cfg->num_inputs; i++) {
1283 hda_nid_t nid = cfg->inputs[i].pin;
1286 if (cfg->inputs[i].type != type)
1288 if (!can_be_multiio_pin(codec, location, nid))
1290 for (j = 0; j < spec->multi_ios; j++) {
1291 if (nid == spec->multi_io[j].pin)
1294 if (j < spec->multi_ios)
1298 dac = get_dac_if_single(codec, nid);
1300 dac = look_for_dac(codec, nid, false);
1305 path = snd_hda_add_new_path(codec, dac, nid,
1311 /* print_nid_path("multiio", path); */
1312 spec->multi_io[spec->multi_ios].pin = nid;
1313 spec->multi_io[spec->multi_ios].dac = dac;
1314 spec->out_paths[cfg->line_outs + spec->multi_ios] =
1315 snd_hda_get_path_idx(codec, path);
1317 if (spec->multi_ios >= 2)
1323 badness = BAD_MULTI_IO;
1324 if (old_pins == spec->multi_ios) {
1326 return 1; /* nothing found */
1328 return badness; /* no badness if nothing found */
1330 if (!hardwired && spec->multi_ios < 2) {
1331 /* cancel newly assigned paths */
1332 spec->paths.used -= spec->multi_ios - old_pins;
1333 spec->multi_ios = old_pins;
1337 /* assign volume and mute controls */
1338 for (i = old_pins; i < spec->multi_ios; i++) {
1339 path = snd_hda_get_path_from_idx(codec, spec->out_paths[cfg->line_outs + i]);
1340 badness += assign_out_path_ctls(codec, path);
1346 /* map DACs for all pins in the list if they are single connections */
1347 static bool map_singles(struct hda_codec *codec, int outs,
1348 const hda_nid_t *pins, hda_nid_t *dacs, int *path_idx)
1350 struct hda_gen_spec *spec = codec->spec;
1353 for (i = 0; i < outs; i++) {
1354 struct nid_path *path;
1358 dac = get_dac_if_single(codec, pins[i]);
1361 path = snd_hda_add_new_path(codec, dac, pins[i],
1363 if (!path && !i && spec->mixer_nid)
1364 path = snd_hda_add_new_path(codec, dac, pins[i], 0);
1368 /* print_nid_path("output", path); */
1369 path->active = true;
1370 path_idx[i] = snd_hda_get_path_idx(codec, path);
1376 /* create a new path including aamix if available, and return its index */
1377 static int check_aamix_out_path(struct hda_codec *codec, int path_idx)
1379 struct hda_gen_spec *spec = codec->spec;
1380 struct nid_path *path;
1381 hda_nid_t path_dac, dac, pin;
1383 path = snd_hda_get_path_from_idx(codec, path_idx);
1384 if (!path || !path->depth ||
1385 is_nid_contained(path, spec->mixer_nid))
1387 path_dac = path->path[0];
1388 dac = spec->private_dac_nids[0];
1389 pin = path->path[path->depth - 1];
1390 path = snd_hda_add_new_path(codec, dac, pin, spec->mixer_nid);
1392 if (dac != path_dac)
1394 else if (spec->multiout.hp_out_nid[0])
1395 dac = spec->multiout.hp_out_nid[0];
1396 else if (spec->multiout.extra_out_nid[0])
1397 dac = spec->multiout.extra_out_nid[0];
1401 path = snd_hda_add_new_path(codec, dac, pin,
1406 /* print_nid_path("output-aamix", path); */
1407 path->active = false; /* unused as default */
1408 return snd_hda_get_path_idx(codec, path);
1411 /* check whether the independent HP is available with the current config */
1412 static bool indep_hp_possible(struct hda_codec *codec)
1414 struct hda_gen_spec *spec = codec->spec;
1415 struct auto_pin_cfg *cfg = &spec->autocfg;
1416 struct nid_path *path;
1419 if (cfg->line_out_type == AUTO_PIN_HP_OUT)
1420 idx = spec->out_paths[0];
1422 idx = spec->hp_paths[0];
1423 path = snd_hda_get_path_from_idx(codec, idx);
1427 /* assume no path conflicts unless aamix is involved */
1428 if (!spec->mixer_nid || !is_nid_contained(path, spec->mixer_nid))
1431 /* check whether output paths contain aamix */
1432 for (i = 0; i < cfg->line_outs; i++) {
1433 if (spec->out_paths[i] == idx)
1435 path = snd_hda_get_path_from_idx(codec, spec->out_paths[i]);
1436 if (path && is_nid_contained(path, spec->mixer_nid))
1439 for (i = 0; i < cfg->speaker_outs; i++) {
1440 path = snd_hda_get_path_from_idx(codec, spec->speaker_paths[i]);
1441 if (path && is_nid_contained(path, spec->mixer_nid))
1448 /* fill the empty entries in the dac array for speaker/hp with the
1449 * shared dac pointed by the paths
1451 static void refill_shared_dacs(struct hda_codec *codec, int num_outs,
1452 hda_nid_t *dacs, int *path_idx)
1454 struct nid_path *path;
1457 for (i = 0; i < num_outs; i++) {
1460 path = snd_hda_get_path_from_idx(codec, path_idx[i]);
1463 dacs[i] = path->path[0];
1467 /* fill in the dac_nids table from the parsed pin configuration */
1468 static int fill_and_eval_dacs(struct hda_codec *codec,
1469 bool fill_hardwired,
1470 bool fill_mio_first)
1472 struct hda_gen_spec *spec = codec->spec;
1473 struct auto_pin_cfg *cfg = &spec->autocfg;
1474 int i, err, badness;
1476 /* set num_dacs once to full for look_for_dac() */
1477 spec->multiout.num_dacs = cfg->line_outs;
1478 spec->multiout.dac_nids = spec->private_dac_nids;
1479 memset(spec->private_dac_nids, 0, sizeof(spec->private_dac_nids));
1480 memset(spec->multiout.hp_out_nid, 0, sizeof(spec->multiout.hp_out_nid));
1481 memset(spec->multiout.extra_out_nid, 0, sizeof(spec->multiout.extra_out_nid));
1482 spec->multi_ios = 0;
1483 snd_array_free(&spec->paths);
1485 /* clear path indices */
1486 memset(spec->out_paths, 0, sizeof(spec->out_paths));
1487 memset(spec->hp_paths, 0, sizeof(spec->hp_paths));
1488 memset(spec->speaker_paths, 0, sizeof(spec->speaker_paths));
1489 memset(spec->aamix_out_paths, 0, sizeof(spec->aamix_out_paths));
1490 memset(spec->digout_paths, 0, sizeof(spec->digout_paths));
1491 memset(spec->input_paths, 0, sizeof(spec->input_paths));
1492 memset(spec->loopback_paths, 0, sizeof(spec->loopback_paths));
1493 memset(&spec->digin_path, 0, sizeof(spec->digin_path));
1497 /* fill hard-wired DACs first */
1498 if (fill_hardwired) {
1501 mapped = map_singles(codec, cfg->line_outs,
1503 spec->private_dac_nids,
1505 mapped |= map_singles(codec, cfg->hp_outs,
1507 spec->multiout.hp_out_nid,
1509 mapped |= map_singles(codec, cfg->speaker_outs,
1511 spec->multiout.extra_out_nid,
1512 spec->speaker_paths);
1513 if (fill_mio_first && cfg->line_outs == 1 &&
1514 cfg->line_out_type != AUTO_PIN_SPEAKER_OUT) {
1515 err = fill_multi_ios(codec, cfg->line_out_pins[0], true);
1522 badness += try_assign_dacs(codec, cfg->line_outs, cfg->line_out_pins,
1523 spec->private_dac_nids, spec->out_paths,
1524 spec->main_out_badness);
1526 if (fill_mio_first &&
1527 cfg->line_outs == 1 && cfg->line_out_type != AUTO_PIN_SPEAKER_OUT) {
1528 /* try to fill multi-io first */
1529 err = fill_multi_ios(codec, cfg->line_out_pins[0], false);
1532 /* we don't count badness at this stage yet */
1535 if (cfg->line_out_type != AUTO_PIN_HP_OUT) {
1536 err = try_assign_dacs(codec, cfg->hp_outs, cfg->hp_pins,
1537 spec->multiout.hp_out_nid,
1539 spec->extra_out_badness);
1544 if (cfg->line_out_type != AUTO_PIN_SPEAKER_OUT) {
1545 err = try_assign_dacs(codec, cfg->speaker_outs,
1547 spec->multiout.extra_out_nid,
1548 spec->speaker_paths,
1549 spec->extra_out_badness);
1554 if (cfg->line_outs == 1 && cfg->line_out_type != AUTO_PIN_SPEAKER_OUT) {
1555 err = fill_multi_ios(codec, cfg->line_out_pins[0], false);
1561 if (spec->mixer_nid) {
1562 spec->aamix_out_paths[0] =
1563 check_aamix_out_path(codec, spec->out_paths[0]);
1564 if (cfg->line_out_type != AUTO_PIN_HP_OUT)
1565 spec->aamix_out_paths[1] =
1566 check_aamix_out_path(codec, spec->hp_paths[0]);
1567 if (cfg->line_out_type != AUTO_PIN_SPEAKER_OUT)
1568 spec->aamix_out_paths[2] =
1569 check_aamix_out_path(codec, spec->speaker_paths[0]);
1572 if (cfg->hp_outs && cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
1573 if (count_multiio_pins(codec, cfg->hp_pins[0]) >= 2)
1574 spec->multi_ios = 1; /* give badness */
1576 /* re-count num_dacs and squash invalid entries */
1577 spec->multiout.num_dacs = 0;
1578 for (i = 0; i < cfg->line_outs; i++) {
1579 if (spec->private_dac_nids[i])
1580 spec->multiout.num_dacs++;
1582 memmove(spec->private_dac_nids + i,
1583 spec->private_dac_nids + i + 1,
1584 sizeof(hda_nid_t) * (cfg->line_outs - i - 1));
1585 spec->private_dac_nids[cfg->line_outs - 1] = 0;
1589 spec->ext_channel_count = spec->min_channel_count =
1590 spec->multiout.num_dacs * 2;
1592 if (spec->multi_ios == 2) {
1593 for (i = 0; i < 2; i++)
1594 spec->private_dac_nids[spec->multiout.num_dacs++] =
1595 spec->multi_io[i].dac;
1596 } else if (spec->multi_ios) {
1597 spec->multi_ios = 0;
1598 badness += BAD_MULTI_IO;
1601 if (spec->indep_hp && !indep_hp_possible(codec))
1602 badness += BAD_NO_INDEP_HP;
1604 /* re-fill the shared DAC for speaker / headphone */
1605 if (cfg->line_out_type != AUTO_PIN_HP_OUT)
1606 refill_shared_dacs(codec, cfg->hp_outs,
1607 spec->multiout.hp_out_nid,
1609 if (cfg->line_out_type != AUTO_PIN_SPEAKER_OUT)
1610 refill_shared_dacs(codec, cfg->speaker_outs,
1611 spec->multiout.extra_out_nid,
1612 spec->speaker_paths);
1617 #define DEBUG_BADNESS
1619 #ifdef DEBUG_BADNESS
1620 #define debug_badness snd_printdd
1622 #define debug_badness(...)
1625 #ifdef DEBUG_BADNESS
1626 static inline void print_nid_path_idx(struct hda_codec *codec,
1627 const char *pfx, int idx)
1629 struct nid_path *path;
1631 path = snd_hda_get_path_from_idx(codec, idx);
1633 print_nid_path(pfx, path);
1636 static void debug_show_configs(struct hda_codec *codec,
1637 struct auto_pin_cfg *cfg)
1639 struct hda_gen_spec *spec = codec->spec;
1640 static const char * const lo_type[3] = { "LO", "SP", "HP" };
1643 debug_badness("multi_outs = %x/%x/%x/%x : %x/%x/%x/%x (type %s)\n",
1644 cfg->line_out_pins[0], cfg->line_out_pins[1],
1645 cfg->line_out_pins[2], cfg->line_out_pins[3],
1646 spec->multiout.dac_nids[0],
1647 spec->multiout.dac_nids[1],
1648 spec->multiout.dac_nids[2],
1649 spec->multiout.dac_nids[3],
1650 lo_type[cfg->line_out_type]);
1651 for (i = 0; i < cfg->line_outs; i++)
1652 print_nid_path_idx(codec, " out", spec->out_paths[i]);
1653 if (spec->multi_ios > 0)
1654 debug_badness("multi_ios(%d) = %x/%x : %x/%x\n",
1656 spec->multi_io[0].pin, spec->multi_io[1].pin,
1657 spec->multi_io[0].dac, spec->multi_io[1].dac);
1658 for (i = 0; i < spec->multi_ios; i++)
1659 print_nid_path_idx(codec, " mio",
1660 spec->out_paths[cfg->line_outs + i]);
1662 debug_badness("hp_outs = %x/%x/%x/%x : %x/%x/%x/%x\n",
1663 cfg->hp_pins[0], cfg->hp_pins[1],
1664 cfg->hp_pins[2], cfg->hp_pins[3],
1665 spec->multiout.hp_out_nid[0],
1666 spec->multiout.hp_out_nid[1],
1667 spec->multiout.hp_out_nid[2],
1668 spec->multiout.hp_out_nid[3]);
1669 for (i = 0; i < cfg->hp_outs; i++)
1670 print_nid_path_idx(codec, " hp ", spec->hp_paths[i]);
1671 if (cfg->speaker_outs)
1672 debug_badness("spk_outs = %x/%x/%x/%x : %x/%x/%x/%x\n",
1673 cfg->speaker_pins[0], cfg->speaker_pins[1],
1674 cfg->speaker_pins[2], cfg->speaker_pins[3],
1675 spec->multiout.extra_out_nid[0],
1676 spec->multiout.extra_out_nid[1],
1677 spec->multiout.extra_out_nid[2],
1678 spec->multiout.extra_out_nid[3]);
1679 for (i = 0; i < cfg->speaker_outs; i++)
1680 print_nid_path_idx(codec, " spk", spec->speaker_paths[i]);
1681 for (i = 0; i < 3; i++)
1682 print_nid_path_idx(codec, " mix", spec->aamix_out_paths[i]);
1685 #define debug_show_configs(codec, cfg) /* NOP */
1688 /* find all available DACs of the codec */
1689 static void fill_all_dac_nids(struct hda_codec *codec)
1691 struct hda_gen_spec *spec = codec->spec;
1693 hda_nid_t nid = codec->start_nid;
1695 spec->num_all_dacs = 0;
1696 memset(spec->all_dacs, 0, sizeof(spec->all_dacs));
1697 for (i = 0; i < codec->num_nodes; i++, nid++) {
1698 if (get_wcaps_type(get_wcaps(codec, nid)) != AC_WID_AUD_OUT)
1700 if (spec->num_all_dacs >= ARRAY_SIZE(spec->all_dacs)) {
1701 snd_printk(KERN_ERR "hda: Too many DACs!\n");
1704 spec->all_dacs[spec->num_all_dacs++] = nid;
1708 static int parse_output_paths(struct hda_codec *codec)
1710 struct hda_gen_spec *spec = codec->spec;
1711 struct auto_pin_cfg *cfg = &spec->autocfg;
1712 struct auto_pin_cfg *best_cfg;
1714 int best_badness = INT_MAX;
1716 bool fill_hardwired = true, fill_mio_first = true;
1717 bool best_wired = true, best_mio = true;
1718 bool hp_spk_swapped = false;
1720 best_cfg = kmalloc(sizeof(*best_cfg), GFP_KERNEL);
1726 badness = fill_and_eval_dacs(codec, fill_hardwired,
1732 debug_badness("==> lo_type=%d, wired=%d, mio=%d, badness=0x%x\n",
1733 cfg->line_out_type, fill_hardwired, fill_mio_first,
1735 debug_show_configs(codec, cfg);
1736 if (badness < best_badness) {
1737 best_badness = badness;
1739 best_wired = fill_hardwired;
1740 best_mio = fill_mio_first;
1744 fill_mio_first = !fill_mio_first;
1745 if (!fill_mio_first)
1747 fill_hardwired = !fill_hardwired;
1748 if (!fill_hardwired)
1752 hp_spk_swapped = true;
1753 if (cfg->speaker_outs > 0 &&
1754 cfg->line_out_type == AUTO_PIN_HP_OUT) {
1755 cfg->hp_outs = cfg->line_outs;
1756 memcpy(cfg->hp_pins, cfg->line_out_pins,
1757 sizeof(cfg->hp_pins));
1758 cfg->line_outs = cfg->speaker_outs;
1759 memcpy(cfg->line_out_pins, cfg->speaker_pins,
1760 sizeof(cfg->speaker_pins));
1761 cfg->speaker_outs = 0;
1762 memset(cfg->speaker_pins, 0, sizeof(cfg->speaker_pins));
1763 cfg->line_out_type = AUTO_PIN_SPEAKER_OUT;
1764 fill_hardwired = true;
1767 if (cfg->hp_outs > 0 &&
1768 cfg->line_out_type == AUTO_PIN_SPEAKER_OUT) {
1769 cfg->speaker_outs = cfg->line_outs;
1770 memcpy(cfg->speaker_pins, cfg->line_out_pins,
1771 sizeof(cfg->speaker_pins));
1772 cfg->line_outs = cfg->hp_outs;
1773 memcpy(cfg->line_out_pins, cfg->hp_pins,
1774 sizeof(cfg->hp_pins));
1776 memset(cfg->hp_pins, 0, sizeof(cfg->hp_pins));
1777 cfg->line_out_type = AUTO_PIN_HP_OUT;
1778 fill_hardwired = true;
1785 debug_badness("==> restoring best_cfg\n");
1787 fill_and_eval_dacs(codec, best_wired, best_mio);
1789 debug_badness("==> Best config: lo_type=%d, wired=%d, mio=%d\n",
1790 cfg->line_out_type, best_wired, best_mio);
1791 debug_show_configs(codec, cfg);
1793 if (cfg->line_out_pins[0]) {
1794 struct nid_path *path;
1795 path = snd_hda_get_path_from_idx(codec, spec->out_paths[0]);
1797 spec->vmaster_nid = look_for_out_vol_nid(codec, path);
1798 if (spec->vmaster_nid)
1799 snd_hda_set_vmaster_tlv(codec, spec->vmaster_nid,
1800 HDA_OUTPUT, spec->vmaster_tlv);
1803 /* set initial pinctl targets */
1804 if (spec->prefer_hp_amp || cfg->line_out_type == AUTO_PIN_HP_OUT)
1808 set_pin_targets(codec, cfg->line_outs, cfg->line_out_pins, val);
1809 if (cfg->line_out_type != AUTO_PIN_HP_OUT)
1810 set_pin_targets(codec, cfg->hp_outs, cfg->hp_pins, PIN_HP);
1811 if (cfg->line_out_type != AUTO_PIN_SPEAKER_OUT) {
1812 val = spec->prefer_hp_amp ? PIN_HP : PIN_OUT;
1813 set_pin_targets(codec, cfg->speaker_outs,
1814 cfg->speaker_pins, val);
1817 /* clear indep_hp flag if not available */
1818 if (spec->indep_hp && !indep_hp_possible(codec))
1825 /* add playback controls from the parsed DAC table */
1826 static int create_multi_out_ctls(struct hda_codec *codec,
1827 const struct auto_pin_cfg *cfg)
1829 struct hda_gen_spec *spec = codec->spec;
1830 int i, err, noutputs;
1832 noutputs = cfg->line_outs;
1833 if (spec->multi_ios > 0 && cfg->line_outs < 3)
1834 noutputs += spec->multi_ios;
1836 for (i = 0; i < noutputs; i++) {
1839 struct nid_path *path;
1841 path = snd_hda_get_path_from_idx(codec, spec->out_paths[i]);
1845 name = get_line_out_pfx(codec, i, &index, NID_PATH_VOL_CTL);
1846 if (!name || !strcmp(name, "CLFE")) {
1848 err = add_vol_ctl(codec, "Center", 0, 1, path);
1851 err = add_vol_ctl(codec, "LFE", 0, 2, path);
1855 err = add_stereo_vol(codec, name, index, path);
1860 name = get_line_out_pfx(codec, i, &index, NID_PATH_MUTE_CTL);
1861 if (!name || !strcmp(name, "CLFE")) {
1862 err = add_sw_ctl(codec, "Center", 0, 1, path);
1865 err = add_sw_ctl(codec, "LFE", 0, 2, path);
1869 err = add_stereo_sw(codec, name, index, path);
1877 static int create_extra_out(struct hda_codec *codec, int path_idx,
1878 const char *pfx, int cidx)
1880 struct nid_path *path;
1883 path = snd_hda_get_path_from_idx(codec, path_idx);
1886 err = add_stereo_vol(codec, pfx, cidx, path);
1889 err = add_stereo_sw(codec, pfx, cidx, path);
1895 /* add playback controls for speaker and HP outputs */
1896 static int create_extra_outs(struct hda_codec *codec, int num_pins,
1897 const int *paths, const char *pfx)
1901 for (i = 0; i < num_pins; i++) {
1906 if (num_pins == 2 && i == 1 && !strcmp(pfx, "Speaker"))
1907 name = "Bass Speaker";
1908 else if (num_pins >= 3) {
1909 snprintf(tmp, sizeof(tmp), "%s %s",
1910 pfx, channel_name[i]);
1916 err = create_extra_out(codec, paths[i], name, idx);
1923 static int create_hp_out_ctls(struct hda_codec *codec)
1925 struct hda_gen_spec *spec = codec->spec;
1926 return create_extra_outs(codec, spec->autocfg.hp_outs,
1931 static int create_speaker_out_ctls(struct hda_codec *codec)
1933 struct hda_gen_spec *spec = codec->spec;
1934 return create_extra_outs(codec, spec->autocfg.speaker_outs,
1935 spec->speaker_paths,
1940 * independent HP controls
1943 static void call_hp_automute(struct hda_codec *codec, struct hda_jack_tbl *jack);
1944 static int indep_hp_info(struct snd_kcontrol *kcontrol,
1945 struct snd_ctl_elem_info *uinfo)
1947 return snd_hda_enum_bool_helper_info(kcontrol, uinfo);
1950 static int indep_hp_get(struct snd_kcontrol *kcontrol,
1951 struct snd_ctl_elem_value *ucontrol)
1953 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1954 struct hda_gen_spec *spec = codec->spec;
1955 ucontrol->value.enumerated.item[0] = spec->indep_hp_enabled;
1959 static void update_aamix_paths(struct hda_codec *codec, bool do_mix,
1960 int nomix_path_idx, int mix_path_idx,
1963 static int indep_hp_put(struct snd_kcontrol *kcontrol,
1964 struct snd_ctl_elem_value *ucontrol)
1966 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1967 struct hda_gen_spec *spec = codec->spec;
1968 unsigned int select = ucontrol->value.enumerated.item[0];
1971 mutex_lock(&spec->pcm_mutex);
1972 if (spec->active_streams) {
1977 if (spec->indep_hp_enabled != select) {
1979 if (spec->autocfg.line_out_type == AUTO_PIN_HP_OUT)
1980 dacp = &spec->private_dac_nids[0];
1982 dacp = &spec->multiout.hp_out_nid[0];
1984 /* update HP aamix paths in case it conflicts with indep HP */
1985 if (spec->have_aamix_ctl) {
1986 if (spec->autocfg.line_out_type == AUTO_PIN_HP_OUT)
1987 update_aamix_paths(codec, spec->aamix_mode,
1989 spec->aamix_out_paths[0],
1990 spec->autocfg.line_out_type);
1992 update_aamix_paths(codec, spec->aamix_mode,
1994 spec->aamix_out_paths[1],
1998 spec->indep_hp_enabled = select;
1999 if (spec->indep_hp_enabled)
2002 *dacp = spec->alt_dac_nid;
2004 call_hp_automute(codec, NULL);
2008 mutex_unlock(&spec->pcm_mutex);
2012 static const struct snd_kcontrol_new indep_hp_ctl = {
2013 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2014 .name = "Independent HP",
2015 .info = indep_hp_info,
2016 .get = indep_hp_get,
2017 .put = indep_hp_put,
2021 static int create_indep_hp_ctls(struct hda_codec *codec)
2023 struct hda_gen_spec *spec = codec->spec;
2026 if (!spec->indep_hp)
2028 if (spec->autocfg.line_out_type == AUTO_PIN_HP_OUT)
2029 dac = spec->multiout.dac_nids[0];
2031 dac = spec->multiout.hp_out_nid[0];
2037 spec->indep_hp_enabled = false;
2038 spec->alt_dac_nid = dac;
2039 if (!snd_hda_gen_add_kctl(spec, NULL, &indep_hp_ctl))
2045 * channel mode enum control
2048 static int ch_mode_info(struct snd_kcontrol *kcontrol,
2049 struct snd_ctl_elem_info *uinfo)
2051 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2052 struct hda_gen_spec *spec = codec->spec;
2055 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
2057 uinfo->value.enumerated.items = spec->multi_ios + 1;
2058 if (uinfo->value.enumerated.item > spec->multi_ios)
2059 uinfo->value.enumerated.item = spec->multi_ios;
2060 chs = uinfo->value.enumerated.item * 2 + spec->min_channel_count;
2061 sprintf(uinfo->value.enumerated.name, "%dch", chs);
2065 static int ch_mode_get(struct snd_kcontrol *kcontrol,
2066 struct snd_ctl_elem_value *ucontrol)
2068 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2069 struct hda_gen_spec *spec = codec->spec;
2070 ucontrol->value.enumerated.item[0] =
2071 (spec->ext_channel_count - spec->min_channel_count) / 2;
2075 static inline struct nid_path *
2076 get_multiio_path(struct hda_codec *codec, int idx)
2078 struct hda_gen_spec *spec = codec->spec;
2079 return snd_hda_get_path_from_idx(codec,
2080 spec->out_paths[spec->autocfg.line_outs + idx]);
2083 static void update_automute_all(struct hda_codec *codec);
2085 /* Default value to be passed as aamix argument for snd_hda_activate_path();
2086 * used for output paths
2088 static bool aamix_default(struct hda_gen_spec *spec)
2090 return !spec->have_aamix_ctl || spec->aamix_mode;
2093 static int set_multi_io(struct hda_codec *codec, int idx, bool output)
2095 struct hda_gen_spec *spec = codec->spec;
2096 hda_nid_t nid = spec->multi_io[idx].pin;
2097 struct nid_path *path;
2099 path = get_multiio_path(codec, idx);
2103 if (path->active == output)
2107 set_pin_target(codec, nid, PIN_OUT, true);
2108 snd_hda_activate_path(codec, path, true, aamix_default(spec));
2109 set_pin_eapd(codec, nid, true);
2111 set_pin_eapd(codec, nid, false);
2112 snd_hda_activate_path(codec, path, false, aamix_default(spec));
2113 set_pin_target(codec, nid, spec->multi_io[idx].ctl_in, true);
2114 path_power_down_sync(codec, path);
2117 /* update jack retasking in case it modifies any of them */
2118 update_automute_all(codec);
2123 static int ch_mode_put(struct snd_kcontrol *kcontrol,
2124 struct snd_ctl_elem_value *ucontrol)
2126 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2127 struct hda_gen_spec *spec = codec->spec;
2130 ch = ucontrol->value.enumerated.item[0];
2131 if (ch < 0 || ch > spec->multi_ios)
2133 if (ch == (spec->ext_channel_count - spec->min_channel_count) / 2)
2135 spec->ext_channel_count = ch * 2 + spec->min_channel_count;
2136 for (i = 0; i < spec->multi_ios; i++)
2137 set_multi_io(codec, i, i < ch);
2138 spec->multiout.max_channels = max(spec->ext_channel_count,
2139 spec->const_channel_count);
2140 if (spec->need_dac_fix)
2141 spec->multiout.num_dacs = spec->multiout.max_channels / 2;
2145 static const struct snd_kcontrol_new channel_mode_enum = {
2146 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2147 .name = "Channel Mode",
2148 .info = ch_mode_info,
2153 static int create_multi_channel_mode(struct hda_codec *codec)
2155 struct hda_gen_spec *spec = codec->spec;
2157 if (spec->multi_ios > 0) {
2158 if (!snd_hda_gen_add_kctl(spec, NULL, &channel_mode_enum))
2165 * aamix loopback enable/disable switch
2168 #define loopback_mixing_info indep_hp_info
2170 static int loopback_mixing_get(struct snd_kcontrol *kcontrol,
2171 struct snd_ctl_elem_value *ucontrol)
2173 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2174 struct hda_gen_spec *spec = codec->spec;
2175 ucontrol->value.enumerated.item[0] = spec->aamix_mode;
2179 static void update_aamix_paths(struct hda_codec *codec, bool do_mix,
2180 int nomix_path_idx, int mix_path_idx,
2183 struct hda_gen_spec *spec = codec->spec;
2184 struct nid_path *nomix_path, *mix_path;
2186 nomix_path = snd_hda_get_path_from_idx(codec, nomix_path_idx);
2187 mix_path = snd_hda_get_path_from_idx(codec, mix_path_idx);
2188 if (!nomix_path || !mix_path)
2191 /* if HP aamix path is driven from a different DAC and the
2192 * independent HP mode is ON, can't turn on aamix path
2194 if (out_type == AUTO_PIN_HP_OUT && spec->indep_hp_enabled &&
2195 mix_path->path[0] != spec->alt_dac_nid)
2199 snd_hda_activate_path(codec, nomix_path, false, true);
2200 snd_hda_activate_path(codec, mix_path, true, true);
2201 path_power_down_sync(codec, nomix_path);
2203 snd_hda_activate_path(codec, mix_path, false, false);
2204 snd_hda_activate_path(codec, nomix_path, true, false);
2205 path_power_down_sync(codec, mix_path);
2209 static int loopback_mixing_put(struct snd_kcontrol *kcontrol,
2210 struct snd_ctl_elem_value *ucontrol)
2212 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2213 struct hda_gen_spec *spec = codec->spec;
2214 unsigned int val = ucontrol->value.enumerated.item[0];
2216 if (val == spec->aamix_mode)
2218 spec->aamix_mode = val;
2219 update_aamix_paths(codec, val, spec->out_paths[0],
2220 spec->aamix_out_paths[0],
2221 spec->autocfg.line_out_type);
2222 update_aamix_paths(codec, val, spec->hp_paths[0],
2223 spec->aamix_out_paths[1],
2225 update_aamix_paths(codec, val, spec->speaker_paths[0],
2226 spec->aamix_out_paths[2],
2227 AUTO_PIN_SPEAKER_OUT);
2231 static const struct snd_kcontrol_new loopback_mixing_enum = {
2232 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2233 .name = "Loopback Mixing",
2234 .info = loopback_mixing_info,
2235 .get = loopback_mixing_get,
2236 .put = loopback_mixing_put,
2239 static int create_loopback_mixing_ctl(struct hda_codec *codec)
2241 struct hda_gen_spec *spec = codec->spec;
2243 if (!spec->mixer_nid)
2245 if (!(spec->aamix_out_paths[0] || spec->aamix_out_paths[1] ||
2246 spec->aamix_out_paths[2]))
2248 if (!snd_hda_gen_add_kctl(spec, NULL, &loopback_mixing_enum))
2250 spec->have_aamix_ctl = 1;
2255 * shared headphone/mic handling
2258 static void call_update_outputs(struct hda_codec *codec);
2260 /* for shared I/O, change the pin-control accordingly */
2261 static void update_hp_mic(struct hda_codec *codec, int adc_mux, bool force)
2263 struct hda_gen_spec *spec = codec->spec;
2268 pin = spec->hp_mic_pin;
2269 as_mic = spec->cur_mux[adc_mux] == spec->hp_mic_mux_idx;
2272 val = snd_hda_codec_get_pin_target(codec, pin);
2282 val = snd_hda_get_default_vref(codec, pin);
2283 /* if the HP pin doesn't support VREF and the codec driver gives an
2284 * alternative pin, set up the VREF on that pin instead
2286 if (val == AC_PINCTL_VREF_HIZ && spec->shared_mic_vref_pin) {
2287 const hda_nid_t vref_pin = spec->shared_mic_vref_pin;
2288 unsigned int vref_val = snd_hda_get_default_vref(codec, vref_pin);
2289 if (vref_val != AC_PINCTL_VREF_HIZ)
2290 snd_hda_set_pin_ctl_cache(codec, vref_pin,
2291 PIN_IN | (as_mic ? vref_val : 0));
2294 if (!spec->hp_mic_jack_modes) {
2299 set_pin_target(codec, pin, val, true);
2300 call_hp_automute(codec, NULL);
2304 /* create a shared input with the headphone out */
2305 static int create_hp_mic(struct hda_codec *codec)
2307 struct hda_gen_spec *spec = codec->spec;
2308 struct auto_pin_cfg *cfg = &spec->autocfg;
2309 unsigned int defcfg;
2312 if (!spec->hp_mic) {
2313 if (spec->suppress_hp_mic_detect)
2315 /* automatic detection: only if no input or a single internal
2316 * input pin is found, try to detect the shared hp/mic
2318 if (cfg->num_inputs > 1)
2320 else if (cfg->num_inputs == 1) {
2321 defcfg = snd_hda_codec_get_pincfg(codec, cfg->inputs[0].pin);
2322 if (snd_hda_get_input_pin_attr(defcfg) != INPUT_PIN_ATTR_INT)
2327 spec->hp_mic = 0; /* clear once */
2328 if (cfg->num_inputs >= AUTO_CFG_MAX_INS)
2332 if (cfg->line_out_type == AUTO_PIN_HP_OUT && cfg->line_outs > 0)
2333 nid = cfg->line_out_pins[0];
2334 else if (cfg->hp_outs > 0)
2335 nid = cfg->hp_pins[0];
2339 if (!(snd_hda_query_pin_caps(codec, nid) & AC_PINCAP_IN))
2340 return 0; /* no input */
2342 cfg->inputs[cfg->num_inputs].pin = nid;
2343 cfg->inputs[cfg->num_inputs].type = AUTO_PIN_MIC;
2344 cfg->inputs[cfg->num_inputs].is_headphone_mic = 1;
2347 spec->hp_mic_pin = nid;
2348 /* we can't handle auto-mic together with HP-mic */
2349 spec->suppress_auto_mic = 1;
2350 snd_printdd("hda-codec: Enable shared I/O jack on NID 0x%x\n", nid);
2358 static int create_hp_mic_jack_mode(struct hda_codec *codec, hda_nid_t pin);
2360 static const char * const out_jack_texts[] = {
2361 "Line Out", "Headphone Out",
2364 static int out_jack_mode_info(struct snd_kcontrol *kcontrol,
2365 struct snd_ctl_elem_info *uinfo)
2367 return snd_hda_enum_helper_info(kcontrol, uinfo, 2, out_jack_texts);
2370 static int out_jack_mode_get(struct snd_kcontrol *kcontrol,
2371 struct snd_ctl_elem_value *ucontrol)
2373 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2374 hda_nid_t nid = kcontrol->private_value;
2375 if (snd_hda_codec_get_pin_target(codec, nid) == PIN_HP)
2376 ucontrol->value.enumerated.item[0] = 1;
2378 ucontrol->value.enumerated.item[0] = 0;
2382 static int out_jack_mode_put(struct snd_kcontrol *kcontrol,
2383 struct snd_ctl_elem_value *ucontrol)
2385 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2386 hda_nid_t nid = kcontrol->private_value;
2389 val = ucontrol->value.enumerated.item[0] ? PIN_HP : PIN_OUT;
2390 if (snd_hda_codec_get_pin_target(codec, nid) == val)
2392 snd_hda_set_pin_ctl_cache(codec, nid, val);
2396 static const struct snd_kcontrol_new out_jack_mode_enum = {
2397 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2398 .info = out_jack_mode_info,
2399 .get = out_jack_mode_get,
2400 .put = out_jack_mode_put,
2403 static bool find_kctl_name(struct hda_codec *codec, const char *name, int idx)
2405 struct hda_gen_spec *spec = codec->spec;
2408 for (i = 0; i < spec->kctls.used; i++) {
2409 struct snd_kcontrol_new *kctl = snd_array_elem(&spec->kctls, i);
2410 if (!strcmp(kctl->name, name) && kctl->index == idx)
2416 static void get_jack_mode_name(struct hda_codec *codec, hda_nid_t pin,
2417 char *name, size_t name_len)
2419 struct hda_gen_spec *spec = codec->spec;
2422 snd_hda_get_pin_label(codec, pin, &spec->autocfg, name, name_len, &idx);
2423 strlcat(name, " Jack Mode", name_len);
2425 for (; find_kctl_name(codec, name, idx); idx++)
2429 static int get_out_jack_num_items(struct hda_codec *codec, hda_nid_t pin)
2431 struct hda_gen_spec *spec = codec->spec;
2432 if (spec->add_jack_modes) {
2433 unsigned int pincap = snd_hda_query_pin_caps(codec, pin);
2434 if ((pincap & AC_PINCAP_OUT) && (pincap & AC_PINCAP_HP_DRV))
2440 static int create_out_jack_modes(struct hda_codec *codec, int num_pins,
2443 struct hda_gen_spec *spec = codec->spec;
2446 for (i = 0; i < num_pins; i++) {
2447 hda_nid_t pin = pins[i];
2448 if (pin == spec->hp_mic_pin) {
2449 int ret = create_hp_mic_jack_mode(codec, pin);
2454 if (get_out_jack_num_items(codec, pin) > 1) {
2455 struct snd_kcontrol_new *knew;
2457 get_jack_mode_name(codec, pin, name, sizeof(name));
2458 knew = snd_hda_gen_add_kctl(spec, name,
2459 &out_jack_mode_enum);
2462 knew->private_value = pin;
2473 /* from AC_PINCTL_VREF_HIZ to AC_PINCTL_VREF_100 */
2476 static const char * const vref_texts[NUM_VREFS] = {
2477 "Line In", "Mic 50pc Bias", "Mic 0V Bias",
2478 "", "Mic 80pc Bias", "Mic 100pc Bias"
2481 static unsigned int get_vref_caps(struct hda_codec *codec, hda_nid_t pin)
2483 unsigned int pincap;
2485 pincap = snd_hda_query_pin_caps(codec, pin);
2486 pincap = (pincap & AC_PINCAP_VREF) >> AC_PINCAP_VREF_SHIFT;
2487 /* filter out unusual vrefs */
2488 pincap &= ~(AC_PINCAP_VREF_GRD | AC_PINCAP_VREF_100);
2492 /* convert from the enum item index to the vref ctl index (0=HIZ, 1=50%...) */
2493 static int get_vref_idx(unsigned int vref_caps, unsigned int item_idx)
2495 unsigned int i, n = 0;
2497 for (i = 0; i < NUM_VREFS; i++) {
2498 if (vref_caps & (1 << i)) {
2507 /* convert back from the vref ctl index to the enum item index */
2508 static int cvt_from_vref_idx(unsigned int vref_caps, unsigned int idx)
2510 unsigned int i, n = 0;
2512 for (i = 0; i < NUM_VREFS; i++) {
2515 if (vref_caps & (1 << i))
2521 static int in_jack_mode_info(struct snd_kcontrol *kcontrol,
2522 struct snd_ctl_elem_info *uinfo)
2524 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2525 hda_nid_t nid = kcontrol->private_value;
2526 unsigned int vref_caps = get_vref_caps(codec, nid);
2528 snd_hda_enum_helper_info(kcontrol, uinfo, hweight32(vref_caps),
2530 /* set the right text */
2531 strcpy(uinfo->value.enumerated.name,
2532 vref_texts[get_vref_idx(vref_caps, uinfo->value.enumerated.item)]);
2536 static int in_jack_mode_get(struct snd_kcontrol *kcontrol,
2537 struct snd_ctl_elem_value *ucontrol)
2539 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2540 hda_nid_t nid = kcontrol->private_value;
2541 unsigned int vref_caps = get_vref_caps(codec, nid);
2544 idx = snd_hda_codec_get_pin_target(codec, nid) & AC_PINCTL_VREFEN;
2545 ucontrol->value.enumerated.item[0] = cvt_from_vref_idx(vref_caps, idx);
2549 static int in_jack_mode_put(struct snd_kcontrol *kcontrol,
2550 struct snd_ctl_elem_value *ucontrol)
2552 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2553 hda_nid_t nid = kcontrol->private_value;
2554 unsigned int vref_caps = get_vref_caps(codec, nid);
2555 unsigned int val, idx;
2557 val = snd_hda_codec_get_pin_target(codec, nid);
2558 idx = cvt_from_vref_idx(vref_caps, val & AC_PINCTL_VREFEN);
2559 if (idx == ucontrol->value.enumerated.item[0])
2562 val &= ~AC_PINCTL_VREFEN;
2563 val |= get_vref_idx(vref_caps, ucontrol->value.enumerated.item[0]);
2564 snd_hda_set_pin_ctl_cache(codec, nid, val);
2568 static const struct snd_kcontrol_new in_jack_mode_enum = {
2569 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2570 .info = in_jack_mode_info,
2571 .get = in_jack_mode_get,
2572 .put = in_jack_mode_put,
2575 static int get_in_jack_num_items(struct hda_codec *codec, hda_nid_t pin)
2577 struct hda_gen_spec *spec = codec->spec;
2579 if (spec->add_jack_modes)
2580 nitems = hweight32(get_vref_caps(codec, pin));
2581 return nitems ? nitems : 1;
2584 static int create_in_jack_mode(struct hda_codec *codec, hda_nid_t pin)
2586 struct hda_gen_spec *spec = codec->spec;
2587 struct snd_kcontrol_new *knew;
2589 unsigned int defcfg;
2591 if (pin == spec->hp_mic_pin)
2592 return 0; /* already done in create_out_jack_mode() */
2594 /* no jack mode for fixed pins */
2595 defcfg = snd_hda_codec_get_pincfg(codec, pin);
2596 if (snd_hda_get_input_pin_attr(defcfg) == INPUT_PIN_ATTR_INT)
2599 /* no multiple vref caps? */
2600 if (get_in_jack_num_items(codec, pin) <= 1)
2603 get_jack_mode_name(codec, pin, name, sizeof(name));
2604 knew = snd_hda_gen_add_kctl(spec, name, &in_jack_mode_enum);
2607 knew->private_value = pin;
2612 * HP/mic shared jack mode
2614 static int hp_mic_jack_mode_info(struct snd_kcontrol *kcontrol,
2615 struct snd_ctl_elem_info *uinfo)
2617 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2618 hda_nid_t nid = kcontrol->private_value;
2619 int out_jacks = get_out_jack_num_items(codec, nid);
2620 int in_jacks = get_in_jack_num_items(codec, nid);
2621 const char *text = NULL;
2624 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
2626 uinfo->value.enumerated.items = out_jacks + in_jacks;
2627 if (uinfo->value.enumerated.item >= uinfo->value.enumerated.items)
2628 uinfo->value.enumerated.item = uinfo->value.enumerated.items - 1;
2629 idx = uinfo->value.enumerated.item;
2630 if (idx < out_jacks) {
2632 text = out_jack_texts[idx];
2634 text = "Headphone Out";
2638 unsigned int vref_caps = get_vref_caps(codec, nid);
2639 text = vref_texts[get_vref_idx(vref_caps, idx)];
2644 strcpy(uinfo->value.enumerated.name, text);
2648 static int get_cur_hp_mic_jack_mode(struct hda_codec *codec, hda_nid_t nid)
2650 int out_jacks = get_out_jack_num_items(codec, nid);
2651 int in_jacks = get_in_jack_num_items(codec, nid);
2652 unsigned int val = snd_hda_codec_get_pin_target(codec, nid);
2655 if (val & PIN_OUT) {
2656 if (out_jacks > 1 && val == PIN_HP)
2658 } else if (val & PIN_IN) {
2661 unsigned int vref_caps = get_vref_caps(codec, nid);
2662 val &= AC_PINCTL_VREFEN;
2663 idx += cvt_from_vref_idx(vref_caps, val);
2669 static int hp_mic_jack_mode_get(struct snd_kcontrol *kcontrol,
2670 struct snd_ctl_elem_value *ucontrol)
2672 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2673 hda_nid_t nid = kcontrol->private_value;
2674 ucontrol->value.enumerated.item[0] =
2675 get_cur_hp_mic_jack_mode(codec, nid);
2679 static int hp_mic_jack_mode_put(struct snd_kcontrol *kcontrol,
2680 struct snd_ctl_elem_value *ucontrol)
2682 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2683 hda_nid_t nid = kcontrol->private_value;
2684 int out_jacks = get_out_jack_num_items(codec, nid);
2685 int in_jacks = get_in_jack_num_items(codec, nid);
2686 unsigned int val, oldval, idx;
2688 oldval = get_cur_hp_mic_jack_mode(codec, nid);
2689 idx = ucontrol->value.enumerated.item[0];
2693 if (idx < out_jacks) {
2695 val = idx ? PIN_HP : PIN_OUT;
2701 unsigned int vref_caps = get_vref_caps(codec, nid);
2702 val = snd_hda_codec_get_pin_target(codec, nid);
2703 val &= ~(AC_PINCTL_VREFEN | PIN_HP);
2704 val |= get_vref_idx(vref_caps, idx) | PIN_IN;
2706 val = snd_hda_get_default_vref(codec, nid);
2708 snd_hda_set_pin_ctl_cache(codec, nid, val);
2709 call_hp_automute(codec, NULL);
2714 static const struct snd_kcontrol_new hp_mic_jack_mode_enum = {
2715 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2716 .info = hp_mic_jack_mode_info,
2717 .get = hp_mic_jack_mode_get,
2718 .put = hp_mic_jack_mode_put,
2721 static int create_hp_mic_jack_mode(struct hda_codec *codec, hda_nid_t pin)
2723 struct hda_gen_spec *spec = codec->spec;
2724 struct snd_kcontrol_new *knew;
2726 if (get_out_jack_num_items(codec, pin) <= 1 &&
2727 get_in_jack_num_items(codec, pin) <= 1)
2728 return 0; /* no need */
2729 knew = snd_hda_gen_add_kctl(spec, "Headphone Mic Jack Mode",
2730 &hp_mic_jack_mode_enum);
2733 knew->private_value = pin;
2734 spec->hp_mic_jack_modes = 1;
2742 /* add the powersave loopback-list entry */
2743 static int add_loopback_list(struct hda_gen_spec *spec, hda_nid_t mix, int idx)
2745 struct hda_amp_list *list;
2747 list = snd_array_new(&spec->loopback_list);
2751 list->dir = HDA_INPUT;
2753 spec->loopback.amplist = spec->loopback_list.list;
2757 /* create input playback/capture controls for the given pin */
2758 static int new_analog_input(struct hda_codec *codec, int input_idx,
2759 hda_nid_t pin, const char *ctlname, int ctlidx,
2762 struct hda_gen_spec *spec = codec->spec;
2763 struct nid_path *path;
2767 if (!nid_has_volume(codec, mix_nid, HDA_INPUT) &&
2768 !nid_has_mute(codec, mix_nid, HDA_INPUT))
2769 return 0; /* no need for analog loopback */
2771 path = snd_hda_add_new_path(codec, pin, mix_nid, 0);
2774 print_nid_path("loopback", path);
2775 spec->loopback_paths[input_idx] = snd_hda_get_path_idx(codec, path);
2777 idx = path->idx[path->depth - 1];
2778 if (nid_has_volume(codec, mix_nid, HDA_INPUT)) {
2779 val = HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT);
2780 err = __add_pb_vol_ctrl(spec, HDA_CTL_WIDGET_VOL, ctlname, ctlidx, val);
2783 path->ctls[NID_PATH_VOL_CTL] = val;
2786 if (nid_has_mute(codec, mix_nid, HDA_INPUT)) {
2787 val = HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT);
2788 err = __add_pb_sw_ctrl(spec, HDA_CTL_WIDGET_MUTE, ctlname, ctlidx, val);
2791 path->ctls[NID_PATH_MUTE_CTL] = val;
2794 path->active = true;
2795 err = add_loopback_list(spec, mix_nid, idx);
2799 if (spec->mixer_nid != spec->mixer_merge_nid &&
2800 !spec->loopback_merge_path) {
2801 path = snd_hda_add_new_path(codec, spec->mixer_nid,
2802 spec->mixer_merge_nid, 0);
2804 print_nid_path("loopback-merge", path);
2805 path->active = true;
2806 spec->loopback_merge_path =
2807 snd_hda_get_path_idx(codec, path);
2814 static int is_input_pin(struct hda_codec *codec, hda_nid_t nid)
2816 unsigned int pincap = snd_hda_query_pin_caps(codec, nid);
2817 return (pincap & AC_PINCAP_IN) != 0;
2820 /* Parse the codec tree and retrieve ADCs */
2821 static int fill_adc_nids(struct hda_codec *codec)
2823 struct hda_gen_spec *spec = codec->spec;
2825 hda_nid_t *adc_nids = spec->adc_nids;
2826 int max_nums = ARRAY_SIZE(spec->adc_nids);
2829 nid = codec->start_nid;
2830 for (i = 0; i < codec->num_nodes; i++, nid++) {
2831 unsigned int caps = get_wcaps(codec, nid);
2832 int type = get_wcaps_type(caps);
2834 if (type != AC_WID_AUD_IN || (caps & AC_WCAP_DIGITAL))
2836 adc_nids[nums] = nid;
2837 if (++nums >= max_nums)
2840 spec->num_adc_nids = nums;
2842 /* copy the detected ADCs to all_adcs[] */
2843 spec->num_all_adcs = nums;
2844 memcpy(spec->all_adcs, spec->adc_nids, nums * sizeof(hda_nid_t));
2849 /* filter out invalid adc_nids that don't give all active input pins;
2850 * if needed, check whether dynamic ADC-switching is available
2852 static int check_dyn_adc_switch(struct hda_codec *codec)
2854 struct hda_gen_spec *spec = codec->spec;
2855 struct hda_input_mux *imux = &spec->input_mux;
2856 unsigned int ok_bits;
2861 for (n = 0; n < spec->num_adc_nids; n++) {
2862 for (i = 0; i < imux->num_items; i++) {
2863 if (!spec->input_paths[i][n])
2866 if (i >= imux->num_items) {
2867 ok_bits |= (1 << n);
2873 /* check whether ADC-switch is possible */
2874 for (i = 0; i < imux->num_items; i++) {
2875 for (n = 0; n < spec->num_adc_nids; n++) {
2876 if (spec->input_paths[i][n]) {
2877 spec->dyn_adc_idx[i] = n;
2883 snd_printdd("hda-codec: enabling ADC switching\n");
2884 spec->dyn_adc_switch = 1;
2885 } else if (nums != spec->num_adc_nids) {
2886 /* shrink the invalid adcs and input paths */
2888 for (n = 0; n < spec->num_adc_nids; n++) {
2889 if (!(ok_bits & (1 << n)))
2892 spec->adc_nids[nums] = spec->adc_nids[n];
2893 for (i = 0; i < imux->num_items; i++) {
2894 invalidate_nid_path(codec,
2895 spec->input_paths[i][nums]);
2896 spec->input_paths[i][nums] =
2897 spec->input_paths[i][n];
2902 spec->num_adc_nids = nums;
2905 if (imux->num_items == 1 ||
2906 (imux->num_items == 2 && spec->hp_mic)) {
2907 snd_printdd("hda-codec: reducing to a single ADC\n");
2908 spec->num_adc_nids = 1; /* reduce to a single ADC */
2911 /* single index for individual volumes ctls */
2912 if (!spec->dyn_adc_switch && spec->multi_cap_vol)
2913 spec->num_adc_nids = 1;
2918 /* parse capture source paths from the given pin and create imux items */
2919 static int parse_capture_source(struct hda_codec *codec, hda_nid_t pin,
2920 int cfg_idx, int num_adcs,
2921 const char *label, int anchor)
2923 struct hda_gen_spec *spec = codec->spec;
2924 struct hda_input_mux *imux = &spec->input_mux;
2925 int imux_idx = imux->num_items;
2926 bool imux_added = false;
2929 for (c = 0; c < num_adcs; c++) {
2930 struct nid_path *path;
2931 hda_nid_t adc = spec->adc_nids[c];
2933 if (!is_reachable_path(codec, pin, adc))
2935 path = snd_hda_add_new_path(codec, pin, adc, anchor);
2938 print_nid_path("input", path);
2939 spec->input_paths[imux_idx][c] =
2940 snd_hda_get_path_idx(codec, path);
2943 if (spec->hp_mic_pin == pin)
2944 spec->hp_mic_mux_idx = imux->num_items;
2945 spec->imux_pins[imux->num_items] = pin;
2946 snd_hda_add_imux_item(imux, label, cfg_idx, NULL);
2955 * create playback/capture controls for input pins
2958 /* fill the label for each input at first */
2959 static int fill_input_pin_labels(struct hda_codec *codec)
2961 struct hda_gen_spec *spec = codec->spec;
2962 const struct auto_pin_cfg *cfg = &spec->autocfg;
2965 for (i = 0; i < cfg->num_inputs; i++) {
2966 hda_nid_t pin = cfg->inputs[i].pin;
2970 if (!is_input_pin(codec, pin))
2973 label = hda_get_autocfg_input_label(codec, cfg, i);
2975 for (j = i - 1; j >= 0; j--) {
2976 if (spec->input_labels[j] &&
2977 !strcmp(spec->input_labels[j], label)) {
2978 idx = spec->input_label_idxs[j] + 1;
2983 spec->input_labels[i] = label;
2984 spec->input_label_idxs[i] = idx;
2990 #define CFG_IDX_MIX 99 /* a dummy cfg->input idx for stereo mix */
2992 static int create_input_ctls(struct hda_codec *codec)
2994 struct hda_gen_spec *spec = codec->spec;
2995 const struct auto_pin_cfg *cfg = &spec->autocfg;
2996 hda_nid_t mixer = spec->mixer_nid;
3001 num_adcs = fill_adc_nids(codec);
3005 err = fill_input_pin_labels(codec);
3009 for (i = 0; i < cfg->num_inputs; i++) {
3012 pin = cfg->inputs[i].pin;
3013 if (!is_input_pin(codec, pin))
3017 if (cfg->inputs[i].type == AUTO_PIN_MIC)
3018 val |= snd_hda_get_default_vref(codec, pin);
3019 if (pin != spec->hp_mic_pin)
3020 set_pin_target(codec, pin, val, false);
3023 if (is_reachable_path(codec, pin, mixer)) {
3024 err = new_analog_input(codec, i, pin,
3025 spec->input_labels[i],
3026 spec->input_label_idxs[i],
3033 err = parse_capture_source(codec, pin, i, num_adcs,
3034 spec->input_labels[i], -mixer);
3038 if (spec->add_jack_modes) {
3039 err = create_in_jack_mode(codec, pin);
3045 if (mixer && spec->add_stereo_mix_input) {
3046 err = parse_capture_source(codec, mixer, CFG_IDX_MIX, num_adcs,
3060 /* get the input path specified by the given adc and imux indices */
3061 static struct nid_path *get_input_path(struct hda_codec *codec, int adc_idx, int imux_idx)
3063 struct hda_gen_spec *spec = codec->spec;
3064 if (imux_idx < 0 || imux_idx >= HDA_MAX_NUM_INPUTS) {
3068 if (spec->dyn_adc_switch)
3069 adc_idx = spec->dyn_adc_idx[imux_idx];
3070 if (adc_idx < 0 || adc_idx >= AUTO_CFG_MAX_INS) {
3074 return snd_hda_get_path_from_idx(codec, spec->input_paths[imux_idx][adc_idx]);
3077 static int mux_select(struct hda_codec *codec, unsigned int adc_idx,
3080 static int mux_enum_info(struct snd_kcontrol *kcontrol,
3081 struct snd_ctl_elem_info *uinfo)
3083 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3084 struct hda_gen_spec *spec = codec->spec;
3085 return snd_hda_input_mux_info(&spec->input_mux, uinfo);
3088 static int mux_enum_get(struct snd_kcontrol *kcontrol,
3089 struct snd_ctl_elem_value *ucontrol)
3091 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3092 struct hda_gen_spec *spec = codec->spec;
3093 /* the ctls are created at once with multiple counts */
3094 unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
3096 ucontrol->value.enumerated.item[0] = spec->cur_mux[adc_idx];
3100 static int mux_enum_put(struct snd_kcontrol *kcontrol,
3101 struct snd_ctl_elem_value *ucontrol)
3103 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3104 unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
3105 return mux_select(codec, adc_idx,
3106 ucontrol->value.enumerated.item[0]);
3109 static const struct snd_kcontrol_new cap_src_temp = {
3110 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3111 .name = "Input Source",
3112 .info = mux_enum_info,
3113 .get = mux_enum_get,
3114 .put = mux_enum_put,
3118 * capture volume and capture switch ctls
3121 typedef int (*put_call_t)(struct snd_kcontrol *kcontrol,
3122 struct snd_ctl_elem_value *ucontrol);
3124 /* call the given amp update function for all amps in the imux list at once */
3125 static int cap_put_caller(struct snd_kcontrol *kcontrol,
3126 struct snd_ctl_elem_value *ucontrol,
3127 put_call_t func, int type)
3129 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3130 struct hda_gen_spec *spec = codec->spec;
3131 const struct hda_input_mux *imux;
3132 struct nid_path *path;
3133 int i, adc_idx, err = 0;
3135 imux = &spec->input_mux;
3136 adc_idx = kcontrol->id.index;
3137 mutex_lock(&codec->control_mutex);
3138 /* we use the cache-only update at first since multiple input paths
3139 * may shared the same amp; by updating only caches, the redundant
3140 * writes to hardware can be reduced.
3142 codec->cached_write = 1;
3143 for (i = 0; i < imux->num_items; i++) {
3144 path = get_input_path(codec, adc_idx, i);
3145 if (!path || !path->ctls[type])
3147 kcontrol->private_value = path->ctls[type];
3148 err = func(kcontrol, ucontrol);
3153 codec->cached_write = 0;
3154 mutex_unlock(&codec->control_mutex);
3155 snd_hda_codec_flush_cache(codec); /* flush the updates */
3156 if (err >= 0 && spec->cap_sync_hook)
3157 spec->cap_sync_hook(codec, ucontrol);
3161 /* capture volume ctl callbacks */
3162 #define cap_vol_info snd_hda_mixer_amp_volume_info
3163 #define cap_vol_get snd_hda_mixer_amp_volume_get
3164 #define cap_vol_tlv snd_hda_mixer_amp_tlv
3166 static int cap_vol_put(struct snd_kcontrol *kcontrol,
3167 struct snd_ctl_elem_value *ucontrol)
3169 return cap_put_caller(kcontrol, ucontrol,
3170 snd_hda_mixer_amp_volume_put,
3174 static const struct snd_kcontrol_new cap_vol_temp = {
3175 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3176 .name = "Capture Volume",
3177 .access = (SNDRV_CTL_ELEM_ACCESS_READWRITE |
3178 SNDRV_CTL_ELEM_ACCESS_TLV_READ |
3179 SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK),
3180 .info = cap_vol_info,
3183 .tlv = { .c = cap_vol_tlv },
3186 /* capture switch ctl callbacks */
3187 #define cap_sw_info snd_ctl_boolean_stereo_info
3188 #define cap_sw_get snd_hda_mixer_amp_switch_get
3190 static int cap_sw_put(struct snd_kcontrol *kcontrol,
3191 struct snd_ctl_elem_value *ucontrol)
3193 return cap_put_caller(kcontrol, ucontrol,
3194 snd_hda_mixer_amp_switch_put,
3198 static const struct snd_kcontrol_new cap_sw_temp = {
3199 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3200 .name = "Capture Switch",
3201 .info = cap_sw_info,
3206 static int parse_capvol_in_path(struct hda_codec *codec, struct nid_path *path)
3211 path->ctls[NID_PATH_VOL_CTL] = path->ctls[NID_PATH_MUTE_CTL] = 0;
3212 for (depth = 0; depth < 3; depth++) {
3213 if (depth >= path->depth)
3215 i = path->depth - depth - 1;
3216 nid = path->path[i];
3217 if (!path->ctls[NID_PATH_VOL_CTL]) {
3218 if (nid_has_volume(codec, nid, HDA_OUTPUT))
3219 path->ctls[NID_PATH_VOL_CTL] =
3220 HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
3221 else if (nid_has_volume(codec, nid, HDA_INPUT)) {
3222 int idx = path->idx[i];
3223 if (!depth && codec->single_adc_amp)
3225 path->ctls[NID_PATH_VOL_CTL] =
3226 HDA_COMPOSE_AMP_VAL(nid, 3, idx, HDA_INPUT);
3229 if (!path->ctls[NID_PATH_MUTE_CTL]) {
3230 if (nid_has_mute(codec, nid, HDA_OUTPUT))
3231 path->ctls[NID_PATH_MUTE_CTL] =
3232 HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
3233 else if (nid_has_mute(codec, nid, HDA_INPUT)) {
3234 int idx = path->idx[i];
3235 if (!depth && codec->single_adc_amp)
3237 path->ctls[NID_PATH_MUTE_CTL] =
3238 HDA_COMPOSE_AMP_VAL(nid, 3, idx, HDA_INPUT);
3245 static bool is_inv_dmic_pin(struct hda_codec *codec, hda_nid_t nid)
3247 struct hda_gen_spec *spec = codec->spec;
3248 struct auto_pin_cfg *cfg = &spec->autocfg;
3252 if (!spec->inv_dmic_split)
3254 for (i = 0; i < cfg->num_inputs; i++) {
3255 if (cfg->inputs[i].pin != nid)
3257 if (cfg->inputs[i].type != AUTO_PIN_MIC)
3259 val = snd_hda_codec_get_pincfg(codec, nid);
3260 return snd_hda_get_input_pin_attr(val) == INPUT_PIN_ATTR_INT;
3265 /* capture switch put callback for a single control with hook call */
3266 static int cap_single_sw_put(struct snd_kcontrol *kcontrol,
3267 struct snd_ctl_elem_value *ucontrol)
3269 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3270 struct hda_gen_spec *spec = codec->spec;
3273 ret = snd_hda_mixer_amp_switch_put(kcontrol, ucontrol);
3277 if (spec->cap_sync_hook)
3278 spec->cap_sync_hook(codec, ucontrol);
3283 static int add_single_cap_ctl(struct hda_codec *codec, const char *label,
3284 int idx, bool is_switch, unsigned int ctl,
3287 struct hda_gen_spec *spec = codec->spec;
3289 int type = is_switch ? HDA_CTL_WIDGET_MUTE : HDA_CTL_WIDGET_VOL;
3290 const char *sfx = is_switch ? "Switch" : "Volume";
3291 unsigned int chs = inv_dmic ? 1 : 3;
3292 struct snd_kcontrol_new *knew;
3298 snprintf(tmpname, sizeof(tmpname),
3299 "%s Capture %s", label, sfx);
3301 snprintf(tmpname, sizeof(tmpname),
3303 knew = add_control(spec, type, tmpname, idx,
3304 amp_val_replace_channels(ctl, chs));
3308 knew->put = cap_single_sw_put;
3312 /* Make independent right kcontrol */
3314 snprintf(tmpname, sizeof(tmpname),
3315 "Inverted %s Capture %s", label, sfx);
3317 snprintf(tmpname, sizeof(tmpname),
3318 "Inverted Capture %s", sfx);
3319 knew = add_control(spec, type, tmpname, idx,
3320 amp_val_replace_channels(ctl, 2));
3324 knew->put = cap_single_sw_put;
3328 /* create single (and simple) capture volume and switch controls */
3329 static int create_single_cap_vol_ctl(struct hda_codec *codec, int idx,
3330 unsigned int vol_ctl, unsigned int sw_ctl,
3334 err = add_single_cap_ctl(codec, NULL, idx, false, vol_ctl, inv_dmic);
3337 err = add_single_cap_ctl(codec, NULL, idx, true, sw_ctl, inv_dmic);
3343 /* create bound capture volume and switch controls */
3344 static int create_bind_cap_vol_ctl(struct hda_codec *codec, int idx,
3345 unsigned int vol_ctl, unsigned int sw_ctl)
3347 struct hda_gen_spec *spec = codec->spec;
3348 struct snd_kcontrol_new *knew;
3351 knew = snd_hda_gen_add_kctl(spec, NULL, &cap_vol_temp);
3355 knew->private_value = vol_ctl;
3356 knew->subdevice = HDA_SUBDEV_AMP_FLAG;
3359 knew = snd_hda_gen_add_kctl(spec, NULL, &cap_sw_temp);
3363 knew->private_value = sw_ctl;
3364 knew->subdevice = HDA_SUBDEV_AMP_FLAG;
3369 /* return the vol ctl when used first in the imux list */
3370 static unsigned int get_first_cap_ctl(struct hda_codec *codec, int idx, int type)
3372 struct nid_path *path;
3376 path = get_input_path(codec, 0, idx);
3379 ctl = path->ctls[type];
3382 for (i = 0; i < idx - 1; i++) {
3383 path = get_input_path(codec, 0, i);
3384 if (path && path->ctls[type] == ctl)
3390 /* create individual capture volume and switch controls per input */
3391 static int create_multi_cap_vol_ctl(struct hda_codec *codec)
3393 struct hda_gen_spec *spec = codec->spec;
3394 struct hda_input_mux *imux = &spec->input_mux;
3397 for (i = 0; i < imux->num_items; i++) {
3401 idx = imux->items[i].index;
3402 if (idx >= spec->autocfg.num_inputs)
3404 inv_dmic = is_inv_dmic_pin(codec, spec->imux_pins[i]);
3406 for (type = 0; type < 2; type++) {
3407 err = add_single_cap_ctl(codec,
3408 spec->input_labels[idx],
3409 spec->input_label_idxs[idx],
3411 get_first_cap_ctl(codec, i, type),
3420 static int create_capture_mixers(struct hda_codec *codec)
3422 struct hda_gen_spec *spec = codec->spec;
3423 struct hda_input_mux *imux = &spec->input_mux;
3424 int i, n, nums, err;
3426 if (spec->dyn_adc_switch)
3429 nums = spec->num_adc_nids;
3431 if (!spec->auto_mic && imux->num_items > 1) {
3432 struct snd_kcontrol_new *knew;
3434 name = nums > 1 ? "Input Source" : "Capture Source";
3435 knew = snd_hda_gen_add_kctl(spec, name, &cap_src_temp);
3441 for (n = 0; n < nums; n++) {
3443 bool multi_cap_vol = spec->multi_cap_vol;
3444 bool inv_dmic = false;
3448 for (i = 0; i < imux->num_items; i++) {
3449 struct nid_path *path;
3450 path = get_input_path(codec, n, i);
3453 parse_capvol_in_path(codec, path);
3455 vol = path->ctls[NID_PATH_VOL_CTL];
3456 else if (vol != path->ctls[NID_PATH_VOL_CTL]) {
3458 if (!same_amp_caps(codec, vol,
3459 path->ctls[NID_PATH_VOL_CTL], HDA_INPUT))
3460 multi_cap_vol = true;
3463 sw = path->ctls[NID_PATH_MUTE_CTL];
3464 else if (sw != path->ctls[NID_PATH_MUTE_CTL]) {
3466 if (!same_amp_caps(codec, sw,
3467 path->ctls[NID_PATH_MUTE_CTL], HDA_INPUT))
3468 multi_cap_vol = true;
3470 if (is_inv_dmic_pin(codec, spec->imux_pins[i]))
3475 err = create_single_cap_vol_ctl(codec, n, vol, sw,
3477 else if (!multi_cap_vol)
3478 err = create_bind_cap_vol_ctl(codec, n, vol, sw);
3480 err = create_multi_cap_vol_ctl(codec);
3489 * add mic boosts if needed
3492 /* check whether the given amp is feasible as a boost volume */
3493 static bool check_boost_vol(struct hda_codec *codec, hda_nid_t nid,
3498 if (!nid_has_volume(codec, nid, dir) ||
3499 is_ctl_associated(codec, nid, dir, idx, NID_PATH_VOL_CTL) ||
3500 is_ctl_associated(codec, nid, dir, idx, NID_PATH_BOOST_CTL))
3503 step = (query_amp_caps(codec, nid, dir) & AC_AMPCAP_STEP_SIZE)
3504 >> AC_AMPCAP_STEP_SIZE_SHIFT;
3510 /* look for a boost amp in a widget close to the pin */
3511 static unsigned int look_for_boost_amp(struct hda_codec *codec,
3512 struct nid_path *path)
3514 unsigned int val = 0;
3518 for (depth = 0; depth < 3; depth++) {
3519 if (depth >= path->depth - 1)
3521 nid = path->path[depth];
3522 if (depth && check_boost_vol(codec, nid, HDA_OUTPUT, 0)) {
3523 val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
3525 } else if (check_boost_vol(codec, nid, HDA_INPUT,
3526 path->idx[depth])) {
3527 val = HDA_COMPOSE_AMP_VAL(nid, 3, path->idx[depth],
3536 static int parse_mic_boost(struct hda_codec *codec)
3538 struct hda_gen_spec *spec = codec->spec;
3539 struct auto_pin_cfg *cfg = &spec->autocfg;
3540 struct hda_input_mux *imux = &spec->input_mux;
3543 if (!spec->num_adc_nids)
3546 for (i = 0; i < imux->num_items; i++) {
3547 struct nid_path *path;
3550 char boost_label[44];
3552 idx = imux->items[i].index;
3553 if (idx >= imux->num_items)
3556 /* check only line-in and mic pins */
3557 if (cfg->inputs[idx].type > AUTO_PIN_LINE_IN)
3560 path = get_input_path(codec, 0, i);
3564 val = look_for_boost_amp(codec, path);
3568 /* create a boost control */
3569 snprintf(boost_label, sizeof(boost_label),
3570 "%s Boost Volume", spec->input_labels[idx]);
3571 if (!add_control(spec, HDA_CTL_WIDGET_VOL, boost_label,
3572 spec->input_label_idxs[idx], val))
3575 path->ctls[NID_PATH_BOOST_CTL] = val;
3581 * parse digital I/Os and set up NIDs in BIOS auto-parse mode
3583 static void parse_digital(struct hda_codec *codec)
3585 struct hda_gen_spec *spec = codec->spec;
3586 struct nid_path *path;
3588 hda_nid_t dig_nid, pin;
3590 /* support multiple SPDIFs; the secondary is set up as a slave */
3592 for (i = 0; i < spec->autocfg.dig_outs; i++) {
3593 pin = spec->autocfg.dig_out_pins[i];
3594 dig_nid = look_for_dac(codec, pin, true);
3597 path = snd_hda_add_new_path(codec, dig_nid, pin, 0);
3600 print_nid_path("digout", path);
3601 path->active = true;
3602 spec->digout_paths[i] = snd_hda_get_path_idx(codec, path);
3603 set_pin_target(codec, pin, PIN_OUT, false);
3605 spec->multiout.dig_out_nid = dig_nid;
3606 spec->dig_out_type = spec->autocfg.dig_out_type[0];
3608 spec->multiout.slave_dig_outs = spec->slave_dig_outs;
3609 if (nums >= ARRAY_SIZE(spec->slave_dig_outs) - 1)
3611 spec->slave_dig_outs[nums - 1] = dig_nid;
3616 if (spec->autocfg.dig_in_pin) {
3617 pin = spec->autocfg.dig_in_pin;
3618 dig_nid = codec->start_nid;
3619 for (i = 0; i < codec->num_nodes; i++, dig_nid++) {
3620 unsigned int wcaps = get_wcaps(codec, dig_nid);
3621 if (get_wcaps_type(wcaps) != AC_WID_AUD_IN)
3623 if (!(wcaps & AC_WCAP_DIGITAL))
3625 path = snd_hda_add_new_path(codec, pin, dig_nid, 0);
3627 print_nid_path("digin", path);
3628 path->active = true;
3629 spec->dig_in_nid = dig_nid;
3630 spec->digin_path = snd_hda_get_path_idx(codec, path);
3631 set_pin_target(codec, pin, PIN_IN, false);
3640 * input MUX handling
3643 static bool dyn_adc_pcm_resetup(struct hda_codec *codec, int cur);
3645 /* select the given imux item; either unmute exclusively or select the route */
3646 static int mux_select(struct hda_codec *codec, unsigned int adc_idx,
3649 struct hda_gen_spec *spec = codec->spec;
3650 const struct hda_input_mux *imux;
3651 struct nid_path *old_path, *path;
3653 imux = &spec->input_mux;
3654 if (!imux->num_items)
3657 if (idx >= imux->num_items)
3658 idx = imux->num_items - 1;
3659 if (spec->cur_mux[adc_idx] == idx)
3662 old_path = get_input_path(codec, adc_idx, spec->cur_mux[adc_idx]);
3665 if (old_path->active)
3666 snd_hda_activate_path(codec, old_path, false, false);
3668 spec->cur_mux[adc_idx] = idx;
3671 update_hp_mic(codec, adc_idx, false);
3673 if (spec->dyn_adc_switch)
3674 dyn_adc_pcm_resetup(codec, idx);
3676 path = get_input_path(codec, adc_idx, idx);
3681 snd_hda_activate_path(codec, path, true, false);
3682 if (spec->cap_sync_hook)
3683 spec->cap_sync_hook(codec, NULL);
3684 path_power_down_sync(codec, old_path);
3690 * Jack detections for HP auto-mute and mic-switch
3693 /* check each pin in the given array; returns true if any of them is plugged */
3694 static bool detect_jacks(struct hda_codec *codec, int num_pins, hda_nid_t *pins)
3698 for (i = 0; i < num_pins; i++) {
3699 hda_nid_t nid = pins[i];
3702 /* don't detect pins retasked as inputs */
3703 if (snd_hda_codec_get_pin_target(codec, nid) & AC_PINCTL_IN_EN)
3705 present |= snd_hda_jack_detect(codec, nid);
3710 /* standard HP/line-out auto-mute helper */
3711 static void do_automute(struct hda_codec *codec, int num_pins, hda_nid_t *pins,
3714 struct hda_gen_spec *spec = codec->spec;
3717 for (i = 0; i < num_pins; i++) {
3718 hda_nid_t nid = pins[i];
3719 unsigned int val, oldval;
3722 oldval = snd_hda_codec_get_pin_target(codec, nid);
3723 if (oldval & PIN_IN)
3724 continue; /* no mute for inputs */
3725 /* don't reset VREF value in case it's controlling
3726 * the amp (see alc861_fixup_asus_amp_vref_0f())
3728 if (spec->keep_vref_in_automute)
3729 val = oldval & ~PIN_HP;
3734 /* here we call update_pin_ctl() so that the pinctl is changed
3735 * without changing the pinctl target value;
3736 * the original target value will be still referred at the
3737 * init / resume again
3739 update_pin_ctl(codec, nid, val);
3740 set_pin_eapd(codec, nid, !mute);
3744 /* Toggle outputs muting */
3745 void snd_hda_gen_update_outputs(struct hda_codec *codec)
3747 struct hda_gen_spec *spec = codec->spec;
3750 /* Control HP pins/amps depending on master_mute state;
3751 * in general, HP pins/amps control should be enabled in all cases,
3752 * but currently set only for master_mute, just to be safe
3754 do_automute(codec, ARRAY_SIZE(spec->autocfg.hp_pins),
3755 spec->autocfg.hp_pins, spec->master_mute);
3757 if (!spec->automute_speaker)
3760 on = spec->hp_jack_present | spec->line_jack_present;
3761 on |= spec->master_mute;
3762 spec->speaker_muted = on;
3763 do_automute(codec, ARRAY_SIZE(spec->autocfg.speaker_pins),
3764 spec->autocfg.speaker_pins, on);
3766 /* toggle line-out mutes if needed, too */
3767 /* if LO is a copy of either HP or Speaker, don't need to handle it */
3768 if (spec->autocfg.line_out_pins[0] == spec->autocfg.hp_pins[0] ||
3769 spec->autocfg.line_out_pins[0] == spec->autocfg.speaker_pins[0])
3771 if (!spec->automute_lo)
3774 on = spec->hp_jack_present;
3775 on |= spec->master_mute;
3776 spec->line_out_muted = on;
3777 do_automute(codec, ARRAY_SIZE(spec->autocfg.line_out_pins),
3778 spec->autocfg.line_out_pins, on);
3780 EXPORT_SYMBOL_HDA(snd_hda_gen_update_outputs);
3782 static void call_update_outputs(struct hda_codec *codec)
3784 struct hda_gen_spec *spec = codec->spec;
3785 if (spec->automute_hook)
3786 spec->automute_hook(codec);
3788 snd_hda_gen_update_outputs(codec);
3791 /* standard HP-automute helper */
3792 void snd_hda_gen_hp_automute(struct hda_codec *codec, struct hda_jack_tbl *jack)
3794 struct hda_gen_spec *spec = codec->spec;
3795 hda_nid_t *pins = spec->autocfg.hp_pins;
3796 int num_pins = ARRAY_SIZE(spec->autocfg.hp_pins);
3798 /* No detection for the first HP jack during indep-HP mode */
3799 if (spec->indep_hp_enabled) {
3804 spec->hp_jack_present = detect_jacks(codec, num_pins, pins);
3805 if (!spec->detect_hp || (!spec->automute_speaker && !spec->automute_lo))
3807 call_update_outputs(codec);
3809 EXPORT_SYMBOL_HDA(snd_hda_gen_hp_automute);
3811 /* standard line-out-automute helper */
3812 void snd_hda_gen_line_automute(struct hda_codec *codec, struct hda_jack_tbl *jack)
3814 struct hda_gen_spec *spec = codec->spec;
3816 if (spec->autocfg.line_out_type == AUTO_PIN_SPEAKER_OUT)
3818 /* check LO jack only when it's different from HP */
3819 if (spec->autocfg.line_out_pins[0] == spec->autocfg.hp_pins[0])
3822 spec->line_jack_present =
3823 detect_jacks(codec, ARRAY_SIZE(spec->autocfg.line_out_pins),
3824 spec->autocfg.line_out_pins);
3825 if (!spec->automute_speaker || !spec->detect_lo)
3827 call_update_outputs(codec);
3829 EXPORT_SYMBOL_HDA(snd_hda_gen_line_automute);
3831 /* standard mic auto-switch helper */
3832 void snd_hda_gen_mic_autoswitch(struct hda_codec *codec, struct hda_jack_tbl *jack)
3834 struct hda_gen_spec *spec = codec->spec;
3837 if (!spec->auto_mic)
3840 for (i = spec->am_num_entries - 1; i > 0; i--) {
3841 hda_nid_t pin = spec->am_entry[i].pin;
3842 /* don't detect pins retasked as outputs */
3843 if (snd_hda_codec_get_pin_target(codec, pin) & AC_PINCTL_OUT_EN)
3845 if (snd_hda_jack_detect(codec, pin)) {
3846 mux_select(codec, 0, spec->am_entry[i].idx);
3850 mux_select(codec, 0, spec->am_entry[0].idx);
3852 EXPORT_SYMBOL_HDA(snd_hda_gen_mic_autoswitch);
3854 /* call appropriate hooks */
3855 static void call_hp_automute(struct hda_codec *codec, struct hda_jack_tbl *jack)
3857 struct hda_gen_spec *spec = codec->spec;
3858 if (spec->hp_automute_hook)
3859 spec->hp_automute_hook(codec, jack);
3861 snd_hda_gen_hp_automute(codec, jack);
3864 static void call_line_automute(struct hda_codec *codec,
3865 struct hda_jack_tbl *jack)
3867 struct hda_gen_spec *spec = codec->spec;
3868 if (spec->line_automute_hook)
3869 spec->line_automute_hook(codec, jack);
3871 snd_hda_gen_line_automute(codec, jack);
3874 static void call_mic_autoswitch(struct hda_codec *codec,
3875 struct hda_jack_tbl *jack)
3877 struct hda_gen_spec *spec = codec->spec;
3878 if (spec->mic_autoswitch_hook)
3879 spec->mic_autoswitch_hook(codec, jack);
3881 snd_hda_gen_mic_autoswitch(codec, jack);
3884 /* update jack retasking */
3885 static void update_automute_all(struct hda_codec *codec)
3887 call_hp_automute(codec, NULL);
3888 call_line_automute(codec, NULL);
3889 call_mic_autoswitch(codec, NULL);
3893 * Auto-Mute mode mixer enum support
3895 static int automute_mode_info(struct snd_kcontrol *kcontrol,
3896 struct snd_ctl_elem_info *uinfo)
3898 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3899 struct hda_gen_spec *spec = codec->spec;
3900 static const char * const texts3[] = {
3901 "Disabled", "Speaker Only", "Line Out+Speaker"
3904 if (spec->automute_speaker_possible && spec->automute_lo_possible)
3905 return snd_hda_enum_helper_info(kcontrol, uinfo, 3, texts3);
3906 return snd_hda_enum_bool_helper_info(kcontrol, uinfo);
3909 static int automute_mode_get(struct snd_kcontrol *kcontrol,
3910 struct snd_ctl_elem_value *ucontrol)
3912 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3913 struct hda_gen_spec *spec = codec->spec;
3914 unsigned int val = 0;
3915 if (spec->automute_speaker)
3917 if (spec->automute_lo)
3920 ucontrol->value.enumerated.item[0] = val;
3924 static int automute_mode_put(struct snd_kcontrol *kcontrol,
3925 struct snd_ctl_elem_value *ucontrol)
3927 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3928 struct hda_gen_spec *spec = codec->spec;
3930 switch (ucontrol->value.enumerated.item[0]) {
3932 if (!spec->automute_speaker && !spec->automute_lo)
3934 spec->automute_speaker = 0;
3935 spec->automute_lo = 0;
3938 if (spec->automute_speaker_possible) {
3939 if (!spec->automute_lo && spec->automute_speaker)
3941 spec->automute_speaker = 1;
3942 spec->automute_lo = 0;
3943 } else if (spec->automute_lo_possible) {
3944 if (spec->automute_lo)
3946 spec->automute_lo = 1;
3951 if (!spec->automute_lo_possible || !spec->automute_speaker_possible)
3953 if (spec->automute_speaker && spec->automute_lo)
3955 spec->automute_speaker = 1;
3956 spec->automute_lo = 1;
3961 call_update_outputs(codec);
3965 static const struct snd_kcontrol_new automute_mode_enum = {
3966 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3967 .name = "Auto-Mute Mode",
3968 .info = automute_mode_info,
3969 .get = automute_mode_get,
3970 .put = automute_mode_put,
3973 static int add_automute_mode_enum(struct hda_codec *codec)
3975 struct hda_gen_spec *spec = codec->spec;
3977 if (!snd_hda_gen_add_kctl(spec, NULL, &automute_mode_enum))
3983 * Check the availability of HP/line-out auto-mute;
3984 * Set up appropriately if really supported
3986 static int check_auto_mute_availability(struct hda_codec *codec)
3988 struct hda_gen_spec *spec = codec->spec;
3989 struct auto_pin_cfg *cfg = &spec->autocfg;
3993 if (spec->suppress_auto_mute)
3996 if (cfg->hp_pins[0])
3998 if (cfg->line_out_pins[0])
4000 if (cfg->speaker_pins[0])
4002 if (present < 2) /* need two different output types */
4005 if (!cfg->speaker_pins[0] &&
4006 cfg->line_out_type == AUTO_PIN_SPEAKER_OUT) {
4007 memcpy(cfg->speaker_pins, cfg->line_out_pins,
4008 sizeof(cfg->speaker_pins));
4009 cfg->speaker_outs = cfg->line_outs;
4012 if (!cfg->hp_pins[0] &&
4013 cfg->line_out_type == AUTO_PIN_HP_OUT) {
4014 memcpy(cfg->hp_pins, cfg->line_out_pins,
4015 sizeof(cfg->hp_pins));
4016 cfg->hp_outs = cfg->line_outs;
4019 for (i = 0; i < cfg->hp_outs; i++) {
4020 hda_nid_t nid = cfg->hp_pins[i];
4021 if (!is_jack_detectable(codec, nid))
4023 snd_printdd("hda-codec: Enable HP auto-muting on NID 0x%x\n",
4025 snd_hda_jack_detect_enable_callback(codec, nid, HDA_GEN_HP_EVENT,
4027 spec->detect_hp = 1;
4030 if (cfg->line_out_type == AUTO_PIN_LINE_OUT && cfg->line_outs) {
4031 if (cfg->speaker_outs)
4032 for (i = 0; i < cfg->line_outs; i++) {
4033 hda_nid_t nid = cfg->line_out_pins[i];
4034 if (!is_jack_detectable(codec, nid))
4036 snd_printdd("hda-codec: Enable Line-Out auto-muting on NID 0x%x\n", nid);
4037 snd_hda_jack_detect_enable_callback(codec, nid,
4038 HDA_GEN_FRONT_EVENT,
4039 call_line_automute);
4040 spec->detect_lo = 1;
4042 spec->automute_lo_possible = spec->detect_hp;
4045 spec->automute_speaker_possible = cfg->speaker_outs &&
4046 (spec->detect_hp || spec->detect_lo);
4048 spec->automute_lo = spec->automute_lo_possible;
4049 spec->automute_speaker = spec->automute_speaker_possible;
4051 if (spec->automute_speaker_possible || spec->automute_lo_possible) {
4052 /* create a control for automute mode */
4053 err = add_automute_mode_enum(codec);
4060 /* check whether all auto-mic pins are valid; setup indices if OK */
4061 static bool auto_mic_check_imux(struct hda_codec *codec)
4063 struct hda_gen_spec *spec = codec->spec;
4064 const struct hda_input_mux *imux;
4067 imux = &spec->input_mux;
4068 for (i = 0; i < spec->am_num_entries; i++) {
4069 spec->am_entry[i].idx =
4070 find_idx_in_nid_list(spec->am_entry[i].pin,
4071 spec->imux_pins, imux->num_items);
4072 if (spec->am_entry[i].idx < 0)
4073 return false; /* no corresponding imux */
4076 /* we don't need the jack detection for the first pin */
4077 for (i = 1; i < spec->am_num_entries; i++)
4078 snd_hda_jack_detect_enable_callback(codec,
4079 spec->am_entry[i].pin,
4081 call_mic_autoswitch);
4085 static int compare_attr(const void *ap, const void *bp)
4087 const struct automic_entry *a = ap;
4088 const struct automic_entry *b = bp;
4089 return (int)(a->attr - b->attr);
4093 * Check the availability of auto-mic switch;
4094 * Set up if really supported
4096 static int check_auto_mic_availability(struct hda_codec *codec)
4098 struct hda_gen_spec *spec = codec->spec;
4099 struct auto_pin_cfg *cfg = &spec->autocfg;
4103 if (spec->suppress_auto_mic)
4108 for (i = 0; i < cfg->num_inputs; i++) {
4109 hda_nid_t nid = cfg->inputs[i].pin;
4111 attr = snd_hda_codec_get_pincfg(codec, nid);
4112 attr = snd_hda_get_input_pin_attr(attr);
4113 if (types & (1 << attr))
4114 return 0; /* already occupied */
4116 case INPUT_PIN_ATTR_INT:
4117 if (cfg->inputs[i].type != AUTO_PIN_MIC)
4118 return 0; /* invalid type */
4120 case INPUT_PIN_ATTR_UNUSED:
4121 return 0; /* invalid entry */
4123 if (cfg->inputs[i].type > AUTO_PIN_LINE_IN)
4124 return 0; /* invalid type */
4125 if (!spec->line_in_auto_switch &&
4126 cfg->inputs[i].type != AUTO_PIN_MIC)
4127 return 0; /* only mic is allowed */
4128 if (!is_jack_detectable(codec, nid))
4129 return 0; /* no unsol support */
4132 if (num_pins >= MAX_AUTO_MIC_PINS)
4134 types |= (1 << attr);
4135 spec->am_entry[num_pins].pin = nid;
4136 spec->am_entry[num_pins].attr = attr;
4143 spec->am_num_entries = num_pins;
4144 /* sort the am_entry in the order of attr so that the pin with a
4145 * higher attr will be selected when the jack is plugged.
4147 sort(spec->am_entry, num_pins, sizeof(spec->am_entry[0]),
4148 compare_attr, NULL);
4150 if (!auto_mic_check_imux(codec))
4154 spec->num_adc_nids = 1;
4155 spec->cur_mux[0] = spec->am_entry[0].idx;
4156 snd_printdd("hda-codec: Enable auto-mic switch on NID 0x%x/0x%x/0x%x\n",
4157 spec->am_entry[0].pin,
4158 spec->am_entry[1].pin,
4159 spec->am_entry[2].pin);
4164 /* power_filter hook; make inactive widgets into power down */
4165 static unsigned int snd_hda_gen_path_power_filter(struct hda_codec *codec,
4167 unsigned int power_state)
4169 if (power_state != AC_PWRST_D0)
4171 if (get_wcaps_type(get_wcaps(codec, nid)) >= AC_WID_POWER)
4173 if (is_active_nid_for_any(codec, nid))
4180 * Parse the given BIOS configuration and set up the hda_gen_spec
4182 * return 1 if successful, 0 if the proper config is not found,
4183 * or a negative error code
4185 int snd_hda_gen_parse_auto_config(struct hda_codec *codec,
4186 struct auto_pin_cfg *cfg)
4188 struct hda_gen_spec *spec = codec->spec;
4191 parse_user_hints(codec);
4193 if (spec->mixer_nid && !spec->mixer_merge_nid)
4194 spec->mixer_merge_nid = spec->mixer_nid;
4196 if (cfg != &spec->autocfg) {
4197 spec->autocfg = *cfg;
4198 cfg = &spec->autocfg;
4201 if (!spec->main_out_badness)
4202 spec->main_out_badness = &hda_main_out_badness;
4203 if (!spec->extra_out_badness)
4204 spec->extra_out_badness = &hda_extra_out_badness;
4206 fill_all_dac_nids(codec);
4208 if (!cfg->line_outs) {
4209 if (cfg->dig_outs || cfg->dig_in_pin) {
4210 spec->multiout.max_channels = 2;
4211 spec->no_analog = 1;
4214 return 0; /* can't find valid BIOS pin config */
4217 if (!spec->no_primary_hp &&
4218 cfg->line_out_type == AUTO_PIN_SPEAKER_OUT &&
4219 cfg->line_outs <= cfg->hp_outs) {
4220 /* use HP as primary out */
4221 cfg->speaker_outs = cfg->line_outs;
4222 memcpy(cfg->speaker_pins, cfg->line_out_pins,
4223 sizeof(cfg->speaker_pins));
4224 cfg->line_outs = cfg->hp_outs;
4225 memcpy(cfg->line_out_pins, cfg->hp_pins, sizeof(cfg->hp_pins));
4227 memset(cfg->hp_pins, 0, sizeof(cfg->hp_pins));
4228 cfg->line_out_type = AUTO_PIN_HP_OUT;
4231 err = parse_output_paths(codec);
4234 err = create_multi_channel_mode(codec);
4237 err = create_multi_out_ctls(codec, cfg);
4240 err = create_hp_out_ctls(codec);
4243 err = create_speaker_out_ctls(codec);
4246 err = create_indep_hp_ctls(codec);
4249 err = create_loopback_mixing_ctl(codec);
4252 err = create_hp_mic(codec);
4255 err = create_input_ctls(codec);
4259 spec->const_channel_count = spec->ext_channel_count;
4260 /* check the multiple speaker and headphone pins */
4261 if (cfg->line_out_type != AUTO_PIN_SPEAKER_OUT)
4262 spec->const_channel_count = max(spec->const_channel_count,
4263 cfg->speaker_outs * 2);
4264 if (cfg->line_out_type != AUTO_PIN_HP_OUT)
4265 spec->const_channel_count = max(spec->const_channel_count,
4267 spec->multiout.max_channels = max(spec->ext_channel_count,
4268 spec->const_channel_count);
4270 err = check_auto_mute_availability(codec);
4274 err = check_dyn_adc_switch(codec);
4278 err = check_auto_mic_availability(codec);
4282 err = create_capture_mixers(codec);
4286 err = parse_mic_boost(codec);
4290 if (spec->add_jack_modes) {
4291 if (cfg->line_out_type != AUTO_PIN_SPEAKER_OUT) {
4292 err = create_out_jack_modes(codec, cfg->line_outs,
4293 cfg->line_out_pins);
4297 if (cfg->line_out_type != AUTO_PIN_HP_OUT) {
4298 err = create_out_jack_modes(codec, cfg->hp_outs,
4306 parse_digital(codec);
4308 if (spec->power_down_unused)
4309 codec->power_filter = snd_hda_gen_path_power_filter;
4311 if (!spec->no_analog && spec->beep_nid) {
4312 err = snd_hda_attach_beep_device(codec, spec->beep_nid);
4319 EXPORT_SYMBOL_HDA(snd_hda_gen_parse_auto_config);
4323 * Build control elements
4326 /* slave controls for virtual master */
4327 static const char * const slave_pfxs[] = {
4328 "Front", "Surround", "Center", "LFE", "Side",
4329 "Headphone", "Speaker", "Mono", "Line Out",
4330 "CLFE", "Bass Speaker", "PCM",
4331 "Speaker Front", "Speaker Surround", "Speaker CLFE", "Speaker Side",
4332 "Headphone Front", "Headphone Surround", "Headphone CLFE",
4337 int snd_hda_gen_build_controls(struct hda_codec *codec)
4339 struct hda_gen_spec *spec = codec->spec;
4342 if (spec->kctls.used) {
4343 err = snd_hda_add_new_ctls(codec, spec->kctls.list);
4348 if (spec->multiout.dig_out_nid) {
4349 err = snd_hda_create_dig_out_ctls(codec,
4350 spec->multiout.dig_out_nid,
4351 spec->multiout.dig_out_nid,
4352 spec->pcm_rec[1].pcm_type);
4355 if (!spec->no_analog) {
4356 err = snd_hda_create_spdif_share_sw(codec,
4360 spec->multiout.share_spdif = 1;
4363 if (spec->dig_in_nid) {
4364 err = snd_hda_create_spdif_in_ctls(codec, spec->dig_in_nid);
4369 /* if we have no master control, let's create it */
4370 if (!spec->no_analog &&
4371 !snd_hda_find_mixer_ctl(codec, "Master Playback Volume")) {
4372 err = snd_hda_add_vmaster(codec, "Master Playback Volume",
4373 spec->vmaster_tlv, slave_pfxs,
4378 if (!spec->no_analog &&
4379 !snd_hda_find_mixer_ctl(codec, "Master Playback Switch")) {
4380 err = __snd_hda_add_vmaster(codec, "Master Playback Switch",
4383 true, &spec->vmaster_mute.sw_kctl);
4386 if (spec->vmaster_mute.hook)
4387 snd_hda_add_vmaster_hook(codec, &spec->vmaster_mute,
4388 spec->vmaster_mute_enum);
4391 free_kctls(spec); /* no longer needed */
4393 err = snd_hda_jack_add_kctls(codec, &spec->autocfg);
4399 EXPORT_SYMBOL_HDA(snd_hda_gen_build_controls);
4406 static void call_pcm_playback_hook(struct hda_pcm_stream *hinfo,
4407 struct hda_codec *codec,
4408 struct snd_pcm_substream *substream,
4411 struct hda_gen_spec *spec = codec->spec;
4412 if (spec->pcm_playback_hook)
4413 spec->pcm_playback_hook(hinfo, codec, substream, action);
4416 static void call_pcm_capture_hook(struct hda_pcm_stream *hinfo,
4417 struct hda_codec *codec,
4418 struct snd_pcm_substream *substream,
4421 struct hda_gen_spec *spec = codec->spec;
4422 if (spec->pcm_capture_hook)
4423 spec->pcm_capture_hook(hinfo, codec, substream, action);
4427 * Analog playback callbacks
4429 static int playback_pcm_open(struct hda_pcm_stream *hinfo,
4430 struct hda_codec *codec,
4431 struct snd_pcm_substream *substream)
4433 struct hda_gen_spec *spec = codec->spec;
4436 mutex_lock(&spec->pcm_mutex);
4437 err = snd_hda_multi_out_analog_open(codec,
4438 &spec->multiout, substream,
4441 spec->active_streams |= 1 << STREAM_MULTI_OUT;
4442 call_pcm_playback_hook(hinfo, codec, substream,
4443 HDA_GEN_PCM_ACT_OPEN);
4445 mutex_unlock(&spec->pcm_mutex);
4449 static int playback_pcm_prepare(struct hda_pcm_stream *hinfo,
4450 struct hda_codec *codec,
4451 unsigned int stream_tag,
4452 unsigned int format,
4453 struct snd_pcm_substream *substream)
4455 struct hda_gen_spec *spec = codec->spec;
4458 err = snd_hda_multi_out_analog_prepare(codec, &spec->multiout,
4459 stream_tag, format, substream);
4461 call_pcm_playback_hook(hinfo, codec, substream,
4462 HDA_GEN_PCM_ACT_PREPARE);
4466 static int playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
4467 struct hda_codec *codec,
4468 struct snd_pcm_substream *substream)
4470 struct hda_gen_spec *spec = codec->spec;
4473 err = snd_hda_multi_out_analog_cleanup(codec, &spec->multiout);
4475 call_pcm_playback_hook(hinfo, codec, substream,
4476 HDA_GEN_PCM_ACT_CLEANUP);
4480 static int playback_pcm_close(struct hda_pcm_stream *hinfo,
4481 struct hda_codec *codec,
4482 struct snd_pcm_substream *substream)
4484 struct hda_gen_spec *spec = codec->spec;
4485 mutex_lock(&spec->pcm_mutex);
4486 spec->active_streams &= ~(1 << STREAM_MULTI_OUT);
4487 call_pcm_playback_hook(hinfo, codec, substream,
4488 HDA_GEN_PCM_ACT_CLOSE);
4489 mutex_unlock(&spec->pcm_mutex);
4493 static int capture_pcm_open(struct hda_pcm_stream *hinfo,
4494 struct hda_codec *codec,
4495 struct snd_pcm_substream *substream)
4497 call_pcm_capture_hook(hinfo, codec, substream, HDA_GEN_PCM_ACT_OPEN);
4501 static int capture_pcm_prepare(struct hda_pcm_stream *hinfo,
4502 struct hda_codec *codec,
4503 unsigned int stream_tag,
4504 unsigned int format,
4505 struct snd_pcm_substream *substream)
4507 snd_hda_codec_setup_stream(codec, hinfo->nid, stream_tag, 0, format);
4508 call_pcm_capture_hook(hinfo, codec, substream,
4509 HDA_GEN_PCM_ACT_PREPARE);
4513 static int capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
4514 struct hda_codec *codec,
4515 struct snd_pcm_substream *substream)
4517 snd_hda_codec_cleanup_stream(codec, hinfo->nid);
4518 call_pcm_capture_hook(hinfo, codec, substream,
4519 HDA_GEN_PCM_ACT_CLEANUP);
4523 static int capture_pcm_close(struct hda_pcm_stream *hinfo,
4524 struct hda_codec *codec,
4525 struct snd_pcm_substream *substream)
4527 call_pcm_capture_hook(hinfo, codec, substream, HDA_GEN_PCM_ACT_CLOSE);
4531 static int alt_playback_pcm_open(struct hda_pcm_stream *hinfo,
4532 struct hda_codec *codec,
4533 struct snd_pcm_substream *substream)
4535 struct hda_gen_spec *spec = codec->spec;
4538 mutex_lock(&spec->pcm_mutex);
4539 if (!spec->indep_hp_enabled)
4542 spec->active_streams |= 1 << STREAM_INDEP_HP;
4543 call_pcm_playback_hook(hinfo, codec, substream,
4544 HDA_GEN_PCM_ACT_OPEN);
4545 mutex_unlock(&spec->pcm_mutex);
4549 static int alt_playback_pcm_close(struct hda_pcm_stream *hinfo,
4550 struct hda_codec *codec,
4551 struct snd_pcm_substream *substream)
4553 struct hda_gen_spec *spec = codec->spec;
4554 mutex_lock(&spec->pcm_mutex);
4555 spec->active_streams &= ~(1 << STREAM_INDEP_HP);
4556 call_pcm_playback_hook(hinfo, codec, substream,
4557 HDA_GEN_PCM_ACT_CLOSE);
4558 mutex_unlock(&spec->pcm_mutex);
4562 static int alt_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
4563 struct hda_codec *codec,
4564 unsigned int stream_tag,
4565 unsigned int format,
4566 struct snd_pcm_substream *substream)
4568 snd_hda_codec_setup_stream(codec, hinfo->nid, stream_tag, 0, format);
4569 call_pcm_playback_hook(hinfo, codec, substream,
4570 HDA_GEN_PCM_ACT_PREPARE);
4574 static int alt_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
4575 struct hda_codec *codec,
4576 struct snd_pcm_substream *substream)
4578 snd_hda_codec_cleanup_stream(codec, hinfo->nid);
4579 call_pcm_playback_hook(hinfo, codec, substream,
4580 HDA_GEN_PCM_ACT_CLEANUP);
4587 static int dig_playback_pcm_open(struct hda_pcm_stream *hinfo,
4588 struct hda_codec *codec,
4589 struct snd_pcm_substream *substream)
4591 struct hda_gen_spec *spec = codec->spec;
4592 return snd_hda_multi_out_dig_open(codec, &spec->multiout);
4595 static int dig_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
4596 struct hda_codec *codec,
4597 unsigned int stream_tag,
4598 unsigned int format,
4599 struct snd_pcm_substream *substream)
4601 struct hda_gen_spec *spec = codec->spec;
4602 return snd_hda_multi_out_dig_prepare(codec, &spec->multiout,
4603 stream_tag, format, substream);
4606 static int dig_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
4607 struct hda_codec *codec,
4608 struct snd_pcm_substream *substream)
4610 struct hda_gen_spec *spec = codec->spec;
4611 return snd_hda_multi_out_dig_cleanup(codec, &spec->multiout);
4614 static int dig_playback_pcm_close(struct hda_pcm_stream *hinfo,
4615 struct hda_codec *codec,
4616 struct snd_pcm_substream *substream)
4618 struct hda_gen_spec *spec = codec->spec;
4619 return snd_hda_multi_out_dig_close(codec, &spec->multiout);
4625 #define alt_capture_pcm_open capture_pcm_open
4626 #define alt_capture_pcm_close capture_pcm_close
4628 static int alt_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
4629 struct hda_codec *codec,
4630 unsigned int stream_tag,
4631 unsigned int format,
4632 struct snd_pcm_substream *substream)
4634 struct hda_gen_spec *spec = codec->spec;
4636 snd_hda_codec_setup_stream(codec, spec->adc_nids[substream->number + 1],
4637 stream_tag, 0, format);
4638 call_pcm_capture_hook(hinfo, codec, substream,
4639 HDA_GEN_PCM_ACT_PREPARE);
4643 static int alt_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
4644 struct hda_codec *codec,
4645 struct snd_pcm_substream *substream)
4647 struct hda_gen_spec *spec = codec->spec;
4649 snd_hda_codec_cleanup_stream(codec,
4650 spec->adc_nids[substream->number + 1]);
4651 call_pcm_capture_hook(hinfo, codec, substream,
4652 HDA_GEN_PCM_ACT_CLEANUP);
4658 static const struct hda_pcm_stream pcm_analog_playback = {
4662 /* NID is set in build_pcms */
4664 .open = playback_pcm_open,
4665 .close = playback_pcm_close,
4666 .prepare = playback_pcm_prepare,
4667 .cleanup = playback_pcm_cleanup
4671 static const struct hda_pcm_stream pcm_analog_capture = {
4675 /* NID is set in build_pcms */
4677 .open = capture_pcm_open,
4678 .close = capture_pcm_close,
4679 .prepare = capture_pcm_prepare,
4680 .cleanup = capture_pcm_cleanup
4684 static const struct hda_pcm_stream pcm_analog_alt_playback = {
4688 /* NID is set in build_pcms */
4690 .open = alt_playback_pcm_open,
4691 .close = alt_playback_pcm_close,
4692 .prepare = alt_playback_pcm_prepare,
4693 .cleanup = alt_playback_pcm_cleanup
4697 static const struct hda_pcm_stream pcm_analog_alt_capture = {
4698 .substreams = 2, /* can be overridden */
4701 /* NID is set in build_pcms */
4703 .open = alt_capture_pcm_open,
4704 .close = alt_capture_pcm_close,
4705 .prepare = alt_capture_pcm_prepare,
4706 .cleanup = alt_capture_pcm_cleanup
4710 static const struct hda_pcm_stream pcm_digital_playback = {
4714 /* NID is set in build_pcms */
4716 .open = dig_playback_pcm_open,
4717 .close = dig_playback_pcm_close,
4718 .prepare = dig_playback_pcm_prepare,
4719 .cleanup = dig_playback_pcm_cleanup
4723 static const struct hda_pcm_stream pcm_digital_capture = {
4727 /* NID is set in build_pcms */
4730 /* Used by build_pcms to flag that a PCM has no playback stream */
4731 static const struct hda_pcm_stream pcm_null_stream = {
4738 * dynamic changing ADC PCM streams
4740 static bool dyn_adc_pcm_resetup(struct hda_codec *codec, int cur)
4742 struct hda_gen_spec *spec = codec->spec;
4743 hda_nid_t new_adc = spec->adc_nids[spec->dyn_adc_idx[cur]];
4745 if (spec->cur_adc && spec->cur_adc != new_adc) {
4746 /* stream is running, let's swap the current ADC */
4747 __snd_hda_codec_cleanup_stream(codec, spec->cur_adc, 1);
4748 spec->cur_adc = new_adc;
4749 snd_hda_codec_setup_stream(codec, new_adc,
4750 spec->cur_adc_stream_tag, 0,
4751 spec->cur_adc_format);
4757 /* analog capture with dynamic dual-adc changes */
4758 static int dyn_adc_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
4759 struct hda_codec *codec,
4760 unsigned int stream_tag,
4761 unsigned int format,
4762 struct snd_pcm_substream *substream)
4764 struct hda_gen_spec *spec = codec->spec;
4765 spec->cur_adc = spec->adc_nids[spec->dyn_adc_idx[spec->cur_mux[0]]];
4766 spec->cur_adc_stream_tag = stream_tag;
4767 spec->cur_adc_format = format;
4768 snd_hda_codec_setup_stream(codec, spec->cur_adc, stream_tag, 0, format);
4772 static int dyn_adc_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
4773 struct hda_codec *codec,
4774 struct snd_pcm_substream *substream)
4776 struct hda_gen_spec *spec = codec->spec;
4777 snd_hda_codec_cleanup_stream(codec, spec->cur_adc);
4782 static const struct hda_pcm_stream dyn_adc_pcm_analog_capture = {
4786 .nid = 0, /* fill later */
4788 .prepare = dyn_adc_capture_pcm_prepare,
4789 .cleanup = dyn_adc_capture_pcm_cleanup
4793 static void fill_pcm_stream_name(char *str, size_t len, const char *sfx,
4794 const char *chip_name)
4800 strlcpy(str, chip_name, len);
4802 /* drop non-alnum chars after a space */
4803 for (p = strchr(str, ' '); p; p = strchr(p + 1, ' ')) {
4804 if (!isalnum(p[1])) {
4809 strlcat(str, sfx, len);
4812 /* build PCM streams based on the parsed results */
4813 int snd_hda_gen_build_pcms(struct hda_codec *codec)
4815 struct hda_gen_spec *spec = codec->spec;
4816 struct hda_pcm *info = spec->pcm_rec;
4817 const struct hda_pcm_stream *p;
4818 bool have_multi_adcs;
4820 codec->num_pcms = 1;
4821 codec->pcm_info = info;
4823 if (spec->no_analog)
4826 fill_pcm_stream_name(spec->stream_name_analog,
4827 sizeof(spec->stream_name_analog),
4828 " Analog", codec->chip_name);
4829 info->name = spec->stream_name_analog;
4831 if (spec->multiout.num_dacs > 0) {
4832 p = spec->stream_analog_playback;
4834 p = &pcm_analog_playback;
4835 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *p;
4836 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dac_nids[0];
4837 info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max =
4838 spec->multiout.max_channels;
4839 if (spec->autocfg.line_out_type == AUTO_PIN_SPEAKER_OUT &&
4840 spec->autocfg.line_outs == 2)
4841 info->stream[SNDRV_PCM_STREAM_PLAYBACK].chmap =
4844 if (spec->num_adc_nids) {
4845 p = spec->stream_analog_capture;
4847 if (spec->dyn_adc_switch)
4848 p = &dyn_adc_pcm_analog_capture;
4850 p = &pcm_analog_capture;
4852 info->stream[SNDRV_PCM_STREAM_CAPTURE] = *p;
4853 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adc_nids[0];
4857 /* SPDIF for stream index #1 */
4858 if (spec->multiout.dig_out_nid || spec->dig_in_nid) {
4859 fill_pcm_stream_name(spec->stream_name_digital,
4860 sizeof(spec->stream_name_digital),
4861 " Digital", codec->chip_name);
4862 codec->num_pcms = 2;
4863 codec->slave_dig_outs = spec->multiout.slave_dig_outs;
4864 info = spec->pcm_rec + 1;
4865 info->name = spec->stream_name_digital;
4866 if (spec->dig_out_type)
4867 info->pcm_type = spec->dig_out_type;
4869 info->pcm_type = HDA_PCM_TYPE_SPDIF;
4870 if (spec->multiout.dig_out_nid) {
4871 p = spec->stream_digital_playback;
4873 p = &pcm_digital_playback;
4874 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *p;
4875 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dig_out_nid;
4877 if (spec->dig_in_nid) {
4878 p = spec->stream_digital_capture;
4880 p = &pcm_digital_capture;
4881 info->stream[SNDRV_PCM_STREAM_CAPTURE] = *p;
4882 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->dig_in_nid;
4886 if (spec->no_analog)
4889 /* If the use of more than one ADC is requested for the current
4890 * model, configure a second analog capture-only PCM.
4892 have_multi_adcs = (spec->num_adc_nids > 1) &&
4893 !spec->dyn_adc_switch && !spec->auto_mic;
4894 /* Additional Analaog capture for index #2 */
4895 if (spec->alt_dac_nid || have_multi_adcs) {
4896 fill_pcm_stream_name(spec->stream_name_alt_analog,
4897 sizeof(spec->stream_name_alt_analog),
4898 " Alt Analog", codec->chip_name);
4899 codec->num_pcms = 3;
4900 info = spec->pcm_rec + 2;
4901 info->name = spec->stream_name_alt_analog;
4902 if (spec->alt_dac_nid) {
4903 p = spec->stream_analog_alt_playback;
4905 p = &pcm_analog_alt_playback;
4906 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *p;
4907 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid =
4910 info->stream[SNDRV_PCM_STREAM_PLAYBACK] =
4912 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = 0;
4914 if (have_multi_adcs) {
4915 p = spec->stream_analog_alt_capture;
4917 p = &pcm_analog_alt_capture;
4918 info->stream[SNDRV_PCM_STREAM_CAPTURE] = *p;
4919 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid =
4921 info->stream[SNDRV_PCM_STREAM_CAPTURE].substreams =
4922 spec->num_adc_nids - 1;
4924 info->stream[SNDRV_PCM_STREAM_CAPTURE] =
4926 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = 0;
4932 EXPORT_SYMBOL_HDA(snd_hda_gen_build_pcms);
4936 * Standard auto-parser initializations
4939 /* configure the given path as a proper output */
4940 static void set_output_and_unmute(struct hda_codec *codec, int path_idx)
4942 struct nid_path *path;
4945 path = snd_hda_get_path_from_idx(codec, path_idx);
4946 if (!path || !path->depth)
4948 pin = path->path[path->depth - 1];
4949 restore_pin_ctl(codec, pin);
4950 snd_hda_activate_path(codec, path, path->active,
4951 aamix_default(codec->spec));
4952 set_pin_eapd(codec, pin, path->active);
4955 /* initialize primary output paths */
4956 static void init_multi_out(struct hda_codec *codec)
4958 struct hda_gen_spec *spec = codec->spec;
4961 for (i = 0; i < spec->autocfg.line_outs; i++)
4962 set_output_and_unmute(codec, spec->out_paths[i]);
4966 static void __init_extra_out(struct hda_codec *codec, int num_outs, int *paths)
4970 for (i = 0; i < num_outs; i++)
4971 set_output_and_unmute(codec, paths[i]);
4974 /* initialize hp and speaker paths */
4975 static void init_extra_out(struct hda_codec *codec)
4977 struct hda_gen_spec *spec = codec->spec;
4979 if (spec->autocfg.line_out_type != AUTO_PIN_HP_OUT)
4980 __init_extra_out(codec, spec->autocfg.hp_outs, spec->hp_paths);
4981 if (spec->autocfg.line_out_type != AUTO_PIN_SPEAKER_OUT)
4982 __init_extra_out(codec, spec->autocfg.speaker_outs,
4983 spec->speaker_paths);
4986 /* initialize multi-io paths */
4987 static void init_multi_io(struct hda_codec *codec)
4989 struct hda_gen_spec *spec = codec->spec;
4992 for (i = 0; i < spec->multi_ios; i++) {
4993 hda_nid_t pin = spec->multi_io[i].pin;
4994 struct nid_path *path;
4995 path = get_multiio_path(codec, i);
4998 if (!spec->multi_io[i].ctl_in)
4999 spec->multi_io[i].ctl_in =
5000 snd_hda_codec_get_pin_target(codec, pin);
5001 snd_hda_activate_path(codec, path, path->active,
5002 aamix_default(spec));
5006 /* set up input pins and loopback paths */
5007 static void init_analog_input(struct hda_codec *codec)
5009 struct hda_gen_spec *spec = codec->spec;
5010 struct auto_pin_cfg *cfg = &spec->autocfg;
5013 for (i = 0; i < cfg->num_inputs; i++) {
5014 hda_nid_t nid = cfg->inputs[i].pin;
5015 if (is_input_pin(codec, nid))
5016 restore_pin_ctl(codec, nid);
5018 /* init loopback inputs */
5019 if (spec->mixer_nid) {
5020 resume_path_from_idx(codec, spec->loopback_paths[i]);
5021 resume_path_from_idx(codec, spec->loopback_merge_path);
5026 /* initialize ADC paths */
5027 static void init_input_src(struct hda_codec *codec)
5029 struct hda_gen_spec *spec = codec->spec;
5030 struct hda_input_mux *imux = &spec->input_mux;
5031 struct nid_path *path;
5034 if (spec->dyn_adc_switch)
5037 nums = spec->num_adc_nids;
5039 for (c = 0; c < nums; c++) {
5040 for (i = 0; i < imux->num_items; i++) {
5041 path = get_input_path(codec, c, i);
5043 bool active = path->active;
5044 if (i == spec->cur_mux[c])
5046 snd_hda_activate_path(codec, path, active, false);
5050 update_hp_mic(codec, c, true);
5053 if (spec->cap_sync_hook)
5054 spec->cap_sync_hook(codec, NULL);
5057 /* set right pin controls for digital I/O */
5058 static void init_digital(struct hda_codec *codec)
5060 struct hda_gen_spec *spec = codec->spec;
5064 for (i = 0; i < spec->autocfg.dig_outs; i++)
5065 set_output_and_unmute(codec, spec->digout_paths[i]);
5066 pin = spec->autocfg.dig_in_pin;
5068 restore_pin_ctl(codec, pin);
5069 resume_path_from_idx(codec, spec->digin_path);
5073 /* clear unsol-event tags on unused pins; Conexant codecs seem to leave
5074 * invalid unsol tags by some reason
5076 static void clear_unsol_on_unused_pins(struct hda_codec *codec)
5080 for (i = 0; i < codec->init_pins.used; i++) {
5081 struct hda_pincfg *pin = snd_array_elem(&codec->init_pins, i);
5082 hda_nid_t nid = pin->nid;
5083 if (is_jack_detectable(codec, nid) &&
5084 !snd_hda_jack_tbl_get(codec, nid))
5085 snd_hda_codec_update_cache(codec, nid, 0,
5086 AC_VERB_SET_UNSOLICITED_ENABLE, 0);
5091 * initialize the generic spec;
5092 * this can be put as patch_ops.init function
5094 int snd_hda_gen_init(struct hda_codec *codec)
5096 struct hda_gen_spec *spec = codec->spec;
5098 if (spec->init_hook)
5099 spec->init_hook(codec);
5101 snd_hda_apply_verbs(codec);
5103 codec->cached_write = 1;
5105 init_multi_out(codec);
5106 init_extra_out(codec);
5107 init_multi_io(codec);
5108 init_analog_input(codec);
5109 init_input_src(codec);
5110 init_digital(codec);
5112 clear_unsol_on_unused_pins(codec);
5114 /* call init functions of standard auto-mute helpers */
5115 update_automute_all(codec);
5117 snd_hda_codec_flush_cache(codec);
5119 if (spec->vmaster_mute.sw_kctl && spec->vmaster_mute.hook)
5120 snd_hda_sync_vmaster_hook(&spec->vmaster_mute);
5122 hda_call_check_power_status(codec, 0x01);
5125 EXPORT_SYMBOL_HDA(snd_hda_gen_init);
5128 * free the generic spec;
5129 * this can be put as patch_ops.free function
5131 void snd_hda_gen_free(struct hda_codec *codec)
5133 snd_hda_detach_beep_device(codec);
5134 snd_hda_gen_spec_free(codec->spec);
5138 EXPORT_SYMBOL_HDA(snd_hda_gen_free);
5142 * check the loopback power save state;
5143 * this can be put as patch_ops.check_power_status function
5145 int snd_hda_gen_check_power_status(struct hda_codec *codec, hda_nid_t nid)
5147 struct hda_gen_spec *spec = codec->spec;
5148 return snd_hda_check_amp_list_power(codec, &spec->loopback, nid);
5150 EXPORT_SYMBOL_HDA(snd_hda_gen_check_power_status);
5155 * the generic codec support
5158 static const struct hda_codec_ops generic_patch_ops = {
5159 .build_controls = snd_hda_gen_build_controls,
5160 .build_pcms = snd_hda_gen_build_pcms,
5161 .init = snd_hda_gen_init,
5162 .free = snd_hda_gen_free,
5163 .unsol_event = snd_hda_jack_unsol_event,
5165 .check_power_status = snd_hda_gen_check_power_status,
5169 int snd_hda_parse_generic_codec(struct hda_codec *codec)
5171 struct hda_gen_spec *spec;
5174 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
5177 snd_hda_gen_spec_init(spec);
5180 err = snd_hda_parse_pin_defcfg(codec, &spec->autocfg, NULL, 0);
5184 err = snd_hda_gen_parse_auto_config(codec, &spec->autocfg);
5188 codec->patch_ops = generic_patch_ops;
5192 snd_hda_gen_free(codec);
5195 EXPORT_SYMBOL_HDA(snd_hda_parse_generic_codec);