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 /* return a DAC if paired to the given pin by codec driver */
472 static hda_nid_t get_preferred_dac(struct hda_codec *codec, hda_nid_t pin)
474 struct hda_gen_spec *spec = codec->spec;
475 const hda_nid_t *list = spec->preferred_dacs;
479 for (; *list; list += 2)
485 /* look for an empty DAC slot */
486 static hda_nid_t look_for_dac(struct hda_codec *codec, hda_nid_t pin,
489 struct hda_gen_spec *spec = codec->spec;
493 for (i = 0; i < spec->num_all_dacs; i++) {
494 hda_nid_t nid = spec->all_dacs[i];
495 if (!nid || is_dac_already_used(codec, nid))
497 cap_digital = !!(get_wcaps(codec, nid) & AC_WCAP_DIGITAL);
498 if (is_digital != cap_digital)
500 if (is_reachable_path(codec, nid, pin))
506 /* replace the channels in the composed amp value with the given number */
507 static unsigned int amp_val_replace_channels(unsigned int val, unsigned int chs)
509 val &= ~(0x3U << 16);
514 /* check whether the widget has the given amp capability for the direction */
515 static bool check_amp_caps(struct hda_codec *codec, hda_nid_t nid,
516 int dir, unsigned int bits)
520 if (get_wcaps(codec, nid) & (1 << (dir + 1)))
521 if (query_amp_caps(codec, nid, dir) & bits)
526 static bool same_amp_caps(struct hda_codec *codec, hda_nid_t nid1,
527 hda_nid_t nid2, int dir)
529 if (!(get_wcaps(codec, nid1) & (1 << (dir + 1))))
530 return !(get_wcaps(codec, nid2) & (1 << (dir + 1)));
531 return (query_amp_caps(codec, nid1, dir) ==
532 query_amp_caps(codec, nid2, dir));
535 #define nid_has_mute(codec, nid, dir) \
536 check_amp_caps(codec, nid, dir, (AC_AMPCAP_MUTE | AC_AMPCAP_MIN_MUTE))
537 #define nid_has_volume(codec, nid, dir) \
538 check_amp_caps(codec, nid, dir, AC_AMPCAP_NUM_STEPS)
540 /* look for a widget suitable for assigning a mute switch in the path */
541 static hda_nid_t look_for_out_mute_nid(struct hda_codec *codec,
542 struct nid_path *path)
546 for (i = path->depth - 1; i >= 0; i--) {
547 if (nid_has_mute(codec, path->path[i], HDA_OUTPUT))
548 return path->path[i];
549 if (i != path->depth - 1 && i != 0 &&
550 nid_has_mute(codec, path->path[i], HDA_INPUT))
551 return path->path[i];
556 /* look for a widget suitable for assigning a volume ctl in the path */
557 static hda_nid_t look_for_out_vol_nid(struct hda_codec *codec,
558 struct nid_path *path)
562 for (i = path->depth - 1; i >= 0; i--) {
563 if (nid_has_volume(codec, path->path[i], HDA_OUTPUT))
564 return path->path[i];
570 * path activation / deactivation
573 /* can have the amp-in capability? */
574 static bool has_amp_in(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_IN_AMP))
582 if (type == AC_WID_PIN && idx > 0) /* only for input pins */
587 /* can have the amp-out capability? */
588 static bool has_amp_out(struct hda_codec *codec, struct nid_path *path, int idx)
590 hda_nid_t nid = path->path[idx];
591 unsigned int caps = get_wcaps(codec, nid);
592 unsigned int type = get_wcaps_type(caps);
594 if (!(caps & AC_WCAP_OUT_AMP))
596 if (type == AC_WID_PIN && !idx) /* only for output pins */
601 /* check whether the given (nid,dir,idx) is active */
602 static bool is_active_nid(struct hda_codec *codec, hda_nid_t nid,
603 unsigned int dir, unsigned int idx)
605 struct hda_gen_spec *spec = codec->spec;
608 for (n = 0; n < spec->paths.used; n++) {
609 struct nid_path *path = snd_array_elem(&spec->paths, n);
612 for (i = 0; i < path->depth; i++) {
613 if (path->path[i] == nid) {
614 if (dir == HDA_OUTPUT || path->idx[i] == idx)
623 /* check whether the NID is referred by any active paths */
624 #define is_active_nid_for_any(codec, nid) \
625 is_active_nid(codec, nid, HDA_OUTPUT, 0)
627 /* get the default amp value for the target state */
628 static int get_amp_val_to_activate(struct hda_codec *codec, hda_nid_t nid,
629 int dir, unsigned int caps, bool enable)
631 unsigned int val = 0;
633 if (caps & AC_AMPCAP_NUM_STEPS) {
636 val = (caps & AC_AMPCAP_OFFSET) >> AC_AMPCAP_OFFSET_SHIFT;
638 if (caps & (AC_AMPCAP_MUTE | AC_AMPCAP_MIN_MUTE)) {
645 /* initialize the amp value (only at the first time) */
646 static void init_amp(struct hda_codec *codec, hda_nid_t nid, int dir, int idx)
648 unsigned int caps = query_amp_caps(codec, nid, dir);
649 int val = get_amp_val_to_activate(codec, nid, dir, caps, false);
650 snd_hda_codec_amp_init_stereo(codec, nid, dir, idx, 0xff, val);
653 /* calculate amp value mask we can modify;
654 * if the given amp is controlled by mixers, don't touch it
656 static unsigned int get_amp_mask_to_modify(struct hda_codec *codec,
657 hda_nid_t nid, int dir, int idx,
660 unsigned int mask = 0xff;
662 if (caps & (AC_AMPCAP_MUTE | AC_AMPCAP_MIN_MUTE)) {
663 if (is_ctl_associated(codec, nid, dir, idx, NID_PATH_MUTE_CTL))
666 if (caps & AC_AMPCAP_NUM_STEPS) {
667 if (is_ctl_associated(codec, nid, dir, idx, NID_PATH_VOL_CTL) ||
668 is_ctl_associated(codec, nid, dir, idx, NID_PATH_BOOST_CTL))
674 static void activate_amp(struct hda_codec *codec, hda_nid_t nid, int dir,
675 int idx, int idx_to_check, bool enable)
678 unsigned int mask, val;
680 if (!enable && is_active_nid(codec, nid, dir, idx_to_check))
683 caps = query_amp_caps(codec, nid, dir);
684 val = get_amp_val_to_activate(codec, nid, dir, caps, enable);
685 mask = get_amp_mask_to_modify(codec, nid, dir, idx_to_check, caps);
690 snd_hda_codec_amp_stereo(codec, nid, dir, idx, mask, val);
693 static void activate_amp_out(struct hda_codec *codec, struct nid_path *path,
696 hda_nid_t nid = path->path[i];
697 init_amp(codec, nid, HDA_OUTPUT, 0);
698 activate_amp(codec, nid, HDA_OUTPUT, 0, 0, enable);
701 static void activate_amp_in(struct hda_codec *codec, struct nid_path *path,
702 int i, bool enable, bool add_aamix)
704 struct hda_gen_spec *spec = codec->spec;
705 const hda_nid_t *conn;
708 hda_nid_t nid = path->path[i];
710 nums = snd_hda_get_conn_list(codec, nid, &conn);
711 type = get_wcaps_type(get_wcaps(codec, nid));
712 if (type == AC_WID_PIN ||
713 (type == AC_WID_AUD_IN && codec->single_adc_amp)) {
719 for (n = 0; n < nums; n++)
720 init_amp(codec, nid, HDA_INPUT, n);
722 /* here is a little bit tricky in comparison with activate_amp_out();
723 * when aa-mixer is available, we need to enable the path as well
725 for (n = 0; n < nums; n++) {
726 if (n != idx && (!add_aamix || conn[n] != spec->mixer_merge_nid))
728 activate_amp(codec, nid, HDA_INPUT, n, idx, enable);
732 /* activate or deactivate the given path
733 * if @add_aamix is set, enable the input from aa-mix NID as well (if any)
735 void snd_hda_activate_path(struct hda_codec *codec, struct nid_path *path,
736 bool enable, bool add_aamix)
738 struct hda_gen_spec *spec = codec->spec;
742 path->active = false;
744 for (i = path->depth - 1; i >= 0; i--) {
745 hda_nid_t nid = path->path[i];
746 if (enable && spec->power_down_unused) {
747 /* make sure the widget is powered up */
748 if (!snd_hda_check_power_state(codec, nid, AC_PWRST_D0))
749 snd_hda_codec_write(codec, nid, 0,
750 AC_VERB_SET_POWER_STATE,
753 if (enable && path->multi[i])
754 snd_hda_codec_write_cache(codec, nid, 0,
755 AC_VERB_SET_CONNECT_SEL,
757 if (has_amp_in(codec, path, i))
758 activate_amp_in(codec, path, i, enable, add_aamix);
759 if (has_amp_out(codec, path, i))
760 activate_amp_out(codec, path, i, enable);
766 EXPORT_SYMBOL_HDA(snd_hda_activate_path);
768 /* if the given path is inactive, put widgets into D3 (only if suitable) */
769 static void path_power_down_sync(struct hda_codec *codec, struct nid_path *path)
771 struct hda_gen_spec *spec = codec->spec;
772 bool changed = false;
775 if (!spec->power_down_unused || path->active)
778 for (i = 0; i < path->depth; i++) {
779 hda_nid_t nid = path->path[i];
780 if (!snd_hda_check_power_state(codec, nid, AC_PWRST_D3) &&
781 !is_active_nid_for_any(codec, nid)) {
782 snd_hda_codec_write(codec, nid, 0,
783 AC_VERB_SET_POWER_STATE,
791 snd_hda_codec_read(codec, path->path[0], 0,
792 AC_VERB_GET_POWER_STATE, 0);
796 /* turn on/off EAPD on the given pin */
797 static void set_pin_eapd(struct hda_codec *codec, hda_nid_t pin, bool enable)
799 struct hda_gen_spec *spec = codec->spec;
800 if (spec->own_eapd_ctl ||
801 !(snd_hda_query_pin_caps(codec, pin) & AC_PINCAP_EAPD))
803 if (spec->keep_eapd_on && !enable)
807 snd_hda_codec_update_cache(codec, pin, 0,
808 AC_VERB_SET_EAPD_BTLENABLE,
809 enable ? 0x02 : 0x00);
812 /* re-initialize the path specified by the given path index */
813 static void resume_path_from_idx(struct hda_codec *codec, int path_idx)
815 struct nid_path *path = snd_hda_get_path_from_idx(codec, path_idx);
817 snd_hda_activate_path(codec, path, path->active, false);
822 * Helper functions for creating mixer ctl elements
830 static const struct snd_kcontrol_new control_templates[] = {
831 HDA_CODEC_VOLUME(NULL, 0, 0, 0),
832 HDA_CODEC_MUTE(NULL, 0, 0, 0),
833 HDA_BIND_MUTE(NULL, 0, 0, 0),
836 /* add dynamic controls from template */
837 static struct snd_kcontrol_new *
838 add_control(struct hda_gen_spec *spec, int type, const char *name,
839 int cidx, unsigned long val)
841 struct snd_kcontrol_new *knew;
843 knew = snd_hda_gen_add_kctl(spec, name, &control_templates[type]);
847 if (get_amp_nid_(val))
848 knew->subdevice = HDA_SUBDEV_AMP_FLAG;
849 knew->private_value = val;
853 static int add_control_with_pfx(struct hda_gen_spec *spec, int type,
854 const char *pfx, const char *dir,
855 const char *sfx, int cidx, unsigned long val)
858 snprintf(name, sizeof(name), "%s %s %s", pfx, dir, sfx);
859 if (!add_control(spec, type, name, cidx, val))
864 #define add_pb_vol_ctrl(spec, type, pfx, val) \
865 add_control_with_pfx(spec, type, pfx, "Playback", "Volume", 0, val)
866 #define add_pb_sw_ctrl(spec, type, pfx, val) \
867 add_control_with_pfx(spec, type, pfx, "Playback", "Switch", 0, val)
868 #define __add_pb_vol_ctrl(spec, type, pfx, cidx, val) \
869 add_control_with_pfx(spec, type, pfx, "Playback", "Volume", cidx, val)
870 #define __add_pb_sw_ctrl(spec, type, pfx, cidx, val) \
871 add_control_with_pfx(spec, type, pfx, "Playback", "Switch", cidx, val)
873 static int add_vol_ctl(struct hda_codec *codec, const char *pfx, int cidx,
874 unsigned int chs, struct nid_path *path)
879 val = path->ctls[NID_PATH_VOL_CTL];
882 val = amp_val_replace_channels(val, chs);
883 return __add_pb_vol_ctrl(codec->spec, HDA_CTL_WIDGET_VOL, pfx, cidx, val);
886 /* return the channel bits suitable for the given path->ctls[] */
887 static int get_default_ch_nums(struct hda_codec *codec, struct nid_path *path,
890 int chs = 1; /* mono (left only) */
892 hda_nid_t nid = get_amp_nid_(path->ctls[type]);
893 if (nid && (get_wcaps(codec, nid) & AC_WCAP_STEREO))
894 chs = 3; /* stereo */
899 static int add_stereo_vol(struct hda_codec *codec, const char *pfx, int cidx,
900 struct nid_path *path)
902 int chs = get_default_ch_nums(codec, path, NID_PATH_VOL_CTL);
903 return add_vol_ctl(codec, pfx, cidx, chs, path);
906 /* create a mute-switch for the given mixer widget;
907 * if it has multiple sources (e.g. DAC and loopback), create a bind-mute
909 static int add_sw_ctl(struct hda_codec *codec, const char *pfx, int cidx,
910 unsigned int chs, struct nid_path *path)
913 int type = HDA_CTL_WIDGET_MUTE;
917 val = path->ctls[NID_PATH_MUTE_CTL];
920 val = amp_val_replace_channels(val, chs);
921 if (get_amp_direction_(val) == HDA_INPUT) {
922 hda_nid_t nid = get_amp_nid_(val);
923 int nums = snd_hda_get_num_conns(codec, nid);
925 type = HDA_CTL_BIND_MUTE;
929 return __add_pb_sw_ctrl(codec->spec, type, pfx, cidx, val);
932 static int add_stereo_sw(struct hda_codec *codec, const char *pfx,
933 int cidx, struct nid_path *path)
935 int chs = get_default_ch_nums(codec, path, NID_PATH_MUTE_CTL);
936 return add_sw_ctl(codec, pfx, cidx, chs, path);
939 /* any ctl assigned to the path with the given index? */
940 static bool path_has_mixer(struct hda_codec *codec, int path_idx, int ctl_type)
942 struct nid_path *path = snd_hda_get_path_from_idx(codec, path_idx);
943 return path && path->ctls[ctl_type];
946 static const char * const channel_name[4] = {
947 "Front", "Surround", "CLFE", "Side"
950 /* give some appropriate ctl name prefix for the given line out channel */
951 static const char *get_line_out_pfx(struct hda_codec *codec, int ch,
952 int *index, int ctl_type)
954 struct hda_gen_spec *spec = codec->spec;
955 struct auto_pin_cfg *cfg = &spec->autocfg;
958 if (cfg->line_outs == 1 && !spec->multi_ios &&
959 !cfg->hp_outs && !cfg->speaker_outs)
960 return spec->vmaster_mute.hook ? "PCM" : "Master";
962 /* if there is really a single DAC used in the whole output paths,
963 * use it master (or "PCM" if a vmaster hook is present)
965 if (spec->multiout.num_dacs == 1 && !spec->mixer_nid &&
966 !spec->multiout.hp_out_nid[0] && !spec->multiout.extra_out_nid[0])
967 return spec->vmaster_mute.hook ? "PCM" : "Master";
969 /* multi-io channels */
970 if (ch >= cfg->line_outs)
971 return channel_name[ch];
973 switch (cfg->line_out_type) {
974 case AUTO_PIN_SPEAKER_OUT:
975 /* if the primary channel vol/mute is shared with HP volume,
976 * don't name it as Speaker
978 if (!ch && cfg->hp_outs &&
979 !path_has_mixer(codec, spec->hp_paths[0], ctl_type))
981 if (cfg->line_outs == 1)
983 if (cfg->line_outs == 2)
984 return ch ? "Bass Speaker" : "Speaker";
986 case AUTO_PIN_HP_OUT:
987 /* if the primary channel vol/mute is shared with spk volume,
988 * don't name it as Headphone
990 if (!ch && cfg->speaker_outs &&
991 !path_has_mixer(codec, spec->speaker_paths[0], ctl_type))
993 /* for multi-io case, only the primary out */
994 if (ch && spec->multi_ios)
1000 /* for a single channel output, we don't have to name the channel */
1001 if (cfg->line_outs == 1 && !spec->multi_ios)
1004 if (ch >= ARRAY_SIZE(channel_name)) {
1009 return channel_name[ch];
1013 * Parse output paths
1016 /* badness definition */
1018 /* No primary DAC is found for the main output */
1019 BAD_NO_PRIMARY_DAC = 0x10000,
1020 /* No DAC is found for the extra output */
1021 BAD_NO_DAC = 0x4000,
1022 /* No possible multi-ios */
1023 BAD_MULTI_IO = 0x120,
1024 /* No individual DAC for extra output */
1025 BAD_NO_EXTRA_DAC = 0x102,
1026 /* No individual DAC for extra surrounds */
1027 BAD_NO_EXTRA_SURR_DAC = 0x101,
1028 /* Primary DAC shared with main surrounds */
1029 BAD_SHARED_SURROUND = 0x100,
1030 /* No independent HP possible */
1031 BAD_NO_INDEP_HP = 0x10,
1032 /* Primary DAC shared with main CLFE */
1033 BAD_SHARED_CLFE = 0x10,
1034 /* Primary DAC shared with extra surrounds */
1035 BAD_SHARED_EXTRA_SURROUND = 0x10,
1036 /* Volume widget is shared */
1037 BAD_SHARED_VOL = 0x10,
1040 /* look for widgets in the given path which are appropriate for
1041 * volume and mute controls, and assign the values to ctls[].
1043 * When no appropriate widget is found in the path, the badness value
1044 * is incremented depending on the situation. The function returns the
1045 * total badness for both volume and mute controls.
1047 static int assign_out_path_ctls(struct hda_codec *codec, struct nid_path *path)
1054 return BAD_SHARED_VOL * 2;
1056 if (path->ctls[NID_PATH_VOL_CTL] ||
1057 path->ctls[NID_PATH_MUTE_CTL])
1058 return 0; /* already evaluated */
1060 nid = look_for_out_vol_nid(codec, path);
1062 val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
1063 if (is_ctl_used(codec, val, NID_PATH_VOL_CTL))
1064 badness += BAD_SHARED_VOL;
1066 path->ctls[NID_PATH_VOL_CTL] = val;
1068 badness += BAD_SHARED_VOL;
1069 nid = look_for_out_mute_nid(codec, path);
1071 unsigned int wid_type = get_wcaps_type(get_wcaps(codec, nid));
1072 if (wid_type == AC_WID_PIN || wid_type == AC_WID_AUD_OUT ||
1073 nid_has_mute(codec, nid, HDA_OUTPUT))
1074 val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
1076 val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT);
1077 if (is_ctl_used(codec, val, NID_PATH_MUTE_CTL))
1078 badness += BAD_SHARED_VOL;
1080 path->ctls[NID_PATH_MUTE_CTL] = val;
1082 badness += BAD_SHARED_VOL;
1086 const struct badness_table hda_main_out_badness = {
1087 .no_primary_dac = BAD_NO_PRIMARY_DAC,
1088 .no_dac = BAD_NO_DAC,
1089 .shared_primary = BAD_NO_PRIMARY_DAC,
1090 .shared_surr = BAD_SHARED_SURROUND,
1091 .shared_clfe = BAD_SHARED_CLFE,
1092 .shared_surr_main = BAD_SHARED_SURROUND,
1094 EXPORT_SYMBOL_HDA(hda_main_out_badness);
1096 const struct badness_table hda_extra_out_badness = {
1097 .no_primary_dac = BAD_NO_DAC,
1098 .no_dac = BAD_NO_DAC,
1099 .shared_primary = BAD_NO_EXTRA_DAC,
1100 .shared_surr = BAD_SHARED_EXTRA_SURROUND,
1101 .shared_clfe = BAD_SHARED_EXTRA_SURROUND,
1102 .shared_surr_main = BAD_NO_EXTRA_SURR_DAC,
1104 EXPORT_SYMBOL_HDA(hda_extra_out_badness);
1106 /* get the DAC of the primary output corresponding to the given array index */
1107 static hda_nid_t get_primary_out(struct hda_codec *codec, int idx)
1109 struct hda_gen_spec *spec = codec->spec;
1110 struct auto_pin_cfg *cfg = &spec->autocfg;
1112 if (cfg->line_outs > idx)
1113 return spec->private_dac_nids[idx];
1114 idx -= cfg->line_outs;
1115 if (spec->multi_ios > idx)
1116 return spec->multi_io[idx].dac;
1120 /* return the DAC if it's reachable, otherwise zero */
1121 static inline hda_nid_t try_dac(struct hda_codec *codec,
1122 hda_nid_t dac, hda_nid_t pin)
1124 return is_reachable_path(codec, dac, pin) ? dac : 0;
1127 /* try to assign DACs to pins and return the resultant badness */
1128 static int try_assign_dacs(struct hda_codec *codec, int num_outs,
1129 const hda_nid_t *pins, hda_nid_t *dacs,
1131 const struct badness_table *bad)
1133 struct hda_gen_spec *spec = codec->spec;
1141 for (i = 0; i < num_outs; i++) {
1142 struct nid_path *path;
1143 hda_nid_t pin = pins[i];
1145 path = snd_hda_get_path_from_idx(codec, path_idx[i]);
1147 badness += assign_out_path_ctls(codec, path);
1151 dacs[i] = get_preferred_dac(codec, pin);
1153 if (is_dac_already_used(codec, dacs[i]))
1154 badness += bad->shared_primary;
1158 dacs[i] = look_for_dac(codec, pin, false);
1159 if (!dacs[i] && !i) {
1160 /* try to steal the DAC of surrounds for the front */
1161 for (j = 1; j < num_outs; j++) {
1162 if (is_reachable_path(codec, dacs[j], pin)) {
1165 invalidate_nid_path(codec, path_idx[j]);
1174 dac = try_dac(codec, get_primary_out(codec, i), pin);
1176 dac = try_dac(codec, dacs[0], pin);
1178 dac = try_dac(codec, get_primary_out(codec, i), pin);
1181 badness += bad->shared_primary;
1183 badness += bad->shared_surr;
1185 badness += bad->shared_clfe;
1186 } else if (is_reachable_path(codec, spec->private_dac_nids[0], pin)) {
1187 dac = spec->private_dac_nids[0];
1188 badness += bad->shared_surr_main;
1190 badness += bad->no_primary_dac;
1192 badness += bad->no_dac;
1196 path = snd_hda_add_new_path(codec, dac, pin, -spec->mixer_nid);
1197 if (!path && !i && spec->mixer_nid) {
1198 /* try with aamix */
1199 path = snd_hda_add_new_path(codec, dac, pin, 0);
1203 badness += bad->no_dac;
1205 /* print_nid_path("output", path); */
1206 path->active = true;
1207 path_idx[i] = snd_hda_get_path_idx(codec, path);
1208 badness += assign_out_path_ctls(codec, path);
1215 /* return NID if the given pin has only a single connection to a certain DAC */
1216 static hda_nid_t get_dac_if_single(struct hda_codec *codec, hda_nid_t pin)
1218 struct hda_gen_spec *spec = codec->spec;
1220 hda_nid_t nid_found = 0;
1222 for (i = 0; i < spec->num_all_dacs; i++) {
1223 hda_nid_t nid = spec->all_dacs[i];
1224 if (!nid || is_dac_already_used(codec, nid))
1226 if (is_reachable_path(codec, nid, pin)) {
1235 /* check whether the given pin can be a multi-io pin */
1236 static bool can_be_multiio_pin(struct hda_codec *codec,
1237 unsigned int location, hda_nid_t nid)
1239 unsigned int defcfg, caps;
1241 defcfg = snd_hda_codec_get_pincfg(codec, nid);
1242 if (get_defcfg_connect(defcfg) != AC_JACK_PORT_COMPLEX)
1244 if (location && get_defcfg_location(defcfg) != location)
1246 caps = snd_hda_query_pin_caps(codec, nid);
1247 if (!(caps & AC_PINCAP_OUT))
1252 /* count the number of input pins that are capable to be multi-io */
1253 static int count_multiio_pins(struct hda_codec *codec, hda_nid_t reference_pin)
1255 struct hda_gen_spec *spec = codec->spec;
1256 struct auto_pin_cfg *cfg = &spec->autocfg;
1257 unsigned int defcfg = snd_hda_codec_get_pincfg(codec, reference_pin);
1258 unsigned int location = get_defcfg_location(defcfg);
1262 for (type = AUTO_PIN_LINE_IN; type >= AUTO_PIN_MIC; type--) {
1263 for (i = 0; i < cfg->num_inputs; i++) {
1264 if (cfg->inputs[i].type != type)
1266 if (can_be_multiio_pin(codec, location,
1267 cfg->inputs[i].pin))
1277 * When hardwired is set, try to fill ony hardwired pins, and returns
1278 * zero if any pins are filled, non-zero if nothing found.
1279 * When hardwired is off, try to fill possible input pins, and returns
1280 * the badness value.
1282 static int fill_multi_ios(struct hda_codec *codec,
1283 hda_nid_t reference_pin,
1286 struct hda_gen_spec *spec = codec->spec;
1287 struct auto_pin_cfg *cfg = &spec->autocfg;
1288 int type, i, j, num_pins, old_pins;
1289 unsigned int defcfg = snd_hda_codec_get_pincfg(codec, reference_pin);
1290 unsigned int location = get_defcfg_location(defcfg);
1292 struct nid_path *path;
1294 old_pins = spec->multi_ios;
1298 num_pins = count_multiio_pins(codec, reference_pin);
1302 for (type = AUTO_PIN_LINE_IN; type >= AUTO_PIN_MIC; type--) {
1303 for (i = 0; i < cfg->num_inputs; i++) {
1304 hda_nid_t nid = cfg->inputs[i].pin;
1307 if (cfg->inputs[i].type != type)
1309 if (!can_be_multiio_pin(codec, location, nid))
1311 for (j = 0; j < spec->multi_ios; j++) {
1312 if (nid == spec->multi_io[j].pin)
1315 if (j < spec->multi_ios)
1319 dac = get_dac_if_single(codec, nid);
1321 dac = look_for_dac(codec, nid, false);
1326 path = snd_hda_add_new_path(codec, dac, nid,
1332 /* print_nid_path("multiio", path); */
1333 spec->multi_io[spec->multi_ios].pin = nid;
1334 spec->multi_io[spec->multi_ios].dac = dac;
1335 spec->out_paths[cfg->line_outs + spec->multi_ios] =
1336 snd_hda_get_path_idx(codec, path);
1338 if (spec->multi_ios >= 2)
1344 badness = BAD_MULTI_IO;
1345 if (old_pins == spec->multi_ios) {
1347 return 1; /* nothing found */
1349 return badness; /* no badness if nothing found */
1351 if (!hardwired && spec->multi_ios < 2) {
1352 /* cancel newly assigned paths */
1353 spec->paths.used -= spec->multi_ios - old_pins;
1354 spec->multi_ios = old_pins;
1358 /* assign volume and mute controls */
1359 for (i = old_pins; i < spec->multi_ios; i++) {
1360 path = snd_hda_get_path_from_idx(codec, spec->out_paths[cfg->line_outs + i]);
1361 badness += assign_out_path_ctls(codec, path);
1367 /* map DACs for all pins in the list if they are single connections */
1368 static bool map_singles(struct hda_codec *codec, int outs,
1369 const hda_nid_t *pins, hda_nid_t *dacs, int *path_idx)
1371 struct hda_gen_spec *spec = codec->spec;
1374 for (i = 0; i < outs; i++) {
1375 struct nid_path *path;
1379 dac = get_dac_if_single(codec, pins[i]);
1382 path = snd_hda_add_new_path(codec, dac, pins[i],
1384 if (!path && !i && spec->mixer_nid)
1385 path = snd_hda_add_new_path(codec, dac, pins[i], 0);
1389 /* print_nid_path("output", path); */
1390 path->active = true;
1391 path_idx[i] = snd_hda_get_path_idx(codec, path);
1397 /* create a new path including aamix if available, and return its index */
1398 static int check_aamix_out_path(struct hda_codec *codec, int path_idx)
1400 struct hda_gen_spec *spec = codec->spec;
1401 struct nid_path *path;
1402 hda_nid_t path_dac, dac, pin;
1404 path = snd_hda_get_path_from_idx(codec, path_idx);
1405 if (!path || !path->depth ||
1406 is_nid_contained(path, spec->mixer_nid))
1408 path_dac = path->path[0];
1409 dac = spec->private_dac_nids[0];
1410 pin = path->path[path->depth - 1];
1411 path = snd_hda_add_new_path(codec, dac, pin, spec->mixer_nid);
1413 if (dac != path_dac)
1415 else if (spec->multiout.hp_out_nid[0])
1416 dac = spec->multiout.hp_out_nid[0];
1417 else if (spec->multiout.extra_out_nid[0])
1418 dac = spec->multiout.extra_out_nid[0];
1422 path = snd_hda_add_new_path(codec, dac, pin,
1427 /* print_nid_path("output-aamix", path); */
1428 path->active = false; /* unused as default */
1429 return snd_hda_get_path_idx(codec, path);
1432 /* check whether the independent HP is available with the current config */
1433 static bool indep_hp_possible(struct hda_codec *codec)
1435 struct hda_gen_spec *spec = codec->spec;
1436 struct auto_pin_cfg *cfg = &spec->autocfg;
1437 struct nid_path *path;
1440 if (cfg->line_out_type == AUTO_PIN_HP_OUT)
1441 idx = spec->out_paths[0];
1443 idx = spec->hp_paths[0];
1444 path = snd_hda_get_path_from_idx(codec, idx);
1448 /* assume no path conflicts unless aamix is involved */
1449 if (!spec->mixer_nid || !is_nid_contained(path, spec->mixer_nid))
1452 /* check whether output paths contain aamix */
1453 for (i = 0; i < cfg->line_outs; i++) {
1454 if (spec->out_paths[i] == idx)
1456 path = snd_hda_get_path_from_idx(codec, spec->out_paths[i]);
1457 if (path && is_nid_contained(path, spec->mixer_nid))
1460 for (i = 0; i < cfg->speaker_outs; i++) {
1461 path = snd_hda_get_path_from_idx(codec, spec->speaker_paths[i]);
1462 if (path && is_nid_contained(path, spec->mixer_nid))
1469 /* fill the empty entries in the dac array for speaker/hp with the
1470 * shared dac pointed by the paths
1472 static void refill_shared_dacs(struct hda_codec *codec, int num_outs,
1473 hda_nid_t *dacs, int *path_idx)
1475 struct nid_path *path;
1478 for (i = 0; i < num_outs; i++) {
1481 path = snd_hda_get_path_from_idx(codec, path_idx[i]);
1484 dacs[i] = path->path[0];
1488 /* fill in the dac_nids table from the parsed pin configuration */
1489 static int fill_and_eval_dacs(struct hda_codec *codec,
1490 bool fill_hardwired,
1491 bool fill_mio_first)
1493 struct hda_gen_spec *spec = codec->spec;
1494 struct auto_pin_cfg *cfg = &spec->autocfg;
1495 int i, err, badness;
1497 /* set num_dacs once to full for look_for_dac() */
1498 spec->multiout.num_dacs = cfg->line_outs;
1499 spec->multiout.dac_nids = spec->private_dac_nids;
1500 memset(spec->private_dac_nids, 0, sizeof(spec->private_dac_nids));
1501 memset(spec->multiout.hp_out_nid, 0, sizeof(spec->multiout.hp_out_nid));
1502 memset(spec->multiout.extra_out_nid, 0, sizeof(spec->multiout.extra_out_nid));
1503 spec->multi_ios = 0;
1504 snd_array_free(&spec->paths);
1506 /* clear path indices */
1507 memset(spec->out_paths, 0, sizeof(spec->out_paths));
1508 memset(spec->hp_paths, 0, sizeof(spec->hp_paths));
1509 memset(spec->speaker_paths, 0, sizeof(spec->speaker_paths));
1510 memset(spec->aamix_out_paths, 0, sizeof(spec->aamix_out_paths));
1511 memset(spec->digout_paths, 0, sizeof(spec->digout_paths));
1512 memset(spec->input_paths, 0, sizeof(spec->input_paths));
1513 memset(spec->loopback_paths, 0, sizeof(spec->loopback_paths));
1514 memset(&spec->digin_path, 0, sizeof(spec->digin_path));
1518 /* fill hard-wired DACs first */
1519 if (fill_hardwired) {
1522 mapped = map_singles(codec, cfg->line_outs,
1524 spec->private_dac_nids,
1526 mapped |= map_singles(codec, cfg->hp_outs,
1528 spec->multiout.hp_out_nid,
1530 mapped |= map_singles(codec, cfg->speaker_outs,
1532 spec->multiout.extra_out_nid,
1533 spec->speaker_paths);
1534 if (fill_mio_first && cfg->line_outs == 1 &&
1535 cfg->line_out_type != AUTO_PIN_SPEAKER_OUT) {
1536 err = fill_multi_ios(codec, cfg->line_out_pins[0], true);
1543 badness += try_assign_dacs(codec, cfg->line_outs, cfg->line_out_pins,
1544 spec->private_dac_nids, spec->out_paths,
1545 spec->main_out_badness);
1547 if (fill_mio_first &&
1548 cfg->line_outs == 1 && cfg->line_out_type != AUTO_PIN_SPEAKER_OUT) {
1549 /* try to fill multi-io first */
1550 err = fill_multi_ios(codec, cfg->line_out_pins[0], false);
1553 /* we don't count badness at this stage yet */
1556 if (cfg->line_out_type != AUTO_PIN_HP_OUT) {
1557 err = try_assign_dacs(codec, cfg->hp_outs, cfg->hp_pins,
1558 spec->multiout.hp_out_nid,
1560 spec->extra_out_badness);
1565 if (cfg->line_out_type != AUTO_PIN_SPEAKER_OUT) {
1566 err = try_assign_dacs(codec, cfg->speaker_outs,
1568 spec->multiout.extra_out_nid,
1569 spec->speaker_paths,
1570 spec->extra_out_badness);
1575 if (cfg->line_outs == 1 && cfg->line_out_type != AUTO_PIN_SPEAKER_OUT) {
1576 err = fill_multi_ios(codec, cfg->line_out_pins[0], false);
1582 if (spec->mixer_nid) {
1583 spec->aamix_out_paths[0] =
1584 check_aamix_out_path(codec, spec->out_paths[0]);
1585 if (cfg->line_out_type != AUTO_PIN_HP_OUT)
1586 spec->aamix_out_paths[1] =
1587 check_aamix_out_path(codec, spec->hp_paths[0]);
1588 if (cfg->line_out_type != AUTO_PIN_SPEAKER_OUT)
1589 spec->aamix_out_paths[2] =
1590 check_aamix_out_path(codec, spec->speaker_paths[0]);
1593 if (cfg->hp_outs && cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
1594 if (count_multiio_pins(codec, cfg->hp_pins[0]) >= 2)
1595 spec->multi_ios = 1; /* give badness */
1597 /* re-count num_dacs and squash invalid entries */
1598 spec->multiout.num_dacs = 0;
1599 for (i = 0; i < cfg->line_outs; i++) {
1600 if (spec->private_dac_nids[i])
1601 spec->multiout.num_dacs++;
1603 memmove(spec->private_dac_nids + i,
1604 spec->private_dac_nids + i + 1,
1605 sizeof(hda_nid_t) * (cfg->line_outs - i - 1));
1606 spec->private_dac_nids[cfg->line_outs - 1] = 0;
1610 spec->ext_channel_count = spec->min_channel_count =
1611 spec->multiout.num_dacs * 2;
1613 if (spec->multi_ios == 2) {
1614 for (i = 0; i < 2; i++)
1615 spec->private_dac_nids[spec->multiout.num_dacs++] =
1616 spec->multi_io[i].dac;
1617 } else if (spec->multi_ios) {
1618 spec->multi_ios = 0;
1619 badness += BAD_MULTI_IO;
1622 if (spec->indep_hp && !indep_hp_possible(codec))
1623 badness += BAD_NO_INDEP_HP;
1625 /* re-fill the shared DAC for speaker / headphone */
1626 if (cfg->line_out_type != AUTO_PIN_HP_OUT)
1627 refill_shared_dacs(codec, cfg->hp_outs,
1628 spec->multiout.hp_out_nid,
1630 if (cfg->line_out_type != AUTO_PIN_SPEAKER_OUT)
1631 refill_shared_dacs(codec, cfg->speaker_outs,
1632 spec->multiout.extra_out_nid,
1633 spec->speaker_paths);
1638 #define DEBUG_BADNESS
1640 #ifdef DEBUG_BADNESS
1641 #define debug_badness snd_printdd
1643 #define debug_badness(...)
1646 #ifdef DEBUG_BADNESS
1647 static inline void print_nid_path_idx(struct hda_codec *codec,
1648 const char *pfx, int idx)
1650 struct nid_path *path;
1652 path = snd_hda_get_path_from_idx(codec, idx);
1654 print_nid_path(pfx, path);
1657 static void debug_show_configs(struct hda_codec *codec,
1658 struct auto_pin_cfg *cfg)
1660 struct hda_gen_spec *spec = codec->spec;
1661 static const char * const lo_type[3] = { "LO", "SP", "HP" };
1664 debug_badness("multi_outs = %x/%x/%x/%x : %x/%x/%x/%x (type %s)\n",
1665 cfg->line_out_pins[0], cfg->line_out_pins[1],
1666 cfg->line_out_pins[2], cfg->line_out_pins[3],
1667 spec->multiout.dac_nids[0],
1668 spec->multiout.dac_nids[1],
1669 spec->multiout.dac_nids[2],
1670 spec->multiout.dac_nids[3],
1671 lo_type[cfg->line_out_type]);
1672 for (i = 0; i < cfg->line_outs; i++)
1673 print_nid_path_idx(codec, " out", spec->out_paths[i]);
1674 if (spec->multi_ios > 0)
1675 debug_badness("multi_ios(%d) = %x/%x : %x/%x\n",
1677 spec->multi_io[0].pin, spec->multi_io[1].pin,
1678 spec->multi_io[0].dac, spec->multi_io[1].dac);
1679 for (i = 0; i < spec->multi_ios; i++)
1680 print_nid_path_idx(codec, " mio",
1681 spec->out_paths[cfg->line_outs + i]);
1683 debug_badness("hp_outs = %x/%x/%x/%x : %x/%x/%x/%x\n",
1684 cfg->hp_pins[0], cfg->hp_pins[1],
1685 cfg->hp_pins[2], cfg->hp_pins[3],
1686 spec->multiout.hp_out_nid[0],
1687 spec->multiout.hp_out_nid[1],
1688 spec->multiout.hp_out_nid[2],
1689 spec->multiout.hp_out_nid[3]);
1690 for (i = 0; i < cfg->hp_outs; i++)
1691 print_nid_path_idx(codec, " hp ", spec->hp_paths[i]);
1692 if (cfg->speaker_outs)
1693 debug_badness("spk_outs = %x/%x/%x/%x : %x/%x/%x/%x\n",
1694 cfg->speaker_pins[0], cfg->speaker_pins[1],
1695 cfg->speaker_pins[2], cfg->speaker_pins[3],
1696 spec->multiout.extra_out_nid[0],
1697 spec->multiout.extra_out_nid[1],
1698 spec->multiout.extra_out_nid[2],
1699 spec->multiout.extra_out_nid[3]);
1700 for (i = 0; i < cfg->speaker_outs; i++)
1701 print_nid_path_idx(codec, " spk", spec->speaker_paths[i]);
1702 for (i = 0; i < 3; i++)
1703 print_nid_path_idx(codec, " mix", spec->aamix_out_paths[i]);
1706 #define debug_show_configs(codec, cfg) /* NOP */
1709 /* find all available DACs of the codec */
1710 static void fill_all_dac_nids(struct hda_codec *codec)
1712 struct hda_gen_spec *spec = codec->spec;
1714 hda_nid_t nid = codec->start_nid;
1716 spec->num_all_dacs = 0;
1717 memset(spec->all_dacs, 0, sizeof(spec->all_dacs));
1718 for (i = 0; i < codec->num_nodes; i++, nid++) {
1719 if (get_wcaps_type(get_wcaps(codec, nid)) != AC_WID_AUD_OUT)
1721 if (spec->num_all_dacs >= ARRAY_SIZE(spec->all_dacs)) {
1722 snd_printk(KERN_ERR "hda: Too many DACs!\n");
1725 spec->all_dacs[spec->num_all_dacs++] = nid;
1729 static int parse_output_paths(struct hda_codec *codec)
1731 struct hda_gen_spec *spec = codec->spec;
1732 struct auto_pin_cfg *cfg = &spec->autocfg;
1733 struct auto_pin_cfg *best_cfg;
1735 int best_badness = INT_MAX;
1737 bool fill_hardwired = true, fill_mio_first = true;
1738 bool best_wired = true, best_mio = true;
1739 bool hp_spk_swapped = false;
1741 best_cfg = kmalloc(sizeof(*best_cfg), GFP_KERNEL);
1747 badness = fill_and_eval_dacs(codec, fill_hardwired,
1753 debug_badness("==> lo_type=%d, wired=%d, mio=%d, badness=0x%x\n",
1754 cfg->line_out_type, fill_hardwired, fill_mio_first,
1756 debug_show_configs(codec, cfg);
1757 if (badness < best_badness) {
1758 best_badness = badness;
1760 best_wired = fill_hardwired;
1761 best_mio = fill_mio_first;
1765 fill_mio_first = !fill_mio_first;
1766 if (!fill_mio_first)
1768 fill_hardwired = !fill_hardwired;
1769 if (!fill_hardwired)
1773 hp_spk_swapped = true;
1774 if (cfg->speaker_outs > 0 &&
1775 cfg->line_out_type == AUTO_PIN_HP_OUT) {
1776 cfg->hp_outs = cfg->line_outs;
1777 memcpy(cfg->hp_pins, cfg->line_out_pins,
1778 sizeof(cfg->hp_pins));
1779 cfg->line_outs = cfg->speaker_outs;
1780 memcpy(cfg->line_out_pins, cfg->speaker_pins,
1781 sizeof(cfg->speaker_pins));
1782 cfg->speaker_outs = 0;
1783 memset(cfg->speaker_pins, 0, sizeof(cfg->speaker_pins));
1784 cfg->line_out_type = AUTO_PIN_SPEAKER_OUT;
1785 fill_hardwired = true;
1788 if (cfg->hp_outs > 0 &&
1789 cfg->line_out_type == AUTO_PIN_SPEAKER_OUT) {
1790 cfg->speaker_outs = cfg->line_outs;
1791 memcpy(cfg->speaker_pins, cfg->line_out_pins,
1792 sizeof(cfg->speaker_pins));
1793 cfg->line_outs = cfg->hp_outs;
1794 memcpy(cfg->line_out_pins, cfg->hp_pins,
1795 sizeof(cfg->hp_pins));
1797 memset(cfg->hp_pins, 0, sizeof(cfg->hp_pins));
1798 cfg->line_out_type = AUTO_PIN_HP_OUT;
1799 fill_hardwired = true;
1806 debug_badness("==> restoring best_cfg\n");
1808 fill_and_eval_dacs(codec, best_wired, best_mio);
1810 debug_badness("==> Best config: lo_type=%d, wired=%d, mio=%d\n",
1811 cfg->line_out_type, best_wired, best_mio);
1812 debug_show_configs(codec, cfg);
1814 if (cfg->line_out_pins[0]) {
1815 struct nid_path *path;
1816 path = snd_hda_get_path_from_idx(codec, spec->out_paths[0]);
1818 spec->vmaster_nid = look_for_out_vol_nid(codec, path);
1819 if (spec->vmaster_nid)
1820 snd_hda_set_vmaster_tlv(codec, spec->vmaster_nid,
1821 HDA_OUTPUT, spec->vmaster_tlv);
1824 /* set initial pinctl targets */
1825 if (spec->prefer_hp_amp || cfg->line_out_type == AUTO_PIN_HP_OUT)
1829 set_pin_targets(codec, cfg->line_outs, cfg->line_out_pins, val);
1830 if (cfg->line_out_type != AUTO_PIN_HP_OUT)
1831 set_pin_targets(codec, cfg->hp_outs, cfg->hp_pins, PIN_HP);
1832 if (cfg->line_out_type != AUTO_PIN_SPEAKER_OUT) {
1833 val = spec->prefer_hp_amp ? PIN_HP : PIN_OUT;
1834 set_pin_targets(codec, cfg->speaker_outs,
1835 cfg->speaker_pins, val);
1838 /* clear indep_hp flag if not available */
1839 if (spec->indep_hp && !indep_hp_possible(codec))
1846 /* add playback controls from the parsed DAC table */
1847 static int create_multi_out_ctls(struct hda_codec *codec,
1848 const struct auto_pin_cfg *cfg)
1850 struct hda_gen_spec *spec = codec->spec;
1851 int i, err, noutputs;
1853 noutputs = cfg->line_outs;
1854 if (spec->multi_ios > 0 && cfg->line_outs < 3)
1855 noutputs += spec->multi_ios;
1857 for (i = 0; i < noutputs; i++) {
1860 struct nid_path *path;
1862 path = snd_hda_get_path_from_idx(codec, spec->out_paths[i]);
1866 name = get_line_out_pfx(codec, i, &index, NID_PATH_VOL_CTL);
1867 if (!name || !strcmp(name, "CLFE")) {
1869 err = add_vol_ctl(codec, "Center", 0, 1, path);
1872 err = add_vol_ctl(codec, "LFE", 0, 2, path);
1876 err = add_stereo_vol(codec, name, index, path);
1881 name = get_line_out_pfx(codec, i, &index, NID_PATH_MUTE_CTL);
1882 if (!name || !strcmp(name, "CLFE")) {
1883 err = add_sw_ctl(codec, "Center", 0, 1, path);
1886 err = add_sw_ctl(codec, "LFE", 0, 2, path);
1890 err = add_stereo_sw(codec, name, index, path);
1898 static int create_extra_out(struct hda_codec *codec, int path_idx,
1899 const char *pfx, int cidx)
1901 struct nid_path *path;
1904 path = snd_hda_get_path_from_idx(codec, path_idx);
1907 err = add_stereo_vol(codec, pfx, cidx, path);
1910 err = add_stereo_sw(codec, pfx, cidx, path);
1916 /* add playback controls for speaker and HP outputs */
1917 static int create_extra_outs(struct hda_codec *codec, int num_pins,
1918 const int *paths, const char *pfx)
1922 for (i = 0; i < num_pins; i++) {
1927 if (num_pins == 2 && i == 1 && !strcmp(pfx, "Speaker"))
1928 name = "Bass Speaker";
1929 else if (num_pins >= 3) {
1930 snprintf(tmp, sizeof(tmp), "%s %s",
1931 pfx, channel_name[i]);
1937 err = create_extra_out(codec, paths[i], name, idx);
1944 static int create_hp_out_ctls(struct hda_codec *codec)
1946 struct hda_gen_spec *spec = codec->spec;
1947 return create_extra_outs(codec, spec->autocfg.hp_outs,
1952 static int create_speaker_out_ctls(struct hda_codec *codec)
1954 struct hda_gen_spec *spec = codec->spec;
1955 return create_extra_outs(codec, spec->autocfg.speaker_outs,
1956 spec->speaker_paths,
1961 * independent HP controls
1964 static void call_hp_automute(struct hda_codec *codec, struct hda_jack_tbl *jack);
1965 static int indep_hp_info(struct snd_kcontrol *kcontrol,
1966 struct snd_ctl_elem_info *uinfo)
1968 return snd_hda_enum_bool_helper_info(kcontrol, uinfo);
1971 static int indep_hp_get(struct snd_kcontrol *kcontrol,
1972 struct snd_ctl_elem_value *ucontrol)
1974 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1975 struct hda_gen_spec *spec = codec->spec;
1976 ucontrol->value.enumerated.item[0] = spec->indep_hp_enabled;
1980 static void update_aamix_paths(struct hda_codec *codec, bool do_mix,
1981 int nomix_path_idx, int mix_path_idx,
1984 static int indep_hp_put(struct snd_kcontrol *kcontrol,
1985 struct snd_ctl_elem_value *ucontrol)
1987 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1988 struct hda_gen_spec *spec = codec->spec;
1989 unsigned int select = ucontrol->value.enumerated.item[0];
1992 mutex_lock(&spec->pcm_mutex);
1993 if (spec->active_streams) {
1998 if (spec->indep_hp_enabled != select) {
2000 if (spec->autocfg.line_out_type == AUTO_PIN_HP_OUT)
2001 dacp = &spec->private_dac_nids[0];
2003 dacp = &spec->multiout.hp_out_nid[0];
2005 /* update HP aamix paths in case it conflicts with indep HP */
2006 if (spec->have_aamix_ctl) {
2007 if (spec->autocfg.line_out_type == AUTO_PIN_HP_OUT)
2008 update_aamix_paths(codec, spec->aamix_mode,
2010 spec->aamix_out_paths[0],
2011 spec->autocfg.line_out_type);
2013 update_aamix_paths(codec, spec->aamix_mode,
2015 spec->aamix_out_paths[1],
2019 spec->indep_hp_enabled = select;
2020 if (spec->indep_hp_enabled)
2023 *dacp = spec->alt_dac_nid;
2025 call_hp_automute(codec, NULL);
2029 mutex_unlock(&spec->pcm_mutex);
2033 static const struct snd_kcontrol_new indep_hp_ctl = {
2034 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2035 .name = "Independent HP",
2036 .info = indep_hp_info,
2037 .get = indep_hp_get,
2038 .put = indep_hp_put,
2042 static int create_indep_hp_ctls(struct hda_codec *codec)
2044 struct hda_gen_spec *spec = codec->spec;
2047 if (!spec->indep_hp)
2049 if (spec->autocfg.line_out_type == AUTO_PIN_HP_OUT)
2050 dac = spec->multiout.dac_nids[0];
2052 dac = spec->multiout.hp_out_nid[0];
2058 spec->indep_hp_enabled = false;
2059 spec->alt_dac_nid = dac;
2060 if (!snd_hda_gen_add_kctl(spec, NULL, &indep_hp_ctl))
2066 * channel mode enum control
2069 static int ch_mode_info(struct snd_kcontrol *kcontrol,
2070 struct snd_ctl_elem_info *uinfo)
2072 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2073 struct hda_gen_spec *spec = codec->spec;
2076 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
2078 uinfo->value.enumerated.items = spec->multi_ios + 1;
2079 if (uinfo->value.enumerated.item > spec->multi_ios)
2080 uinfo->value.enumerated.item = spec->multi_ios;
2081 chs = uinfo->value.enumerated.item * 2 + spec->min_channel_count;
2082 sprintf(uinfo->value.enumerated.name, "%dch", chs);
2086 static int ch_mode_get(struct snd_kcontrol *kcontrol,
2087 struct snd_ctl_elem_value *ucontrol)
2089 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2090 struct hda_gen_spec *spec = codec->spec;
2091 ucontrol->value.enumerated.item[0] =
2092 (spec->ext_channel_count - spec->min_channel_count) / 2;
2096 static inline struct nid_path *
2097 get_multiio_path(struct hda_codec *codec, int idx)
2099 struct hda_gen_spec *spec = codec->spec;
2100 return snd_hda_get_path_from_idx(codec,
2101 spec->out_paths[spec->autocfg.line_outs + idx]);
2104 static void update_automute_all(struct hda_codec *codec);
2106 /* Default value to be passed as aamix argument for snd_hda_activate_path();
2107 * used for output paths
2109 static bool aamix_default(struct hda_gen_spec *spec)
2111 return !spec->have_aamix_ctl || spec->aamix_mode;
2114 static int set_multi_io(struct hda_codec *codec, int idx, bool output)
2116 struct hda_gen_spec *spec = codec->spec;
2117 hda_nid_t nid = spec->multi_io[idx].pin;
2118 struct nid_path *path;
2120 path = get_multiio_path(codec, idx);
2124 if (path->active == output)
2128 set_pin_target(codec, nid, PIN_OUT, true);
2129 snd_hda_activate_path(codec, path, true, aamix_default(spec));
2130 set_pin_eapd(codec, nid, true);
2132 set_pin_eapd(codec, nid, false);
2133 snd_hda_activate_path(codec, path, false, aamix_default(spec));
2134 set_pin_target(codec, nid, spec->multi_io[idx].ctl_in, true);
2135 path_power_down_sync(codec, path);
2138 /* update jack retasking in case it modifies any of them */
2139 update_automute_all(codec);
2144 static int ch_mode_put(struct snd_kcontrol *kcontrol,
2145 struct snd_ctl_elem_value *ucontrol)
2147 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2148 struct hda_gen_spec *spec = codec->spec;
2151 ch = ucontrol->value.enumerated.item[0];
2152 if (ch < 0 || ch > spec->multi_ios)
2154 if (ch == (spec->ext_channel_count - spec->min_channel_count) / 2)
2156 spec->ext_channel_count = ch * 2 + spec->min_channel_count;
2157 for (i = 0; i < spec->multi_ios; i++)
2158 set_multi_io(codec, i, i < ch);
2159 spec->multiout.max_channels = max(spec->ext_channel_count,
2160 spec->const_channel_count);
2161 if (spec->need_dac_fix)
2162 spec->multiout.num_dacs = spec->multiout.max_channels / 2;
2166 static const struct snd_kcontrol_new channel_mode_enum = {
2167 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2168 .name = "Channel Mode",
2169 .info = ch_mode_info,
2174 static int create_multi_channel_mode(struct hda_codec *codec)
2176 struct hda_gen_spec *spec = codec->spec;
2178 if (spec->multi_ios > 0) {
2179 if (!snd_hda_gen_add_kctl(spec, NULL, &channel_mode_enum))
2186 * aamix loopback enable/disable switch
2189 #define loopback_mixing_info indep_hp_info
2191 static int loopback_mixing_get(struct snd_kcontrol *kcontrol,
2192 struct snd_ctl_elem_value *ucontrol)
2194 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2195 struct hda_gen_spec *spec = codec->spec;
2196 ucontrol->value.enumerated.item[0] = spec->aamix_mode;
2200 static void update_aamix_paths(struct hda_codec *codec, bool do_mix,
2201 int nomix_path_idx, int mix_path_idx,
2204 struct hda_gen_spec *spec = codec->spec;
2205 struct nid_path *nomix_path, *mix_path;
2207 nomix_path = snd_hda_get_path_from_idx(codec, nomix_path_idx);
2208 mix_path = snd_hda_get_path_from_idx(codec, mix_path_idx);
2209 if (!nomix_path || !mix_path)
2212 /* if HP aamix path is driven from a different DAC and the
2213 * independent HP mode is ON, can't turn on aamix path
2215 if (out_type == AUTO_PIN_HP_OUT && spec->indep_hp_enabled &&
2216 mix_path->path[0] != spec->alt_dac_nid)
2220 snd_hda_activate_path(codec, nomix_path, false, true);
2221 snd_hda_activate_path(codec, mix_path, true, true);
2222 path_power_down_sync(codec, nomix_path);
2224 snd_hda_activate_path(codec, mix_path, false, false);
2225 snd_hda_activate_path(codec, nomix_path, true, false);
2226 path_power_down_sync(codec, mix_path);
2230 static int loopback_mixing_put(struct snd_kcontrol *kcontrol,
2231 struct snd_ctl_elem_value *ucontrol)
2233 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2234 struct hda_gen_spec *spec = codec->spec;
2235 unsigned int val = ucontrol->value.enumerated.item[0];
2237 if (val == spec->aamix_mode)
2239 spec->aamix_mode = val;
2240 update_aamix_paths(codec, val, spec->out_paths[0],
2241 spec->aamix_out_paths[0],
2242 spec->autocfg.line_out_type);
2243 update_aamix_paths(codec, val, spec->hp_paths[0],
2244 spec->aamix_out_paths[1],
2246 update_aamix_paths(codec, val, spec->speaker_paths[0],
2247 spec->aamix_out_paths[2],
2248 AUTO_PIN_SPEAKER_OUT);
2252 static const struct snd_kcontrol_new loopback_mixing_enum = {
2253 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2254 .name = "Loopback Mixing",
2255 .info = loopback_mixing_info,
2256 .get = loopback_mixing_get,
2257 .put = loopback_mixing_put,
2260 static int create_loopback_mixing_ctl(struct hda_codec *codec)
2262 struct hda_gen_spec *spec = codec->spec;
2264 if (!spec->mixer_nid)
2266 if (!(spec->aamix_out_paths[0] || spec->aamix_out_paths[1] ||
2267 spec->aamix_out_paths[2]))
2269 if (!snd_hda_gen_add_kctl(spec, NULL, &loopback_mixing_enum))
2271 spec->have_aamix_ctl = 1;
2276 * shared headphone/mic handling
2279 static void call_update_outputs(struct hda_codec *codec);
2281 /* for shared I/O, change the pin-control accordingly */
2282 static void update_hp_mic(struct hda_codec *codec, int adc_mux, bool force)
2284 struct hda_gen_spec *spec = codec->spec;
2289 pin = spec->hp_mic_pin;
2290 as_mic = spec->cur_mux[adc_mux] == spec->hp_mic_mux_idx;
2293 val = snd_hda_codec_get_pin_target(codec, pin);
2303 val = snd_hda_get_default_vref(codec, pin);
2304 /* if the HP pin doesn't support VREF and the codec driver gives an
2305 * alternative pin, set up the VREF on that pin instead
2307 if (val == AC_PINCTL_VREF_HIZ && spec->shared_mic_vref_pin) {
2308 const hda_nid_t vref_pin = spec->shared_mic_vref_pin;
2309 unsigned int vref_val = snd_hda_get_default_vref(codec, vref_pin);
2310 if (vref_val != AC_PINCTL_VREF_HIZ)
2311 snd_hda_set_pin_ctl_cache(codec, vref_pin,
2312 PIN_IN | (as_mic ? vref_val : 0));
2315 if (!spec->hp_mic_jack_modes) {
2320 set_pin_target(codec, pin, val, true);
2321 call_hp_automute(codec, NULL);
2325 /* create a shared input with the headphone out */
2326 static int create_hp_mic(struct hda_codec *codec)
2328 struct hda_gen_spec *spec = codec->spec;
2329 struct auto_pin_cfg *cfg = &spec->autocfg;
2330 unsigned int defcfg;
2333 if (!spec->hp_mic) {
2334 if (spec->suppress_hp_mic_detect)
2336 /* automatic detection: only if no input or a single internal
2337 * input pin is found, try to detect the shared hp/mic
2339 if (cfg->num_inputs > 1)
2341 else if (cfg->num_inputs == 1) {
2342 defcfg = snd_hda_codec_get_pincfg(codec, cfg->inputs[0].pin);
2343 if (snd_hda_get_input_pin_attr(defcfg) != INPUT_PIN_ATTR_INT)
2348 spec->hp_mic = 0; /* clear once */
2349 if (cfg->num_inputs >= AUTO_CFG_MAX_INS)
2353 if (cfg->line_out_type == AUTO_PIN_HP_OUT && cfg->line_outs > 0)
2354 nid = cfg->line_out_pins[0];
2355 else if (cfg->hp_outs > 0)
2356 nid = cfg->hp_pins[0];
2360 if (!(snd_hda_query_pin_caps(codec, nid) & AC_PINCAP_IN))
2361 return 0; /* no input */
2363 cfg->inputs[cfg->num_inputs].pin = nid;
2364 cfg->inputs[cfg->num_inputs].type = AUTO_PIN_MIC;
2365 cfg->inputs[cfg->num_inputs].is_headphone_mic = 1;
2368 spec->hp_mic_pin = nid;
2369 /* we can't handle auto-mic together with HP-mic */
2370 spec->suppress_auto_mic = 1;
2371 snd_printdd("hda-codec: Enable shared I/O jack on NID 0x%x\n", nid);
2379 static int create_hp_mic_jack_mode(struct hda_codec *codec, hda_nid_t pin);
2381 static const char * const out_jack_texts[] = {
2382 "Line Out", "Headphone Out",
2385 static int out_jack_mode_info(struct snd_kcontrol *kcontrol,
2386 struct snd_ctl_elem_info *uinfo)
2388 return snd_hda_enum_helper_info(kcontrol, uinfo, 2, out_jack_texts);
2391 static int out_jack_mode_get(struct snd_kcontrol *kcontrol,
2392 struct snd_ctl_elem_value *ucontrol)
2394 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2395 hda_nid_t nid = kcontrol->private_value;
2396 if (snd_hda_codec_get_pin_target(codec, nid) == PIN_HP)
2397 ucontrol->value.enumerated.item[0] = 1;
2399 ucontrol->value.enumerated.item[0] = 0;
2403 static int out_jack_mode_put(struct snd_kcontrol *kcontrol,
2404 struct snd_ctl_elem_value *ucontrol)
2406 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2407 hda_nid_t nid = kcontrol->private_value;
2410 val = ucontrol->value.enumerated.item[0] ? PIN_HP : PIN_OUT;
2411 if (snd_hda_codec_get_pin_target(codec, nid) == val)
2413 snd_hda_set_pin_ctl_cache(codec, nid, val);
2417 static const struct snd_kcontrol_new out_jack_mode_enum = {
2418 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2419 .info = out_jack_mode_info,
2420 .get = out_jack_mode_get,
2421 .put = out_jack_mode_put,
2424 static bool find_kctl_name(struct hda_codec *codec, const char *name, int idx)
2426 struct hda_gen_spec *spec = codec->spec;
2429 for (i = 0; i < spec->kctls.used; i++) {
2430 struct snd_kcontrol_new *kctl = snd_array_elem(&spec->kctls, i);
2431 if (!strcmp(kctl->name, name) && kctl->index == idx)
2437 static void get_jack_mode_name(struct hda_codec *codec, hda_nid_t pin,
2438 char *name, size_t name_len)
2440 struct hda_gen_spec *spec = codec->spec;
2443 snd_hda_get_pin_label(codec, pin, &spec->autocfg, name, name_len, &idx);
2444 strlcat(name, " Jack Mode", name_len);
2446 for (; find_kctl_name(codec, name, idx); idx++)
2450 static int get_out_jack_num_items(struct hda_codec *codec, hda_nid_t pin)
2452 struct hda_gen_spec *spec = codec->spec;
2453 if (spec->add_jack_modes) {
2454 unsigned int pincap = snd_hda_query_pin_caps(codec, pin);
2455 if ((pincap & AC_PINCAP_OUT) && (pincap & AC_PINCAP_HP_DRV))
2461 static int create_out_jack_modes(struct hda_codec *codec, int num_pins,
2464 struct hda_gen_spec *spec = codec->spec;
2467 for (i = 0; i < num_pins; i++) {
2468 hda_nid_t pin = pins[i];
2469 if (pin == spec->hp_mic_pin)
2471 if (get_out_jack_num_items(codec, pin) > 1) {
2472 struct snd_kcontrol_new *knew;
2474 get_jack_mode_name(codec, pin, name, sizeof(name));
2475 knew = snd_hda_gen_add_kctl(spec, name,
2476 &out_jack_mode_enum);
2479 knew->private_value = pin;
2490 /* from AC_PINCTL_VREF_HIZ to AC_PINCTL_VREF_100 */
2493 static const char * const vref_texts[NUM_VREFS] = {
2494 "Line In", "Mic 50pc Bias", "Mic 0V Bias",
2495 "", "Mic 80pc Bias", "Mic 100pc Bias"
2498 static unsigned int get_vref_caps(struct hda_codec *codec, hda_nid_t pin)
2500 unsigned int pincap;
2502 pincap = snd_hda_query_pin_caps(codec, pin);
2503 pincap = (pincap & AC_PINCAP_VREF) >> AC_PINCAP_VREF_SHIFT;
2504 /* filter out unusual vrefs */
2505 pincap &= ~(AC_PINCAP_VREF_GRD | AC_PINCAP_VREF_100);
2509 /* convert from the enum item index to the vref ctl index (0=HIZ, 1=50%...) */
2510 static int get_vref_idx(unsigned int vref_caps, unsigned int item_idx)
2512 unsigned int i, n = 0;
2514 for (i = 0; i < NUM_VREFS; i++) {
2515 if (vref_caps & (1 << i)) {
2524 /* convert back from the vref ctl index to the enum item index */
2525 static int cvt_from_vref_idx(unsigned int vref_caps, unsigned int idx)
2527 unsigned int i, n = 0;
2529 for (i = 0; i < NUM_VREFS; i++) {
2532 if (vref_caps & (1 << i))
2538 static int in_jack_mode_info(struct snd_kcontrol *kcontrol,
2539 struct snd_ctl_elem_info *uinfo)
2541 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2542 hda_nid_t nid = kcontrol->private_value;
2543 unsigned int vref_caps = get_vref_caps(codec, nid);
2545 snd_hda_enum_helper_info(kcontrol, uinfo, hweight32(vref_caps),
2547 /* set the right text */
2548 strcpy(uinfo->value.enumerated.name,
2549 vref_texts[get_vref_idx(vref_caps, uinfo->value.enumerated.item)]);
2553 static int in_jack_mode_get(struct snd_kcontrol *kcontrol,
2554 struct snd_ctl_elem_value *ucontrol)
2556 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2557 hda_nid_t nid = kcontrol->private_value;
2558 unsigned int vref_caps = get_vref_caps(codec, nid);
2561 idx = snd_hda_codec_get_pin_target(codec, nid) & AC_PINCTL_VREFEN;
2562 ucontrol->value.enumerated.item[0] = cvt_from_vref_idx(vref_caps, idx);
2566 static int in_jack_mode_put(struct snd_kcontrol *kcontrol,
2567 struct snd_ctl_elem_value *ucontrol)
2569 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2570 hda_nid_t nid = kcontrol->private_value;
2571 unsigned int vref_caps = get_vref_caps(codec, nid);
2572 unsigned int val, idx;
2574 val = snd_hda_codec_get_pin_target(codec, nid);
2575 idx = cvt_from_vref_idx(vref_caps, val & AC_PINCTL_VREFEN);
2576 if (idx == ucontrol->value.enumerated.item[0])
2579 val &= ~AC_PINCTL_VREFEN;
2580 val |= get_vref_idx(vref_caps, ucontrol->value.enumerated.item[0]);
2581 snd_hda_set_pin_ctl_cache(codec, nid, val);
2585 static const struct snd_kcontrol_new in_jack_mode_enum = {
2586 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2587 .info = in_jack_mode_info,
2588 .get = in_jack_mode_get,
2589 .put = in_jack_mode_put,
2592 static int get_in_jack_num_items(struct hda_codec *codec, hda_nid_t pin)
2594 struct hda_gen_spec *spec = codec->spec;
2596 if (spec->add_jack_modes)
2597 nitems = hweight32(get_vref_caps(codec, pin));
2598 return nitems ? nitems : 1;
2601 static int create_in_jack_mode(struct hda_codec *codec, hda_nid_t pin)
2603 struct hda_gen_spec *spec = codec->spec;
2604 struct snd_kcontrol_new *knew;
2606 unsigned int defcfg;
2608 if (pin == spec->hp_mic_pin)
2609 return 0; /* already done in create_out_jack_mode() */
2611 /* no jack mode for fixed pins */
2612 defcfg = snd_hda_codec_get_pincfg(codec, pin);
2613 if (snd_hda_get_input_pin_attr(defcfg) == INPUT_PIN_ATTR_INT)
2616 /* no multiple vref caps? */
2617 if (get_in_jack_num_items(codec, pin) <= 1)
2620 get_jack_mode_name(codec, pin, name, sizeof(name));
2621 knew = snd_hda_gen_add_kctl(spec, name, &in_jack_mode_enum);
2624 knew->private_value = pin;
2629 * HP/mic shared jack mode
2631 static int hp_mic_jack_mode_info(struct snd_kcontrol *kcontrol,
2632 struct snd_ctl_elem_info *uinfo)
2634 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2635 hda_nid_t nid = kcontrol->private_value;
2636 int out_jacks = get_out_jack_num_items(codec, nid);
2637 int in_jacks = get_in_jack_num_items(codec, nid);
2638 const char *text = NULL;
2641 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
2643 uinfo->value.enumerated.items = out_jacks + in_jacks;
2644 if (uinfo->value.enumerated.item >= uinfo->value.enumerated.items)
2645 uinfo->value.enumerated.item = uinfo->value.enumerated.items - 1;
2646 idx = uinfo->value.enumerated.item;
2647 if (idx < out_jacks) {
2649 text = out_jack_texts[idx];
2651 text = "Headphone Out";
2655 unsigned int vref_caps = get_vref_caps(codec, nid);
2656 text = vref_texts[get_vref_idx(vref_caps, idx)];
2661 strcpy(uinfo->value.enumerated.name, text);
2665 static int get_cur_hp_mic_jack_mode(struct hda_codec *codec, hda_nid_t nid)
2667 int out_jacks = get_out_jack_num_items(codec, nid);
2668 int in_jacks = get_in_jack_num_items(codec, nid);
2669 unsigned int val = snd_hda_codec_get_pin_target(codec, nid);
2672 if (val & PIN_OUT) {
2673 if (out_jacks > 1 && val == PIN_HP)
2675 } else if (val & PIN_IN) {
2678 unsigned int vref_caps = get_vref_caps(codec, nid);
2679 val &= AC_PINCTL_VREFEN;
2680 idx += cvt_from_vref_idx(vref_caps, val);
2686 static int hp_mic_jack_mode_get(struct snd_kcontrol *kcontrol,
2687 struct snd_ctl_elem_value *ucontrol)
2689 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2690 hda_nid_t nid = kcontrol->private_value;
2691 ucontrol->value.enumerated.item[0] =
2692 get_cur_hp_mic_jack_mode(codec, nid);
2696 static int hp_mic_jack_mode_put(struct snd_kcontrol *kcontrol,
2697 struct snd_ctl_elem_value *ucontrol)
2699 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2700 hda_nid_t nid = kcontrol->private_value;
2701 int out_jacks = get_out_jack_num_items(codec, nid);
2702 int in_jacks = get_in_jack_num_items(codec, nid);
2703 unsigned int val, oldval, idx;
2705 oldval = get_cur_hp_mic_jack_mode(codec, nid);
2706 idx = ucontrol->value.enumerated.item[0];
2710 if (idx < out_jacks) {
2712 val = idx ? PIN_HP : PIN_OUT;
2718 unsigned int vref_caps = get_vref_caps(codec, nid);
2719 val = snd_hda_codec_get_pin_target(codec, nid);
2720 val &= ~(AC_PINCTL_VREFEN | PIN_HP);
2721 val |= get_vref_idx(vref_caps, idx) | PIN_IN;
2723 val = snd_hda_get_default_vref(codec, nid) | PIN_IN;
2725 snd_hda_set_pin_ctl_cache(codec, nid, val);
2726 call_hp_automute(codec, NULL);
2731 static const struct snd_kcontrol_new hp_mic_jack_mode_enum = {
2732 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2733 .info = hp_mic_jack_mode_info,
2734 .get = hp_mic_jack_mode_get,
2735 .put = hp_mic_jack_mode_put,
2738 static int create_hp_mic_jack_mode(struct hda_codec *codec, hda_nid_t pin)
2740 struct hda_gen_spec *spec = codec->spec;
2741 struct snd_kcontrol_new *knew;
2743 knew = snd_hda_gen_add_kctl(spec, "Headphone Mic Jack Mode",
2744 &hp_mic_jack_mode_enum);
2747 knew->private_value = pin;
2748 spec->hp_mic_jack_modes = 1;
2756 /* add the powersave loopback-list entry */
2757 static int add_loopback_list(struct hda_gen_spec *spec, hda_nid_t mix, int idx)
2759 struct hda_amp_list *list;
2761 list = snd_array_new(&spec->loopback_list);
2765 list->dir = HDA_INPUT;
2767 spec->loopback.amplist = spec->loopback_list.list;
2771 /* return true if either a volume or a mute amp is found for the given
2772 * aamix path; the amp has to be either in the mixer node or its direct leaf
2774 static bool look_for_mix_leaf_ctls(struct hda_codec *codec, hda_nid_t mix_nid,
2775 hda_nid_t pin, unsigned int *mix_val,
2776 unsigned int *mute_val)
2779 const hda_nid_t *list;
2782 idx = snd_hda_get_conn_index(codec, mix_nid, pin, true);
2786 *mix_val = *mute_val = 0;
2787 if (nid_has_volume(codec, mix_nid, HDA_INPUT))
2788 *mix_val = HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT);
2789 if (nid_has_mute(codec, mix_nid, HDA_INPUT))
2790 *mute_val = HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT);
2791 if (*mix_val && *mute_val)
2794 /* check leaf node */
2795 num_conns = snd_hda_get_conn_list(codec, mix_nid, &list);
2796 if (num_conns < idx)
2799 if (!*mix_val && nid_has_volume(codec, nid, HDA_OUTPUT) &&
2800 !is_ctl_associated(codec, nid, HDA_OUTPUT, 0, NID_PATH_VOL_CTL))
2801 *mix_val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
2802 if (!*mute_val && nid_has_mute(codec, nid, HDA_OUTPUT) &&
2803 !is_ctl_associated(codec, nid, HDA_OUTPUT, 0, NID_PATH_MUTE_CTL))
2804 *mute_val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
2806 return *mix_val || *mute_val;
2809 /* create input playback/capture controls for the given pin */
2810 static int new_analog_input(struct hda_codec *codec, int input_idx,
2811 hda_nid_t pin, const char *ctlname, int ctlidx,
2814 struct hda_gen_spec *spec = codec->spec;
2815 struct nid_path *path;
2816 unsigned int mix_val, mute_val;
2819 if (!look_for_mix_leaf_ctls(codec, mix_nid, pin, &mix_val, &mute_val))
2822 path = snd_hda_add_new_path(codec, pin, mix_nid, 0);
2825 print_nid_path("loopback", path);
2826 spec->loopback_paths[input_idx] = snd_hda_get_path_idx(codec, path);
2828 idx = path->idx[path->depth - 1];
2830 err = __add_pb_vol_ctrl(spec, HDA_CTL_WIDGET_VOL, ctlname, ctlidx, mix_val);
2833 path->ctls[NID_PATH_VOL_CTL] = mix_val;
2837 err = __add_pb_sw_ctrl(spec, HDA_CTL_WIDGET_MUTE, ctlname, ctlidx, mute_val);
2840 path->ctls[NID_PATH_MUTE_CTL] = mute_val;
2843 path->active = true;
2844 err = add_loopback_list(spec, mix_nid, idx);
2848 if (spec->mixer_nid != spec->mixer_merge_nid &&
2849 !spec->loopback_merge_path) {
2850 path = snd_hda_add_new_path(codec, spec->mixer_nid,
2851 spec->mixer_merge_nid, 0);
2853 print_nid_path("loopback-merge", path);
2854 path->active = true;
2855 spec->loopback_merge_path =
2856 snd_hda_get_path_idx(codec, path);
2863 static int is_input_pin(struct hda_codec *codec, hda_nid_t nid)
2865 unsigned int pincap = snd_hda_query_pin_caps(codec, nid);
2866 return (pincap & AC_PINCAP_IN) != 0;
2869 /* Parse the codec tree and retrieve ADCs */
2870 static int fill_adc_nids(struct hda_codec *codec)
2872 struct hda_gen_spec *spec = codec->spec;
2874 hda_nid_t *adc_nids = spec->adc_nids;
2875 int max_nums = ARRAY_SIZE(spec->adc_nids);
2878 nid = codec->start_nid;
2879 for (i = 0; i < codec->num_nodes; i++, nid++) {
2880 unsigned int caps = get_wcaps(codec, nid);
2881 int type = get_wcaps_type(caps);
2883 if (type != AC_WID_AUD_IN || (caps & AC_WCAP_DIGITAL))
2885 adc_nids[nums] = nid;
2886 if (++nums >= max_nums)
2889 spec->num_adc_nids = nums;
2891 /* copy the detected ADCs to all_adcs[] */
2892 spec->num_all_adcs = nums;
2893 memcpy(spec->all_adcs, spec->adc_nids, nums * sizeof(hda_nid_t));
2898 /* filter out invalid adc_nids that don't give all active input pins;
2899 * if needed, check whether dynamic ADC-switching is available
2901 static int check_dyn_adc_switch(struct hda_codec *codec)
2903 struct hda_gen_spec *spec = codec->spec;
2904 struct hda_input_mux *imux = &spec->input_mux;
2905 unsigned int ok_bits;
2910 for (n = 0; n < spec->num_adc_nids; n++) {
2911 for (i = 0; i < imux->num_items; i++) {
2912 if (!spec->input_paths[i][n])
2915 if (i >= imux->num_items) {
2916 ok_bits |= (1 << n);
2922 /* check whether ADC-switch is possible */
2923 for (i = 0; i < imux->num_items; i++) {
2924 for (n = 0; n < spec->num_adc_nids; n++) {
2925 if (spec->input_paths[i][n]) {
2926 spec->dyn_adc_idx[i] = n;
2932 snd_printdd("hda-codec: enabling ADC switching\n");
2933 spec->dyn_adc_switch = 1;
2934 } else if (nums != spec->num_adc_nids) {
2935 /* shrink the invalid adcs and input paths */
2937 for (n = 0; n < spec->num_adc_nids; n++) {
2938 if (!(ok_bits & (1 << n)))
2941 spec->adc_nids[nums] = spec->adc_nids[n];
2942 for (i = 0; i < imux->num_items; i++) {
2943 invalidate_nid_path(codec,
2944 spec->input_paths[i][nums]);
2945 spec->input_paths[i][nums] =
2946 spec->input_paths[i][n];
2951 spec->num_adc_nids = nums;
2954 if (imux->num_items == 1 ||
2955 (imux->num_items == 2 && spec->hp_mic)) {
2956 snd_printdd("hda-codec: reducing to a single ADC\n");
2957 spec->num_adc_nids = 1; /* reduce to a single ADC */
2960 /* single index for individual volumes ctls */
2961 if (!spec->dyn_adc_switch && spec->multi_cap_vol)
2962 spec->num_adc_nids = 1;
2967 /* parse capture source paths from the given pin and create imux items */
2968 static int parse_capture_source(struct hda_codec *codec, hda_nid_t pin,
2969 int cfg_idx, int num_adcs,
2970 const char *label, int anchor)
2972 struct hda_gen_spec *spec = codec->spec;
2973 struct hda_input_mux *imux = &spec->input_mux;
2974 int imux_idx = imux->num_items;
2975 bool imux_added = false;
2978 for (c = 0; c < num_adcs; c++) {
2979 struct nid_path *path;
2980 hda_nid_t adc = spec->adc_nids[c];
2982 if (!is_reachable_path(codec, pin, adc))
2984 path = snd_hda_add_new_path(codec, pin, adc, anchor);
2987 print_nid_path("input", path);
2988 spec->input_paths[imux_idx][c] =
2989 snd_hda_get_path_idx(codec, path);
2992 if (spec->hp_mic_pin == pin)
2993 spec->hp_mic_mux_idx = imux->num_items;
2994 spec->imux_pins[imux->num_items] = pin;
2995 snd_hda_add_imux_item(imux, label, cfg_idx, NULL);
3004 * create playback/capture controls for input pins
3007 /* fill the label for each input at first */
3008 static int fill_input_pin_labels(struct hda_codec *codec)
3010 struct hda_gen_spec *spec = codec->spec;
3011 const struct auto_pin_cfg *cfg = &spec->autocfg;
3014 for (i = 0; i < cfg->num_inputs; i++) {
3015 hda_nid_t pin = cfg->inputs[i].pin;
3019 if (!is_input_pin(codec, pin))
3022 label = hda_get_autocfg_input_label(codec, cfg, i);
3024 for (j = i - 1; j >= 0; j--) {
3025 if (spec->input_labels[j] &&
3026 !strcmp(spec->input_labels[j], label)) {
3027 idx = spec->input_label_idxs[j] + 1;
3032 spec->input_labels[i] = label;
3033 spec->input_label_idxs[i] = idx;
3039 #define CFG_IDX_MIX 99 /* a dummy cfg->input idx for stereo mix */
3041 static int create_input_ctls(struct hda_codec *codec)
3043 struct hda_gen_spec *spec = codec->spec;
3044 const struct auto_pin_cfg *cfg = &spec->autocfg;
3045 hda_nid_t mixer = spec->mixer_nid;
3050 num_adcs = fill_adc_nids(codec);
3054 err = fill_input_pin_labels(codec);
3058 for (i = 0; i < cfg->num_inputs; i++) {
3061 pin = cfg->inputs[i].pin;
3062 if (!is_input_pin(codec, pin))
3066 if (cfg->inputs[i].type == AUTO_PIN_MIC)
3067 val |= snd_hda_get_default_vref(codec, pin);
3068 if (pin != spec->hp_mic_pin)
3069 set_pin_target(codec, pin, val, false);
3072 if (is_reachable_path(codec, pin, mixer)) {
3073 err = new_analog_input(codec, i, pin,
3074 spec->input_labels[i],
3075 spec->input_label_idxs[i],
3082 err = parse_capture_source(codec, pin, i, num_adcs,
3083 spec->input_labels[i], -mixer);
3087 if (spec->add_jack_modes) {
3088 err = create_in_jack_mode(codec, pin);
3094 if (mixer && spec->add_stereo_mix_input) {
3095 err = parse_capture_source(codec, mixer, CFG_IDX_MIX, num_adcs,
3109 /* get the input path specified by the given adc and imux indices */
3110 static struct nid_path *get_input_path(struct hda_codec *codec, int adc_idx, int imux_idx)
3112 struct hda_gen_spec *spec = codec->spec;
3113 if (imux_idx < 0 || imux_idx >= HDA_MAX_NUM_INPUTS) {
3117 if (spec->dyn_adc_switch)
3118 adc_idx = spec->dyn_adc_idx[imux_idx];
3119 if (adc_idx < 0 || adc_idx >= AUTO_CFG_MAX_INS) {
3123 return snd_hda_get_path_from_idx(codec, spec->input_paths[imux_idx][adc_idx]);
3126 static int mux_select(struct hda_codec *codec, unsigned int adc_idx,
3129 static int mux_enum_info(struct snd_kcontrol *kcontrol,
3130 struct snd_ctl_elem_info *uinfo)
3132 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3133 struct hda_gen_spec *spec = codec->spec;
3134 return snd_hda_input_mux_info(&spec->input_mux, uinfo);
3137 static int mux_enum_get(struct snd_kcontrol *kcontrol,
3138 struct snd_ctl_elem_value *ucontrol)
3140 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3141 struct hda_gen_spec *spec = codec->spec;
3142 /* the ctls are created at once with multiple counts */
3143 unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
3145 ucontrol->value.enumerated.item[0] = spec->cur_mux[adc_idx];
3149 static int mux_enum_put(struct snd_kcontrol *kcontrol,
3150 struct snd_ctl_elem_value *ucontrol)
3152 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3153 unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
3154 return mux_select(codec, adc_idx,
3155 ucontrol->value.enumerated.item[0]);
3158 static const struct snd_kcontrol_new cap_src_temp = {
3159 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3160 .name = "Input Source",
3161 .info = mux_enum_info,
3162 .get = mux_enum_get,
3163 .put = mux_enum_put,
3167 * capture volume and capture switch ctls
3170 typedef int (*put_call_t)(struct snd_kcontrol *kcontrol,
3171 struct snd_ctl_elem_value *ucontrol);
3173 /* call the given amp update function for all amps in the imux list at once */
3174 static int cap_put_caller(struct snd_kcontrol *kcontrol,
3175 struct snd_ctl_elem_value *ucontrol,
3176 put_call_t func, int type)
3178 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3179 struct hda_gen_spec *spec = codec->spec;
3180 const struct hda_input_mux *imux;
3181 struct nid_path *path;
3182 int i, adc_idx, err = 0;
3184 imux = &spec->input_mux;
3185 adc_idx = kcontrol->id.index;
3186 mutex_lock(&codec->control_mutex);
3187 /* we use the cache-only update at first since multiple input paths
3188 * may shared the same amp; by updating only caches, the redundant
3189 * writes to hardware can be reduced.
3191 codec->cached_write = 1;
3192 for (i = 0; i < imux->num_items; i++) {
3193 path = get_input_path(codec, adc_idx, i);
3194 if (!path || !path->ctls[type])
3196 kcontrol->private_value = path->ctls[type];
3197 err = func(kcontrol, ucontrol);
3202 codec->cached_write = 0;
3203 mutex_unlock(&codec->control_mutex);
3204 snd_hda_codec_flush_cache(codec); /* flush the updates */
3205 if (err >= 0 && spec->cap_sync_hook)
3206 spec->cap_sync_hook(codec, ucontrol);
3210 /* capture volume ctl callbacks */
3211 #define cap_vol_info snd_hda_mixer_amp_volume_info
3212 #define cap_vol_get snd_hda_mixer_amp_volume_get
3213 #define cap_vol_tlv snd_hda_mixer_amp_tlv
3215 static int cap_vol_put(struct snd_kcontrol *kcontrol,
3216 struct snd_ctl_elem_value *ucontrol)
3218 return cap_put_caller(kcontrol, ucontrol,
3219 snd_hda_mixer_amp_volume_put,
3223 static const struct snd_kcontrol_new cap_vol_temp = {
3224 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3225 .name = "Capture Volume",
3226 .access = (SNDRV_CTL_ELEM_ACCESS_READWRITE |
3227 SNDRV_CTL_ELEM_ACCESS_TLV_READ |
3228 SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK),
3229 .info = cap_vol_info,
3232 .tlv = { .c = cap_vol_tlv },
3235 /* capture switch ctl callbacks */
3236 #define cap_sw_info snd_ctl_boolean_stereo_info
3237 #define cap_sw_get snd_hda_mixer_amp_switch_get
3239 static int cap_sw_put(struct snd_kcontrol *kcontrol,
3240 struct snd_ctl_elem_value *ucontrol)
3242 return cap_put_caller(kcontrol, ucontrol,
3243 snd_hda_mixer_amp_switch_put,
3247 static const struct snd_kcontrol_new cap_sw_temp = {
3248 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3249 .name = "Capture Switch",
3250 .info = cap_sw_info,
3255 static int parse_capvol_in_path(struct hda_codec *codec, struct nid_path *path)
3260 path->ctls[NID_PATH_VOL_CTL] = path->ctls[NID_PATH_MUTE_CTL] = 0;
3261 for (depth = 0; depth < 3; depth++) {
3262 if (depth >= path->depth)
3264 i = path->depth - depth - 1;
3265 nid = path->path[i];
3266 if (!path->ctls[NID_PATH_VOL_CTL]) {
3267 if (nid_has_volume(codec, nid, HDA_OUTPUT))
3268 path->ctls[NID_PATH_VOL_CTL] =
3269 HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
3270 else if (nid_has_volume(codec, nid, HDA_INPUT)) {
3271 int idx = path->idx[i];
3272 if (!depth && codec->single_adc_amp)
3274 path->ctls[NID_PATH_VOL_CTL] =
3275 HDA_COMPOSE_AMP_VAL(nid, 3, idx, HDA_INPUT);
3278 if (!path->ctls[NID_PATH_MUTE_CTL]) {
3279 if (nid_has_mute(codec, nid, HDA_OUTPUT))
3280 path->ctls[NID_PATH_MUTE_CTL] =
3281 HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
3282 else if (nid_has_mute(codec, nid, HDA_INPUT)) {
3283 int idx = path->idx[i];
3284 if (!depth && codec->single_adc_amp)
3286 path->ctls[NID_PATH_MUTE_CTL] =
3287 HDA_COMPOSE_AMP_VAL(nid, 3, idx, HDA_INPUT);
3294 static bool is_inv_dmic_pin(struct hda_codec *codec, hda_nid_t nid)
3296 struct hda_gen_spec *spec = codec->spec;
3297 struct auto_pin_cfg *cfg = &spec->autocfg;
3301 if (!spec->inv_dmic_split)
3303 for (i = 0; i < cfg->num_inputs; i++) {
3304 if (cfg->inputs[i].pin != nid)
3306 if (cfg->inputs[i].type != AUTO_PIN_MIC)
3308 val = snd_hda_codec_get_pincfg(codec, nid);
3309 return snd_hda_get_input_pin_attr(val) == INPUT_PIN_ATTR_INT;
3314 /* capture switch put callback for a single control with hook call */
3315 static int cap_single_sw_put(struct snd_kcontrol *kcontrol,
3316 struct snd_ctl_elem_value *ucontrol)
3318 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3319 struct hda_gen_spec *spec = codec->spec;
3322 ret = snd_hda_mixer_amp_switch_put(kcontrol, ucontrol);
3326 if (spec->cap_sync_hook)
3327 spec->cap_sync_hook(codec, ucontrol);
3332 static int add_single_cap_ctl(struct hda_codec *codec, const char *label,
3333 int idx, bool is_switch, unsigned int ctl,
3336 struct hda_gen_spec *spec = codec->spec;
3338 int type = is_switch ? HDA_CTL_WIDGET_MUTE : HDA_CTL_WIDGET_VOL;
3339 const char *sfx = is_switch ? "Switch" : "Volume";
3340 unsigned int chs = inv_dmic ? 1 : 3;
3341 struct snd_kcontrol_new *knew;
3347 snprintf(tmpname, sizeof(tmpname),
3348 "%s Capture %s", label, sfx);
3350 snprintf(tmpname, sizeof(tmpname),
3352 knew = add_control(spec, type, tmpname, idx,
3353 amp_val_replace_channels(ctl, chs));
3357 knew->put = cap_single_sw_put;
3361 /* Make independent right kcontrol */
3363 snprintf(tmpname, sizeof(tmpname),
3364 "Inverted %s Capture %s", label, sfx);
3366 snprintf(tmpname, sizeof(tmpname),
3367 "Inverted Capture %s", sfx);
3368 knew = add_control(spec, type, tmpname, idx,
3369 amp_val_replace_channels(ctl, 2));
3373 knew->put = cap_single_sw_put;
3377 /* create single (and simple) capture volume and switch controls */
3378 static int create_single_cap_vol_ctl(struct hda_codec *codec, int idx,
3379 unsigned int vol_ctl, unsigned int sw_ctl,
3383 err = add_single_cap_ctl(codec, NULL, idx, false, vol_ctl, inv_dmic);
3386 err = add_single_cap_ctl(codec, NULL, idx, true, sw_ctl, inv_dmic);
3392 /* create bound capture volume and switch controls */
3393 static int create_bind_cap_vol_ctl(struct hda_codec *codec, int idx,
3394 unsigned int vol_ctl, unsigned int sw_ctl)
3396 struct hda_gen_spec *spec = codec->spec;
3397 struct snd_kcontrol_new *knew;
3400 knew = snd_hda_gen_add_kctl(spec, NULL, &cap_vol_temp);
3404 knew->private_value = vol_ctl;
3405 knew->subdevice = HDA_SUBDEV_AMP_FLAG;
3408 knew = snd_hda_gen_add_kctl(spec, NULL, &cap_sw_temp);
3412 knew->private_value = sw_ctl;
3413 knew->subdevice = HDA_SUBDEV_AMP_FLAG;
3418 /* return the vol ctl when used first in the imux list */
3419 static unsigned int get_first_cap_ctl(struct hda_codec *codec, int idx, int type)
3421 struct nid_path *path;
3425 path = get_input_path(codec, 0, idx);
3428 ctl = path->ctls[type];
3431 for (i = 0; i < idx - 1; i++) {
3432 path = get_input_path(codec, 0, i);
3433 if (path && path->ctls[type] == ctl)
3439 /* create individual capture volume and switch controls per input */
3440 static int create_multi_cap_vol_ctl(struct hda_codec *codec)
3442 struct hda_gen_spec *spec = codec->spec;
3443 struct hda_input_mux *imux = &spec->input_mux;
3446 for (i = 0; i < imux->num_items; i++) {
3450 idx = imux->items[i].index;
3451 if (idx >= spec->autocfg.num_inputs)
3453 inv_dmic = is_inv_dmic_pin(codec, spec->imux_pins[i]);
3455 for (type = 0; type < 2; type++) {
3456 err = add_single_cap_ctl(codec,
3457 spec->input_labels[idx],
3458 spec->input_label_idxs[idx],
3460 get_first_cap_ctl(codec, i, type),
3469 static int create_capture_mixers(struct hda_codec *codec)
3471 struct hda_gen_spec *spec = codec->spec;
3472 struct hda_input_mux *imux = &spec->input_mux;
3473 int i, n, nums, err;
3475 if (spec->dyn_adc_switch)
3478 nums = spec->num_adc_nids;
3480 if (!spec->auto_mic && imux->num_items > 1) {
3481 struct snd_kcontrol_new *knew;
3483 name = nums > 1 ? "Input Source" : "Capture Source";
3484 knew = snd_hda_gen_add_kctl(spec, name, &cap_src_temp);
3490 for (n = 0; n < nums; n++) {
3492 bool multi_cap_vol = spec->multi_cap_vol;
3493 bool inv_dmic = false;
3497 for (i = 0; i < imux->num_items; i++) {
3498 struct nid_path *path;
3499 path = get_input_path(codec, n, i);
3502 parse_capvol_in_path(codec, path);
3504 vol = path->ctls[NID_PATH_VOL_CTL];
3505 else if (vol != path->ctls[NID_PATH_VOL_CTL]) {
3507 if (!same_amp_caps(codec, vol,
3508 path->ctls[NID_PATH_VOL_CTL], HDA_INPUT))
3509 multi_cap_vol = true;
3512 sw = path->ctls[NID_PATH_MUTE_CTL];
3513 else if (sw != path->ctls[NID_PATH_MUTE_CTL]) {
3515 if (!same_amp_caps(codec, sw,
3516 path->ctls[NID_PATH_MUTE_CTL], HDA_INPUT))
3517 multi_cap_vol = true;
3519 if (is_inv_dmic_pin(codec, spec->imux_pins[i]))
3524 err = create_single_cap_vol_ctl(codec, n, vol, sw,
3526 else if (!multi_cap_vol && !inv_dmic)
3527 err = create_bind_cap_vol_ctl(codec, n, vol, sw);
3529 err = create_multi_cap_vol_ctl(codec);
3538 * add mic boosts if needed
3541 /* check whether the given amp is feasible as a boost volume */
3542 static bool check_boost_vol(struct hda_codec *codec, hda_nid_t nid,
3547 if (!nid_has_volume(codec, nid, dir) ||
3548 is_ctl_associated(codec, nid, dir, idx, NID_PATH_VOL_CTL) ||
3549 is_ctl_associated(codec, nid, dir, idx, NID_PATH_BOOST_CTL))
3552 step = (query_amp_caps(codec, nid, dir) & AC_AMPCAP_STEP_SIZE)
3553 >> AC_AMPCAP_STEP_SIZE_SHIFT;
3559 /* look for a boost amp in a widget close to the pin */
3560 static unsigned int look_for_boost_amp(struct hda_codec *codec,
3561 struct nid_path *path)
3563 unsigned int val = 0;
3567 for (depth = 0; depth < 3; depth++) {
3568 if (depth >= path->depth - 1)
3570 nid = path->path[depth];
3571 if (depth && check_boost_vol(codec, nid, HDA_OUTPUT, 0)) {
3572 val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
3574 } else if (check_boost_vol(codec, nid, HDA_INPUT,
3575 path->idx[depth])) {
3576 val = HDA_COMPOSE_AMP_VAL(nid, 3, path->idx[depth],
3585 static int parse_mic_boost(struct hda_codec *codec)
3587 struct hda_gen_spec *spec = codec->spec;
3588 struct auto_pin_cfg *cfg = &spec->autocfg;
3589 struct hda_input_mux *imux = &spec->input_mux;
3592 if (!spec->num_adc_nids)
3595 for (i = 0; i < imux->num_items; i++) {
3596 struct nid_path *path;
3599 char boost_label[44];
3601 idx = imux->items[i].index;
3602 if (idx >= imux->num_items)
3605 /* check only line-in and mic pins */
3606 if (cfg->inputs[idx].type > AUTO_PIN_LINE_IN)
3609 path = get_input_path(codec, 0, i);
3613 val = look_for_boost_amp(codec, path);
3617 /* create a boost control */
3618 snprintf(boost_label, sizeof(boost_label),
3619 "%s Boost Volume", spec->input_labels[idx]);
3620 if (!add_control(spec, HDA_CTL_WIDGET_VOL, boost_label,
3621 spec->input_label_idxs[idx], val))
3624 path->ctls[NID_PATH_BOOST_CTL] = val;
3630 * parse digital I/Os and set up NIDs in BIOS auto-parse mode
3632 static void parse_digital(struct hda_codec *codec)
3634 struct hda_gen_spec *spec = codec->spec;
3635 struct nid_path *path;
3637 hda_nid_t dig_nid, pin;
3639 /* support multiple SPDIFs; the secondary is set up as a slave */
3641 for (i = 0; i < spec->autocfg.dig_outs; i++) {
3642 pin = spec->autocfg.dig_out_pins[i];
3643 dig_nid = look_for_dac(codec, pin, true);
3646 path = snd_hda_add_new_path(codec, dig_nid, pin, 0);
3649 print_nid_path("digout", path);
3650 path->active = true;
3651 spec->digout_paths[i] = snd_hda_get_path_idx(codec, path);
3652 set_pin_target(codec, pin, PIN_OUT, false);
3654 spec->multiout.dig_out_nid = dig_nid;
3655 spec->dig_out_type = spec->autocfg.dig_out_type[0];
3657 spec->multiout.slave_dig_outs = spec->slave_dig_outs;
3658 if (nums >= ARRAY_SIZE(spec->slave_dig_outs) - 1)
3660 spec->slave_dig_outs[nums - 1] = dig_nid;
3665 if (spec->autocfg.dig_in_pin) {
3666 pin = spec->autocfg.dig_in_pin;
3667 dig_nid = codec->start_nid;
3668 for (i = 0; i < codec->num_nodes; i++, dig_nid++) {
3669 unsigned int wcaps = get_wcaps(codec, dig_nid);
3670 if (get_wcaps_type(wcaps) != AC_WID_AUD_IN)
3672 if (!(wcaps & AC_WCAP_DIGITAL))
3674 path = snd_hda_add_new_path(codec, pin, dig_nid, 0);
3676 print_nid_path("digin", path);
3677 path->active = true;
3678 spec->dig_in_nid = dig_nid;
3679 spec->digin_path = snd_hda_get_path_idx(codec, path);
3680 set_pin_target(codec, pin, PIN_IN, false);
3689 * input MUX handling
3692 static bool dyn_adc_pcm_resetup(struct hda_codec *codec, int cur);
3694 /* select the given imux item; either unmute exclusively or select the route */
3695 static int mux_select(struct hda_codec *codec, unsigned int adc_idx,
3698 struct hda_gen_spec *spec = codec->spec;
3699 const struct hda_input_mux *imux;
3700 struct nid_path *old_path, *path;
3702 imux = &spec->input_mux;
3703 if (!imux->num_items)
3706 if (idx >= imux->num_items)
3707 idx = imux->num_items - 1;
3708 if (spec->cur_mux[adc_idx] == idx)
3711 old_path = get_input_path(codec, adc_idx, spec->cur_mux[adc_idx]);
3714 if (old_path->active)
3715 snd_hda_activate_path(codec, old_path, false, false);
3717 spec->cur_mux[adc_idx] = idx;
3720 update_hp_mic(codec, adc_idx, false);
3722 if (spec->dyn_adc_switch)
3723 dyn_adc_pcm_resetup(codec, idx);
3725 path = get_input_path(codec, adc_idx, idx);
3730 snd_hda_activate_path(codec, path, true, false);
3731 if (spec->cap_sync_hook)
3732 spec->cap_sync_hook(codec, NULL);
3733 path_power_down_sync(codec, old_path);
3739 * Jack detections for HP auto-mute and mic-switch
3742 /* check each pin in the given array; returns true if any of them is plugged */
3743 static bool detect_jacks(struct hda_codec *codec, int num_pins, hda_nid_t *pins)
3747 for (i = 0; i < num_pins; i++) {
3748 hda_nid_t nid = pins[i];
3751 /* don't detect pins retasked as inputs */
3752 if (snd_hda_codec_get_pin_target(codec, nid) & AC_PINCTL_IN_EN)
3754 present |= snd_hda_jack_detect(codec, nid);
3759 /* standard HP/line-out auto-mute helper */
3760 static void do_automute(struct hda_codec *codec, int num_pins, hda_nid_t *pins,
3763 struct hda_gen_spec *spec = codec->spec;
3766 for (i = 0; i < num_pins; i++) {
3767 hda_nid_t nid = pins[i];
3768 unsigned int val, oldval;
3771 oldval = snd_hda_codec_get_pin_target(codec, nid);
3772 if (oldval & PIN_IN)
3773 continue; /* no mute for inputs */
3774 /* don't reset VREF value in case it's controlling
3775 * the amp (see alc861_fixup_asus_amp_vref_0f())
3777 if (spec->keep_vref_in_automute)
3778 val = oldval & ~PIN_HP;
3783 /* here we call update_pin_ctl() so that the pinctl is changed
3784 * without changing the pinctl target value;
3785 * the original target value will be still referred at the
3786 * init / resume again
3788 update_pin_ctl(codec, nid, val);
3789 set_pin_eapd(codec, nid, !mute);
3793 /* Toggle outputs muting */
3794 void snd_hda_gen_update_outputs(struct hda_codec *codec)
3796 struct hda_gen_spec *spec = codec->spec;
3799 /* Control HP pins/amps depending on master_mute state;
3800 * in general, HP pins/amps control should be enabled in all cases,
3801 * but currently set only for master_mute, just to be safe
3803 do_automute(codec, ARRAY_SIZE(spec->autocfg.hp_pins),
3804 spec->autocfg.hp_pins, spec->master_mute);
3806 if (!spec->automute_speaker)
3809 on = spec->hp_jack_present | spec->line_jack_present;
3810 on |= spec->master_mute;
3811 spec->speaker_muted = on;
3812 do_automute(codec, ARRAY_SIZE(spec->autocfg.speaker_pins),
3813 spec->autocfg.speaker_pins, on);
3815 /* toggle line-out mutes if needed, too */
3816 /* if LO is a copy of either HP or Speaker, don't need to handle it */
3817 if (spec->autocfg.line_out_pins[0] == spec->autocfg.hp_pins[0] ||
3818 spec->autocfg.line_out_pins[0] == spec->autocfg.speaker_pins[0])
3820 if (!spec->automute_lo)
3823 on = spec->hp_jack_present;
3824 on |= spec->master_mute;
3825 spec->line_out_muted = on;
3826 do_automute(codec, ARRAY_SIZE(spec->autocfg.line_out_pins),
3827 spec->autocfg.line_out_pins, on);
3829 EXPORT_SYMBOL_HDA(snd_hda_gen_update_outputs);
3831 static void call_update_outputs(struct hda_codec *codec)
3833 struct hda_gen_spec *spec = codec->spec;
3834 if (spec->automute_hook)
3835 spec->automute_hook(codec);
3837 snd_hda_gen_update_outputs(codec);
3840 /* standard HP-automute helper */
3841 void snd_hda_gen_hp_automute(struct hda_codec *codec, struct hda_jack_tbl *jack)
3843 struct hda_gen_spec *spec = codec->spec;
3844 hda_nid_t *pins = spec->autocfg.hp_pins;
3845 int num_pins = ARRAY_SIZE(spec->autocfg.hp_pins);
3847 /* No detection for the first HP jack during indep-HP mode */
3848 if (spec->indep_hp_enabled) {
3853 spec->hp_jack_present = detect_jacks(codec, num_pins, pins);
3854 if (!spec->detect_hp || (!spec->automute_speaker && !spec->automute_lo))
3856 call_update_outputs(codec);
3858 EXPORT_SYMBOL_HDA(snd_hda_gen_hp_automute);
3860 /* standard line-out-automute helper */
3861 void snd_hda_gen_line_automute(struct hda_codec *codec, struct hda_jack_tbl *jack)
3863 struct hda_gen_spec *spec = codec->spec;
3865 if (spec->autocfg.line_out_type == AUTO_PIN_SPEAKER_OUT)
3867 /* check LO jack only when it's different from HP */
3868 if (spec->autocfg.line_out_pins[0] == spec->autocfg.hp_pins[0])
3871 spec->line_jack_present =
3872 detect_jacks(codec, ARRAY_SIZE(spec->autocfg.line_out_pins),
3873 spec->autocfg.line_out_pins);
3874 if (!spec->automute_speaker || !spec->detect_lo)
3876 call_update_outputs(codec);
3878 EXPORT_SYMBOL_HDA(snd_hda_gen_line_automute);
3880 /* standard mic auto-switch helper */
3881 void snd_hda_gen_mic_autoswitch(struct hda_codec *codec, struct hda_jack_tbl *jack)
3883 struct hda_gen_spec *spec = codec->spec;
3886 if (!spec->auto_mic)
3889 for (i = spec->am_num_entries - 1; i > 0; i--) {
3890 hda_nid_t pin = spec->am_entry[i].pin;
3891 /* don't detect pins retasked as outputs */
3892 if (snd_hda_codec_get_pin_target(codec, pin) & AC_PINCTL_OUT_EN)
3894 if (snd_hda_jack_detect(codec, pin)) {
3895 mux_select(codec, 0, spec->am_entry[i].idx);
3899 mux_select(codec, 0, spec->am_entry[0].idx);
3901 EXPORT_SYMBOL_HDA(snd_hda_gen_mic_autoswitch);
3903 /* call appropriate hooks */
3904 static void call_hp_automute(struct hda_codec *codec, struct hda_jack_tbl *jack)
3906 struct hda_gen_spec *spec = codec->spec;
3907 if (spec->hp_automute_hook)
3908 spec->hp_automute_hook(codec, jack);
3910 snd_hda_gen_hp_automute(codec, jack);
3913 static void call_line_automute(struct hda_codec *codec,
3914 struct hda_jack_tbl *jack)
3916 struct hda_gen_spec *spec = codec->spec;
3917 if (spec->line_automute_hook)
3918 spec->line_automute_hook(codec, jack);
3920 snd_hda_gen_line_automute(codec, jack);
3923 static void call_mic_autoswitch(struct hda_codec *codec,
3924 struct hda_jack_tbl *jack)
3926 struct hda_gen_spec *spec = codec->spec;
3927 if (spec->mic_autoswitch_hook)
3928 spec->mic_autoswitch_hook(codec, jack);
3930 snd_hda_gen_mic_autoswitch(codec, jack);
3933 /* update jack retasking */
3934 static void update_automute_all(struct hda_codec *codec)
3936 call_hp_automute(codec, NULL);
3937 call_line_automute(codec, NULL);
3938 call_mic_autoswitch(codec, NULL);
3942 * Auto-Mute mode mixer enum support
3944 static int automute_mode_info(struct snd_kcontrol *kcontrol,
3945 struct snd_ctl_elem_info *uinfo)
3947 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3948 struct hda_gen_spec *spec = codec->spec;
3949 static const char * const texts3[] = {
3950 "Disabled", "Speaker Only", "Line Out+Speaker"
3953 if (spec->automute_speaker_possible && spec->automute_lo_possible)
3954 return snd_hda_enum_helper_info(kcontrol, uinfo, 3, texts3);
3955 return snd_hda_enum_bool_helper_info(kcontrol, uinfo);
3958 static int automute_mode_get(struct snd_kcontrol *kcontrol,
3959 struct snd_ctl_elem_value *ucontrol)
3961 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3962 struct hda_gen_spec *spec = codec->spec;
3963 unsigned int val = 0;
3964 if (spec->automute_speaker)
3966 if (spec->automute_lo)
3969 ucontrol->value.enumerated.item[0] = val;
3973 static int automute_mode_put(struct snd_kcontrol *kcontrol,
3974 struct snd_ctl_elem_value *ucontrol)
3976 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3977 struct hda_gen_spec *spec = codec->spec;
3979 switch (ucontrol->value.enumerated.item[0]) {
3981 if (!spec->automute_speaker && !spec->automute_lo)
3983 spec->automute_speaker = 0;
3984 spec->automute_lo = 0;
3987 if (spec->automute_speaker_possible) {
3988 if (!spec->automute_lo && spec->automute_speaker)
3990 spec->automute_speaker = 1;
3991 spec->automute_lo = 0;
3992 } else if (spec->automute_lo_possible) {
3993 if (spec->automute_lo)
3995 spec->automute_lo = 1;
4000 if (!spec->automute_lo_possible || !spec->automute_speaker_possible)
4002 if (spec->automute_speaker && spec->automute_lo)
4004 spec->automute_speaker = 1;
4005 spec->automute_lo = 1;
4010 call_update_outputs(codec);
4014 static const struct snd_kcontrol_new automute_mode_enum = {
4015 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
4016 .name = "Auto-Mute Mode",
4017 .info = automute_mode_info,
4018 .get = automute_mode_get,
4019 .put = automute_mode_put,
4022 static int add_automute_mode_enum(struct hda_codec *codec)
4024 struct hda_gen_spec *spec = codec->spec;
4026 if (!snd_hda_gen_add_kctl(spec, NULL, &automute_mode_enum))
4032 * Check the availability of HP/line-out auto-mute;
4033 * Set up appropriately if really supported
4035 static int check_auto_mute_availability(struct hda_codec *codec)
4037 struct hda_gen_spec *spec = codec->spec;
4038 struct auto_pin_cfg *cfg = &spec->autocfg;
4042 if (spec->suppress_auto_mute)
4045 if (cfg->hp_pins[0])
4047 if (cfg->line_out_pins[0])
4049 if (cfg->speaker_pins[0])
4051 if (present < 2) /* need two different output types */
4054 if (!cfg->speaker_pins[0] &&
4055 cfg->line_out_type == AUTO_PIN_SPEAKER_OUT) {
4056 memcpy(cfg->speaker_pins, cfg->line_out_pins,
4057 sizeof(cfg->speaker_pins));
4058 cfg->speaker_outs = cfg->line_outs;
4061 if (!cfg->hp_pins[0] &&
4062 cfg->line_out_type == AUTO_PIN_HP_OUT) {
4063 memcpy(cfg->hp_pins, cfg->line_out_pins,
4064 sizeof(cfg->hp_pins));
4065 cfg->hp_outs = cfg->line_outs;
4068 for (i = 0; i < cfg->hp_outs; i++) {
4069 hda_nid_t nid = cfg->hp_pins[i];
4070 if (!is_jack_detectable(codec, nid))
4072 snd_printdd("hda-codec: Enable HP auto-muting on NID 0x%x\n",
4074 snd_hda_jack_detect_enable_callback(codec, nid, HDA_GEN_HP_EVENT,
4076 spec->detect_hp = 1;
4079 if (cfg->line_out_type == AUTO_PIN_LINE_OUT && cfg->line_outs) {
4080 if (cfg->speaker_outs)
4081 for (i = 0; i < cfg->line_outs; i++) {
4082 hda_nid_t nid = cfg->line_out_pins[i];
4083 if (!is_jack_detectable(codec, nid))
4085 snd_printdd("hda-codec: Enable Line-Out auto-muting on NID 0x%x\n", nid);
4086 snd_hda_jack_detect_enable_callback(codec, nid,
4087 HDA_GEN_FRONT_EVENT,
4088 call_line_automute);
4089 spec->detect_lo = 1;
4091 spec->automute_lo_possible = spec->detect_hp;
4094 spec->automute_speaker_possible = cfg->speaker_outs &&
4095 (spec->detect_hp || spec->detect_lo);
4097 spec->automute_lo = spec->automute_lo_possible;
4098 spec->automute_speaker = spec->automute_speaker_possible;
4100 if (spec->automute_speaker_possible || spec->automute_lo_possible) {
4101 /* create a control for automute mode */
4102 err = add_automute_mode_enum(codec);
4109 /* check whether all auto-mic pins are valid; setup indices if OK */
4110 static bool auto_mic_check_imux(struct hda_codec *codec)
4112 struct hda_gen_spec *spec = codec->spec;
4113 const struct hda_input_mux *imux;
4116 imux = &spec->input_mux;
4117 for (i = 0; i < spec->am_num_entries; i++) {
4118 spec->am_entry[i].idx =
4119 find_idx_in_nid_list(spec->am_entry[i].pin,
4120 spec->imux_pins, imux->num_items);
4121 if (spec->am_entry[i].idx < 0)
4122 return false; /* no corresponding imux */
4125 /* we don't need the jack detection for the first pin */
4126 for (i = 1; i < spec->am_num_entries; i++)
4127 snd_hda_jack_detect_enable_callback(codec,
4128 spec->am_entry[i].pin,
4130 call_mic_autoswitch);
4134 static int compare_attr(const void *ap, const void *bp)
4136 const struct automic_entry *a = ap;
4137 const struct automic_entry *b = bp;
4138 return (int)(a->attr - b->attr);
4142 * Check the availability of auto-mic switch;
4143 * Set up if really supported
4145 static int check_auto_mic_availability(struct hda_codec *codec)
4147 struct hda_gen_spec *spec = codec->spec;
4148 struct auto_pin_cfg *cfg = &spec->autocfg;
4152 if (spec->suppress_auto_mic)
4157 for (i = 0; i < cfg->num_inputs; i++) {
4158 hda_nid_t nid = cfg->inputs[i].pin;
4160 attr = snd_hda_codec_get_pincfg(codec, nid);
4161 attr = snd_hda_get_input_pin_attr(attr);
4162 if (types & (1 << attr))
4163 return 0; /* already occupied */
4165 case INPUT_PIN_ATTR_INT:
4166 if (cfg->inputs[i].type != AUTO_PIN_MIC)
4167 return 0; /* invalid type */
4169 case INPUT_PIN_ATTR_UNUSED:
4170 return 0; /* invalid entry */
4172 if (cfg->inputs[i].type > AUTO_PIN_LINE_IN)
4173 return 0; /* invalid type */
4174 if (!spec->line_in_auto_switch &&
4175 cfg->inputs[i].type != AUTO_PIN_MIC)
4176 return 0; /* only mic is allowed */
4177 if (!is_jack_detectable(codec, nid))
4178 return 0; /* no unsol support */
4181 if (num_pins >= MAX_AUTO_MIC_PINS)
4183 types |= (1 << attr);
4184 spec->am_entry[num_pins].pin = nid;
4185 spec->am_entry[num_pins].attr = attr;
4192 spec->am_num_entries = num_pins;
4193 /* sort the am_entry in the order of attr so that the pin with a
4194 * higher attr will be selected when the jack is plugged.
4196 sort(spec->am_entry, num_pins, sizeof(spec->am_entry[0]),
4197 compare_attr, NULL);
4199 if (!auto_mic_check_imux(codec))
4203 spec->num_adc_nids = 1;
4204 spec->cur_mux[0] = spec->am_entry[0].idx;
4205 snd_printdd("hda-codec: Enable auto-mic switch on NID 0x%x/0x%x/0x%x\n",
4206 spec->am_entry[0].pin,
4207 spec->am_entry[1].pin,
4208 spec->am_entry[2].pin);
4213 /* power_filter hook; make inactive widgets into power down */
4214 static unsigned int snd_hda_gen_path_power_filter(struct hda_codec *codec,
4216 unsigned int power_state)
4218 if (power_state != AC_PWRST_D0)
4220 if (get_wcaps_type(get_wcaps(codec, nid)) >= AC_WID_POWER)
4222 if (is_active_nid_for_any(codec, nid))
4227 /* mute all aamix inputs initially; parse up to the first leaves */
4228 static void mute_all_mixer_nid(struct hda_codec *codec, hda_nid_t mix)
4231 const hda_nid_t *conn;
4234 nums = snd_hda_get_conn_list(codec, mix, &conn);
4235 has_amp = nid_has_mute(codec, mix, HDA_INPUT);
4236 for (i = 0; i < nums; i++) {
4238 snd_hda_codec_amp_stereo(codec, mix,
4240 0xff, HDA_AMP_MUTE);
4241 else if (nid_has_volume(codec, conn[i], HDA_OUTPUT))
4242 snd_hda_codec_amp_stereo(codec, conn[i],
4244 0xff, HDA_AMP_MUTE);
4249 * Parse the given BIOS configuration and set up the hda_gen_spec
4251 * return 1 if successful, 0 if the proper config is not found,
4252 * or a negative error code
4254 int snd_hda_gen_parse_auto_config(struct hda_codec *codec,
4255 struct auto_pin_cfg *cfg)
4257 struct hda_gen_spec *spec = codec->spec;
4260 parse_user_hints(codec);
4262 if (spec->mixer_nid && !spec->mixer_merge_nid)
4263 spec->mixer_merge_nid = spec->mixer_nid;
4265 if (cfg != &spec->autocfg) {
4266 spec->autocfg = *cfg;
4267 cfg = &spec->autocfg;
4270 if (!spec->main_out_badness)
4271 spec->main_out_badness = &hda_main_out_badness;
4272 if (!spec->extra_out_badness)
4273 spec->extra_out_badness = &hda_extra_out_badness;
4275 fill_all_dac_nids(codec);
4277 if (!cfg->line_outs) {
4278 if (cfg->dig_outs || cfg->dig_in_pin) {
4279 spec->multiout.max_channels = 2;
4280 spec->no_analog = 1;
4283 return 0; /* can't find valid BIOS pin config */
4286 if (!spec->no_primary_hp &&
4287 cfg->line_out_type == AUTO_PIN_SPEAKER_OUT &&
4288 cfg->line_outs <= cfg->hp_outs) {
4289 /* use HP as primary out */
4290 cfg->speaker_outs = cfg->line_outs;
4291 memcpy(cfg->speaker_pins, cfg->line_out_pins,
4292 sizeof(cfg->speaker_pins));
4293 cfg->line_outs = cfg->hp_outs;
4294 memcpy(cfg->line_out_pins, cfg->hp_pins, sizeof(cfg->hp_pins));
4296 memset(cfg->hp_pins, 0, sizeof(cfg->hp_pins));
4297 cfg->line_out_type = AUTO_PIN_HP_OUT;
4300 err = parse_output_paths(codec);
4303 err = create_multi_channel_mode(codec);
4306 err = create_multi_out_ctls(codec, cfg);
4309 err = create_hp_out_ctls(codec);
4312 err = create_speaker_out_ctls(codec);
4315 err = create_indep_hp_ctls(codec);
4318 err = create_loopback_mixing_ctl(codec);
4321 err = create_hp_mic(codec);
4324 err = create_input_ctls(codec);
4328 spec->const_channel_count = spec->ext_channel_count;
4329 /* check the multiple speaker and headphone pins */
4330 if (cfg->line_out_type != AUTO_PIN_SPEAKER_OUT)
4331 spec->const_channel_count = max(spec->const_channel_count,
4332 cfg->speaker_outs * 2);
4333 if (cfg->line_out_type != AUTO_PIN_HP_OUT)
4334 spec->const_channel_count = max(spec->const_channel_count,
4336 spec->multiout.max_channels = max(spec->ext_channel_count,
4337 spec->const_channel_count);
4339 err = check_auto_mute_availability(codec);
4343 err = check_dyn_adc_switch(codec);
4347 err = check_auto_mic_availability(codec);
4351 err = create_capture_mixers(codec);
4355 err = parse_mic_boost(codec);
4359 /* create "Headphone Mic Jack Mode" if no input selection is
4360 * available (or user specifies add_jack_modes hint)
4362 if (spec->hp_mic_pin &&
4363 (spec->auto_mic || spec->input_mux.num_items == 1 ||
4364 spec->add_jack_modes)) {
4365 err = create_hp_mic_jack_mode(codec, spec->hp_mic_pin);
4370 if (spec->add_jack_modes) {
4371 if (cfg->line_out_type != AUTO_PIN_SPEAKER_OUT) {
4372 err = create_out_jack_modes(codec, cfg->line_outs,
4373 cfg->line_out_pins);
4377 if (cfg->line_out_type != AUTO_PIN_HP_OUT) {
4378 err = create_out_jack_modes(codec, cfg->hp_outs,
4385 /* mute all aamix input initially */
4386 if (spec->mixer_nid)
4387 mute_all_mixer_nid(codec, spec->mixer_nid);
4390 parse_digital(codec);
4392 if (spec->power_down_unused)
4393 codec->power_filter = snd_hda_gen_path_power_filter;
4395 if (!spec->no_analog && spec->beep_nid) {
4396 err = snd_hda_attach_beep_device(codec, spec->beep_nid);
4403 EXPORT_SYMBOL_HDA(snd_hda_gen_parse_auto_config);
4407 * Build control elements
4410 /* slave controls for virtual master */
4411 static const char * const slave_pfxs[] = {
4412 "Front", "Surround", "Center", "LFE", "Side",
4413 "Headphone", "Speaker", "Mono", "Line Out",
4414 "CLFE", "Bass Speaker", "PCM",
4415 "Speaker Front", "Speaker Surround", "Speaker CLFE", "Speaker Side",
4416 "Headphone Front", "Headphone Surround", "Headphone CLFE",
4421 int snd_hda_gen_build_controls(struct hda_codec *codec)
4423 struct hda_gen_spec *spec = codec->spec;
4426 if (spec->kctls.used) {
4427 err = snd_hda_add_new_ctls(codec, spec->kctls.list);
4432 if (spec->multiout.dig_out_nid) {
4433 err = snd_hda_create_dig_out_ctls(codec,
4434 spec->multiout.dig_out_nid,
4435 spec->multiout.dig_out_nid,
4436 spec->pcm_rec[1].pcm_type);
4439 if (!spec->no_analog) {
4440 err = snd_hda_create_spdif_share_sw(codec,
4444 spec->multiout.share_spdif = 1;
4447 if (spec->dig_in_nid) {
4448 err = snd_hda_create_spdif_in_ctls(codec, spec->dig_in_nid);
4453 /* if we have no master control, let's create it */
4454 if (!spec->no_analog &&
4455 !snd_hda_find_mixer_ctl(codec, "Master Playback Volume")) {
4456 err = snd_hda_add_vmaster(codec, "Master Playback Volume",
4457 spec->vmaster_tlv, slave_pfxs,
4462 if (!spec->no_analog &&
4463 !snd_hda_find_mixer_ctl(codec, "Master Playback Switch")) {
4464 err = __snd_hda_add_vmaster(codec, "Master Playback Switch",
4467 true, &spec->vmaster_mute.sw_kctl);
4470 if (spec->vmaster_mute.hook) {
4471 snd_hda_add_vmaster_hook(codec, &spec->vmaster_mute,
4472 spec->vmaster_mute_enum);
4473 snd_hda_sync_vmaster_hook(&spec->vmaster_mute);
4477 free_kctls(spec); /* no longer needed */
4479 err = snd_hda_jack_add_kctls(codec, &spec->autocfg);
4485 EXPORT_SYMBOL_HDA(snd_hda_gen_build_controls);
4492 static void call_pcm_playback_hook(struct hda_pcm_stream *hinfo,
4493 struct hda_codec *codec,
4494 struct snd_pcm_substream *substream,
4497 struct hda_gen_spec *spec = codec->spec;
4498 if (spec->pcm_playback_hook)
4499 spec->pcm_playback_hook(hinfo, codec, substream, action);
4502 static void call_pcm_capture_hook(struct hda_pcm_stream *hinfo,
4503 struct hda_codec *codec,
4504 struct snd_pcm_substream *substream,
4507 struct hda_gen_spec *spec = codec->spec;
4508 if (spec->pcm_capture_hook)
4509 spec->pcm_capture_hook(hinfo, codec, substream, action);
4513 * Analog playback callbacks
4515 static int playback_pcm_open(struct hda_pcm_stream *hinfo,
4516 struct hda_codec *codec,
4517 struct snd_pcm_substream *substream)
4519 struct hda_gen_spec *spec = codec->spec;
4522 mutex_lock(&spec->pcm_mutex);
4523 err = snd_hda_multi_out_analog_open(codec,
4524 &spec->multiout, substream,
4527 spec->active_streams |= 1 << STREAM_MULTI_OUT;
4528 call_pcm_playback_hook(hinfo, codec, substream,
4529 HDA_GEN_PCM_ACT_OPEN);
4531 mutex_unlock(&spec->pcm_mutex);
4535 static int playback_pcm_prepare(struct hda_pcm_stream *hinfo,
4536 struct hda_codec *codec,
4537 unsigned int stream_tag,
4538 unsigned int format,
4539 struct snd_pcm_substream *substream)
4541 struct hda_gen_spec *spec = codec->spec;
4544 err = snd_hda_multi_out_analog_prepare(codec, &spec->multiout,
4545 stream_tag, format, substream);
4547 call_pcm_playback_hook(hinfo, codec, substream,
4548 HDA_GEN_PCM_ACT_PREPARE);
4552 static int playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
4553 struct hda_codec *codec,
4554 struct snd_pcm_substream *substream)
4556 struct hda_gen_spec *spec = codec->spec;
4559 err = snd_hda_multi_out_analog_cleanup(codec, &spec->multiout);
4561 call_pcm_playback_hook(hinfo, codec, substream,
4562 HDA_GEN_PCM_ACT_CLEANUP);
4566 static int playback_pcm_close(struct hda_pcm_stream *hinfo,
4567 struct hda_codec *codec,
4568 struct snd_pcm_substream *substream)
4570 struct hda_gen_spec *spec = codec->spec;
4571 mutex_lock(&spec->pcm_mutex);
4572 spec->active_streams &= ~(1 << STREAM_MULTI_OUT);
4573 call_pcm_playback_hook(hinfo, codec, substream,
4574 HDA_GEN_PCM_ACT_CLOSE);
4575 mutex_unlock(&spec->pcm_mutex);
4579 static int capture_pcm_open(struct hda_pcm_stream *hinfo,
4580 struct hda_codec *codec,
4581 struct snd_pcm_substream *substream)
4583 call_pcm_capture_hook(hinfo, codec, substream, HDA_GEN_PCM_ACT_OPEN);
4587 static int capture_pcm_prepare(struct hda_pcm_stream *hinfo,
4588 struct hda_codec *codec,
4589 unsigned int stream_tag,
4590 unsigned int format,
4591 struct snd_pcm_substream *substream)
4593 snd_hda_codec_setup_stream(codec, hinfo->nid, stream_tag, 0, format);
4594 call_pcm_capture_hook(hinfo, codec, substream,
4595 HDA_GEN_PCM_ACT_PREPARE);
4599 static int capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
4600 struct hda_codec *codec,
4601 struct snd_pcm_substream *substream)
4603 snd_hda_codec_cleanup_stream(codec, hinfo->nid);
4604 call_pcm_capture_hook(hinfo, codec, substream,
4605 HDA_GEN_PCM_ACT_CLEANUP);
4609 static int capture_pcm_close(struct hda_pcm_stream *hinfo,
4610 struct hda_codec *codec,
4611 struct snd_pcm_substream *substream)
4613 call_pcm_capture_hook(hinfo, codec, substream, HDA_GEN_PCM_ACT_CLOSE);
4617 static int alt_playback_pcm_open(struct hda_pcm_stream *hinfo,
4618 struct hda_codec *codec,
4619 struct snd_pcm_substream *substream)
4621 struct hda_gen_spec *spec = codec->spec;
4624 mutex_lock(&spec->pcm_mutex);
4625 if (!spec->indep_hp_enabled)
4628 spec->active_streams |= 1 << STREAM_INDEP_HP;
4629 call_pcm_playback_hook(hinfo, codec, substream,
4630 HDA_GEN_PCM_ACT_OPEN);
4631 mutex_unlock(&spec->pcm_mutex);
4635 static int alt_playback_pcm_close(struct hda_pcm_stream *hinfo,
4636 struct hda_codec *codec,
4637 struct snd_pcm_substream *substream)
4639 struct hda_gen_spec *spec = codec->spec;
4640 mutex_lock(&spec->pcm_mutex);
4641 spec->active_streams &= ~(1 << STREAM_INDEP_HP);
4642 call_pcm_playback_hook(hinfo, codec, substream,
4643 HDA_GEN_PCM_ACT_CLOSE);
4644 mutex_unlock(&spec->pcm_mutex);
4648 static int alt_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
4649 struct hda_codec *codec,
4650 unsigned int stream_tag,
4651 unsigned int format,
4652 struct snd_pcm_substream *substream)
4654 snd_hda_codec_setup_stream(codec, hinfo->nid, stream_tag, 0, format);
4655 call_pcm_playback_hook(hinfo, codec, substream,
4656 HDA_GEN_PCM_ACT_PREPARE);
4660 static int alt_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
4661 struct hda_codec *codec,
4662 struct snd_pcm_substream *substream)
4664 snd_hda_codec_cleanup_stream(codec, hinfo->nid);
4665 call_pcm_playback_hook(hinfo, codec, substream,
4666 HDA_GEN_PCM_ACT_CLEANUP);
4673 static int dig_playback_pcm_open(struct hda_pcm_stream *hinfo,
4674 struct hda_codec *codec,
4675 struct snd_pcm_substream *substream)
4677 struct hda_gen_spec *spec = codec->spec;
4678 return snd_hda_multi_out_dig_open(codec, &spec->multiout);
4681 static int dig_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
4682 struct hda_codec *codec,
4683 unsigned int stream_tag,
4684 unsigned int format,
4685 struct snd_pcm_substream *substream)
4687 struct hda_gen_spec *spec = codec->spec;
4688 return snd_hda_multi_out_dig_prepare(codec, &spec->multiout,
4689 stream_tag, format, substream);
4692 static int dig_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
4693 struct hda_codec *codec,
4694 struct snd_pcm_substream *substream)
4696 struct hda_gen_spec *spec = codec->spec;
4697 return snd_hda_multi_out_dig_cleanup(codec, &spec->multiout);
4700 static int dig_playback_pcm_close(struct hda_pcm_stream *hinfo,
4701 struct hda_codec *codec,
4702 struct snd_pcm_substream *substream)
4704 struct hda_gen_spec *spec = codec->spec;
4705 return snd_hda_multi_out_dig_close(codec, &spec->multiout);
4711 #define alt_capture_pcm_open capture_pcm_open
4712 #define alt_capture_pcm_close capture_pcm_close
4714 static int alt_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
4715 struct hda_codec *codec,
4716 unsigned int stream_tag,
4717 unsigned int format,
4718 struct snd_pcm_substream *substream)
4720 struct hda_gen_spec *spec = codec->spec;
4722 snd_hda_codec_setup_stream(codec, spec->adc_nids[substream->number + 1],
4723 stream_tag, 0, format);
4724 call_pcm_capture_hook(hinfo, codec, substream,
4725 HDA_GEN_PCM_ACT_PREPARE);
4729 static int alt_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
4730 struct hda_codec *codec,
4731 struct snd_pcm_substream *substream)
4733 struct hda_gen_spec *spec = codec->spec;
4735 snd_hda_codec_cleanup_stream(codec,
4736 spec->adc_nids[substream->number + 1]);
4737 call_pcm_capture_hook(hinfo, codec, substream,
4738 HDA_GEN_PCM_ACT_CLEANUP);
4744 static const struct hda_pcm_stream pcm_analog_playback = {
4748 /* NID is set in build_pcms */
4750 .open = playback_pcm_open,
4751 .close = playback_pcm_close,
4752 .prepare = playback_pcm_prepare,
4753 .cleanup = playback_pcm_cleanup
4757 static const struct hda_pcm_stream pcm_analog_capture = {
4761 /* NID is set in build_pcms */
4763 .open = capture_pcm_open,
4764 .close = capture_pcm_close,
4765 .prepare = capture_pcm_prepare,
4766 .cleanup = capture_pcm_cleanup
4770 static const struct hda_pcm_stream pcm_analog_alt_playback = {
4774 /* NID is set in build_pcms */
4776 .open = alt_playback_pcm_open,
4777 .close = alt_playback_pcm_close,
4778 .prepare = alt_playback_pcm_prepare,
4779 .cleanup = alt_playback_pcm_cleanup
4783 static const struct hda_pcm_stream pcm_analog_alt_capture = {
4784 .substreams = 2, /* can be overridden */
4787 /* NID is set in build_pcms */
4789 .open = alt_capture_pcm_open,
4790 .close = alt_capture_pcm_close,
4791 .prepare = alt_capture_pcm_prepare,
4792 .cleanup = alt_capture_pcm_cleanup
4796 static const struct hda_pcm_stream pcm_digital_playback = {
4800 /* NID is set in build_pcms */
4802 .open = dig_playback_pcm_open,
4803 .close = dig_playback_pcm_close,
4804 .prepare = dig_playback_pcm_prepare,
4805 .cleanup = dig_playback_pcm_cleanup
4809 static const struct hda_pcm_stream pcm_digital_capture = {
4813 /* NID is set in build_pcms */
4816 /* Used by build_pcms to flag that a PCM has no playback stream */
4817 static const struct hda_pcm_stream pcm_null_stream = {
4824 * dynamic changing ADC PCM streams
4826 static bool dyn_adc_pcm_resetup(struct hda_codec *codec, int cur)
4828 struct hda_gen_spec *spec = codec->spec;
4829 hda_nid_t new_adc = spec->adc_nids[spec->dyn_adc_idx[cur]];
4831 if (spec->cur_adc && spec->cur_adc != new_adc) {
4832 /* stream is running, let's swap the current ADC */
4833 __snd_hda_codec_cleanup_stream(codec, spec->cur_adc, 1);
4834 spec->cur_adc = new_adc;
4835 snd_hda_codec_setup_stream(codec, new_adc,
4836 spec->cur_adc_stream_tag, 0,
4837 spec->cur_adc_format);
4843 /* analog capture with dynamic dual-adc changes */
4844 static int dyn_adc_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
4845 struct hda_codec *codec,
4846 unsigned int stream_tag,
4847 unsigned int format,
4848 struct snd_pcm_substream *substream)
4850 struct hda_gen_spec *spec = codec->spec;
4851 spec->cur_adc = spec->adc_nids[spec->dyn_adc_idx[spec->cur_mux[0]]];
4852 spec->cur_adc_stream_tag = stream_tag;
4853 spec->cur_adc_format = format;
4854 snd_hda_codec_setup_stream(codec, spec->cur_adc, stream_tag, 0, format);
4858 static int dyn_adc_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
4859 struct hda_codec *codec,
4860 struct snd_pcm_substream *substream)
4862 struct hda_gen_spec *spec = codec->spec;
4863 snd_hda_codec_cleanup_stream(codec, spec->cur_adc);
4868 static const struct hda_pcm_stream dyn_adc_pcm_analog_capture = {
4872 .nid = 0, /* fill later */
4874 .prepare = dyn_adc_capture_pcm_prepare,
4875 .cleanup = dyn_adc_capture_pcm_cleanup
4879 static void fill_pcm_stream_name(char *str, size_t len, const char *sfx,
4880 const char *chip_name)
4886 strlcpy(str, chip_name, len);
4888 /* drop non-alnum chars after a space */
4889 for (p = strchr(str, ' '); p; p = strchr(p + 1, ' ')) {
4890 if (!isalnum(p[1])) {
4895 strlcat(str, sfx, len);
4898 /* build PCM streams based on the parsed results */
4899 int snd_hda_gen_build_pcms(struct hda_codec *codec)
4901 struct hda_gen_spec *spec = codec->spec;
4902 struct hda_pcm *info = spec->pcm_rec;
4903 const struct hda_pcm_stream *p;
4904 bool have_multi_adcs;
4906 codec->num_pcms = 1;
4907 codec->pcm_info = info;
4909 if (spec->no_analog)
4912 fill_pcm_stream_name(spec->stream_name_analog,
4913 sizeof(spec->stream_name_analog),
4914 " Analog", codec->chip_name);
4915 info->name = spec->stream_name_analog;
4917 if (spec->multiout.num_dacs > 0) {
4918 p = spec->stream_analog_playback;
4920 p = &pcm_analog_playback;
4921 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *p;
4922 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dac_nids[0];
4923 info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max =
4924 spec->multiout.max_channels;
4925 if (spec->autocfg.line_out_type == AUTO_PIN_SPEAKER_OUT &&
4926 spec->autocfg.line_outs == 2)
4927 info->stream[SNDRV_PCM_STREAM_PLAYBACK].chmap =
4930 if (spec->num_adc_nids) {
4931 p = spec->stream_analog_capture;
4933 if (spec->dyn_adc_switch)
4934 p = &dyn_adc_pcm_analog_capture;
4936 p = &pcm_analog_capture;
4938 info->stream[SNDRV_PCM_STREAM_CAPTURE] = *p;
4939 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adc_nids[0];
4943 /* SPDIF for stream index #1 */
4944 if (spec->multiout.dig_out_nid || spec->dig_in_nid) {
4945 fill_pcm_stream_name(spec->stream_name_digital,
4946 sizeof(spec->stream_name_digital),
4947 " Digital", codec->chip_name);
4948 codec->num_pcms = 2;
4949 codec->slave_dig_outs = spec->multiout.slave_dig_outs;
4950 info = spec->pcm_rec + 1;
4951 info->name = spec->stream_name_digital;
4952 if (spec->dig_out_type)
4953 info->pcm_type = spec->dig_out_type;
4955 info->pcm_type = HDA_PCM_TYPE_SPDIF;
4956 if (spec->multiout.dig_out_nid) {
4957 p = spec->stream_digital_playback;
4959 p = &pcm_digital_playback;
4960 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *p;
4961 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dig_out_nid;
4963 if (spec->dig_in_nid) {
4964 p = spec->stream_digital_capture;
4966 p = &pcm_digital_capture;
4967 info->stream[SNDRV_PCM_STREAM_CAPTURE] = *p;
4968 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->dig_in_nid;
4972 if (spec->no_analog)
4975 /* If the use of more than one ADC is requested for the current
4976 * model, configure a second analog capture-only PCM.
4978 have_multi_adcs = (spec->num_adc_nids > 1) &&
4979 !spec->dyn_adc_switch && !spec->auto_mic;
4980 /* Additional Analaog capture for index #2 */
4981 if (spec->alt_dac_nid || have_multi_adcs) {
4982 fill_pcm_stream_name(spec->stream_name_alt_analog,
4983 sizeof(spec->stream_name_alt_analog),
4984 " Alt Analog", codec->chip_name);
4985 codec->num_pcms = 3;
4986 info = spec->pcm_rec + 2;
4987 info->name = spec->stream_name_alt_analog;
4988 if (spec->alt_dac_nid) {
4989 p = spec->stream_analog_alt_playback;
4991 p = &pcm_analog_alt_playback;
4992 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *p;
4993 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid =
4996 info->stream[SNDRV_PCM_STREAM_PLAYBACK] =
4998 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = 0;
5000 if (have_multi_adcs) {
5001 p = spec->stream_analog_alt_capture;
5003 p = &pcm_analog_alt_capture;
5004 info->stream[SNDRV_PCM_STREAM_CAPTURE] = *p;
5005 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid =
5007 info->stream[SNDRV_PCM_STREAM_CAPTURE].substreams =
5008 spec->num_adc_nids - 1;
5010 info->stream[SNDRV_PCM_STREAM_CAPTURE] =
5012 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = 0;
5018 EXPORT_SYMBOL_HDA(snd_hda_gen_build_pcms);
5022 * Standard auto-parser initializations
5025 /* configure the given path as a proper output */
5026 static void set_output_and_unmute(struct hda_codec *codec, int path_idx)
5028 struct nid_path *path;
5031 path = snd_hda_get_path_from_idx(codec, path_idx);
5032 if (!path || !path->depth)
5034 pin = path->path[path->depth - 1];
5035 restore_pin_ctl(codec, pin);
5036 snd_hda_activate_path(codec, path, path->active,
5037 aamix_default(codec->spec));
5038 set_pin_eapd(codec, pin, path->active);
5041 /* initialize primary output paths */
5042 static void init_multi_out(struct hda_codec *codec)
5044 struct hda_gen_spec *spec = codec->spec;
5047 for (i = 0; i < spec->autocfg.line_outs; i++)
5048 set_output_and_unmute(codec, spec->out_paths[i]);
5052 static void __init_extra_out(struct hda_codec *codec, int num_outs, int *paths)
5056 for (i = 0; i < num_outs; i++)
5057 set_output_and_unmute(codec, paths[i]);
5060 /* initialize hp and speaker paths */
5061 static void init_extra_out(struct hda_codec *codec)
5063 struct hda_gen_spec *spec = codec->spec;
5065 if (spec->autocfg.line_out_type != AUTO_PIN_HP_OUT)
5066 __init_extra_out(codec, spec->autocfg.hp_outs, spec->hp_paths);
5067 if (spec->autocfg.line_out_type != AUTO_PIN_SPEAKER_OUT)
5068 __init_extra_out(codec, spec->autocfg.speaker_outs,
5069 spec->speaker_paths);
5072 /* initialize multi-io paths */
5073 static void init_multi_io(struct hda_codec *codec)
5075 struct hda_gen_spec *spec = codec->spec;
5078 for (i = 0; i < spec->multi_ios; i++) {
5079 hda_nid_t pin = spec->multi_io[i].pin;
5080 struct nid_path *path;
5081 path = get_multiio_path(codec, i);
5084 if (!spec->multi_io[i].ctl_in)
5085 spec->multi_io[i].ctl_in =
5086 snd_hda_codec_get_pin_target(codec, pin);
5087 snd_hda_activate_path(codec, path, path->active,
5088 aamix_default(spec));
5092 /* set up input pins and loopback paths */
5093 static void init_analog_input(struct hda_codec *codec)
5095 struct hda_gen_spec *spec = codec->spec;
5096 struct auto_pin_cfg *cfg = &spec->autocfg;
5099 for (i = 0; i < cfg->num_inputs; i++) {
5100 hda_nid_t nid = cfg->inputs[i].pin;
5101 if (is_input_pin(codec, nid))
5102 restore_pin_ctl(codec, nid);
5104 /* init loopback inputs */
5105 if (spec->mixer_nid) {
5106 resume_path_from_idx(codec, spec->loopback_paths[i]);
5107 resume_path_from_idx(codec, spec->loopback_merge_path);
5112 /* initialize ADC paths */
5113 static void init_input_src(struct hda_codec *codec)
5115 struct hda_gen_spec *spec = codec->spec;
5116 struct hda_input_mux *imux = &spec->input_mux;
5117 struct nid_path *path;
5120 if (spec->dyn_adc_switch)
5123 nums = spec->num_adc_nids;
5125 for (c = 0; c < nums; c++) {
5126 for (i = 0; i < imux->num_items; i++) {
5127 path = get_input_path(codec, c, i);
5129 bool active = path->active;
5130 if (i == spec->cur_mux[c])
5132 snd_hda_activate_path(codec, path, active, false);
5136 update_hp_mic(codec, c, true);
5139 if (spec->cap_sync_hook)
5140 spec->cap_sync_hook(codec, NULL);
5143 /* set right pin controls for digital I/O */
5144 static void init_digital(struct hda_codec *codec)
5146 struct hda_gen_spec *spec = codec->spec;
5150 for (i = 0; i < spec->autocfg.dig_outs; i++)
5151 set_output_and_unmute(codec, spec->digout_paths[i]);
5152 pin = spec->autocfg.dig_in_pin;
5154 restore_pin_ctl(codec, pin);
5155 resume_path_from_idx(codec, spec->digin_path);
5159 /* clear unsol-event tags on unused pins; Conexant codecs seem to leave
5160 * invalid unsol tags by some reason
5162 static void clear_unsol_on_unused_pins(struct hda_codec *codec)
5166 for (i = 0; i < codec->init_pins.used; i++) {
5167 struct hda_pincfg *pin = snd_array_elem(&codec->init_pins, i);
5168 hda_nid_t nid = pin->nid;
5169 if (is_jack_detectable(codec, nid) &&
5170 !snd_hda_jack_tbl_get(codec, nid))
5171 snd_hda_codec_update_cache(codec, nid, 0,
5172 AC_VERB_SET_UNSOLICITED_ENABLE, 0);
5177 * initialize the generic spec;
5178 * this can be put as patch_ops.init function
5180 int snd_hda_gen_init(struct hda_codec *codec)
5182 struct hda_gen_spec *spec = codec->spec;
5184 if (spec->init_hook)
5185 spec->init_hook(codec);
5187 snd_hda_apply_verbs(codec);
5189 codec->cached_write = 1;
5191 init_multi_out(codec);
5192 init_extra_out(codec);
5193 init_multi_io(codec);
5194 init_analog_input(codec);
5195 init_input_src(codec);
5196 init_digital(codec);
5198 clear_unsol_on_unused_pins(codec);
5200 /* call init functions of standard auto-mute helpers */
5201 update_automute_all(codec);
5203 snd_hda_codec_flush_cache(codec);
5205 if (spec->vmaster_mute.sw_kctl && spec->vmaster_mute.hook)
5206 snd_hda_sync_vmaster_hook(&spec->vmaster_mute);
5208 hda_call_check_power_status(codec, 0x01);
5211 EXPORT_SYMBOL_HDA(snd_hda_gen_init);
5214 * free the generic spec;
5215 * this can be put as patch_ops.free function
5217 void snd_hda_gen_free(struct hda_codec *codec)
5219 snd_hda_detach_beep_device(codec);
5220 snd_hda_gen_spec_free(codec->spec);
5224 EXPORT_SYMBOL_HDA(snd_hda_gen_free);
5228 * check the loopback power save state;
5229 * this can be put as patch_ops.check_power_status function
5231 int snd_hda_gen_check_power_status(struct hda_codec *codec, hda_nid_t nid)
5233 struct hda_gen_spec *spec = codec->spec;
5234 return snd_hda_check_amp_list_power(codec, &spec->loopback, nid);
5236 EXPORT_SYMBOL_HDA(snd_hda_gen_check_power_status);
5241 * the generic codec support
5244 static const struct hda_codec_ops generic_patch_ops = {
5245 .build_controls = snd_hda_gen_build_controls,
5246 .build_pcms = snd_hda_gen_build_pcms,
5247 .init = snd_hda_gen_init,
5248 .free = snd_hda_gen_free,
5249 .unsol_event = snd_hda_jack_unsol_event,
5251 .check_power_status = snd_hda_gen_check_power_status,
5255 int snd_hda_parse_generic_codec(struct hda_codec *codec)
5257 struct hda_gen_spec *spec;
5260 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
5263 snd_hda_gen_spec_init(spec);
5266 err = snd_hda_parse_pin_defcfg(codec, &spec->autocfg, NULL, 0);
5270 err = snd_hda_gen_parse_auto_config(codec, &spec->autocfg);
5274 codec->patch_ops = generic_patch_ops;
5278 snd_hda_gen_free(codec);
5281 EXPORT_SYMBOL_HDA(snd_hda_parse_generic_codec);