2 * Universal Interface for Intel High Definition Audio Codec
4 * Generic widget tree parser
6 * Copyright (c) 2004 Takashi Iwai <tiwai@suse.de>
8 * This driver is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 2 of the License, or
11 * (at your option) any later version.
13 * This driver is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, write to the Free Software
20 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
23 #include <linux/init.h>
24 #include <linux/slab.h>
25 #include <linux/export.h>
26 #include <linux/sort.h>
27 #include <linux/delay.h>
28 #include <linux/ctype.h>
29 #include <linux/string.h>
30 #include <linux/bitops.h>
31 #include <linux/module.h>
32 #include <sound/core.h>
33 #include <sound/jack.h>
34 #include <sound/tlv.h>
35 #include "hda_codec.h"
36 #include "hda_local.h"
37 #include "hda_auto_parser.h"
40 #include "hda_generic.h"
44 * snd_hda_gen_spec_init - initialize hda_gen_spec struct
45 * @spec: hda_gen_spec object to initialize
47 * Initialize the given hda_gen_spec object.
49 int snd_hda_gen_spec_init(struct hda_gen_spec
*spec
)
51 snd_array_init(&spec
->kctls
, sizeof(struct snd_kcontrol_new
), 32);
52 snd_array_init(&spec
->paths
, sizeof(struct nid_path
), 8);
53 snd_array_init(&spec
->loopback_list
, sizeof(struct hda_amp_list
), 8);
54 mutex_init(&spec
->pcm_mutex
);
57 EXPORT_SYMBOL_GPL(snd_hda_gen_spec_init
);
60 * snd_hda_gen_add_kctl - Add a new kctl_new struct from the template
61 * @spec: hda_gen_spec object
62 * @name: name string to override the template, NULL if unchanged
63 * @temp: template for the new kctl
65 * Add a new kctl (actually snd_kcontrol_new to be instantiated later)
66 * element based on the given snd_kcontrol_new template @temp and the
67 * name string @name to the list in @spec.
68 * Returns the newly created object or NULL as error.
70 struct snd_kcontrol_new
*
71 snd_hda_gen_add_kctl(struct hda_gen_spec
*spec
, const char *name
,
72 const struct snd_kcontrol_new
*temp
)
74 struct snd_kcontrol_new
*knew
= snd_array_new(&spec
->kctls
);
79 knew
->name
= kstrdup(name
, GFP_KERNEL
);
81 knew
->name
= kstrdup(knew
->name
, GFP_KERNEL
);
86 EXPORT_SYMBOL_GPL(snd_hda_gen_add_kctl
);
88 static void free_kctls(struct hda_gen_spec
*spec
)
90 if (spec
->kctls
.list
) {
91 struct snd_kcontrol_new
*kctl
= spec
->kctls
.list
;
93 for (i
= 0; i
< spec
->kctls
.used
; i
++)
96 snd_array_free(&spec
->kctls
);
99 static void snd_hda_gen_spec_free(struct hda_gen_spec
*spec
)
104 snd_array_free(&spec
->paths
);
105 snd_array_free(&spec
->loopback_list
);
111 static void parse_user_hints(struct hda_codec
*codec
)
113 struct hda_gen_spec
*spec
= codec
->spec
;
116 val
= snd_hda_get_bool_hint(codec
, "jack_detect");
118 codec
->no_jack_detect
= !val
;
119 val
= snd_hda_get_bool_hint(codec
, "inv_jack_detect");
121 codec
->inv_jack_detect
= !!val
;
122 val
= snd_hda_get_bool_hint(codec
, "trigger_sense");
124 codec
->no_trigger_sense
= !val
;
125 val
= snd_hda_get_bool_hint(codec
, "inv_eapd");
127 codec
->inv_eapd
= !!val
;
128 val
= snd_hda_get_bool_hint(codec
, "pcm_format_first");
130 codec
->pcm_format_first
= !!val
;
131 val
= snd_hda_get_bool_hint(codec
, "sticky_stream");
133 codec
->no_sticky_stream
= !val
;
134 val
= snd_hda_get_bool_hint(codec
, "spdif_status_reset");
136 codec
->spdif_status_reset
= !!val
;
137 val
= snd_hda_get_bool_hint(codec
, "pin_amp_workaround");
139 codec
->pin_amp_workaround
= !!val
;
140 val
= snd_hda_get_bool_hint(codec
, "single_adc_amp");
142 codec
->single_adc_amp
= !!val
;
143 val
= snd_hda_get_bool_hint(codec
, "power_save_node");
145 codec
->power_save_node
= !!val
;
147 val
= snd_hda_get_bool_hint(codec
, "auto_mute");
149 spec
->suppress_auto_mute
= !val
;
150 val
= snd_hda_get_bool_hint(codec
, "auto_mic");
152 spec
->suppress_auto_mic
= !val
;
153 val
= snd_hda_get_bool_hint(codec
, "line_in_auto_switch");
155 spec
->line_in_auto_switch
= !!val
;
156 val
= snd_hda_get_bool_hint(codec
, "auto_mute_via_amp");
158 spec
->auto_mute_via_amp
= !!val
;
159 val
= snd_hda_get_bool_hint(codec
, "need_dac_fix");
161 spec
->need_dac_fix
= !!val
;
162 val
= snd_hda_get_bool_hint(codec
, "primary_hp");
164 spec
->no_primary_hp
= !val
;
165 val
= snd_hda_get_bool_hint(codec
, "multi_io");
167 spec
->no_multi_io
= !val
;
168 val
= snd_hda_get_bool_hint(codec
, "multi_cap_vol");
170 spec
->multi_cap_vol
= !!val
;
171 val
= snd_hda_get_bool_hint(codec
, "inv_dmic_split");
173 spec
->inv_dmic_split
= !!val
;
174 val
= snd_hda_get_bool_hint(codec
, "indep_hp");
176 spec
->indep_hp
= !!val
;
177 val
= snd_hda_get_bool_hint(codec
, "add_stereo_mix_input");
179 spec
->add_stereo_mix_input
= !!val
;
180 /* the following two are just for compatibility */
181 val
= snd_hda_get_bool_hint(codec
, "add_out_jack_modes");
183 spec
->add_jack_modes
= !!val
;
184 val
= snd_hda_get_bool_hint(codec
, "add_in_jack_modes");
186 spec
->add_jack_modes
= !!val
;
187 val
= snd_hda_get_bool_hint(codec
, "add_jack_modes");
189 spec
->add_jack_modes
= !!val
;
190 val
= snd_hda_get_bool_hint(codec
, "power_down_unused");
192 spec
->power_down_unused
= !!val
;
193 val
= snd_hda_get_bool_hint(codec
, "add_hp_mic");
195 spec
->hp_mic
= !!val
;
196 val
= snd_hda_get_bool_hint(codec
, "hp_mic_detect");
198 spec
->suppress_hp_mic_detect
= !val
;
200 if (!snd_hda_get_int_hint(codec
, "mixer_nid", &val
))
201 spec
->mixer_nid
= val
;
205 * pin control value accesses
208 #define update_pin_ctl(codec, pin, val) \
209 snd_hda_codec_update_cache(codec, pin, 0, \
210 AC_VERB_SET_PIN_WIDGET_CONTROL, val)
212 /* restore the pinctl based on the cached value */
213 static inline void restore_pin_ctl(struct hda_codec
*codec
, hda_nid_t pin
)
215 update_pin_ctl(codec
, pin
, snd_hda_codec_get_pin_target(codec
, pin
));
218 /* set the pinctl target value and write it if requested */
219 static void set_pin_target(struct hda_codec
*codec
, hda_nid_t pin
,
220 unsigned int val
, bool do_write
)
224 val
= snd_hda_correct_pin_ctl(codec
, pin
, val
);
225 snd_hda_codec_set_pin_target(codec
, pin
, val
);
227 update_pin_ctl(codec
, pin
, val
);
230 /* set pinctl target values for all given pins */
231 static void set_pin_targets(struct hda_codec
*codec
, int num_pins
,
232 hda_nid_t
*pins
, unsigned int val
)
235 for (i
= 0; i
< num_pins
; i
++)
236 set_pin_target(codec
, pins
[i
], val
, false);
243 /* return the position of NID in the list, or -1 if not found */
244 static int find_idx_in_nid_list(hda_nid_t nid
, const hda_nid_t
*list
, int nums
)
247 for (i
= 0; i
< nums
; i
++)
253 /* return true if the given NID is contained in the path */
254 static bool is_nid_contained(struct nid_path
*path
, hda_nid_t nid
)
256 return find_idx_in_nid_list(nid
, path
->path
, path
->depth
) >= 0;
259 static struct nid_path
*get_nid_path(struct hda_codec
*codec
,
260 hda_nid_t from_nid
, hda_nid_t to_nid
,
263 struct hda_gen_spec
*spec
= codec
->spec
;
266 for (i
= 0; i
< spec
->paths
.used
; i
++) {
267 struct nid_path
*path
= snd_array_elem(&spec
->paths
, i
);
268 if (path
->depth
<= 0)
270 if ((!from_nid
|| path
->path
[0] == from_nid
) &&
271 (!to_nid
|| path
->path
[path
->depth
- 1] == to_nid
)) {
273 (anchor_nid
> 0 && is_nid_contained(path
, anchor_nid
)) ||
274 (anchor_nid
< 0 && !is_nid_contained(path
, anchor_nid
)))
282 * snd_hda_get_path_idx - get the index number corresponding to the path
284 * @codec: the HDA codec
285 * @path: nid_path object
287 * The returned index starts from 1, i.e. the actual array index with offset 1,
288 * and zero is handled as an invalid path
290 int snd_hda_get_path_idx(struct hda_codec
*codec
, struct nid_path
*path
)
292 struct hda_gen_spec
*spec
= codec
->spec
;
293 struct nid_path
*array
= spec
->paths
.list
;
296 if (!spec
->paths
.used
)
299 if (idx
< 0 || idx
>= spec
->paths
.used
)
303 EXPORT_SYMBOL_GPL(snd_hda_get_path_idx
);
306 * snd_hda_get_path_from_idx - get the path instance corresponding to the
308 * @codec: the HDA codec
309 * @idx: the path index
311 struct nid_path
*snd_hda_get_path_from_idx(struct hda_codec
*codec
, int idx
)
313 struct hda_gen_spec
*spec
= codec
->spec
;
315 if (idx
<= 0 || idx
> spec
->paths
.used
)
317 return snd_array_elem(&spec
->paths
, idx
- 1);
319 EXPORT_SYMBOL_GPL(snd_hda_get_path_from_idx
);
321 /* check whether the given DAC is already found in any existing paths */
322 static bool is_dac_already_used(struct hda_codec
*codec
, hda_nid_t nid
)
324 struct hda_gen_spec
*spec
= codec
->spec
;
327 for (i
= 0; i
< spec
->paths
.used
; i
++) {
328 struct nid_path
*path
= snd_array_elem(&spec
->paths
, i
);
329 if (path
->path
[0] == nid
)
335 /* check whether the given two widgets can be connected */
336 static bool is_reachable_path(struct hda_codec
*codec
,
337 hda_nid_t from_nid
, hda_nid_t to_nid
)
339 if (!from_nid
|| !to_nid
)
341 return snd_hda_get_conn_index(codec
, to_nid
, from_nid
, true) >= 0;
344 /* nid, dir and idx */
345 #define AMP_VAL_COMPARE_MASK (0xffff | (1U << 18) | (0x0f << 19))
347 /* check whether the given ctl is already assigned in any path elements */
348 static bool is_ctl_used(struct hda_codec
*codec
, unsigned int val
, int type
)
350 struct hda_gen_spec
*spec
= codec
->spec
;
353 val
&= AMP_VAL_COMPARE_MASK
;
354 for (i
= 0; i
< spec
->paths
.used
; i
++) {
355 struct nid_path
*path
= snd_array_elem(&spec
->paths
, i
);
356 if ((path
->ctls
[type
] & AMP_VAL_COMPARE_MASK
) == val
)
362 /* check whether a control with the given (nid, dir, idx) was assigned */
363 static bool is_ctl_associated(struct hda_codec
*codec
, hda_nid_t nid
,
364 int dir
, int idx
, int type
)
366 unsigned int val
= HDA_COMPOSE_AMP_VAL(nid
, 3, idx
, dir
);
367 return is_ctl_used(codec
, val
, type
);
370 static void print_nid_path(struct hda_codec
*codec
,
371 const char *pfx
, struct nid_path
*path
)
378 for (i
= 0; i
< path
->depth
; i
++)
379 pos
+= scnprintf(pos
, sizeof(buf
) - (pos
- buf
), "%s%02x",
380 pos
!= buf
? ":" : "",
383 codec_dbg(codec
, "%s path: depth=%d '%s'\n", pfx
, path
->depth
, buf
);
386 /* called recursively */
387 static bool __parse_nid_path(struct hda_codec
*codec
,
388 hda_nid_t from_nid
, hda_nid_t to_nid
,
389 int anchor_nid
, struct nid_path
*path
,
392 const hda_nid_t
*conn
;
395 if (to_nid
== anchor_nid
)
396 anchor_nid
= 0; /* anchor passed */
397 else if (to_nid
== (hda_nid_t
)(-anchor_nid
))
398 return false; /* hit the exclusive nid */
400 nums
= snd_hda_get_conn_list(codec
, to_nid
, &conn
);
401 for (i
= 0; i
< nums
; i
++) {
402 if (conn
[i
] != from_nid
) {
403 /* special case: when from_nid is 0,
404 * try to find an empty DAC
407 get_wcaps_type(get_wcaps(codec
, conn
[i
])) != AC_WID_AUD_OUT
||
408 is_dac_already_used(codec
, conn
[i
]))
411 /* anchor is not requested or already passed? */
415 if (depth
>= MAX_NID_PATH_DEPTH
)
417 for (i
= 0; i
< nums
; i
++) {
419 type
= get_wcaps_type(get_wcaps(codec
, conn
[i
]));
420 if (type
== AC_WID_AUD_OUT
|| type
== AC_WID_AUD_IN
||
423 if (__parse_nid_path(codec
, from_nid
, conn
[i
],
424 anchor_nid
, path
, depth
+ 1))
430 path
->path
[path
->depth
] = conn
[i
];
431 path
->idx
[path
->depth
+ 1] = i
;
432 if (nums
> 1 && get_wcaps_type(get_wcaps(codec
, to_nid
)) != AC_WID_AUD_MIX
)
433 path
->multi
[path
->depth
+ 1] = 1;
439 * snd_hda_parse_nid_path - parse the widget path from the given nid to
441 * @codec: the HDA codec
442 * @from_nid: the NID where the path start from
443 * @to_nid: the NID where the path ends at
444 * @anchor_nid: the anchor indication
445 * @path: the path object to store the result
447 * Returns true if a matching path is found.
449 * The parsing behavior depends on parameters:
450 * when @from_nid is 0, try to find an empty DAC;
451 * when @anchor_nid is set to a positive value, only paths through the widget
452 * with the given value are evaluated.
453 * when @anchor_nid is set to a negative value, paths through the widget
454 * with the negative of given value are excluded, only other paths are chosen.
455 * when @anchor_nid is zero, no special handling about path selection.
457 static bool snd_hda_parse_nid_path(struct hda_codec
*codec
, hda_nid_t from_nid
,
458 hda_nid_t to_nid
, int anchor_nid
,
459 struct nid_path
*path
)
461 if (__parse_nid_path(codec
, from_nid
, to_nid
, anchor_nid
, path
, 1)) {
462 path
->path
[path
->depth
] = to_nid
;
470 * snd_hda_add_new_path - parse the path between the given NIDs and
471 * add to the path list
472 * @codec: the HDA codec
473 * @from_nid: the NID where the path start from
474 * @to_nid: the NID where the path ends at
475 * @anchor_nid: the anchor indication, see snd_hda_parse_nid_path()
477 * If no valid path is found, returns NULL.
480 snd_hda_add_new_path(struct hda_codec
*codec
, hda_nid_t from_nid
,
481 hda_nid_t to_nid
, int anchor_nid
)
483 struct hda_gen_spec
*spec
= codec
->spec
;
484 struct nid_path
*path
;
486 if (from_nid
&& to_nid
&& !is_reachable_path(codec
, from_nid
, to_nid
))
489 /* check whether the path has been already added */
490 path
= get_nid_path(codec
, from_nid
, to_nid
, anchor_nid
);
494 path
= snd_array_new(&spec
->paths
);
497 memset(path
, 0, sizeof(*path
));
498 if (snd_hda_parse_nid_path(codec
, from_nid
, to_nid
, anchor_nid
, path
))
504 EXPORT_SYMBOL_GPL(snd_hda_add_new_path
);
506 /* clear the given path as invalid so that it won't be picked up later */
507 static void invalidate_nid_path(struct hda_codec
*codec
, int idx
)
509 struct nid_path
*path
= snd_hda_get_path_from_idx(codec
, idx
);
512 memset(path
, 0, sizeof(*path
));
515 /* return a DAC if paired to the given pin by codec driver */
516 static hda_nid_t
get_preferred_dac(struct hda_codec
*codec
, hda_nid_t pin
)
518 struct hda_gen_spec
*spec
= codec
->spec
;
519 const hda_nid_t
*list
= spec
->preferred_dacs
;
523 for (; *list
; list
+= 2)
529 /* look for an empty DAC slot */
530 static hda_nid_t
look_for_dac(struct hda_codec
*codec
, hda_nid_t pin
,
533 struct hda_gen_spec
*spec
= codec
->spec
;
537 for (i
= 0; i
< spec
->num_all_dacs
; i
++) {
538 hda_nid_t nid
= spec
->all_dacs
[i
];
539 if (!nid
|| is_dac_already_used(codec
, nid
))
541 cap_digital
= !!(get_wcaps(codec
, nid
) & AC_WCAP_DIGITAL
);
542 if (is_digital
!= cap_digital
)
544 if (is_reachable_path(codec
, nid
, pin
))
550 /* replace the channels in the composed amp value with the given number */
551 static unsigned int amp_val_replace_channels(unsigned int val
, unsigned int chs
)
553 val
&= ~(0x3U
<< 16);
558 static bool same_amp_caps(struct hda_codec
*codec
, hda_nid_t nid1
,
559 hda_nid_t nid2
, int dir
)
561 if (!(get_wcaps(codec
, nid1
) & (1 << (dir
+ 1))))
562 return !(get_wcaps(codec
, nid2
) & (1 << (dir
+ 1)));
563 return (query_amp_caps(codec
, nid1
, dir
) ==
564 query_amp_caps(codec
, nid2
, dir
));
567 /* look for a widget suitable for assigning a mute switch in the path */
568 static hda_nid_t
look_for_out_mute_nid(struct hda_codec
*codec
,
569 struct nid_path
*path
)
573 for (i
= path
->depth
- 1; i
>= 0; i
--) {
574 if (nid_has_mute(codec
, path
->path
[i
], HDA_OUTPUT
))
575 return path
->path
[i
];
576 if (i
!= path
->depth
- 1 && i
!= 0 &&
577 nid_has_mute(codec
, path
->path
[i
], HDA_INPUT
))
578 return path
->path
[i
];
583 /* look for a widget suitable for assigning a volume ctl in the path */
584 static hda_nid_t
look_for_out_vol_nid(struct hda_codec
*codec
,
585 struct nid_path
*path
)
587 struct hda_gen_spec
*spec
= codec
->spec
;
590 for (i
= path
->depth
- 1; i
>= 0; i
--) {
591 hda_nid_t nid
= path
->path
[i
];
592 if ((spec
->out_vol_mask
>> nid
) & 1)
594 if (nid_has_volume(codec
, nid
, HDA_OUTPUT
))
601 * path activation / deactivation
604 /* can have the amp-in capability? */
605 static bool has_amp_in(struct hda_codec
*codec
, struct nid_path
*path
, int idx
)
607 hda_nid_t nid
= path
->path
[idx
];
608 unsigned int caps
= get_wcaps(codec
, nid
);
609 unsigned int type
= get_wcaps_type(caps
);
611 if (!(caps
& AC_WCAP_IN_AMP
))
613 if (type
== AC_WID_PIN
&& idx
> 0) /* only for input pins */
618 /* can have the amp-out capability? */
619 static bool has_amp_out(struct hda_codec
*codec
, struct nid_path
*path
, int idx
)
621 hda_nid_t nid
= path
->path
[idx
];
622 unsigned int caps
= get_wcaps(codec
, nid
);
623 unsigned int type
= get_wcaps_type(caps
);
625 if (!(caps
& AC_WCAP_OUT_AMP
))
627 if (type
== AC_WID_PIN
&& !idx
) /* only for output pins */
632 /* check whether the given (nid,dir,idx) is active */
633 static bool is_active_nid(struct hda_codec
*codec
, hda_nid_t nid
,
634 unsigned int dir
, unsigned int idx
)
636 struct hda_gen_spec
*spec
= codec
->spec
;
637 int type
= get_wcaps_type(get_wcaps(codec
, nid
));
640 if (nid
== codec
->core
.afg
)
643 for (n
= 0; n
< spec
->paths
.used
; n
++) {
644 struct nid_path
*path
= snd_array_elem(&spec
->paths
, n
);
647 if (codec
->power_save_node
) {
648 if (!path
->stream_enabled
)
650 /* ignore unplugged paths except for DAC/ADC */
651 if (!(path
->pin_enabled
|| path
->pin_fixed
) &&
652 type
!= AC_WID_AUD_OUT
&& type
!= AC_WID_AUD_IN
)
655 for (i
= 0; i
< path
->depth
; i
++) {
656 if (path
->path
[i
] == nid
) {
657 if (dir
== HDA_OUTPUT
|| idx
== -1 ||
667 /* check whether the NID is referred by any active paths */
668 #define is_active_nid_for_any(codec, nid) \
669 is_active_nid(codec, nid, HDA_OUTPUT, -1)
671 /* get the default amp value for the target state */
672 static int get_amp_val_to_activate(struct hda_codec
*codec
, hda_nid_t nid
,
673 int dir
, unsigned int caps
, bool enable
)
675 unsigned int val
= 0;
677 if (caps
& AC_AMPCAP_NUM_STEPS
) {
680 val
= (caps
& AC_AMPCAP_OFFSET
) >> AC_AMPCAP_OFFSET_SHIFT
;
682 if (caps
& (AC_AMPCAP_MUTE
| AC_AMPCAP_MIN_MUTE
)) {
689 /* is this a stereo widget or a stereo-to-mono mix? */
690 static bool is_stereo_amps(struct hda_codec
*codec
, hda_nid_t nid
, int dir
)
692 unsigned int wcaps
= get_wcaps(codec
, nid
);
695 if (wcaps
& AC_WCAP_STEREO
)
697 if (dir
!= HDA_INPUT
|| get_wcaps_type(wcaps
) != AC_WID_AUD_MIX
)
699 if (snd_hda_get_num_conns(codec
, nid
) != 1)
701 if (snd_hda_get_connections(codec
, nid
, &conn
, 1) < 0)
703 return !!(get_wcaps(codec
, conn
) & AC_WCAP_STEREO
);
706 /* initialize the amp value (only at the first time) */
707 static void init_amp(struct hda_codec
*codec
, hda_nid_t nid
, int dir
, int idx
)
709 unsigned int caps
= query_amp_caps(codec
, nid
, dir
);
710 int val
= get_amp_val_to_activate(codec
, nid
, dir
, caps
, false);
712 if (is_stereo_amps(codec
, nid
, dir
))
713 snd_hda_codec_amp_init_stereo(codec
, nid
, dir
, idx
, 0xff, val
);
715 snd_hda_codec_amp_init(codec
, nid
, 0, dir
, idx
, 0xff, val
);
718 /* update the amp, doing in stereo or mono depending on NID */
719 static int update_amp(struct hda_codec
*codec
, hda_nid_t nid
, int dir
, int idx
,
720 unsigned int mask
, unsigned int val
)
722 if (is_stereo_amps(codec
, nid
, dir
))
723 return snd_hda_codec_amp_stereo(codec
, nid
, dir
, idx
,
726 return snd_hda_codec_amp_update(codec
, nid
, 0, dir
, idx
,
730 /* calculate amp value mask we can modify;
731 * if the given amp is controlled by mixers, don't touch it
733 static unsigned int get_amp_mask_to_modify(struct hda_codec
*codec
,
734 hda_nid_t nid
, int dir
, int idx
,
737 unsigned int mask
= 0xff;
739 if (caps
& (AC_AMPCAP_MUTE
| AC_AMPCAP_MIN_MUTE
)) {
740 if (is_ctl_associated(codec
, nid
, dir
, idx
, NID_PATH_MUTE_CTL
))
743 if (caps
& AC_AMPCAP_NUM_STEPS
) {
744 if (is_ctl_associated(codec
, nid
, dir
, idx
, NID_PATH_VOL_CTL
) ||
745 is_ctl_associated(codec
, nid
, dir
, idx
, NID_PATH_BOOST_CTL
))
751 static void activate_amp(struct hda_codec
*codec
, hda_nid_t nid
, int dir
,
752 int idx
, int idx_to_check
, bool enable
)
755 unsigned int mask
, val
;
757 caps
= query_amp_caps(codec
, nid
, dir
);
758 val
= get_amp_val_to_activate(codec
, nid
, dir
, caps
, enable
);
759 mask
= get_amp_mask_to_modify(codec
, nid
, dir
, idx_to_check
, caps
);
764 update_amp(codec
, nid
, dir
, idx
, mask
, val
);
767 static void check_and_activate_amp(struct hda_codec
*codec
, hda_nid_t nid
,
768 int dir
, int idx
, int idx_to_check
,
771 /* check whether the given amp is still used by others */
772 if (!enable
&& is_active_nid(codec
, nid
, dir
, idx_to_check
))
774 activate_amp(codec
, nid
, dir
, idx
, idx_to_check
, enable
);
777 static void activate_amp_out(struct hda_codec
*codec
, struct nid_path
*path
,
780 hda_nid_t nid
= path
->path
[i
];
781 init_amp(codec
, nid
, HDA_OUTPUT
, 0);
782 check_and_activate_amp(codec
, nid
, HDA_OUTPUT
, 0, 0, enable
);
785 static void activate_amp_in(struct hda_codec
*codec
, struct nid_path
*path
,
786 int i
, bool enable
, bool add_aamix
)
788 struct hda_gen_spec
*spec
= codec
->spec
;
789 const hda_nid_t
*conn
;
792 hda_nid_t nid
= path
->path
[i
];
794 nums
= snd_hda_get_conn_list(codec
, nid
, &conn
);
795 type
= get_wcaps_type(get_wcaps(codec
, nid
));
796 if (type
== AC_WID_PIN
||
797 (type
== AC_WID_AUD_IN
&& codec
->single_adc_amp
)) {
803 for (n
= 0; n
< nums
; n
++)
804 init_amp(codec
, nid
, HDA_INPUT
, n
);
806 /* here is a little bit tricky in comparison with activate_amp_out();
807 * when aa-mixer is available, we need to enable the path as well
809 for (n
= 0; n
< nums
; n
++) {
811 if (conn
[n
] != spec
->mixer_merge_nid
)
813 /* when aamix is disabled, force to off */
815 activate_amp(codec
, nid
, HDA_INPUT
, n
, n
, false);
819 check_and_activate_amp(codec
, nid
, HDA_INPUT
, n
, idx
, enable
);
823 /* sync power of each widget in the the given path */
824 static hda_nid_t
path_power_update(struct hda_codec
*codec
,
825 struct nid_path
*path
,
826 bool allow_powerdown
)
828 hda_nid_t nid
, changed
= 0;
831 for (i
= 0; i
< path
->depth
; i
++) {
833 if (!(get_wcaps(codec
, nid
) & AC_WCAP_POWER
))
835 if (nid
== codec
->core
.afg
)
837 if (!allow_powerdown
|| is_active_nid_for_any(codec
, nid
))
841 if (!snd_hda_check_power_state(codec
, nid
, state
)) {
842 snd_hda_codec_write(codec
, nid
, 0,
843 AC_VERB_SET_POWER_STATE
, state
);
845 /* all known codecs seem to be capable to handl
846 * widgets state even in D3, so far.
847 * if any new codecs need to restore the widget
848 * states after D0 transition, call the function
852 if (state
== AC_PWRST_D0
)
853 snd_hdac_regmap_sync_node(&codec
->core
, nid
);
860 /* do sync with the last power state change */
861 static void sync_power_state_change(struct hda_codec
*codec
, hda_nid_t nid
)
865 snd_hda_codec_read(codec
, nid
, 0, AC_VERB_GET_POWER_STATE
, 0);
870 * snd_hda_activate_path - activate or deactivate the given path
871 * @codec: the HDA codec
872 * @path: the path to activate/deactivate
873 * @enable: flag to activate or not
874 * @add_aamix: enable the input from aamix NID
876 * If @add_aamix is set, enable the input from aa-mix NID as well (if any).
878 void snd_hda_activate_path(struct hda_codec
*codec
, struct nid_path
*path
,
879 bool enable
, bool add_aamix
)
881 struct hda_gen_spec
*spec
= codec
->spec
;
884 path
->active
= enable
;
886 /* make sure the widget is powered up */
887 if (enable
&& (spec
->power_down_unused
|| codec
->power_save_node
))
888 path_power_update(codec
, path
, codec
->power_save_node
);
890 for (i
= path
->depth
- 1; i
>= 0; i
--) {
891 hda_nid_t nid
= path
->path
[i
];
893 if (enable
&& path
->multi
[i
])
894 snd_hda_codec_update_cache(codec
, nid
, 0,
895 AC_VERB_SET_CONNECT_SEL
,
897 if (has_amp_in(codec
, path
, i
))
898 activate_amp_in(codec
, path
, i
, enable
, add_aamix
);
899 if (has_amp_out(codec
, path
, i
))
900 activate_amp_out(codec
, path
, i
, enable
);
903 EXPORT_SYMBOL_GPL(snd_hda_activate_path
);
905 /* if the given path is inactive, put widgets into D3 (only if suitable) */
906 static void path_power_down_sync(struct hda_codec
*codec
, struct nid_path
*path
)
908 struct hda_gen_spec
*spec
= codec
->spec
;
910 if (!(spec
->power_down_unused
|| codec
->power_save_node
) || path
->active
)
912 sync_power_state_change(codec
, path_power_update(codec
, path
, true));
915 /* turn on/off EAPD on the given pin */
916 static void set_pin_eapd(struct hda_codec
*codec
, hda_nid_t pin
, bool enable
)
918 struct hda_gen_spec
*spec
= codec
->spec
;
919 if (spec
->own_eapd_ctl
||
920 !(snd_hda_query_pin_caps(codec
, pin
) & AC_PINCAP_EAPD
))
922 if (spec
->keep_eapd_on
&& !enable
)
926 snd_hda_codec_update_cache(codec
, pin
, 0,
927 AC_VERB_SET_EAPD_BTLENABLE
,
928 enable
? 0x02 : 0x00);
931 /* re-initialize the path specified by the given path index */
932 static void resume_path_from_idx(struct hda_codec
*codec
, int path_idx
)
934 struct nid_path
*path
= snd_hda_get_path_from_idx(codec
, path_idx
);
936 snd_hda_activate_path(codec
, path
, path
->active
, false);
941 * Helper functions for creating mixer ctl elements
944 static int hda_gen_mixer_mute_put(struct snd_kcontrol
*kcontrol
,
945 struct snd_ctl_elem_value
*ucontrol
);
946 static int hda_gen_bind_mute_put(struct snd_kcontrol
*kcontrol
,
947 struct snd_ctl_elem_value
*ucontrol
);
954 static const struct snd_kcontrol_new control_templates
[] = {
955 HDA_CODEC_VOLUME(NULL
, 0, 0, 0),
956 /* only the put callback is replaced for handling the special mute */
958 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
959 .subdevice
= HDA_SUBDEV_AMP_FLAG
,
960 .info
= snd_hda_mixer_amp_switch_info
,
961 .get
= snd_hda_mixer_amp_switch_get
,
962 .put
= hda_gen_mixer_mute_put
, /* replaced */
963 .private_value
= HDA_COMPOSE_AMP_VAL(0, 3, 0, 0),
966 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
967 .info
= snd_hda_mixer_amp_switch_info
,
968 .get
= snd_hda_mixer_bind_switch_get
,
969 .put
= hda_gen_bind_mute_put
, /* replaced */
970 .private_value
= HDA_COMPOSE_AMP_VAL(0, 3, 0, 0),
974 /* add dynamic controls from template */
975 static struct snd_kcontrol_new
*
976 add_control(struct hda_gen_spec
*spec
, int type
, const char *name
,
977 int cidx
, unsigned long val
)
979 struct snd_kcontrol_new
*knew
;
981 knew
= snd_hda_gen_add_kctl(spec
, name
, &control_templates
[type
]);
985 if (get_amp_nid_(val
))
986 knew
->subdevice
= HDA_SUBDEV_AMP_FLAG
;
987 knew
->private_value
= val
;
991 static int add_control_with_pfx(struct hda_gen_spec
*spec
, int type
,
992 const char *pfx
, const char *dir
,
993 const char *sfx
, int cidx
, unsigned long val
)
995 char name
[SNDRV_CTL_ELEM_ID_NAME_MAXLEN
];
996 snprintf(name
, sizeof(name
), "%s %s %s", pfx
, dir
, sfx
);
997 if (!add_control(spec
, type
, name
, cidx
, val
))
1002 #define add_pb_vol_ctrl(spec, type, pfx, val) \
1003 add_control_with_pfx(spec, type, pfx, "Playback", "Volume", 0, val)
1004 #define add_pb_sw_ctrl(spec, type, pfx, val) \
1005 add_control_with_pfx(spec, type, pfx, "Playback", "Switch", 0, val)
1006 #define __add_pb_vol_ctrl(spec, type, pfx, cidx, val) \
1007 add_control_with_pfx(spec, type, pfx, "Playback", "Volume", cidx, val)
1008 #define __add_pb_sw_ctrl(spec, type, pfx, cidx, val) \
1009 add_control_with_pfx(spec, type, pfx, "Playback", "Switch", cidx, val)
1011 static int add_vol_ctl(struct hda_codec
*codec
, const char *pfx
, int cidx
,
1012 unsigned int chs
, struct nid_path
*path
)
1017 val
= path
->ctls
[NID_PATH_VOL_CTL
];
1020 val
= amp_val_replace_channels(val
, chs
);
1021 return __add_pb_vol_ctrl(codec
->spec
, HDA_CTL_WIDGET_VOL
, pfx
, cidx
, val
);
1024 /* return the channel bits suitable for the given path->ctls[] */
1025 static int get_default_ch_nums(struct hda_codec
*codec
, struct nid_path
*path
,
1028 int chs
= 1; /* mono (left only) */
1030 hda_nid_t nid
= get_amp_nid_(path
->ctls
[type
]);
1031 if (nid
&& (get_wcaps(codec
, nid
) & AC_WCAP_STEREO
))
1032 chs
= 3; /* stereo */
1037 static int add_stereo_vol(struct hda_codec
*codec
, const char *pfx
, int cidx
,
1038 struct nid_path
*path
)
1040 int chs
= get_default_ch_nums(codec
, path
, NID_PATH_VOL_CTL
);
1041 return add_vol_ctl(codec
, pfx
, cidx
, chs
, path
);
1044 /* create a mute-switch for the given mixer widget;
1045 * if it has multiple sources (e.g. DAC and loopback), create a bind-mute
1047 static int add_sw_ctl(struct hda_codec
*codec
, const char *pfx
, int cidx
,
1048 unsigned int chs
, struct nid_path
*path
)
1051 int type
= HDA_CTL_WIDGET_MUTE
;
1055 val
= path
->ctls
[NID_PATH_MUTE_CTL
];
1058 val
= amp_val_replace_channels(val
, chs
);
1059 if (get_amp_direction_(val
) == HDA_INPUT
) {
1060 hda_nid_t nid
= get_amp_nid_(val
);
1061 int nums
= snd_hda_get_num_conns(codec
, nid
);
1063 type
= HDA_CTL_BIND_MUTE
;
1067 return __add_pb_sw_ctrl(codec
->spec
, type
, pfx
, cidx
, val
);
1070 static int add_stereo_sw(struct hda_codec
*codec
, const char *pfx
,
1071 int cidx
, struct nid_path
*path
)
1073 int chs
= get_default_ch_nums(codec
, path
, NID_PATH_MUTE_CTL
);
1074 return add_sw_ctl(codec
, pfx
, cidx
, chs
, path
);
1077 /* playback mute control with the software mute bit check */
1078 static void sync_auto_mute_bits(struct snd_kcontrol
*kcontrol
,
1079 struct snd_ctl_elem_value
*ucontrol
)
1081 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
1082 struct hda_gen_spec
*spec
= codec
->spec
;
1084 if (spec
->auto_mute_via_amp
) {
1085 hda_nid_t nid
= get_amp_nid(kcontrol
);
1086 bool enabled
= !((spec
->mute_bits
>> nid
) & 1);
1087 ucontrol
->value
.integer
.value
[0] &= enabled
;
1088 ucontrol
->value
.integer
.value
[1] &= enabled
;
1092 static int hda_gen_mixer_mute_put(struct snd_kcontrol
*kcontrol
,
1093 struct snd_ctl_elem_value
*ucontrol
)
1095 sync_auto_mute_bits(kcontrol
, ucontrol
);
1096 return snd_hda_mixer_amp_switch_put(kcontrol
, ucontrol
);
1099 static int hda_gen_bind_mute_put(struct snd_kcontrol
*kcontrol
,
1100 struct snd_ctl_elem_value
*ucontrol
)
1102 sync_auto_mute_bits(kcontrol
, ucontrol
);
1103 return snd_hda_mixer_bind_switch_put(kcontrol
, ucontrol
);
1106 /* any ctl assigned to the path with the given index? */
1107 static bool path_has_mixer(struct hda_codec
*codec
, int path_idx
, int ctl_type
)
1109 struct nid_path
*path
= snd_hda_get_path_from_idx(codec
, path_idx
);
1110 return path
&& path
->ctls
[ctl_type
];
1113 static const char * const channel_name
[4] = {
1114 "Front", "Surround", "CLFE", "Side"
1117 /* give some appropriate ctl name prefix for the given line out channel */
1118 static const char *get_line_out_pfx(struct hda_codec
*codec
, int ch
,
1119 int *index
, int ctl_type
)
1121 struct hda_gen_spec
*spec
= codec
->spec
;
1122 struct auto_pin_cfg
*cfg
= &spec
->autocfg
;
1125 if (cfg
->line_outs
== 1 && !spec
->multi_ios
&&
1126 !cfg
->hp_outs
&& !cfg
->speaker_outs
)
1127 return spec
->vmaster_mute
.hook
? "PCM" : "Master";
1129 /* if there is really a single DAC used in the whole output paths,
1130 * use it master (or "PCM" if a vmaster hook is present)
1132 if (spec
->multiout
.num_dacs
== 1 && !spec
->mixer_nid
&&
1133 !spec
->multiout
.hp_out_nid
[0] && !spec
->multiout
.extra_out_nid
[0])
1134 return spec
->vmaster_mute
.hook
? "PCM" : "Master";
1136 /* multi-io channels */
1137 if (ch
>= cfg
->line_outs
)
1138 return channel_name
[ch
];
1140 switch (cfg
->line_out_type
) {
1141 case AUTO_PIN_SPEAKER_OUT
:
1142 /* if the primary channel vol/mute is shared with HP volume,
1143 * don't name it as Speaker
1145 if (!ch
&& cfg
->hp_outs
&&
1146 !path_has_mixer(codec
, spec
->hp_paths
[0], ctl_type
))
1148 if (cfg
->line_outs
== 1)
1150 if (cfg
->line_outs
== 2)
1151 return ch
? "Bass Speaker" : "Speaker";
1153 case AUTO_PIN_HP_OUT
:
1154 /* if the primary channel vol/mute is shared with spk volume,
1155 * don't name it as Headphone
1157 if (!ch
&& cfg
->speaker_outs
&&
1158 !path_has_mixer(codec
, spec
->speaker_paths
[0], ctl_type
))
1160 /* for multi-io case, only the primary out */
1161 if (ch
&& spec
->multi_ios
)
1165 case AUTO_PIN_LINE_OUT
:
1166 /* This deals with the case where we have two DACs and
1167 * one LO, one HP and one Speaker */
1168 if (!ch
&& cfg
->speaker_outs
&& cfg
->hp_outs
) {
1169 bool hp_lo_shared
= !path_has_mixer(codec
, spec
->hp_paths
[0], ctl_type
);
1170 bool spk_lo_shared
= !path_has_mixer(codec
, spec
->speaker_paths
[0], ctl_type
);
1171 if (hp_lo_shared
&& spk_lo_shared
)
1172 return spec
->vmaster_mute
.hook
? "PCM" : "Master";
1174 return "Headphone+LO";
1176 return "Speaker+LO";
1180 /* for a single channel output, we don't have to name the channel */
1181 if (cfg
->line_outs
== 1 && !spec
->multi_ios
)
1184 if (ch
>= ARRAY_SIZE(channel_name
)) {
1189 return channel_name
[ch
];
1193 * Parse output paths
1196 /* badness definition */
1198 /* No primary DAC is found for the main output */
1199 BAD_NO_PRIMARY_DAC
= 0x10000,
1200 /* No DAC is found for the extra output */
1201 BAD_NO_DAC
= 0x4000,
1202 /* No possible multi-ios */
1203 BAD_MULTI_IO
= 0x120,
1204 /* No individual DAC for extra output */
1205 BAD_NO_EXTRA_DAC
= 0x102,
1206 /* No individual DAC for extra surrounds */
1207 BAD_NO_EXTRA_SURR_DAC
= 0x101,
1208 /* Primary DAC shared with main surrounds */
1209 BAD_SHARED_SURROUND
= 0x100,
1210 /* No independent HP possible */
1211 BAD_NO_INDEP_HP
= 0x10,
1212 /* Primary DAC shared with main CLFE */
1213 BAD_SHARED_CLFE
= 0x10,
1214 /* Primary DAC shared with extra surrounds */
1215 BAD_SHARED_EXTRA_SURROUND
= 0x10,
1216 /* Volume widget is shared */
1217 BAD_SHARED_VOL
= 0x10,
1220 /* look for widgets in the given path which are appropriate for
1221 * volume and mute controls, and assign the values to ctls[].
1223 * When no appropriate widget is found in the path, the badness value
1224 * is incremented depending on the situation. The function returns the
1225 * total badness for both volume and mute controls.
1227 static int assign_out_path_ctls(struct hda_codec
*codec
, struct nid_path
*path
)
1229 struct hda_gen_spec
*spec
= codec
->spec
;
1235 return BAD_SHARED_VOL
* 2;
1237 if (path
->ctls
[NID_PATH_VOL_CTL
] ||
1238 path
->ctls
[NID_PATH_MUTE_CTL
])
1239 return 0; /* already evaluated */
1241 nid
= look_for_out_vol_nid(codec
, path
);
1243 val
= HDA_COMPOSE_AMP_VAL(nid
, 3, 0, HDA_OUTPUT
);
1244 if (spec
->dac_min_mute
)
1245 val
|= HDA_AMP_VAL_MIN_MUTE
;
1246 if (is_ctl_used(codec
, val
, NID_PATH_VOL_CTL
))
1247 badness
+= BAD_SHARED_VOL
;
1249 path
->ctls
[NID_PATH_VOL_CTL
] = val
;
1251 badness
+= BAD_SHARED_VOL
;
1252 nid
= look_for_out_mute_nid(codec
, path
);
1254 unsigned int wid_type
= get_wcaps_type(get_wcaps(codec
, nid
));
1255 if (wid_type
== AC_WID_PIN
|| wid_type
== AC_WID_AUD_OUT
||
1256 nid_has_mute(codec
, nid
, HDA_OUTPUT
))
1257 val
= HDA_COMPOSE_AMP_VAL(nid
, 3, 0, HDA_OUTPUT
);
1259 val
= HDA_COMPOSE_AMP_VAL(nid
, 3, 0, HDA_INPUT
);
1260 if (is_ctl_used(codec
, val
, NID_PATH_MUTE_CTL
))
1261 badness
+= BAD_SHARED_VOL
;
1263 path
->ctls
[NID_PATH_MUTE_CTL
] = val
;
1265 badness
+= BAD_SHARED_VOL
;
1269 const struct badness_table hda_main_out_badness
= {
1270 .no_primary_dac
= BAD_NO_PRIMARY_DAC
,
1271 .no_dac
= BAD_NO_DAC
,
1272 .shared_primary
= BAD_NO_PRIMARY_DAC
,
1273 .shared_surr
= BAD_SHARED_SURROUND
,
1274 .shared_clfe
= BAD_SHARED_CLFE
,
1275 .shared_surr_main
= BAD_SHARED_SURROUND
,
1277 EXPORT_SYMBOL_GPL(hda_main_out_badness
);
1279 const struct badness_table hda_extra_out_badness
= {
1280 .no_primary_dac
= BAD_NO_DAC
,
1281 .no_dac
= BAD_NO_DAC
,
1282 .shared_primary
= BAD_NO_EXTRA_DAC
,
1283 .shared_surr
= BAD_SHARED_EXTRA_SURROUND
,
1284 .shared_clfe
= BAD_SHARED_EXTRA_SURROUND
,
1285 .shared_surr_main
= BAD_NO_EXTRA_SURR_DAC
,
1287 EXPORT_SYMBOL_GPL(hda_extra_out_badness
);
1289 /* get the DAC of the primary output corresponding to the given array index */
1290 static hda_nid_t
get_primary_out(struct hda_codec
*codec
, int idx
)
1292 struct hda_gen_spec
*spec
= codec
->spec
;
1293 struct auto_pin_cfg
*cfg
= &spec
->autocfg
;
1295 if (cfg
->line_outs
> idx
)
1296 return spec
->private_dac_nids
[idx
];
1297 idx
-= cfg
->line_outs
;
1298 if (spec
->multi_ios
> idx
)
1299 return spec
->multi_io
[idx
].dac
;
1303 /* return the DAC if it's reachable, otherwise zero */
1304 static inline hda_nid_t
try_dac(struct hda_codec
*codec
,
1305 hda_nid_t dac
, hda_nid_t pin
)
1307 return is_reachable_path(codec
, dac
, pin
) ? dac
: 0;
1310 /* try to assign DACs to pins and return the resultant badness */
1311 static int try_assign_dacs(struct hda_codec
*codec
, int num_outs
,
1312 const hda_nid_t
*pins
, hda_nid_t
*dacs
,
1314 const struct badness_table
*bad
)
1316 struct hda_gen_spec
*spec
= codec
->spec
;
1324 for (i
= 0; i
< num_outs
; i
++) {
1325 struct nid_path
*path
;
1326 hda_nid_t pin
= pins
[i
];
1328 path
= snd_hda_get_path_from_idx(codec
, path_idx
[i
]);
1330 badness
+= assign_out_path_ctls(codec
, path
);
1334 dacs
[i
] = get_preferred_dac(codec
, pin
);
1336 if (is_dac_already_used(codec
, dacs
[i
]))
1337 badness
+= bad
->shared_primary
;
1341 dacs
[i
] = look_for_dac(codec
, pin
, false);
1342 if (!dacs
[i
] && !i
) {
1343 /* try to steal the DAC of surrounds for the front */
1344 for (j
= 1; j
< num_outs
; j
++) {
1345 if (is_reachable_path(codec
, dacs
[j
], pin
)) {
1348 invalidate_nid_path(codec
, path_idx
[j
]);
1357 dac
= try_dac(codec
, get_primary_out(codec
, i
), pin
);
1359 dac
= try_dac(codec
, dacs
[0], pin
);
1361 dac
= try_dac(codec
, get_primary_out(codec
, i
), pin
);
1364 badness
+= bad
->shared_primary
;
1366 badness
+= bad
->shared_surr
;
1368 badness
+= bad
->shared_clfe
;
1369 } else if (is_reachable_path(codec
, spec
->private_dac_nids
[0], pin
)) {
1370 dac
= spec
->private_dac_nids
[0];
1371 badness
+= bad
->shared_surr_main
;
1373 badness
+= bad
->no_primary_dac
;
1375 badness
+= bad
->no_dac
;
1379 path
= snd_hda_add_new_path(codec
, dac
, pin
, -spec
->mixer_nid
);
1380 if (!path
&& !i
&& spec
->mixer_nid
) {
1381 /* try with aamix */
1382 path
= snd_hda_add_new_path(codec
, dac
, pin
, 0);
1386 badness
+= bad
->no_dac
;
1388 /* print_nid_path(codec, "output", path); */
1389 path
->active
= true;
1390 path_idx
[i
] = snd_hda_get_path_idx(codec
, path
);
1391 badness
+= assign_out_path_ctls(codec
, path
);
1398 /* return NID if the given pin has only a single connection to a certain DAC */
1399 static hda_nid_t
get_dac_if_single(struct hda_codec
*codec
, hda_nid_t pin
)
1401 struct hda_gen_spec
*spec
= codec
->spec
;
1403 hda_nid_t nid_found
= 0;
1405 for (i
= 0; i
< spec
->num_all_dacs
; i
++) {
1406 hda_nid_t nid
= spec
->all_dacs
[i
];
1407 if (!nid
|| is_dac_already_used(codec
, nid
))
1409 if (is_reachable_path(codec
, nid
, pin
)) {
1418 /* check whether the given pin can be a multi-io pin */
1419 static bool can_be_multiio_pin(struct hda_codec
*codec
,
1420 unsigned int location
, hda_nid_t nid
)
1422 unsigned int defcfg
, caps
;
1424 defcfg
= snd_hda_codec_get_pincfg(codec
, nid
);
1425 if (get_defcfg_connect(defcfg
) != AC_JACK_PORT_COMPLEX
)
1427 if (location
&& get_defcfg_location(defcfg
) != location
)
1429 caps
= snd_hda_query_pin_caps(codec
, nid
);
1430 if (!(caps
& AC_PINCAP_OUT
))
1435 /* count the number of input pins that are capable to be multi-io */
1436 static int count_multiio_pins(struct hda_codec
*codec
, hda_nid_t reference_pin
)
1438 struct hda_gen_spec
*spec
= codec
->spec
;
1439 struct auto_pin_cfg
*cfg
= &spec
->autocfg
;
1440 unsigned int defcfg
= snd_hda_codec_get_pincfg(codec
, reference_pin
);
1441 unsigned int location
= get_defcfg_location(defcfg
);
1445 for (type
= AUTO_PIN_LINE_IN
; type
>= AUTO_PIN_MIC
; type
--) {
1446 for (i
= 0; i
< cfg
->num_inputs
; i
++) {
1447 if (cfg
->inputs
[i
].type
!= type
)
1449 if (can_be_multiio_pin(codec
, location
,
1450 cfg
->inputs
[i
].pin
))
1460 * When hardwired is set, try to fill ony hardwired pins, and returns
1461 * zero if any pins are filled, non-zero if nothing found.
1462 * When hardwired is off, try to fill possible input pins, and returns
1463 * the badness value.
1465 static int fill_multi_ios(struct hda_codec
*codec
,
1466 hda_nid_t reference_pin
,
1469 struct hda_gen_spec
*spec
= codec
->spec
;
1470 struct auto_pin_cfg
*cfg
= &spec
->autocfg
;
1471 int type
, i
, j
, num_pins
, old_pins
;
1472 unsigned int defcfg
= snd_hda_codec_get_pincfg(codec
, reference_pin
);
1473 unsigned int location
= get_defcfg_location(defcfg
);
1475 struct nid_path
*path
;
1477 old_pins
= spec
->multi_ios
;
1481 num_pins
= count_multiio_pins(codec
, reference_pin
);
1485 for (type
= AUTO_PIN_LINE_IN
; type
>= AUTO_PIN_MIC
; type
--) {
1486 for (i
= 0; i
< cfg
->num_inputs
; i
++) {
1487 hda_nid_t nid
= cfg
->inputs
[i
].pin
;
1490 if (cfg
->inputs
[i
].type
!= type
)
1492 if (!can_be_multiio_pin(codec
, location
, nid
))
1494 for (j
= 0; j
< spec
->multi_ios
; j
++) {
1495 if (nid
== spec
->multi_io
[j
].pin
)
1498 if (j
< spec
->multi_ios
)
1502 dac
= get_dac_if_single(codec
, nid
);
1504 dac
= look_for_dac(codec
, nid
, false);
1509 path
= snd_hda_add_new_path(codec
, dac
, nid
,
1515 /* print_nid_path(codec, "multiio", path); */
1516 spec
->multi_io
[spec
->multi_ios
].pin
= nid
;
1517 spec
->multi_io
[spec
->multi_ios
].dac
= dac
;
1518 spec
->out_paths
[cfg
->line_outs
+ spec
->multi_ios
] =
1519 snd_hda_get_path_idx(codec
, path
);
1521 if (spec
->multi_ios
>= 2)
1527 badness
= BAD_MULTI_IO
;
1528 if (old_pins
== spec
->multi_ios
) {
1530 return 1; /* nothing found */
1532 return badness
; /* no badness if nothing found */
1534 if (!hardwired
&& spec
->multi_ios
< 2) {
1535 /* cancel newly assigned paths */
1536 spec
->paths
.used
-= spec
->multi_ios
- old_pins
;
1537 spec
->multi_ios
= old_pins
;
1541 /* assign volume and mute controls */
1542 for (i
= old_pins
; i
< spec
->multi_ios
; i
++) {
1543 path
= snd_hda_get_path_from_idx(codec
, spec
->out_paths
[cfg
->line_outs
+ i
]);
1544 badness
+= assign_out_path_ctls(codec
, path
);
1550 /* map DACs for all pins in the list if they are single connections */
1551 static bool map_singles(struct hda_codec
*codec
, int outs
,
1552 const hda_nid_t
*pins
, hda_nid_t
*dacs
, int *path_idx
)
1554 struct hda_gen_spec
*spec
= codec
->spec
;
1557 for (i
= 0; i
< outs
; i
++) {
1558 struct nid_path
*path
;
1562 dac
= get_dac_if_single(codec
, pins
[i
]);
1565 path
= snd_hda_add_new_path(codec
, dac
, pins
[i
],
1567 if (!path
&& !i
&& spec
->mixer_nid
)
1568 path
= snd_hda_add_new_path(codec
, dac
, pins
[i
], 0);
1572 /* print_nid_path(codec, "output", path); */
1573 path
->active
= true;
1574 path_idx
[i
] = snd_hda_get_path_idx(codec
, path
);
1580 static inline bool has_aamix_out_paths(struct hda_gen_spec
*spec
)
1582 return spec
->aamix_out_paths
[0] || spec
->aamix_out_paths
[1] ||
1583 spec
->aamix_out_paths
[2];
1586 /* create a new path including aamix if available, and return its index */
1587 static int check_aamix_out_path(struct hda_codec
*codec
, int path_idx
)
1589 struct hda_gen_spec
*spec
= codec
->spec
;
1590 struct nid_path
*path
;
1591 hda_nid_t path_dac
, dac
, pin
;
1593 path
= snd_hda_get_path_from_idx(codec
, path_idx
);
1594 if (!path
|| !path
->depth
||
1595 is_nid_contained(path
, spec
->mixer_nid
))
1597 path_dac
= path
->path
[0];
1598 dac
= spec
->private_dac_nids
[0];
1599 pin
= path
->path
[path
->depth
- 1];
1600 path
= snd_hda_add_new_path(codec
, dac
, pin
, spec
->mixer_nid
);
1602 if (dac
!= path_dac
)
1604 else if (spec
->multiout
.hp_out_nid
[0])
1605 dac
= spec
->multiout
.hp_out_nid
[0];
1606 else if (spec
->multiout
.extra_out_nid
[0])
1607 dac
= spec
->multiout
.extra_out_nid
[0];
1611 path
= snd_hda_add_new_path(codec
, dac
, pin
,
1616 /* print_nid_path(codec, "output-aamix", path); */
1617 path
->active
= false; /* unused as default */
1618 path
->pin_fixed
= true; /* static route */
1619 return snd_hda_get_path_idx(codec
, path
);
1622 /* check whether the independent HP is available with the current config */
1623 static bool indep_hp_possible(struct hda_codec
*codec
)
1625 struct hda_gen_spec
*spec
= codec
->spec
;
1626 struct auto_pin_cfg
*cfg
= &spec
->autocfg
;
1627 struct nid_path
*path
;
1630 if (cfg
->line_out_type
== AUTO_PIN_HP_OUT
)
1631 idx
= spec
->out_paths
[0];
1633 idx
= spec
->hp_paths
[0];
1634 path
= snd_hda_get_path_from_idx(codec
, idx
);
1638 /* assume no path conflicts unless aamix is involved */
1639 if (!spec
->mixer_nid
|| !is_nid_contained(path
, spec
->mixer_nid
))
1642 /* check whether output paths contain aamix */
1643 for (i
= 0; i
< cfg
->line_outs
; i
++) {
1644 if (spec
->out_paths
[i
] == idx
)
1646 path
= snd_hda_get_path_from_idx(codec
, spec
->out_paths
[i
]);
1647 if (path
&& is_nid_contained(path
, spec
->mixer_nid
))
1650 for (i
= 0; i
< cfg
->speaker_outs
; i
++) {
1651 path
= snd_hda_get_path_from_idx(codec
, spec
->speaker_paths
[i
]);
1652 if (path
&& is_nid_contained(path
, spec
->mixer_nid
))
1659 /* fill the empty entries in the dac array for speaker/hp with the
1660 * shared dac pointed by the paths
1662 static void refill_shared_dacs(struct hda_codec
*codec
, int num_outs
,
1663 hda_nid_t
*dacs
, int *path_idx
)
1665 struct nid_path
*path
;
1668 for (i
= 0; i
< num_outs
; i
++) {
1671 path
= snd_hda_get_path_from_idx(codec
, path_idx
[i
]);
1674 dacs
[i
] = path
->path
[0];
1678 /* fill in the dac_nids table from the parsed pin configuration */
1679 static int fill_and_eval_dacs(struct hda_codec
*codec
,
1680 bool fill_hardwired
,
1681 bool fill_mio_first
)
1683 struct hda_gen_spec
*spec
= codec
->spec
;
1684 struct auto_pin_cfg
*cfg
= &spec
->autocfg
;
1685 int i
, err
, badness
;
1687 /* set num_dacs once to full for look_for_dac() */
1688 spec
->multiout
.num_dacs
= cfg
->line_outs
;
1689 spec
->multiout
.dac_nids
= spec
->private_dac_nids
;
1690 memset(spec
->private_dac_nids
, 0, sizeof(spec
->private_dac_nids
));
1691 memset(spec
->multiout
.hp_out_nid
, 0, sizeof(spec
->multiout
.hp_out_nid
));
1692 memset(spec
->multiout
.extra_out_nid
, 0, sizeof(spec
->multiout
.extra_out_nid
));
1693 spec
->multi_ios
= 0;
1694 snd_array_free(&spec
->paths
);
1696 /* clear path indices */
1697 memset(spec
->out_paths
, 0, sizeof(spec
->out_paths
));
1698 memset(spec
->hp_paths
, 0, sizeof(spec
->hp_paths
));
1699 memset(spec
->speaker_paths
, 0, sizeof(spec
->speaker_paths
));
1700 memset(spec
->aamix_out_paths
, 0, sizeof(spec
->aamix_out_paths
));
1701 memset(spec
->digout_paths
, 0, sizeof(spec
->digout_paths
));
1702 memset(spec
->input_paths
, 0, sizeof(spec
->input_paths
));
1703 memset(spec
->loopback_paths
, 0, sizeof(spec
->loopback_paths
));
1704 memset(&spec
->digin_path
, 0, sizeof(spec
->digin_path
));
1708 /* fill hard-wired DACs first */
1709 if (fill_hardwired
) {
1712 mapped
= map_singles(codec
, cfg
->line_outs
,
1714 spec
->private_dac_nids
,
1716 mapped
|= map_singles(codec
, cfg
->hp_outs
,
1718 spec
->multiout
.hp_out_nid
,
1720 mapped
|= map_singles(codec
, cfg
->speaker_outs
,
1722 spec
->multiout
.extra_out_nid
,
1723 spec
->speaker_paths
);
1724 if (!spec
->no_multi_io
&&
1725 fill_mio_first
&& cfg
->line_outs
== 1 &&
1726 cfg
->line_out_type
!= AUTO_PIN_SPEAKER_OUT
) {
1727 err
= fill_multi_ios(codec
, cfg
->line_out_pins
[0], true);
1734 badness
+= try_assign_dacs(codec
, cfg
->line_outs
, cfg
->line_out_pins
,
1735 spec
->private_dac_nids
, spec
->out_paths
,
1736 spec
->main_out_badness
);
1738 if (!spec
->no_multi_io
&& fill_mio_first
&&
1739 cfg
->line_outs
== 1 && cfg
->line_out_type
!= AUTO_PIN_SPEAKER_OUT
) {
1740 /* try to fill multi-io first */
1741 err
= fill_multi_ios(codec
, cfg
->line_out_pins
[0], false);
1744 /* we don't count badness at this stage yet */
1747 if (cfg
->line_out_type
!= AUTO_PIN_HP_OUT
) {
1748 err
= try_assign_dacs(codec
, cfg
->hp_outs
, cfg
->hp_pins
,
1749 spec
->multiout
.hp_out_nid
,
1751 spec
->extra_out_badness
);
1756 if (cfg
->line_out_type
!= AUTO_PIN_SPEAKER_OUT
) {
1757 err
= try_assign_dacs(codec
, cfg
->speaker_outs
,
1759 spec
->multiout
.extra_out_nid
,
1760 spec
->speaker_paths
,
1761 spec
->extra_out_badness
);
1766 if (!spec
->no_multi_io
&&
1767 cfg
->line_outs
== 1 && cfg
->line_out_type
!= AUTO_PIN_SPEAKER_OUT
) {
1768 err
= fill_multi_ios(codec
, cfg
->line_out_pins
[0], false);
1774 if (spec
->mixer_nid
) {
1775 spec
->aamix_out_paths
[0] =
1776 check_aamix_out_path(codec
, spec
->out_paths
[0]);
1777 if (cfg
->line_out_type
!= AUTO_PIN_HP_OUT
)
1778 spec
->aamix_out_paths
[1] =
1779 check_aamix_out_path(codec
, spec
->hp_paths
[0]);
1780 if (cfg
->line_out_type
!= AUTO_PIN_SPEAKER_OUT
)
1781 spec
->aamix_out_paths
[2] =
1782 check_aamix_out_path(codec
, spec
->speaker_paths
[0]);
1785 if (!spec
->no_multi_io
&&
1786 cfg
->hp_outs
&& cfg
->line_out_type
== AUTO_PIN_SPEAKER_OUT
)
1787 if (count_multiio_pins(codec
, cfg
->hp_pins
[0]) >= 2)
1788 spec
->multi_ios
= 1; /* give badness */
1790 /* re-count num_dacs and squash invalid entries */
1791 spec
->multiout
.num_dacs
= 0;
1792 for (i
= 0; i
< cfg
->line_outs
; i
++) {
1793 if (spec
->private_dac_nids
[i
])
1794 spec
->multiout
.num_dacs
++;
1796 memmove(spec
->private_dac_nids
+ i
,
1797 spec
->private_dac_nids
+ i
+ 1,
1798 sizeof(hda_nid_t
) * (cfg
->line_outs
- i
- 1));
1799 spec
->private_dac_nids
[cfg
->line_outs
- 1] = 0;
1803 spec
->ext_channel_count
= spec
->min_channel_count
=
1804 spec
->multiout
.num_dacs
* 2;
1806 if (spec
->multi_ios
== 2) {
1807 for (i
= 0; i
< 2; i
++)
1808 spec
->private_dac_nids
[spec
->multiout
.num_dacs
++] =
1809 spec
->multi_io
[i
].dac
;
1810 } else if (spec
->multi_ios
) {
1811 spec
->multi_ios
= 0;
1812 badness
+= BAD_MULTI_IO
;
1815 if (spec
->indep_hp
&& !indep_hp_possible(codec
))
1816 badness
+= BAD_NO_INDEP_HP
;
1818 /* re-fill the shared DAC for speaker / headphone */
1819 if (cfg
->line_out_type
!= AUTO_PIN_HP_OUT
)
1820 refill_shared_dacs(codec
, cfg
->hp_outs
,
1821 spec
->multiout
.hp_out_nid
,
1823 if (cfg
->line_out_type
!= AUTO_PIN_SPEAKER_OUT
)
1824 refill_shared_dacs(codec
, cfg
->speaker_outs
,
1825 spec
->multiout
.extra_out_nid
,
1826 spec
->speaker_paths
);
1831 #define DEBUG_BADNESS
1833 #ifdef DEBUG_BADNESS
1834 #define debug_badness(fmt, ...) \
1835 codec_dbg(codec, fmt, ##__VA_ARGS__)
1837 #define debug_badness(fmt, ...) \
1838 do { if (0) codec_dbg(codec, fmt, ##__VA_ARGS__); } while (0)
1841 #ifdef DEBUG_BADNESS
1842 static inline void print_nid_path_idx(struct hda_codec
*codec
,
1843 const char *pfx
, int idx
)
1845 struct nid_path
*path
;
1847 path
= snd_hda_get_path_from_idx(codec
, idx
);
1849 print_nid_path(codec
, pfx
, path
);
1852 static void debug_show_configs(struct hda_codec
*codec
,
1853 struct auto_pin_cfg
*cfg
)
1855 struct hda_gen_spec
*spec
= codec
->spec
;
1856 static const char * const lo_type
[3] = { "LO", "SP", "HP" };
1859 debug_badness("multi_outs = %x/%x/%x/%x : %x/%x/%x/%x (type %s)\n",
1860 cfg
->line_out_pins
[0], cfg
->line_out_pins
[1],
1861 cfg
->line_out_pins
[2], cfg
->line_out_pins
[3],
1862 spec
->multiout
.dac_nids
[0],
1863 spec
->multiout
.dac_nids
[1],
1864 spec
->multiout
.dac_nids
[2],
1865 spec
->multiout
.dac_nids
[3],
1866 lo_type
[cfg
->line_out_type
]);
1867 for (i
= 0; i
< cfg
->line_outs
; i
++)
1868 print_nid_path_idx(codec
, " out", spec
->out_paths
[i
]);
1869 if (spec
->multi_ios
> 0)
1870 debug_badness("multi_ios(%d) = %x/%x : %x/%x\n",
1872 spec
->multi_io
[0].pin
, spec
->multi_io
[1].pin
,
1873 spec
->multi_io
[0].dac
, spec
->multi_io
[1].dac
);
1874 for (i
= 0; i
< spec
->multi_ios
; i
++)
1875 print_nid_path_idx(codec
, " mio",
1876 spec
->out_paths
[cfg
->line_outs
+ i
]);
1878 debug_badness("hp_outs = %x/%x/%x/%x : %x/%x/%x/%x\n",
1879 cfg
->hp_pins
[0], cfg
->hp_pins
[1],
1880 cfg
->hp_pins
[2], cfg
->hp_pins
[3],
1881 spec
->multiout
.hp_out_nid
[0],
1882 spec
->multiout
.hp_out_nid
[1],
1883 spec
->multiout
.hp_out_nid
[2],
1884 spec
->multiout
.hp_out_nid
[3]);
1885 for (i
= 0; i
< cfg
->hp_outs
; i
++)
1886 print_nid_path_idx(codec
, " hp ", spec
->hp_paths
[i
]);
1887 if (cfg
->speaker_outs
)
1888 debug_badness("spk_outs = %x/%x/%x/%x : %x/%x/%x/%x\n",
1889 cfg
->speaker_pins
[0], cfg
->speaker_pins
[1],
1890 cfg
->speaker_pins
[2], cfg
->speaker_pins
[3],
1891 spec
->multiout
.extra_out_nid
[0],
1892 spec
->multiout
.extra_out_nid
[1],
1893 spec
->multiout
.extra_out_nid
[2],
1894 spec
->multiout
.extra_out_nid
[3]);
1895 for (i
= 0; i
< cfg
->speaker_outs
; i
++)
1896 print_nid_path_idx(codec
, " spk", spec
->speaker_paths
[i
]);
1897 for (i
= 0; i
< 3; i
++)
1898 print_nid_path_idx(codec
, " mix", spec
->aamix_out_paths
[i
]);
1901 #define debug_show_configs(codec, cfg) /* NOP */
1904 /* find all available DACs of the codec */
1905 static void fill_all_dac_nids(struct hda_codec
*codec
)
1907 struct hda_gen_spec
*spec
= codec
->spec
;
1910 spec
->num_all_dacs
= 0;
1911 memset(spec
->all_dacs
, 0, sizeof(spec
->all_dacs
));
1912 for_each_hda_codec_node(nid
, codec
) {
1913 if (get_wcaps_type(get_wcaps(codec
, nid
)) != AC_WID_AUD_OUT
)
1915 if (spec
->num_all_dacs
>= ARRAY_SIZE(spec
->all_dacs
)) {
1916 codec_err(codec
, "Too many DACs!\n");
1919 spec
->all_dacs
[spec
->num_all_dacs
++] = nid
;
1923 static int parse_output_paths(struct hda_codec
*codec
)
1925 struct hda_gen_spec
*spec
= codec
->spec
;
1926 struct auto_pin_cfg
*cfg
= &spec
->autocfg
;
1927 struct auto_pin_cfg
*best_cfg
;
1929 int best_badness
= INT_MAX
;
1931 bool fill_hardwired
= true, fill_mio_first
= true;
1932 bool best_wired
= true, best_mio
= true;
1933 bool hp_spk_swapped
= false;
1935 best_cfg
= kmalloc(sizeof(*best_cfg
), GFP_KERNEL
);
1941 badness
= fill_and_eval_dacs(codec
, fill_hardwired
,
1947 debug_badness("==> lo_type=%d, wired=%d, mio=%d, badness=0x%x\n",
1948 cfg
->line_out_type
, fill_hardwired
, fill_mio_first
,
1950 debug_show_configs(codec
, cfg
);
1951 if (badness
< best_badness
) {
1952 best_badness
= badness
;
1954 best_wired
= fill_hardwired
;
1955 best_mio
= fill_mio_first
;
1959 fill_mio_first
= !fill_mio_first
;
1960 if (!fill_mio_first
)
1962 fill_hardwired
= !fill_hardwired
;
1963 if (!fill_hardwired
)
1967 hp_spk_swapped
= true;
1968 if (cfg
->speaker_outs
> 0 &&
1969 cfg
->line_out_type
== AUTO_PIN_HP_OUT
) {
1970 cfg
->hp_outs
= cfg
->line_outs
;
1971 memcpy(cfg
->hp_pins
, cfg
->line_out_pins
,
1972 sizeof(cfg
->hp_pins
));
1973 cfg
->line_outs
= cfg
->speaker_outs
;
1974 memcpy(cfg
->line_out_pins
, cfg
->speaker_pins
,
1975 sizeof(cfg
->speaker_pins
));
1976 cfg
->speaker_outs
= 0;
1977 memset(cfg
->speaker_pins
, 0, sizeof(cfg
->speaker_pins
));
1978 cfg
->line_out_type
= AUTO_PIN_SPEAKER_OUT
;
1979 fill_hardwired
= true;
1982 if (cfg
->hp_outs
> 0 &&
1983 cfg
->line_out_type
== AUTO_PIN_SPEAKER_OUT
) {
1984 cfg
->speaker_outs
= cfg
->line_outs
;
1985 memcpy(cfg
->speaker_pins
, cfg
->line_out_pins
,
1986 sizeof(cfg
->speaker_pins
));
1987 cfg
->line_outs
= cfg
->hp_outs
;
1988 memcpy(cfg
->line_out_pins
, cfg
->hp_pins
,
1989 sizeof(cfg
->hp_pins
));
1991 memset(cfg
->hp_pins
, 0, sizeof(cfg
->hp_pins
));
1992 cfg
->line_out_type
= AUTO_PIN_HP_OUT
;
1993 fill_hardwired
= true;
2000 debug_badness("==> restoring best_cfg\n");
2002 fill_and_eval_dacs(codec
, best_wired
, best_mio
);
2004 debug_badness("==> Best config: lo_type=%d, wired=%d, mio=%d\n",
2005 cfg
->line_out_type
, best_wired
, best_mio
);
2006 debug_show_configs(codec
, cfg
);
2008 if (cfg
->line_out_pins
[0]) {
2009 struct nid_path
*path
;
2010 path
= snd_hda_get_path_from_idx(codec
, spec
->out_paths
[0]);
2012 spec
->vmaster_nid
= look_for_out_vol_nid(codec
, path
);
2013 if (spec
->vmaster_nid
) {
2014 snd_hda_set_vmaster_tlv(codec
, spec
->vmaster_nid
,
2015 HDA_OUTPUT
, spec
->vmaster_tlv
);
2016 if (spec
->dac_min_mute
)
2017 spec
->vmaster_tlv
[3] |= TLV_DB_SCALE_MUTE
;
2021 /* set initial pinctl targets */
2022 if (spec
->prefer_hp_amp
|| cfg
->line_out_type
== AUTO_PIN_HP_OUT
)
2026 set_pin_targets(codec
, cfg
->line_outs
, cfg
->line_out_pins
, val
);
2027 if (cfg
->line_out_type
!= AUTO_PIN_HP_OUT
)
2028 set_pin_targets(codec
, cfg
->hp_outs
, cfg
->hp_pins
, PIN_HP
);
2029 if (cfg
->line_out_type
!= AUTO_PIN_SPEAKER_OUT
) {
2030 val
= spec
->prefer_hp_amp
? PIN_HP
: PIN_OUT
;
2031 set_pin_targets(codec
, cfg
->speaker_outs
,
2032 cfg
->speaker_pins
, val
);
2035 /* clear indep_hp flag if not available */
2036 if (spec
->indep_hp
&& !indep_hp_possible(codec
))
2043 /* add playback controls from the parsed DAC table */
2044 static int create_multi_out_ctls(struct hda_codec
*codec
,
2045 const struct auto_pin_cfg
*cfg
)
2047 struct hda_gen_spec
*spec
= codec
->spec
;
2048 int i
, err
, noutputs
;
2050 noutputs
= cfg
->line_outs
;
2051 if (spec
->multi_ios
> 0 && cfg
->line_outs
< 3)
2052 noutputs
+= spec
->multi_ios
;
2054 for (i
= 0; i
< noutputs
; i
++) {
2057 struct nid_path
*path
;
2059 path
= snd_hda_get_path_from_idx(codec
, spec
->out_paths
[i
]);
2063 name
= get_line_out_pfx(codec
, i
, &index
, NID_PATH_VOL_CTL
);
2064 if (!name
|| !strcmp(name
, "CLFE")) {
2066 err
= add_vol_ctl(codec
, "Center", 0, 1, path
);
2069 err
= add_vol_ctl(codec
, "LFE", 0, 2, path
);
2073 err
= add_stereo_vol(codec
, name
, index
, path
);
2078 name
= get_line_out_pfx(codec
, i
, &index
, NID_PATH_MUTE_CTL
);
2079 if (!name
|| !strcmp(name
, "CLFE")) {
2080 err
= add_sw_ctl(codec
, "Center", 0, 1, path
);
2083 err
= add_sw_ctl(codec
, "LFE", 0, 2, path
);
2087 err
= add_stereo_sw(codec
, name
, index
, path
);
2095 static int create_extra_out(struct hda_codec
*codec
, int path_idx
,
2096 const char *pfx
, int cidx
)
2098 struct nid_path
*path
;
2101 path
= snd_hda_get_path_from_idx(codec
, path_idx
);
2104 err
= add_stereo_vol(codec
, pfx
, cidx
, path
);
2107 err
= add_stereo_sw(codec
, pfx
, cidx
, path
);
2113 /* add playback controls for speaker and HP outputs */
2114 static int create_extra_outs(struct hda_codec
*codec
, int num_pins
,
2115 const int *paths
, const char *pfx
)
2119 for (i
= 0; i
< num_pins
; i
++) {
2121 char tmp
[SNDRV_CTL_ELEM_ID_NAME_MAXLEN
];
2124 if (num_pins
== 2 && i
== 1 && !strcmp(pfx
, "Speaker"))
2125 name
= "Bass Speaker";
2126 else if (num_pins
>= 3) {
2127 snprintf(tmp
, sizeof(tmp
), "%s %s",
2128 pfx
, channel_name
[i
]);
2134 err
= create_extra_out(codec
, paths
[i
], name
, idx
);
2141 static int create_hp_out_ctls(struct hda_codec
*codec
)
2143 struct hda_gen_spec
*spec
= codec
->spec
;
2144 return create_extra_outs(codec
, spec
->autocfg
.hp_outs
,
2149 static int create_speaker_out_ctls(struct hda_codec
*codec
)
2151 struct hda_gen_spec
*spec
= codec
->spec
;
2152 return create_extra_outs(codec
, spec
->autocfg
.speaker_outs
,
2153 spec
->speaker_paths
,
2158 * independent HP controls
2161 static void call_hp_automute(struct hda_codec
*codec
,
2162 struct hda_jack_callback
*jack
);
2163 static int indep_hp_info(struct snd_kcontrol
*kcontrol
,
2164 struct snd_ctl_elem_info
*uinfo
)
2166 return snd_hda_enum_bool_helper_info(kcontrol
, uinfo
);
2169 static int indep_hp_get(struct snd_kcontrol
*kcontrol
,
2170 struct snd_ctl_elem_value
*ucontrol
)
2172 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
2173 struct hda_gen_spec
*spec
= codec
->spec
;
2174 ucontrol
->value
.enumerated
.item
[0] = spec
->indep_hp_enabled
;
2178 static void update_aamix_paths(struct hda_codec
*codec
, bool do_mix
,
2179 int nomix_path_idx
, int mix_path_idx
,
2182 static int indep_hp_put(struct snd_kcontrol
*kcontrol
,
2183 struct snd_ctl_elem_value
*ucontrol
)
2185 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
2186 struct hda_gen_spec
*spec
= codec
->spec
;
2187 unsigned int select
= ucontrol
->value
.enumerated
.item
[0];
2190 mutex_lock(&spec
->pcm_mutex
);
2191 if (spec
->active_streams
) {
2196 if (spec
->indep_hp_enabled
!= select
) {
2198 if (spec
->autocfg
.line_out_type
== AUTO_PIN_HP_OUT
)
2199 dacp
= &spec
->private_dac_nids
[0];
2201 dacp
= &spec
->multiout
.hp_out_nid
[0];
2203 /* update HP aamix paths in case it conflicts with indep HP */
2204 if (spec
->have_aamix_ctl
) {
2205 if (spec
->autocfg
.line_out_type
== AUTO_PIN_HP_OUT
)
2206 update_aamix_paths(codec
, spec
->aamix_mode
,
2208 spec
->aamix_out_paths
[0],
2209 spec
->autocfg
.line_out_type
);
2211 update_aamix_paths(codec
, spec
->aamix_mode
,
2213 spec
->aamix_out_paths
[1],
2217 spec
->indep_hp_enabled
= select
;
2218 if (spec
->indep_hp_enabled
)
2221 *dacp
= spec
->alt_dac_nid
;
2223 call_hp_automute(codec
, NULL
);
2227 mutex_unlock(&spec
->pcm_mutex
);
2231 static const struct snd_kcontrol_new indep_hp_ctl
= {
2232 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
2233 .name
= "Independent HP",
2234 .info
= indep_hp_info
,
2235 .get
= indep_hp_get
,
2236 .put
= indep_hp_put
,
2240 static int create_indep_hp_ctls(struct hda_codec
*codec
)
2242 struct hda_gen_spec
*spec
= codec
->spec
;
2245 if (!spec
->indep_hp
)
2247 if (spec
->autocfg
.line_out_type
== AUTO_PIN_HP_OUT
)
2248 dac
= spec
->multiout
.dac_nids
[0];
2250 dac
= spec
->multiout
.hp_out_nid
[0];
2256 spec
->indep_hp_enabled
= false;
2257 spec
->alt_dac_nid
= dac
;
2258 if (!snd_hda_gen_add_kctl(spec
, NULL
, &indep_hp_ctl
))
2264 * channel mode enum control
2267 static int ch_mode_info(struct snd_kcontrol
*kcontrol
,
2268 struct snd_ctl_elem_info
*uinfo
)
2270 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
2271 struct hda_gen_spec
*spec
= codec
->spec
;
2274 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_ENUMERATED
;
2276 uinfo
->value
.enumerated
.items
= spec
->multi_ios
+ 1;
2277 if (uinfo
->value
.enumerated
.item
> spec
->multi_ios
)
2278 uinfo
->value
.enumerated
.item
= spec
->multi_ios
;
2279 chs
= uinfo
->value
.enumerated
.item
* 2 + spec
->min_channel_count
;
2280 sprintf(uinfo
->value
.enumerated
.name
, "%dch", chs
);
2284 static int ch_mode_get(struct snd_kcontrol
*kcontrol
,
2285 struct snd_ctl_elem_value
*ucontrol
)
2287 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
2288 struct hda_gen_spec
*spec
= codec
->spec
;
2289 ucontrol
->value
.enumerated
.item
[0] =
2290 (spec
->ext_channel_count
- spec
->min_channel_count
) / 2;
2294 static inline struct nid_path
*
2295 get_multiio_path(struct hda_codec
*codec
, int idx
)
2297 struct hda_gen_spec
*spec
= codec
->spec
;
2298 return snd_hda_get_path_from_idx(codec
,
2299 spec
->out_paths
[spec
->autocfg
.line_outs
+ idx
]);
2302 static void update_automute_all(struct hda_codec
*codec
);
2304 /* Default value to be passed as aamix argument for snd_hda_activate_path();
2305 * used for output paths
2307 static bool aamix_default(struct hda_gen_spec
*spec
)
2309 return !spec
->have_aamix_ctl
|| spec
->aamix_mode
;
2312 static int set_multi_io(struct hda_codec
*codec
, int idx
, bool output
)
2314 struct hda_gen_spec
*spec
= codec
->spec
;
2315 hda_nid_t nid
= spec
->multi_io
[idx
].pin
;
2316 struct nid_path
*path
;
2318 path
= get_multiio_path(codec
, idx
);
2322 if (path
->active
== output
)
2326 set_pin_target(codec
, nid
, PIN_OUT
, true);
2327 snd_hda_activate_path(codec
, path
, true, aamix_default(spec
));
2328 set_pin_eapd(codec
, nid
, true);
2330 set_pin_eapd(codec
, nid
, false);
2331 snd_hda_activate_path(codec
, path
, false, aamix_default(spec
));
2332 set_pin_target(codec
, nid
, spec
->multi_io
[idx
].ctl_in
, true);
2333 path_power_down_sync(codec
, path
);
2336 /* update jack retasking in case it modifies any of them */
2337 update_automute_all(codec
);
2342 static int ch_mode_put(struct snd_kcontrol
*kcontrol
,
2343 struct snd_ctl_elem_value
*ucontrol
)
2345 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
2346 struct hda_gen_spec
*spec
= codec
->spec
;
2349 ch
= ucontrol
->value
.enumerated
.item
[0];
2350 if (ch
< 0 || ch
> spec
->multi_ios
)
2352 if (ch
== (spec
->ext_channel_count
- spec
->min_channel_count
) / 2)
2354 spec
->ext_channel_count
= ch
* 2 + spec
->min_channel_count
;
2355 for (i
= 0; i
< spec
->multi_ios
; i
++)
2356 set_multi_io(codec
, i
, i
< ch
);
2357 spec
->multiout
.max_channels
= max(spec
->ext_channel_count
,
2358 spec
->const_channel_count
);
2359 if (spec
->need_dac_fix
)
2360 spec
->multiout
.num_dacs
= spec
->multiout
.max_channels
/ 2;
2364 static const struct snd_kcontrol_new channel_mode_enum
= {
2365 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
2366 .name
= "Channel Mode",
2367 .info
= ch_mode_info
,
2372 static int create_multi_channel_mode(struct hda_codec
*codec
)
2374 struct hda_gen_spec
*spec
= codec
->spec
;
2376 if (spec
->multi_ios
> 0) {
2377 if (!snd_hda_gen_add_kctl(spec
, NULL
, &channel_mode_enum
))
2384 * aamix loopback enable/disable switch
2387 #define loopback_mixing_info indep_hp_info
2389 static int loopback_mixing_get(struct snd_kcontrol
*kcontrol
,
2390 struct snd_ctl_elem_value
*ucontrol
)
2392 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
2393 struct hda_gen_spec
*spec
= codec
->spec
;
2394 ucontrol
->value
.enumerated
.item
[0] = spec
->aamix_mode
;
2398 static void update_aamix_paths(struct hda_codec
*codec
, bool do_mix
,
2399 int nomix_path_idx
, int mix_path_idx
,
2402 struct hda_gen_spec
*spec
= codec
->spec
;
2403 struct nid_path
*nomix_path
, *mix_path
;
2405 nomix_path
= snd_hda_get_path_from_idx(codec
, nomix_path_idx
);
2406 mix_path
= snd_hda_get_path_from_idx(codec
, mix_path_idx
);
2407 if (!nomix_path
|| !mix_path
)
2410 /* if HP aamix path is driven from a different DAC and the
2411 * independent HP mode is ON, can't turn on aamix path
2413 if (out_type
== AUTO_PIN_HP_OUT
&& spec
->indep_hp_enabled
&&
2414 mix_path
->path
[0] != spec
->alt_dac_nid
)
2418 snd_hda_activate_path(codec
, nomix_path
, false, true);
2419 snd_hda_activate_path(codec
, mix_path
, true, true);
2420 path_power_down_sync(codec
, nomix_path
);
2422 snd_hda_activate_path(codec
, mix_path
, false, false);
2423 snd_hda_activate_path(codec
, nomix_path
, true, false);
2424 path_power_down_sync(codec
, mix_path
);
2428 /* re-initialize the output paths; only called from loopback_mixing_put() */
2429 static void update_output_paths(struct hda_codec
*codec
, int num_outs
,
2432 struct hda_gen_spec
*spec
= codec
->spec
;
2433 struct nid_path
*path
;
2436 for (i
= 0; i
< num_outs
; i
++) {
2437 path
= snd_hda_get_path_from_idx(codec
, paths
[i
]);
2439 snd_hda_activate_path(codec
, path
, path
->active
,
2444 static int loopback_mixing_put(struct snd_kcontrol
*kcontrol
,
2445 struct snd_ctl_elem_value
*ucontrol
)
2447 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
2448 struct hda_gen_spec
*spec
= codec
->spec
;
2449 const struct auto_pin_cfg
*cfg
= &spec
->autocfg
;
2450 unsigned int val
= ucontrol
->value
.enumerated
.item
[0];
2452 if (val
== spec
->aamix_mode
)
2454 spec
->aamix_mode
= val
;
2455 if (has_aamix_out_paths(spec
)) {
2456 update_aamix_paths(codec
, val
, spec
->out_paths
[0],
2457 spec
->aamix_out_paths
[0],
2458 cfg
->line_out_type
);
2459 update_aamix_paths(codec
, val
, spec
->hp_paths
[0],
2460 spec
->aamix_out_paths
[1],
2462 update_aamix_paths(codec
, val
, spec
->speaker_paths
[0],
2463 spec
->aamix_out_paths
[2],
2464 AUTO_PIN_SPEAKER_OUT
);
2466 update_output_paths(codec
, cfg
->line_outs
, spec
->out_paths
);
2467 if (cfg
->line_out_type
!= AUTO_PIN_HP_OUT
)
2468 update_output_paths(codec
, cfg
->hp_outs
, spec
->hp_paths
);
2469 if (cfg
->line_out_type
!= AUTO_PIN_SPEAKER_OUT
)
2470 update_output_paths(codec
, cfg
->speaker_outs
,
2471 spec
->speaker_paths
);
2476 static const struct snd_kcontrol_new loopback_mixing_enum
= {
2477 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
2478 .name
= "Loopback Mixing",
2479 .info
= loopback_mixing_info
,
2480 .get
= loopback_mixing_get
,
2481 .put
= loopback_mixing_put
,
2484 static int create_loopback_mixing_ctl(struct hda_codec
*codec
)
2486 struct hda_gen_spec
*spec
= codec
->spec
;
2488 if (!spec
->mixer_nid
)
2490 if (!snd_hda_gen_add_kctl(spec
, NULL
, &loopback_mixing_enum
))
2492 spec
->have_aamix_ctl
= 1;
2493 /* if no explicit aamix path is present (e.g. for Realtek codecs),
2494 * enable aamix as default -- just for compatibility
2496 spec
->aamix_mode
= !has_aamix_out_paths(spec
);
2501 * shared headphone/mic handling
2504 static void call_update_outputs(struct hda_codec
*codec
);
2506 /* for shared I/O, change the pin-control accordingly */
2507 static void update_hp_mic(struct hda_codec
*codec
, int adc_mux
, bool force
)
2509 struct hda_gen_spec
*spec
= codec
->spec
;
2514 pin
= spec
->hp_mic_pin
;
2515 as_mic
= spec
->cur_mux
[adc_mux
] == spec
->hp_mic_mux_idx
;
2518 val
= snd_hda_codec_get_pin_target(codec
, pin
);
2528 val
= snd_hda_get_default_vref(codec
, pin
);
2529 /* if the HP pin doesn't support VREF and the codec driver gives an
2530 * alternative pin, set up the VREF on that pin instead
2532 if (val
== AC_PINCTL_VREF_HIZ
&& spec
->shared_mic_vref_pin
) {
2533 const hda_nid_t vref_pin
= spec
->shared_mic_vref_pin
;
2534 unsigned int vref_val
= snd_hda_get_default_vref(codec
, vref_pin
);
2535 if (vref_val
!= AC_PINCTL_VREF_HIZ
)
2536 snd_hda_set_pin_ctl_cache(codec
, vref_pin
,
2537 PIN_IN
| (as_mic
? vref_val
: 0));
2540 if (!spec
->hp_mic_jack_modes
) {
2545 set_pin_target(codec
, pin
, val
, true);
2546 call_hp_automute(codec
, NULL
);
2550 /* create a shared input with the headphone out */
2551 static int create_hp_mic(struct hda_codec
*codec
)
2553 struct hda_gen_spec
*spec
= codec
->spec
;
2554 struct auto_pin_cfg
*cfg
= &spec
->autocfg
;
2555 unsigned int defcfg
;
2558 if (!spec
->hp_mic
) {
2559 if (spec
->suppress_hp_mic_detect
)
2561 /* automatic detection: only if no input or a single internal
2562 * input pin is found, try to detect the shared hp/mic
2564 if (cfg
->num_inputs
> 1)
2566 else if (cfg
->num_inputs
== 1) {
2567 defcfg
= snd_hda_codec_get_pincfg(codec
, cfg
->inputs
[0].pin
);
2568 if (snd_hda_get_input_pin_attr(defcfg
) != INPUT_PIN_ATTR_INT
)
2573 spec
->hp_mic
= 0; /* clear once */
2574 if (cfg
->num_inputs
>= AUTO_CFG_MAX_INS
)
2578 if (cfg
->line_out_type
== AUTO_PIN_HP_OUT
&& cfg
->line_outs
> 0)
2579 nid
= cfg
->line_out_pins
[0];
2580 else if (cfg
->hp_outs
> 0)
2581 nid
= cfg
->hp_pins
[0];
2585 if (!(snd_hda_query_pin_caps(codec
, nid
) & AC_PINCAP_IN
))
2586 return 0; /* no input */
2588 cfg
->inputs
[cfg
->num_inputs
].pin
= nid
;
2589 cfg
->inputs
[cfg
->num_inputs
].type
= AUTO_PIN_MIC
;
2590 cfg
->inputs
[cfg
->num_inputs
].is_headphone_mic
= 1;
2593 spec
->hp_mic_pin
= nid
;
2594 /* we can't handle auto-mic together with HP-mic */
2595 spec
->suppress_auto_mic
= 1;
2596 codec_dbg(codec
, "Enable shared I/O jack on NID 0x%x\n", nid
);
2604 static int create_hp_mic_jack_mode(struct hda_codec
*codec
, hda_nid_t pin
);
2606 static const char * const out_jack_texts
[] = {
2607 "Line Out", "Headphone Out",
2610 static int out_jack_mode_info(struct snd_kcontrol
*kcontrol
,
2611 struct snd_ctl_elem_info
*uinfo
)
2613 return snd_hda_enum_helper_info(kcontrol
, uinfo
, 2, out_jack_texts
);
2616 static int out_jack_mode_get(struct snd_kcontrol
*kcontrol
,
2617 struct snd_ctl_elem_value
*ucontrol
)
2619 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
2620 hda_nid_t nid
= kcontrol
->private_value
;
2621 if (snd_hda_codec_get_pin_target(codec
, nid
) == PIN_HP
)
2622 ucontrol
->value
.enumerated
.item
[0] = 1;
2624 ucontrol
->value
.enumerated
.item
[0] = 0;
2628 static int out_jack_mode_put(struct snd_kcontrol
*kcontrol
,
2629 struct snd_ctl_elem_value
*ucontrol
)
2631 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
2632 hda_nid_t nid
= kcontrol
->private_value
;
2635 val
= ucontrol
->value
.enumerated
.item
[0] ? PIN_HP
: PIN_OUT
;
2636 if (snd_hda_codec_get_pin_target(codec
, nid
) == val
)
2638 snd_hda_set_pin_ctl_cache(codec
, nid
, val
);
2642 static const struct snd_kcontrol_new out_jack_mode_enum
= {
2643 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
2644 .info
= out_jack_mode_info
,
2645 .get
= out_jack_mode_get
,
2646 .put
= out_jack_mode_put
,
2649 static bool find_kctl_name(struct hda_codec
*codec
, const char *name
, int idx
)
2651 struct hda_gen_spec
*spec
= codec
->spec
;
2654 for (i
= 0; i
< spec
->kctls
.used
; i
++) {
2655 struct snd_kcontrol_new
*kctl
= snd_array_elem(&spec
->kctls
, i
);
2656 if (!strcmp(kctl
->name
, name
) && kctl
->index
== idx
)
2662 static void get_jack_mode_name(struct hda_codec
*codec
, hda_nid_t pin
,
2663 char *name
, size_t name_len
)
2665 struct hda_gen_spec
*spec
= codec
->spec
;
2668 snd_hda_get_pin_label(codec
, pin
, &spec
->autocfg
, name
, name_len
, &idx
);
2669 strlcat(name
, " Jack Mode", name_len
);
2671 for (; find_kctl_name(codec
, name
, idx
); idx
++)
2675 static int get_out_jack_num_items(struct hda_codec
*codec
, hda_nid_t pin
)
2677 struct hda_gen_spec
*spec
= codec
->spec
;
2678 if (spec
->add_jack_modes
) {
2679 unsigned int pincap
= snd_hda_query_pin_caps(codec
, pin
);
2680 if ((pincap
& AC_PINCAP_OUT
) && (pincap
& AC_PINCAP_HP_DRV
))
2686 static int create_out_jack_modes(struct hda_codec
*codec
, int num_pins
,
2689 struct hda_gen_spec
*spec
= codec
->spec
;
2692 for (i
= 0; i
< num_pins
; i
++) {
2693 hda_nid_t pin
= pins
[i
];
2694 if (pin
== spec
->hp_mic_pin
)
2696 if (get_out_jack_num_items(codec
, pin
) > 1) {
2697 struct snd_kcontrol_new
*knew
;
2698 char name
[SNDRV_CTL_ELEM_ID_NAME_MAXLEN
];
2699 get_jack_mode_name(codec
, pin
, name
, sizeof(name
));
2700 knew
= snd_hda_gen_add_kctl(spec
, name
,
2701 &out_jack_mode_enum
);
2704 knew
->private_value
= pin
;
2715 /* from AC_PINCTL_VREF_HIZ to AC_PINCTL_VREF_100 */
2718 static const char * const vref_texts
[NUM_VREFS
] = {
2719 "Line In", "Mic 50pc Bias", "Mic 0V Bias",
2720 "", "Mic 80pc Bias", "Mic 100pc Bias"
2723 static unsigned int get_vref_caps(struct hda_codec
*codec
, hda_nid_t pin
)
2725 unsigned int pincap
;
2727 pincap
= snd_hda_query_pin_caps(codec
, pin
);
2728 pincap
= (pincap
& AC_PINCAP_VREF
) >> AC_PINCAP_VREF_SHIFT
;
2729 /* filter out unusual vrefs */
2730 pincap
&= ~(AC_PINCAP_VREF_GRD
| AC_PINCAP_VREF_100
);
2734 /* convert from the enum item index to the vref ctl index (0=HIZ, 1=50%...) */
2735 static int get_vref_idx(unsigned int vref_caps
, unsigned int item_idx
)
2737 unsigned int i
, n
= 0;
2739 for (i
= 0; i
< NUM_VREFS
; i
++) {
2740 if (vref_caps
& (1 << i
)) {
2749 /* convert back from the vref ctl index to the enum item index */
2750 static int cvt_from_vref_idx(unsigned int vref_caps
, unsigned int idx
)
2752 unsigned int i
, n
= 0;
2754 for (i
= 0; i
< NUM_VREFS
; i
++) {
2757 if (vref_caps
& (1 << i
))
2763 static int in_jack_mode_info(struct snd_kcontrol
*kcontrol
,
2764 struct snd_ctl_elem_info
*uinfo
)
2766 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
2767 hda_nid_t nid
= kcontrol
->private_value
;
2768 unsigned int vref_caps
= get_vref_caps(codec
, nid
);
2770 snd_hda_enum_helper_info(kcontrol
, uinfo
, hweight32(vref_caps
),
2772 /* set the right text */
2773 strcpy(uinfo
->value
.enumerated
.name
,
2774 vref_texts
[get_vref_idx(vref_caps
, uinfo
->value
.enumerated
.item
)]);
2778 static int in_jack_mode_get(struct snd_kcontrol
*kcontrol
,
2779 struct snd_ctl_elem_value
*ucontrol
)
2781 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
2782 hda_nid_t nid
= kcontrol
->private_value
;
2783 unsigned int vref_caps
= get_vref_caps(codec
, nid
);
2786 idx
= snd_hda_codec_get_pin_target(codec
, nid
) & AC_PINCTL_VREFEN
;
2787 ucontrol
->value
.enumerated
.item
[0] = cvt_from_vref_idx(vref_caps
, idx
);
2791 static int in_jack_mode_put(struct snd_kcontrol
*kcontrol
,
2792 struct snd_ctl_elem_value
*ucontrol
)
2794 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
2795 hda_nid_t nid
= kcontrol
->private_value
;
2796 unsigned int vref_caps
= get_vref_caps(codec
, nid
);
2797 unsigned int val
, idx
;
2799 val
= snd_hda_codec_get_pin_target(codec
, nid
);
2800 idx
= cvt_from_vref_idx(vref_caps
, val
& AC_PINCTL_VREFEN
);
2801 if (idx
== ucontrol
->value
.enumerated
.item
[0])
2804 val
&= ~AC_PINCTL_VREFEN
;
2805 val
|= get_vref_idx(vref_caps
, ucontrol
->value
.enumerated
.item
[0]);
2806 snd_hda_set_pin_ctl_cache(codec
, nid
, val
);
2810 static const struct snd_kcontrol_new in_jack_mode_enum
= {
2811 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
2812 .info
= in_jack_mode_info
,
2813 .get
= in_jack_mode_get
,
2814 .put
= in_jack_mode_put
,
2817 static int get_in_jack_num_items(struct hda_codec
*codec
, hda_nid_t pin
)
2819 struct hda_gen_spec
*spec
= codec
->spec
;
2821 if (spec
->add_jack_modes
)
2822 nitems
= hweight32(get_vref_caps(codec
, pin
));
2823 return nitems
? nitems
: 1;
2826 static int create_in_jack_mode(struct hda_codec
*codec
, hda_nid_t pin
)
2828 struct hda_gen_spec
*spec
= codec
->spec
;
2829 struct snd_kcontrol_new
*knew
;
2830 char name
[SNDRV_CTL_ELEM_ID_NAME_MAXLEN
];
2831 unsigned int defcfg
;
2833 if (pin
== spec
->hp_mic_pin
)
2834 return 0; /* already done in create_out_jack_mode() */
2836 /* no jack mode for fixed pins */
2837 defcfg
= snd_hda_codec_get_pincfg(codec
, pin
);
2838 if (snd_hda_get_input_pin_attr(defcfg
) == INPUT_PIN_ATTR_INT
)
2841 /* no multiple vref caps? */
2842 if (get_in_jack_num_items(codec
, pin
) <= 1)
2845 get_jack_mode_name(codec
, pin
, name
, sizeof(name
));
2846 knew
= snd_hda_gen_add_kctl(spec
, name
, &in_jack_mode_enum
);
2849 knew
->private_value
= pin
;
2854 * HP/mic shared jack mode
2856 static int hp_mic_jack_mode_info(struct snd_kcontrol
*kcontrol
,
2857 struct snd_ctl_elem_info
*uinfo
)
2859 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
2860 hda_nid_t nid
= kcontrol
->private_value
;
2861 int out_jacks
= get_out_jack_num_items(codec
, nid
);
2862 int in_jacks
= get_in_jack_num_items(codec
, nid
);
2863 const char *text
= NULL
;
2866 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_ENUMERATED
;
2868 uinfo
->value
.enumerated
.items
= out_jacks
+ in_jacks
;
2869 if (uinfo
->value
.enumerated
.item
>= uinfo
->value
.enumerated
.items
)
2870 uinfo
->value
.enumerated
.item
= uinfo
->value
.enumerated
.items
- 1;
2871 idx
= uinfo
->value
.enumerated
.item
;
2872 if (idx
< out_jacks
) {
2874 text
= out_jack_texts
[idx
];
2876 text
= "Headphone Out";
2880 unsigned int vref_caps
= get_vref_caps(codec
, nid
);
2881 text
= vref_texts
[get_vref_idx(vref_caps
, idx
)];
2886 strcpy(uinfo
->value
.enumerated
.name
, text
);
2890 static int get_cur_hp_mic_jack_mode(struct hda_codec
*codec
, hda_nid_t nid
)
2892 int out_jacks
= get_out_jack_num_items(codec
, nid
);
2893 int in_jacks
= get_in_jack_num_items(codec
, nid
);
2894 unsigned int val
= snd_hda_codec_get_pin_target(codec
, nid
);
2897 if (val
& PIN_OUT
) {
2898 if (out_jacks
> 1 && val
== PIN_HP
)
2900 } else if (val
& PIN_IN
) {
2903 unsigned int vref_caps
= get_vref_caps(codec
, nid
);
2904 val
&= AC_PINCTL_VREFEN
;
2905 idx
+= cvt_from_vref_idx(vref_caps
, val
);
2911 static int hp_mic_jack_mode_get(struct snd_kcontrol
*kcontrol
,
2912 struct snd_ctl_elem_value
*ucontrol
)
2914 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
2915 hda_nid_t nid
= kcontrol
->private_value
;
2916 ucontrol
->value
.enumerated
.item
[0] =
2917 get_cur_hp_mic_jack_mode(codec
, nid
);
2921 static int hp_mic_jack_mode_put(struct snd_kcontrol
*kcontrol
,
2922 struct snd_ctl_elem_value
*ucontrol
)
2924 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
2925 hda_nid_t nid
= kcontrol
->private_value
;
2926 int out_jacks
= get_out_jack_num_items(codec
, nid
);
2927 int in_jacks
= get_in_jack_num_items(codec
, nid
);
2928 unsigned int val
, oldval
, idx
;
2930 oldval
= get_cur_hp_mic_jack_mode(codec
, nid
);
2931 idx
= ucontrol
->value
.enumerated
.item
[0];
2935 if (idx
< out_jacks
) {
2937 val
= idx
? PIN_HP
: PIN_OUT
;
2943 unsigned int vref_caps
= get_vref_caps(codec
, nid
);
2944 val
= snd_hda_codec_get_pin_target(codec
, nid
);
2945 val
&= ~(AC_PINCTL_VREFEN
| PIN_HP
);
2946 val
|= get_vref_idx(vref_caps
, idx
) | PIN_IN
;
2948 val
= snd_hda_get_default_vref(codec
, nid
) | PIN_IN
;
2950 snd_hda_set_pin_ctl_cache(codec
, nid
, val
);
2951 call_hp_automute(codec
, NULL
);
2956 static const struct snd_kcontrol_new hp_mic_jack_mode_enum
= {
2957 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
2958 .info
= hp_mic_jack_mode_info
,
2959 .get
= hp_mic_jack_mode_get
,
2960 .put
= hp_mic_jack_mode_put
,
2963 static int create_hp_mic_jack_mode(struct hda_codec
*codec
, hda_nid_t pin
)
2965 struct hda_gen_spec
*spec
= codec
->spec
;
2966 struct snd_kcontrol_new
*knew
;
2968 knew
= snd_hda_gen_add_kctl(spec
, "Headphone Mic Jack Mode",
2969 &hp_mic_jack_mode_enum
);
2972 knew
->private_value
= pin
;
2973 spec
->hp_mic_jack_modes
= 1;
2981 /* add the powersave loopback-list entry */
2982 static int add_loopback_list(struct hda_gen_spec
*spec
, hda_nid_t mix
, int idx
)
2984 struct hda_amp_list
*list
;
2986 list
= snd_array_new(&spec
->loopback_list
);
2990 list
->dir
= HDA_INPUT
;
2992 spec
->loopback
.amplist
= spec
->loopback_list
.list
;
2996 /* return true if either a volume or a mute amp is found for the given
2997 * aamix path; the amp has to be either in the mixer node or its direct leaf
2999 static bool look_for_mix_leaf_ctls(struct hda_codec
*codec
, hda_nid_t mix_nid
,
3000 hda_nid_t pin
, unsigned int *mix_val
,
3001 unsigned int *mute_val
)
3004 const hda_nid_t
*list
;
3007 idx
= snd_hda_get_conn_index(codec
, mix_nid
, pin
, true);
3011 *mix_val
= *mute_val
= 0;
3012 if (nid_has_volume(codec
, mix_nid
, HDA_INPUT
))
3013 *mix_val
= HDA_COMPOSE_AMP_VAL(mix_nid
, 3, idx
, HDA_INPUT
);
3014 if (nid_has_mute(codec
, mix_nid
, HDA_INPUT
))
3015 *mute_val
= HDA_COMPOSE_AMP_VAL(mix_nid
, 3, idx
, HDA_INPUT
);
3016 if (*mix_val
&& *mute_val
)
3019 /* check leaf node */
3020 num_conns
= snd_hda_get_conn_list(codec
, mix_nid
, &list
);
3021 if (num_conns
< idx
)
3024 if (!*mix_val
&& nid_has_volume(codec
, nid
, HDA_OUTPUT
) &&
3025 !is_ctl_associated(codec
, nid
, HDA_OUTPUT
, 0, NID_PATH_VOL_CTL
))
3026 *mix_val
= HDA_COMPOSE_AMP_VAL(nid
, 3, 0, HDA_OUTPUT
);
3027 if (!*mute_val
&& nid_has_mute(codec
, nid
, HDA_OUTPUT
) &&
3028 !is_ctl_associated(codec
, nid
, HDA_OUTPUT
, 0, NID_PATH_MUTE_CTL
))
3029 *mute_val
= HDA_COMPOSE_AMP_VAL(nid
, 3, 0, HDA_OUTPUT
);
3031 return *mix_val
|| *mute_val
;
3034 /* create input playback/capture controls for the given pin */
3035 static int new_analog_input(struct hda_codec
*codec
, int input_idx
,
3036 hda_nid_t pin
, const char *ctlname
, int ctlidx
,
3039 struct hda_gen_spec
*spec
= codec
->spec
;
3040 struct nid_path
*path
;
3041 unsigned int mix_val
, mute_val
;
3044 if (!look_for_mix_leaf_ctls(codec
, mix_nid
, pin
, &mix_val
, &mute_val
))
3047 path
= snd_hda_add_new_path(codec
, pin
, mix_nid
, 0);
3050 print_nid_path(codec
, "loopback", path
);
3051 spec
->loopback_paths
[input_idx
] = snd_hda_get_path_idx(codec
, path
);
3053 idx
= path
->idx
[path
->depth
- 1];
3055 err
= __add_pb_vol_ctrl(spec
, HDA_CTL_WIDGET_VOL
, ctlname
, ctlidx
, mix_val
);
3058 path
->ctls
[NID_PATH_VOL_CTL
] = mix_val
;
3062 err
= __add_pb_sw_ctrl(spec
, HDA_CTL_WIDGET_MUTE
, ctlname
, ctlidx
, mute_val
);
3065 path
->ctls
[NID_PATH_MUTE_CTL
] = mute_val
;
3068 path
->active
= true;
3069 path
->stream_enabled
= true; /* no DAC/ADC involved */
3070 err
= add_loopback_list(spec
, mix_nid
, idx
);
3074 if (spec
->mixer_nid
!= spec
->mixer_merge_nid
&&
3075 !spec
->loopback_merge_path
) {
3076 path
= snd_hda_add_new_path(codec
, spec
->mixer_nid
,
3077 spec
->mixer_merge_nid
, 0);
3079 print_nid_path(codec
, "loopback-merge", path
);
3080 path
->active
= true;
3081 path
->pin_fixed
= true; /* static route */
3082 path
->stream_enabled
= true; /* no DAC/ADC involved */
3083 spec
->loopback_merge_path
=
3084 snd_hda_get_path_idx(codec
, path
);
3091 static int is_input_pin(struct hda_codec
*codec
, hda_nid_t nid
)
3093 unsigned int pincap
= snd_hda_query_pin_caps(codec
, nid
);
3094 return (pincap
& AC_PINCAP_IN
) != 0;
3097 /* Parse the codec tree and retrieve ADCs */
3098 static int fill_adc_nids(struct hda_codec
*codec
)
3100 struct hda_gen_spec
*spec
= codec
->spec
;
3102 hda_nid_t
*adc_nids
= spec
->adc_nids
;
3103 int max_nums
= ARRAY_SIZE(spec
->adc_nids
);
3106 for_each_hda_codec_node(nid
, codec
) {
3107 unsigned int caps
= get_wcaps(codec
, nid
);
3108 int type
= get_wcaps_type(caps
);
3110 if (type
!= AC_WID_AUD_IN
|| (caps
& AC_WCAP_DIGITAL
))
3112 adc_nids
[nums
] = nid
;
3113 if (++nums
>= max_nums
)
3116 spec
->num_adc_nids
= nums
;
3118 /* copy the detected ADCs to all_adcs[] */
3119 spec
->num_all_adcs
= nums
;
3120 memcpy(spec
->all_adcs
, spec
->adc_nids
, nums
* sizeof(hda_nid_t
));
3125 /* filter out invalid adc_nids that don't give all active input pins;
3126 * if needed, check whether dynamic ADC-switching is available
3128 static int check_dyn_adc_switch(struct hda_codec
*codec
)
3130 struct hda_gen_spec
*spec
= codec
->spec
;
3131 struct hda_input_mux
*imux
= &spec
->input_mux
;
3132 unsigned int ok_bits
;
3137 for (n
= 0; n
< spec
->num_adc_nids
; n
++) {
3138 for (i
= 0; i
< imux
->num_items
; i
++) {
3139 if (!spec
->input_paths
[i
][n
])
3142 if (i
>= imux
->num_items
) {
3143 ok_bits
|= (1 << n
);
3149 /* check whether ADC-switch is possible */
3150 for (i
= 0; i
< imux
->num_items
; i
++) {
3151 for (n
= 0; n
< spec
->num_adc_nids
; n
++) {
3152 if (spec
->input_paths
[i
][n
]) {
3153 spec
->dyn_adc_idx
[i
] = n
;
3159 codec_dbg(codec
, "enabling ADC switching\n");
3160 spec
->dyn_adc_switch
= 1;
3161 } else if (nums
!= spec
->num_adc_nids
) {
3162 /* shrink the invalid adcs and input paths */
3164 for (n
= 0; n
< spec
->num_adc_nids
; n
++) {
3165 if (!(ok_bits
& (1 << n
)))
3168 spec
->adc_nids
[nums
] = spec
->adc_nids
[n
];
3169 for (i
= 0; i
< imux
->num_items
; i
++) {
3170 invalidate_nid_path(codec
,
3171 spec
->input_paths
[i
][nums
]);
3172 spec
->input_paths
[i
][nums
] =
3173 spec
->input_paths
[i
][n
];
3178 spec
->num_adc_nids
= nums
;
3181 if (imux
->num_items
== 1 ||
3182 (imux
->num_items
== 2 && spec
->hp_mic
)) {
3183 codec_dbg(codec
, "reducing to a single ADC\n");
3184 spec
->num_adc_nids
= 1; /* reduce to a single ADC */
3187 /* single index for individual volumes ctls */
3188 if (!spec
->dyn_adc_switch
&& spec
->multi_cap_vol
)
3189 spec
->num_adc_nids
= 1;
3194 /* parse capture source paths from the given pin and create imux items */
3195 static int parse_capture_source(struct hda_codec
*codec
, hda_nid_t pin
,
3196 int cfg_idx
, int num_adcs
,
3197 const char *label
, int anchor
)
3199 struct hda_gen_spec
*spec
= codec
->spec
;
3200 struct hda_input_mux
*imux
= &spec
->input_mux
;
3201 int imux_idx
= imux
->num_items
;
3202 bool imux_added
= false;
3205 for (c
= 0; c
< num_adcs
; c
++) {
3206 struct nid_path
*path
;
3207 hda_nid_t adc
= spec
->adc_nids
[c
];
3209 if (!is_reachable_path(codec
, pin
, adc
))
3211 path
= snd_hda_add_new_path(codec
, pin
, adc
, anchor
);
3214 print_nid_path(codec
, "input", path
);
3215 spec
->input_paths
[imux_idx
][c
] =
3216 snd_hda_get_path_idx(codec
, path
);
3219 if (spec
->hp_mic_pin
== pin
)
3220 spec
->hp_mic_mux_idx
= imux
->num_items
;
3221 spec
->imux_pins
[imux
->num_items
] = pin
;
3222 snd_hda_add_imux_item(codec
, imux
, label
, cfg_idx
, NULL
);
3224 if (spec
->dyn_adc_switch
)
3225 spec
->dyn_adc_idx
[imux_idx
] = c
;
3233 * create playback/capture controls for input pins
3236 /* fill the label for each input at first */
3237 static int fill_input_pin_labels(struct hda_codec
*codec
)
3239 struct hda_gen_spec
*spec
= codec
->spec
;
3240 const struct auto_pin_cfg
*cfg
= &spec
->autocfg
;
3243 for (i
= 0; i
< cfg
->num_inputs
; i
++) {
3244 hda_nid_t pin
= cfg
->inputs
[i
].pin
;
3248 if (!is_input_pin(codec
, pin
))
3251 label
= hda_get_autocfg_input_label(codec
, cfg
, i
);
3253 for (j
= i
- 1; j
>= 0; j
--) {
3254 if (spec
->input_labels
[j
] &&
3255 !strcmp(spec
->input_labels
[j
], label
)) {
3256 idx
= spec
->input_label_idxs
[j
] + 1;
3261 spec
->input_labels
[i
] = label
;
3262 spec
->input_label_idxs
[i
] = idx
;
3268 #define CFG_IDX_MIX 99 /* a dummy cfg->input idx for stereo mix */
3270 static int create_input_ctls(struct hda_codec
*codec
)
3272 struct hda_gen_spec
*spec
= codec
->spec
;
3273 const struct auto_pin_cfg
*cfg
= &spec
->autocfg
;
3274 hda_nid_t mixer
= spec
->mixer_nid
;
3279 num_adcs
= fill_adc_nids(codec
);
3283 err
= fill_input_pin_labels(codec
);
3287 for (i
= 0; i
< cfg
->num_inputs
; i
++) {
3290 pin
= cfg
->inputs
[i
].pin
;
3291 if (!is_input_pin(codec
, pin
))
3295 if (cfg
->inputs
[i
].type
== AUTO_PIN_MIC
)
3296 val
|= snd_hda_get_default_vref(codec
, pin
);
3297 if (pin
!= spec
->hp_mic_pin
&&
3298 !snd_hda_codec_get_pin_target(codec
, pin
))
3299 set_pin_target(codec
, pin
, val
, false);
3302 if (is_reachable_path(codec
, pin
, mixer
)) {
3303 err
= new_analog_input(codec
, i
, pin
,
3304 spec
->input_labels
[i
],
3305 spec
->input_label_idxs
[i
],
3312 err
= parse_capture_source(codec
, pin
, i
, num_adcs
,
3313 spec
->input_labels
[i
], -mixer
);
3317 if (spec
->add_jack_modes
) {
3318 err
= create_in_jack_mode(codec
, pin
);
3324 /* add stereo mix when explicitly enabled via hint */
3325 if (mixer
&& spec
->add_stereo_mix_input
== HDA_HINT_STEREO_MIX_ENABLE
) {
3326 err
= parse_capture_source(codec
, mixer
, CFG_IDX_MIX
, num_adcs
,
3331 spec
->suppress_auto_mic
= 1;
3342 /* get the input path specified by the given adc and imux indices */
3343 static struct nid_path
*get_input_path(struct hda_codec
*codec
, int adc_idx
, int imux_idx
)
3345 struct hda_gen_spec
*spec
= codec
->spec
;
3346 if (imux_idx
< 0 || imux_idx
>= HDA_MAX_NUM_INPUTS
) {
3350 if (spec
->dyn_adc_switch
)
3351 adc_idx
= spec
->dyn_adc_idx
[imux_idx
];
3352 if (adc_idx
< 0 || adc_idx
>= AUTO_CFG_MAX_INS
) {
3356 return snd_hda_get_path_from_idx(codec
, spec
->input_paths
[imux_idx
][adc_idx
]);
3359 static int mux_select(struct hda_codec
*codec
, unsigned int adc_idx
,
3362 static int mux_enum_info(struct snd_kcontrol
*kcontrol
,
3363 struct snd_ctl_elem_info
*uinfo
)
3365 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
3366 struct hda_gen_spec
*spec
= codec
->spec
;
3367 return snd_hda_input_mux_info(&spec
->input_mux
, uinfo
);
3370 static int mux_enum_get(struct snd_kcontrol
*kcontrol
,
3371 struct snd_ctl_elem_value
*ucontrol
)
3373 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
3374 struct hda_gen_spec
*spec
= codec
->spec
;
3375 /* the ctls are created at once with multiple counts */
3376 unsigned int adc_idx
= snd_ctl_get_ioffidx(kcontrol
, &ucontrol
->id
);
3378 ucontrol
->value
.enumerated
.item
[0] = spec
->cur_mux
[adc_idx
];
3382 static int mux_enum_put(struct snd_kcontrol
*kcontrol
,
3383 struct snd_ctl_elem_value
*ucontrol
)
3385 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
3386 unsigned int adc_idx
= snd_ctl_get_ioffidx(kcontrol
, &ucontrol
->id
);
3387 return mux_select(codec
, adc_idx
,
3388 ucontrol
->value
.enumerated
.item
[0]);
3391 static const struct snd_kcontrol_new cap_src_temp
= {
3392 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
3393 .name
= "Input Source",
3394 .info
= mux_enum_info
,
3395 .get
= mux_enum_get
,
3396 .put
= mux_enum_put
,
3400 * capture volume and capture switch ctls
3403 typedef int (*put_call_t
)(struct snd_kcontrol
*kcontrol
,
3404 struct snd_ctl_elem_value
*ucontrol
);
3406 /* call the given amp update function for all amps in the imux list at once */
3407 static int cap_put_caller(struct snd_kcontrol
*kcontrol
,
3408 struct snd_ctl_elem_value
*ucontrol
,
3409 put_call_t func
, int type
)
3411 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
3412 struct hda_gen_spec
*spec
= codec
->spec
;
3413 const struct hda_input_mux
*imux
;
3414 struct nid_path
*path
;
3415 int i
, adc_idx
, err
= 0;
3417 imux
= &spec
->input_mux
;
3418 adc_idx
= kcontrol
->id
.index
;
3419 mutex_lock(&codec
->control_mutex
);
3420 for (i
= 0; i
< imux
->num_items
; i
++) {
3421 path
= get_input_path(codec
, adc_idx
, i
);
3422 if (!path
|| !path
->ctls
[type
])
3424 kcontrol
->private_value
= path
->ctls
[type
];
3425 err
= func(kcontrol
, ucontrol
);
3429 mutex_unlock(&codec
->control_mutex
);
3430 if (err
>= 0 && spec
->cap_sync_hook
)
3431 spec
->cap_sync_hook(codec
, kcontrol
, ucontrol
);
3435 /* capture volume ctl callbacks */
3436 #define cap_vol_info snd_hda_mixer_amp_volume_info
3437 #define cap_vol_get snd_hda_mixer_amp_volume_get
3438 #define cap_vol_tlv snd_hda_mixer_amp_tlv
3440 static int cap_vol_put(struct snd_kcontrol
*kcontrol
,
3441 struct snd_ctl_elem_value
*ucontrol
)
3443 return cap_put_caller(kcontrol
, ucontrol
,
3444 snd_hda_mixer_amp_volume_put
,
3448 static const struct snd_kcontrol_new cap_vol_temp
= {
3449 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
3450 .name
= "Capture Volume",
3451 .access
= (SNDRV_CTL_ELEM_ACCESS_READWRITE
|
3452 SNDRV_CTL_ELEM_ACCESS_TLV_READ
|
3453 SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK
),
3454 .info
= cap_vol_info
,
3457 .tlv
= { .c
= cap_vol_tlv
},
3460 /* capture switch ctl callbacks */
3461 #define cap_sw_info snd_ctl_boolean_stereo_info
3462 #define cap_sw_get snd_hda_mixer_amp_switch_get
3464 static int cap_sw_put(struct snd_kcontrol
*kcontrol
,
3465 struct snd_ctl_elem_value
*ucontrol
)
3467 return cap_put_caller(kcontrol
, ucontrol
,
3468 snd_hda_mixer_amp_switch_put
,
3472 static const struct snd_kcontrol_new cap_sw_temp
= {
3473 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
3474 .name
= "Capture Switch",
3475 .info
= cap_sw_info
,
3480 static int parse_capvol_in_path(struct hda_codec
*codec
, struct nid_path
*path
)
3485 path
->ctls
[NID_PATH_VOL_CTL
] = path
->ctls
[NID_PATH_MUTE_CTL
] = 0;
3486 for (depth
= 0; depth
< 3; depth
++) {
3487 if (depth
>= path
->depth
)
3489 i
= path
->depth
- depth
- 1;
3490 nid
= path
->path
[i
];
3491 if (!path
->ctls
[NID_PATH_VOL_CTL
]) {
3492 if (nid_has_volume(codec
, nid
, HDA_OUTPUT
))
3493 path
->ctls
[NID_PATH_VOL_CTL
] =
3494 HDA_COMPOSE_AMP_VAL(nid
, 3, 0, HDA_OUTPUT
);
3495 else if (nid_has_volume(codec
, nid
, HDA_INPUT
)) {
3496 int idx
= path
->idx
[i
];
3497 if (!depth
&& codec
->single_adc_amp
)
3499 path
->ctls
[NID_PATH_VOL_CTL
] =
3500 HDA_COMPOSE_AMP_VAL(nid
, 3, idx
, HDA_INPUT
);
3503 if (!path
->ctls
[NID_PATH_MUTE_CTL
]) {
3504 if (nid_has_mute(codec
, nid
, HDA_OUTPUT
))
3505 path
->ctls
[NID_PATH_MUTE_CTL
] =
3506 HDA_COMPOSE_AMP_VAL(nid
, 3, 0, HDA_OUTPUT
);
3507 else if (nid_has_mute(codec
, nid
, HDA_INPUT
)) {
3508 int idx
= path
->idx
[i
];
3509 if (!depth
&& codec
->single_adc_amp
)
3511 path
->ctls
[NID_PATH_MUTE_CTL
] =
3512 HDA_COMPOSE_AMP_VAL(nid
, 3, idx
, HDA_INPUT
);
3519 static bool is_inv_dmic_pin(struct hda_codec
*codec
, hda_nid_t nid
)
3521 struct hda_gen_spec
*spec
= codec
->spec
;
3522 struct auto_pin_cfg
*cfg
= &spec
->autocfg
;
3526 if (!spec
->inv_dmic_split
)
3528 for (i
= 0; i
< cfg
->num_inputs
; i
++) {
3529 if (cfg
->inputs
[i
].pin
!= nid
)
3531 if (cfg
->inputs
[i
].type
!= AUTO_PIN_MIC
)
3533 val
= snd_hda_codec_get_pincfg(codec
, nid
);
3534 return snd_hda_get_input_pin_attr(val
) == INPUT_PIN_ATTR_INT
;
3539 /* capture switch put callback for a single control with hook call */
3540 static int cap_single_sw_put(struct snd_kcontrol
*kcontrol
,
3541 struct snd_ctl_elem_value
*ucontrol
)
3543 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
3544 struct hda_gen_spec
*spec
= codec
->spec
;
3547 ret
= snd_hda_mixer_amp_switch_put(kcontrol
, ucontrol
);
3551 if (spec
->cap_sync_hook
)
3552 spec
->cap_sync_hook(codec
, kcontrol
, ucontrol
);
3557 static int add_single_cap_ctl(struct hda_codec
*codec
, const char *label
,
3558 int idx
, bool is_switch
, unsigned int ctl
,
3561 struct hda_gen_spec
*spec
= codec
->spec
;
3562 char tmpname
[SNDRV_CTL_ELEM_ID_NAME_MAXLEN
];
3563 int type
= is_switch
? HDA_CTL_WIDGET_MUTE
: HDA_CTL_WIDGET_VOL
;
3564 const char *sfx
= is_switch
? "Switch" : "Volume";
3565 unsigned int chs
= inv_dmic
? 1 : 3;
3566 struct snd_kcontrol_new
*knew
;
3572 snprintf(tmpname
, sizeof(tmpname
),
3573 "%s Capture %s", label
, sfx
);
3575 snprintf(tmpname
, sizeof(tmpname
),
3577 knew
= add_control(spec
, type
, tmpname
, idx
,
3578 amp_val_replace_channels(ctl
, chs
));
3582 knew
->put
= cap_single_sw_put
;
3586 /* Make independent right kcontrol */
3588 snprintf(tmpname
, sizeof(tmpname
),
3589 "Inverted %s Capture %s", label
, sfx
);
3591 snprintf(tmpname
, sizeof(tmpname
),
3592 "Inverted Capture %s", sfx
);
3593 knew
= add_control(spec
, type
, tmpname
, idx
,
3594 amp_val_replace_channels(ctl
, 2));
3598 knew
->put
= cap_single_sw_put
;
3602 /* create single (and simple) capture volume and switch controls */
3603 static int create_single_cap_vol_ctl(struct hda_codec
*codec
, int idx
,
3604 unsigned int vol_ctl
, unsigned int sw_ctl
,
3608 err
= add_single_cap_ctl(codec
, NULL
, idx
, false, vol_ctl
, inv_dmic
);
3611 err
= add_single_cap_ctl(codec
, NULL
, idx
, true, sw_ctl
, inv_dmic
);
3617 /* create bound capture volume and switch controls */
3618 static int create_bind_cap_vol_ctl(struct hda_codec
*codec
, int idx
,
3619 unsigned int vol_ctl
, unsigned int sw_ctl
)
3621 struct hda_gen_spec
*spec
= codec
->spec
;
3622 struct snd_kcontrol_new
*knew
;
3625 knew
= snd_hda_gen_add_kctl(spec
, NULL
, &cap_vol_temp
);
3629 knew
->private_value
= vol_ctl
;
3630 knew
->subdevice
= HDA_SUBDEV_AMP_FLAG
;
3633 knew
= snd_hda_gen_add_kctl(spec
, NULL
, &cap_sw_temp
);
3637 knew
->private_value
= sw_ctl
;
3638 knew
->subdevice
= HDA_SUBDEV_AMP_FLAG
;
3643 /* return the vol ctl when used first in the imux list */
3644 static unsigned int get_first_cap_ctl(struct hda_codec
*codec
, int idx
, int type
)
3646 struct nid_path
*path
;
3650 path
= get_input_path(codec
, 0, idx
);
3653 ctl
= path
->ctls
[type
];
3656 for (i
= 0; i
< idx
- 1; i
++) {
3657 path
= get_input_path(codec
, 0, i
);
3658 if (path
&& path
->ctls
[type
] == ctl
)
3664 /* create individual capture volume and switch controls per input */
3665 static int create_multi_cap_vol_ctl(struct hda_codec
*codec
)
3667 struct hda_gen_spec
*spec
= codec
->spec
;
3668 struct hda_input_mux
*imux
= &spec
->input_mux
;
3671 for (i
= 0; i
< imux
->num_items
; i
++) {
3675 idx
= imux
->items
[i
].index
;
3676 if (idx
>= spec
->autocfg
.num_inputs
)
3678 inv_dmic
= is_inv_dmic_pin(codec
, spec
->imux_pins
[i
]);
3680 for (type
= 0; type
< 2; type
++) {
3681 err
= add_single_cap_ctl(codec
,
3682 spec
->input_labels
[idx
],
3683 spec
->input_label_idxs
[idx
],
3685 get_first_cap_ctl(codec
, i
, type
),
3694 static int create_capture_mixers(struct hda_codec
*codec
)
3696 struct hda_gen_spec
*spec
= codec
->spec
;
3697 struct hda_input_mux
*imux
= &spec
->input_mux
;
3698 int i
, n
, nums
, err
;
3700 if (spec
->dyn_adc_switch
)
3703 nums
= spec
->num_adc_nids
;
3705 if (!spec
->auto_mic
&& imux
->num_items
> 1) {
3706 struct snd_kcontrol_new
*knew
;
3708 name
= nums
> 1 ? "Input Source" : "Capture Source";
3709 knew
= snd_hda_gen_add_kctl(spec
, name
, &cap_src_temp
);
3715 for (n
= 0; n
< nums
; n
++) {
3717 bool multi_cap_vol
= spec
->multi_cap_vol
;
3718 bool inv_dmic
= false;
3722 for (i
= 0; i
< imux
->num_items
; i
++) {
3723 struct nid_path
*path
;
3724 path
= get_input_path(codec
, n
, i
);
3727 parse_capvol_in_path(codec
, path
);
3729 vol
= path
->ctls
[NID_PATH_VOL_CTL
];
3730 else if (vol
!= path
->ctls
[NID_PATH_VOL_CTL
]) {
3732 if (!same_amp_caps(codec
, vol
,
3733 path
->ctls
[NID_PATH_VOL_CTL
], HDA_INPUT
))
3734 multi_cap_vol
= true;
3737 sw
= path
->ctls
[NID_PATH_MUTE_CTL
];
3738 else if (sw
!= path
->ctls
[NID_PATH_MUTE_CTL
]) {
3740 if (!same_amp_caps(codec
, sw
,
3741 path
->ctls
[NID_PATH_MUTE_CTL
], HDA_INPUT
))
3742 multi_cap_vol
= true;
3744 if (is_inv_dmic_pin(codec
, spec
->imux_pins
[i
]))
3749 err
= create_single_cap_vol_ctl(codec
, n
, vol
, sw
,
3751 else if (!multi_cap_vol
&& !inv_dmic
)
3752 err
= create_bind_cap_vol_ctl(codec
, n
, vol
, sw
);
3754 err
= create_multi_cap_vol_ctl(codec
);
3763 * add mic boosts if needed
3766 /* check whether the given amp is feasible as a boost volume */
3767 static bool check_boost_vol(struct hda_codec
*codec
, hda_nid_t nid
,
3772 if (!nid_has_volume(codec
, nid
, dir
) ||
3773 is_ctl_associated(codec
, nid
, dir
, idx
, NID_PATH_VOL_CTL
) ||
3774 is_ctl_associated(codec
, nid
, dir
, idx
, NID_PATH_BOOST_CTL
))
3777 step
= (query_amp_caps(codec
, nid
, dir
) & AC_AMPCAP_STEP_SIZE
)
3778 >> AC_AMPCAP_STEP_SIZE_SHIFT
;
3784 /* look for a boost amp in a widget close to the pin */
3785 static unsigned int look_for_boost_amp(struct hda_codec
*codec
,
3786 struct nid_path
*path
)
3788 unsigned int val
= 0;
3792 for (depth
= 0; depth
< 3; depth
++) {
3793 if (depth
>= path
->depth
- 1)
3795 nid
= path
->path
[depth
];
3796 if (depth
&& check_boost_vol(codec
, nid
, HDA_OUTPUT
, 0)) {
3797 val
= HDA_COMPOSE_AMP_VAL(nid
, 3, 0, HDA_OUTPUT
);
3799 } else if (check_boost_vol(codec
, nid
, HDA_INPUT
,
3800 path
->idx
[depth
])) {
3801 val
= HDA_COMPOSE_AMP_VAL(nid
, 3, path
->idx
[depth
],
3810 static int parse_mic_boost(struct hda_codec
*codec
)
3812 struct hda_gen_spec
*spec
= codec
->spec
;
3813 struct auto_pin_cfg
*cfg
= &spec
->autocfg
;
3814 struct hda_input_mux
*imux
= &spec
->input_mux
;
3817 if (!spec
->num_adc_nids
)
3820 for (i
= 0; i
< imux
->num_items
; i
++) {
3821 struct nid_path
*path
;
3824 char boost_label
[SNDRV_CTL_ELEM_ID_NAME_MAXLEN
];
3826 idx
= imux
->items
[i
].index
;
3827 if (idx
>= imux
->num_items
)
3830 /* check only line-in and mic pins */
3831 if (cfg
->inputs
[idx
].type
> AUTO_PIN_LINE_IN
)
3834 path
= get_input_path(codec
, 0, i
);
3838 val
= look_for_boost_amp(codec
, path
);
3842 /* create a boost control */
3843 snprintf(boost_label
, sizeof(boost_label
),
3844 "%s Boost Volume", spec
->input_labels
[idx
]);
3845 if (!add_control(spec
, HDA_CTL_WIDGET_VOL
, boost_label
,
3846 spec
->input_label_idxs
[idx
], val
))
3849 path
->ctls
[NID_PATH_BOOST_CTL
] = val
;
3855 * parse digital I/Os and set up NIDs in BIOS auto-parse mode
3857 static void parse_digital(struct hda_codec
*codec
)
3859 struct hda_gen_spec
*spec
= codec
->spec
;
3860 struct nid_path
*path
;
3862 hda_nid_t dig_nid
, pin
;
3864 /* support multiple SPDIFs; the secondary is set up as a slave */
3866 for (i
= 0; i
< spec
->autocfg
.dig_outs
; i
++) {
3867 pin
= spec
->autocfg
.dig_out_pins
[i
];
3868 dig_nid
= look_for_dac(codec
, pin
, true);
3871 path
= snd_hda_add_new_path(codec
, dig_nid
, pin
, 0);
3874 print_nid_path(codec
, "digout", path
);
3875 path
->active
= true;
3876 path
->pin_fixed
= true; /* no jack detection */
3877 spec
->digout_paths
[i
] = snd_hda_get_path_idx(codec
, path
);
3878 set_pin_target(codec
, pin
, PIN_OUT
, false);
3880 spec
->multiout
.dig_out_nid
= dig_nid
;
3881 spec
->dig_out_type
= spec
->autocfg
.dig_out_type
[0];
3883 spec
->multiout
.slave_dig_outs
= spec
->slave_dig_outs
;
3884 if (nums
>= ARRAY_SIZE(spec
->slave_dig_outs
) - 1)
3886 spec
->slave_dig_outs
[nums
- 1] = dig_nid
;
3891 if (spec
->autocfg
.dig_in_pin
) {
3892 pin
= spec
->autocfg
.dig_in_pin
;
3893 for_each_hda_codec_node(dig_nid
, codec
) {
3894 unsigned int wcaps
= get_wcaps(codec
, dig_nid
);
3895 if (get_wcaps_type(wcaps
) != AC_WID_AUD_IN
)
3897 if (!(wcaps
& AC_WCAP_DIGITAL
))
3899 path
= snd_hda_add_new_path(codec
, pin
, dig_nid
, 0);
3901 print_nid_path(codec
, "digin", path
);
3902 path
->active
= true;
3903 path
->pin_fixed
= true; /* no jack */
3904 spec
->dig_in_nid
= dig_nid
;
3905 spec
->digin_path
= snd_hda_get_path_idx(codec
, path
);
3906 set_pin_target(codec
, pin
, PIN_IN
, false);
3915 * input MUX handling
3918 static bool dyn_adc_pcm_resetup(struct hda_codec
*codec
, int cur
);
3920 /* select the given imux item; either unmute exclusively or select the route */
3921 static int mux_select(struct hda_codec
*codec
, unsigned int adc_idx
,
3924 struct hda_gen_spec
*spec
= codec
->spec
;
3925 const struct hda_input_mux
*imux
;
3926 struct nid_path
*old_path
, *path
;
3928 imux
= &spec
->input_mux
;
3929 if (!imux
->num_items
)
3932 if (idx
>= imux
->num_items
)
3933 idx
= imux
->num_items
- 1;
3934 if (spec
->cur_mux
[adc_idx
] == idx
)
3937 old_path
= get_input_path(codec
, adc_idx
, spec
->cur_mux
[adc_idx
]);
3940 if (old_path
->active
)
3941 snd_hda_activate_path(codec
, old_path
, false, false);
3943 spec
->cur_mux
[adc_idx
] = idx
;
3946 update_hp_mic(codec
, adc_idx
, false);
3948 if (spec
->dyn_adc_switch
)
3949 dyn_adc_pcm_resetup(codec
, idx
);
3951 path
= get_input_path(codec
, adc_idx
, idx
);
3956 snd_hda_activate_path(codec
, path
, true, false);
3957 if (spec
->cap_sync_hook
)
3958 spec
->cap_sync_hook(codec
, NULL
, NULL
);
3959 path_power_down_sync(codec
, old_path
);
3963 /* power up/down widgets in the all paths that match with the given NID
3964 * as terminals (either start- or endpoint)
3966 * returns the last changed NID, or zero if unchanged.
3968 static hda_nid_t
set_path_power(struct hda_codec
*codec
, hda_nid_t nid
,
3969 int pin_state
, int stream_state
)
3971 struct hda_gen_spec
*spec
= codec
->spec
;
3972 hda_nid_t last
, changed
= 0;
3973 struct nid_path
*path
;
3976 for (n
= 0; n
< spec
->paths
.used
; n
++) {
3977 path
= snd_array_elem(&spec
->paths
, n
);
3978 if (path
->path
[0] == nid
||
3979 path
->path
[path
->depth
- 1] == nid
) {
3980 bool pin_old
= path
->pin_enabled
;
3981 bool stream_old
= path
->stream_enabled
;
3984 path
->pin_enabled
= pin_state
;
3985 if (stream_state
>= 0)
3986 path
->stream_enabled
= stream_state
;
3987 if ((!path
->pin_fixed
&& path
->pin_enabled
!= pin_old
)
3988 || path
->stream_enabled
!= stream_old
) {
3989 last
= path_power_update(codec
, path
, true);
3998 /* check the jack status for power control */
3999 static bool detect_pin_state(struct hda_codec
*codec
, hda_nid_t pin
)
4001 if (!is_jack_detectable(codec
, pin
))
4003 return snd_hda_jack_detect_state(codec
, pin
) != HDA_JACK_NOT_PRESENT
;
4006 /* power up/down the paths of the given pin according to the jack state;
4007 * power = 0/1 : only power up/down if it matches with the jack state,
4008 * < 0 : force power up/down to follow the jack sate
4010 * returns the last changed NID, or zero if unchanged.
4012 static hda_nid_t
set_pin_power_jack(struct hda_codec
*codec
, hda_nid_t pin
,
4017 if (!codec
->power_save_node
)
4020 on
= detect_pin_state(codec
, pin
);
4022 if (power
>= 0 && on
!= power
)
4024 return set_path_power(codec
, pin
, on
, -1);
4027 static void pin_power_callback(struct hda_codec
*codec
,
4028 struct hda_jack_callback
*jack
,
4031 if (jack
&& jack
->nid
)
4032 sync_power_state_change(codec
,
4033 set_pin_power_jack(codec
, jack
->nid
, on
));
4036 /* callback only doing power up -- called at first */
4037 static void pin_power_up_callback(struct hda_codec
*codec
,
4038 struct hda_jack_callback
*jack
)
4040 pin_power_callback(codec
, jack
, true);
4043 /* callback only doing power down -- called at last */
4044 static void pin_power_down_callback(struct hda_codec
*codec
,
4045 struct hda_jack_callback
*jack
)
4047 pin_power_callback(codec
, jack
, false);
4050 /* set up the power up/down callbacks */
4051 static void add_pin_power_ctls(struct hda_codec
*codec
, int num_pins
,
4052 const hda_nid_t
*pins
, bool on
)
4055 hda_jack_callback_fn cb
=
4056 on
? pin_power_up_callback
: pin_power_down_callback
;
4058 for (i
= 0; i
< num_pins
&& pins
[i
]; i
++) {
4059 if (is_jack_detectable(codec
, pins
[i
]))
4060 snd_hda_jack_detect_enable_callback(codec
, pins
[i
], cb
);
4062 set_path_power(codec
, pins
[i
], true, -1);
4066 /* enabled power callback to each available I/O pin with jack detections;
4067 * the digital I/O pins are excluded because of the unreliable detectsion
4069 static void add_all_pin_power_ctls(struct hda_codec
*codec
, bool on
)
4071 struct hda_gen_spec
*spec
= codec
->spec
;
4072 struct auto_pin_cfg
*cfg
= &spec
->autocfg
;
4075 if (!codec
->power_save_node
)
4077 add_pin_power_ctls(codec
, cfg
->line_outs
, cfg
->line_out_pins
, on
);
4078 if (cfg
->line_out_type
!= AUTO_PIN_HP_OUT
)
4079 add_pin_power_ctls(codec
, cfg
->hp_outs
, cfg
->hp_pins
, on
);
4080 if (cfg
->line_out_type
!= AUTO_PIN_SPEAKER_OUT
)
4081 add_pin_power_ctls(codec
, cfg
->speaker_outs
, cfg
->speaker_pins
, on
);
4082 for (i
= 0; i
< cfg
->num_inputs
; i
++)
4083 add_pin_power_ctls(codec
, 1, &cfg
->inputs
[i
].pin
, on
);
4086 /* sync path power up/down with the jack states of given pins */
4087 static void sync_pin_power_ctls(struct hda_codec
*codec
, int num_pins
,
4088 const hda_nid_t
*pins
)
4092 for (i
= 0; i
< num_pins
&& pins
[i
]; i
++)
4093 if (is_jack_detectable(codec
, pins
[i
]))
4094 set_pin_power_jack(codec
, pins
[i
], -1);
4097 /* sync path power up/down with pins; called at init and resume */
4098 static void sync_all_pin_power_ctls(struct hda_codec
*codec
)
4100 struct hda_gen_spec
*spec
= codec
->spec
;
4101 struct auto_pin_cfg
*cfg
= &spec
->autocfg
;
4104 if (!codec
->power_save_node
)
4106 sync_pin_power_ctls(codec
, cfg
->line_outs
, cfg
->line_out_pins
);
4107 if (cfg
->line_out_type
!= AUTO_PIN_HP_OUT
)
4108 sync_pin_power_ctls(codec
, cfg
->hp_outs
, cfg
->hp_pins
);
4109 if (cfg
->line_out_type
!= AUTO_PIN_SPEAKER_OUT
)
4110 sync_pin_power_ctls(codec
, cfg
->speaker_outs
, cfg
->speaker_pins
);
4111 for (i
= 0; i
< cfg
->num_inputs
; i
++)
4112 sync_pin_power_ctls(codec
, 1, &cfg
->inputs
[i
].pin
);
4115 /* add fake paths if not present yet */
4116 static int add_fake_paths(struct hda_codec
*codec
, hda_nid_t nid
,
4117 int num_pins
, const hda_nid_t
*pins
)
4119 struct hda_gen_spec
*spec
= codec
->spec
;
4120 struct nid_path
*path
;
4123 for (i
= 0; i
< num_pins
; i
++) {
4126 if (get_nid_path(codec
, nid
, pins
[i
], 0))
4128 path
= snd_array_new(&spec
->paths
);
4131 memset(path
, 0, sizeof(*path
));
4133 path
->path
[0] = nid
;
4134 path
->path
[1] = pins
[i
];
4135 path
->active
= true;
4140 /* create fake paths to all outputs from beep */
4141 static int add_fake_beep_paths(struct hda_codec
*codec
)
4143 struct hda_gen_spec
*spec
= codec
->spec
;
4144 struct auto_pin_cfg
*cfg
= &spec
->autocfg
;
4145 hda_nid_t nid
= spec
->beep_nid
;
4148 if (!codec
->power_save_node
|| !nid
)
4150 err
= add_fake_paths(codec
, nid
, cfg
->line_outs
, cfg
->line_out_pins
);
4153 if (cfg
->line_out_type
!= AUTO_PIN_HP_OUT
) {
4154 err
= add_fake_paths(codec
, nid
, cfg
->hp_outs
, cfg
->hp_pins
);
4158 if (cfg
->line_out_type
!= AUTO_PIN_SPEAKER_OUT
) {
4159 err
= add_fake_paths(codec
, nid
, cfg
->speaker_outs
,
4167 /* power up/down beep widget and its output paths */
4168 static void beep_power_hook(struct hda_beep
*beep
, bool on
)
4170 set_path_power(beep
->codec
, beep
->nid
, -1, on
);
4174 * snd_hda_gen_fix_pin_power - Fix the power of the given pin widget to D0
4175 * @codec: the HDA codec
4176 * @pin: NID of pin to fix
4178 int snd_hda_gen_fix_pin_power(struct hda_codec
*codec
, hda_nid_t pin
)
4180 struct hda_gen_spec
*spec
= codec
->spec
;
4181 struct nid_path
*path
;
4183 path
= snd_array_new(&spec
->paths
);
4186 memset(path
, 0, sizeof(*path
));
4188 path
->path
[0] = pin
;
4189 path
->active
= true;
4190 path
->pin_fixed
= true;
4191 path
->stream_enabled
= true;
4194 EXPORT_SYMBOL_GPL(snd_hda_gen_fix_pin_power
);
4197 * Jack detections for HP auto-mute and mic-switch
4200 /* check each pin in the given array; returns true if any of them is plugged */
4201 static bool detect_jacks(struct hda_codec
*codec
, int num_pins
, hda_nid_t
*pins
)
4204 bool present
= false;
4206 for (i
= 0; i
< num_pins
; i
++) {
4207 hda_nid_t nid
= pins
[i
];
4210 /* don't detect pins retasked as inputs */
4211 if (snd_hda_codec_get_pin_target(codec
, nid
) & AC_PINCTL_IN_EN
)
4213 if (snd_hda_jack_detect_state(codec
, nid
) == HDA_JACK_PRESENT
)
4219 /* standard HP/line-out auto-mute helper */
4220 static void do_automute(struct hda_codec
*codec
, int num_pins
, hda_nid_t
*pins
,
4221 int *paths
, bool mute
)
4223 struct hda_gen_spec
*spec
= codec
->spec
;
4226 for (i
= 0; i
< num_pins
; i
++) {
4227 hda_nid_t nid
= pins
[i
];
4228 unsigned int val
, oldval
;
4232 oldval
= snd_hda_codec_get_pin_target(codec
, nid
);
4233 if (oldval
& PIN_IN
)
4234 continue; /* no mute for inputs */
4236 if (spec
->auto_mute_via_amp
) {
4237 struct nid_path
*path
;
4240 path
= snd_hda_get_path_from_idx(codec
, paths
[i
]);
4243 mute_nid
= get_amp_nid_(path
->ctls
[NID_PATH_MUTE_CTL
]);
4247 spec
->mute_bits
|= (1ULL << mute_nid
);
4249 spec
->mute_bits
&= ~(1ULL << mute_nid
);
4252 /* don't reset VREF value in case it's controlling
4253 * the amp (see alc861_fixup_asus_amp_vref_0f())
4255 if (spec
->keep_vref_in_automute
)
4256 val
= oldval
& ~PIN_HP
;
4261 /* here we call update_pin_ctl() so that the pinctl is
4262 * changed without changing the pinctl target value;
4263 * the original target value will be still referred at
4264 * the init / resume again
4266 update_pin_ctl(codec
, nid
, val
);
4269 set_pin_eapd(codec
, nid
, !mute
);
4270 if (codec
->power_save_node
) {
4273 on
= detect_pin_state(codec
, nid
);
4274 set_path_power(codec
, nid
, on
, -1);
4280 * snd_hda_gen_update_outputs - Toggle outputs muting
4281 * @codec: the HDA codec
4283 * Update the mute status of all outputs based on the current jack states.
4285 void snd_hda_gen_update_outputs(struct hda_codec
*codec
)
4287 struct hda_gen_spec
*spec
= codec
->spec
;
4291 /* Control HP pins/amps depending on master_mute state;
4292 * in general, HP pins/amps control should be enabled in all cases,
4293 * but currently set only for master_mute, just to be safe
4295 if (spec
->autocfg
.line_out_type
== AUTO_PIN_HP_OUT
)
4296 paths
= spec
->out_paths
;
4298 paths
= spec
->hp_paths
;
4299 do_automute(codec
, ARRAY_SIZE(spec
->autocfg
.hp_pins
),
4300 spec
->autocfg
.hp_pins
, paths
, spec
->master_mute
);
4302 if (!spec
->automute_speaker
)
4305 on
= spec
->hp_jack_present
| spec
->line_jack_present
;
4306 on
|= spec
->master_mute
;
4307 spec
->speaker_muted
= on
;
4308 if (spec
->autocfg
.line_out_type
== AUTO_PIN_SPEAKER_OUT
)
4309 paths
= spec
->out_paths
;
4311 paths
= spec
->speaker_paths
;
4312 do_automute(codec
, ARRAY_SIZE(spec
->autocfg
.speaker_pins
),
4313 spec
->autocfg
.speaker_pins
, paths
, on
);
4315 /* toggle line-out mutes if needed, too */
4316 /* if LO is a copy of either HP or Speaker, don't need to handle it */
4317 if (spec
->autocfg
.line_out_pins
[0] == spec
->autocfg
.hp_pins
[0] ||
4318 spec
->autocfg
.line_out_pins
[0] == spec
->autocfg
.speaker_pins
[0])
4320 if (!spec
->automute_lo
)
4323 on
= spec
->hp_jack_present
;
4324 on
|= spec
->master_mute
;
4325 spec
->line_out_muted
= on
;
4326 paths
= spec
->out_paths
;
4327 do_automute(codec
, ARRAY_SIZE(spec
->autocfg
.line_out_pins
),
4328 spec
->autocfg
.line_out_pins
, paths
, on
);
4330 EXPORT_SYMBOL_GPL(snd_hda_gen_update_outputs
);
4332 static void call_update_outputs(struct hda_codec
*codec
)
4334 struct hda_gen_spec
*spec
= codec
->spec
;
4335 if (spec
->automute_hook
)
4336 spec
->automute_hook(codec
);
4338 snd_hda_gen_update_outputs(codec
);
4340 /* sync the whole vmaster slaves to reflect the new auto-mute status */
4341 if (spec
->auto_mute_via_amp
&& !codec
->bus
->shutdown
)
4342 snd_ctl_sync_vmaster(spec
->vmaster_mute
.sw_kctl
, false);
4346 * snd_hda_gen_hp_automute - standard HP-automute helper
4347 * @codec: the HDA codec
4348 * @jack: jack object, NULL for the whole
4350 void snd_hda_gen_hp_automute(struct hda_codec
*codec
,
4351 struct hda_jack_callback
*jack
)
4353 struct hda_gen_spec
*spec
= codec
->spec
;
4354 hda_nid_t
*pins
= spec
->autocfg
.hp_pins
;
4355 int num_pins
= ARRAY_SIZE(spec
->autocfg
.hp_pins
);
4357 /* No detection for the first HP jack during indep-HP mode */
4358 if (spec
->indep_hp_enabled
) {
4363 spec
->hp_jack_present
= detect_jacks(codec
, num_pins
, pins
);
4364 if (!spec
->detect_hp
|| (!spec
->automute_speaker
&& !spec
->automute_lo
))
4366 call_update_outputs(codec
);
4368 EXPORT_SYMBOL_GPL(snd_hda_gen_hp_automute
);
4371 * snd_hda_gen_line_automute - standard line-out-automute helper
4372 * @codec: the HDA codec
4373 * @jack: jack object, NULL for the whole
4375 void snd_hda_gen_line_automute(struct hda_codec
*codec
,
4376 struct hda_jack_callback
*jack
)
4378 struct hda_gen_spec
*spec
= codec
->spec
;
4380 if (spec
->autocfg
.line_out_type
== AUTO_PIN_SPEAKER_OUT
)
4382 /* check LO jack only when it's different from HP */
4383 if (spec
->autocfg
.line_out_pins
[0] == spec
->autocfg
.hp_pins
[0])
4386 spec
->line_jack_present
=
4387 detect_jacks(codec
, ARRAY_SIZE(spec
->autocfg
.line_out_pins
),
4388 spec
->autocfg
.line_out_pins
);
4389 if (!spec
->automute_speaker
|| !spec
->detect_lo
)
4391 call_update_outputs(codec
);
4393 EXPORT_SYMBOL_GPL(snd_hda_gen_line_automute
);
4396 * snd_hda_gen_mic_autoswitch - standard mic auto-switch helper
4397 * @codec: the HDA codec
4398 * @jack: jack object, NULL for the whole
4400 void snd_hda_gen_mic_autoswitch(struct hda_codec
*codec
,
4401 struct hda_jack_callback
*jack
)
4403 struct hda_gen_spec
*spec
= codec
->spec
;
4406 if (!spec
->auto_mic
)
4409 for (i
= spec
->am_num_entries
- 1; i
> 0; i
--) {
4410 hda_nid_t pin
= spec
->am_entry
[i
].pin
;
4411 /* don't detect pins retasked as outputs */
4412 if (snd_hda_codec_get_pin_target(codec
, pin
) & AC_PINCTL_OUT_EN
)
4414 if (snd_hda_jack_detect_state(codec
, pin
) == HDA_JACK_PRESENT
) {
4415 mux_select(codec
, 0, spec
->am_entry
[i
].idx
);
4419 mux_select(codec
, 0, spec
->am_entry
[0].idx
);
4421 EXPORT_SYMBOL_GPL(snd_hda_gen_mic_autoswitch
);
4423 /* call appropriate hooks */
4424 static void call_hp_automute(struct hda_codec
*codec
,
4425 struct hda_jack_callback
*jack
)
4427 struct hda_gen_spec
*spec
= codec
->spec
;
4428 if (spec
->hp_automute_hook
)
4429 spec
->hp_automute_hook(codec
, jack
);
4431 snd_hda_gen_hp_automute(codec
, jack
);
4434 static void call_line_automute(struct hda_codec
*codec
,
4435 struct hda_jack_callback
*jack
)
4437 struct hda_gen_spec
*spec
= codec
->spec
;
4438 if (spec
->line_automute_hook
)
4439 spec
->line_automute_hook(codec
, jack
);
4441 snd_hda_gen_line_automute(codec
, jack
);
4444 static void call_mic_autoswitch(struct hda_codec
*codec
,
4445 struct hda_jack_callback
*jack
)
4447 struct hda_gen_spec
*spec
= codec
->spec
;
4448 if (spec
->mic_autoswitch_hook
)
4449 spec
->mic_autoswitch_hook(codec
, jack
);
4451 snd_hda_gen_mic_autoswitch(codec
, jack
);
4454 /* update jack retasking */
4455 static void update_automute_all(struct hda_codec
*codec
)
4457 call_hp_automute(codec
, NULL
);
4458 call_line_automute(codec
, NULL
);
4459 call_mic_autoswitch(codec
, NULL
);
4463 * Auto-Mute mode mixer enum support
4465 static int automute_mode_info(struct snd_kcontrol
*kcontrol
,
4466 struct snd_ctl_elem_info
*uinfo
)
4468 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
4469 struct hda_gen_spec
*spec
= codec
->spec
;
4470 static const char * const texts3
[] = {
4471 "Disabled", "Speaker Only", "Line Out+Speaker"
4474 if (spec
->automute_speaker_possible
&& spec
->automute_lo_possible
)
4475 return snd_hda_enum_helper_info(kcontrol
, uinfo
, 3, texts3
);
4476 return snd_hda_enum_bool_helper_info(kcontrol
, uinfo
);
4479 static int automute_mode_get(struct snd_kcontrol
*kcontrol
,
4480 struct snd_ctl_elem_value
*ucontrol
)
4482 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
4483 struct hda_gen_spec
*spec
= codec
->spec
;
4484 unsigned int val
= 0;
4485 if (spec
->automute_speaker
)
4487 if (spec
->automute_lo
)
4490 ucontrol
->value
.enumerated
.item
[0] = val
;
4494 static int automute_mode_put(struct snd_kcontrol
*kcontrol
,
4495 struct snd_ctl_elem_value
*ucontrol
)
4497 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
4498 struct hda_gen_spec
*spec
= codec
->spec
;
4500 switch (ucontrol
->value
.enumerated
.item
[0]) {
4502 if (!spec
->automute_speaker
&& !spec
->automute_lo
)
4504 spec
->automute_speaker
= 0;
4505 spec
->automute_lo
= 0;
4508 if (spec
->automute_speaker_possible
) {
4509 if (!spec
->automute_lo
&& spec
->automute_speaker
)
4511 spec
->automute_speaker
= 1;
4512 spec
->automute_lo
= 0;
4513 } else if (spec
->automute_lo_possible
) {
4514 if (spec
->automute_lo
)
4516 spec
->automute_lo
= 1;
4521 if (!spec
->automute_lo_possible
|| !spec
->automute_speaker_possible
)
4523 if (spec
->automute_speaker
&& spec
->automute_lo
)
4525 spec
->automute_speaker
= 1;
4526 spec
->automute_lo
= 1;
4531 call_update_outputs(codec
);
4535 static const struct snd_kcontrol_new automute_mode_enum
= {
4536 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
4537 .name
= "Auto-Mute Mode",
4538 .info
= automute_mode_info
,
4539 .get
= automute_mode_get
,
4540 .put
= automute_mode_put
,
4543 static int add_automute_mode_enum(struct hda_codec
*codec
)
4545 struct hda_gen_spec
*spec
= codec
->spec
;
4547 if (!snd_hda_gen_add_kctl(spec
, NULL
, &automute_mode_enum
))
4553 * Check the availability of HP/line-out auto-mute;
4554 * Set up appropriately if really supported
4556 static int check_auto_mute_availability(struct hda_codec
*codec
)
4558 struct hda_gen_spec
*spec
= codec
->spec
;
4559 struct auto_pin_cfg
*cfg
= &spec
->autocfg
;
4563 if (spec
->suppress_auto_mute
)
4566 if (cfg
->hp_pins
[0])
4568 if (cfg
->line_out_pins
[0])
4570 if (cfg
->speaker_pins
[0])
4572 if (present
< 2) /* need two different output types */
4575 if (!cfg
->speaker_pins
[0] &&
4576 cfg
->line_out_type
== AUTO_PIN_SPEAKER_OUT
) {
4577 memcpy(cfg
->speaker_pins
, cfg
->line_out_pins
,
4578 sizeof(cfg
->speaker_pins
));
4579 cfg
->speaker_outs
= cfg
->line_outs
;
4582 if (!cfg
->hp_pins
[0] &&
4583 cfg
->line_out_type
== AUTO_PIN_HP_OUT
) {
4584 memcpy(cfg
->hp_pins
, cfg
->line_out_pins
,
4585 sizeof(cfg
->hp_pins
));
4586 cfg
->hp_outs
= cfg
->line_outs
;
4589 for (i
= 0; i
< cfg
->hp_outs
; i
++) {
4590 hda_nid_t nid
= cfg
->hp_pins
[i
];
4591 if (!is_jack_detectable(codec
, nid
))
4593 codec_dbg(codec
, "Enable HP auto-muting on NID 0x%x\n", nid
);
4594 snd_hda_jack_detect_enable_callback(codec
, nid
,
4596 spec
->detect_hp
= 1;
4599 if (cfg
->line_out_type
== AUTO_PIN_LINE_OUT
&& cfg
->line_outs
) {
4600 if (cfg
->speaker_outs
)
4601 for (i
= 0; i
< cfg
->line_outs
; i
++) {
4602 hda_nid_t nid
= cfg
->line_out_pins
[i
];
4603 if (!is_jack_detectable(codec
, nid
))
4605 codec_dbg(codec
, "Enable Line-Out auto-muting on NID 0x%x\n", nid
);
4606 snd_hda_jack_detect_enable_callback(codec
, nid
,
4607 call_line_automute
);
4608 spec
->detect_lo
= 1;
4610 spec
->automute_lo_possible
= spec
->detect_hp
;
4613 spec
->automute_speaker_possible
= cfg
->speaker_outs
&&
4614 (spec
->detect_hp
|| spec
->detect_lo
);
4616 spec
->automute_lo
= spec
->automute_lo_possible
;
4617 spec
->automute_speaker
= spec
->automute_speaker_possible
;
4619 if (spec
->automute_speaker_possible
|| spec
->automute_lo_possible
) {
4620 /* create a control for automute mode */
4621 err
= add_automute_mode_enum(codec
);
4628 /* check whether all auto-mic pins are valid; setup indices if OK */
4629 static bool auto_mic_check_imux(struct hda_codec
*codec
)
4631 struct hda_gen_spec
*spec
= codec
->spec
;
4632 const struct hda_input_mux
*imux
;
4635 imux
= &spec
->input_mux
;
4636 for (i
= 0; i
< spec
->am_num_entries
; i
++) {
4637 spec
->am_entry
[i
].idx
=
4638 find_idx_in_nid_list(spec
->am_entry
[i
].pin
,
4639 spec
->imux_pins
, imux
->num_items
);
4640 if (spec
->am_entry
[i
].idx
< 0)
4641 return false; /* no corresponding imux */
4644 /* we don't need the jack detection for the first pin */
4645 for (i
= 1; i
< spec
->am_num_entries
; i
++)
4646 snd_hda_jack_detect_enable_callback(codec
,
4647 spec
->am_entry
[i
].pin
,
4648 call_mic_autoswitch
);
4652 static int compare_attr(const void *ap
, const void *bp
)
4654 const struct automic_entry
*a
= ap
;
4655 const struct automic_entry
*b
= bp
;
4656 return (int)(a
->attr
- b
->attr
);
4660 * Check the availability of auto-mic switch;
4661 * Set up if really supported
4663 static int check_auto_mic_availability(struct hda_codec
*codec
)
4665 struct hda_gen_spec
*spec
= codec
->spec
;
4666 struct auto_pin_cfg
*cfg
= &spec
->autocfg
;
4670 if (spec
->suppress_auto_mic
)
4675 for (i
= 0; i
< cfg
->num_inputs
; i
++) {
4676 hda_nid_t nid
= cfg
->inputs
[i
].pin
;
4678 attr
= snd_hda_codec_get_pincfg(codec
, nid
);
4679 attr
= snd_hda_get_input_pin_attr(attr
);
4680 if (types
& (1 << attr
))
4681 return 0; /* already occupied */
4683 case INPUT_PIN_ATTR_INT
:
4684 if (cfg
->inputs
[i
].type
!= AUTO_PIN_MIC
)
4685 return 0; /* invalid type */
4687 case INPUT_PIN_ATTR_UNUSED
:
4688 return 0; /* invalid entry */
4690 if (cfg
->inputs
[i
].type
> AUTO_PIN_LINE_IN
)
4691 return 0; /* invalid type */
4692 if (!spec
->line_in_auto_switch
&&
4693 cfg
->inputs
[i
].type
!= AUTO_PIN_MIC
)
4694 return 0; /* only mic is allowed */
4695 if (!is_jack_detectable(codec
, nid
))
4696 return 0; /* no unsol support */
4699 if (num_pins
>= MAX_AUTO_MIC_PINS
)
4701 types
|= (1 << attr
);
4702 spec
->am_entry
[num_pins
].pin
= nid
;
4703 spec
->am_entry
[num_pins
].attr
= attr
;
4710 spec
->am_num_entries
= num_pins
;
4711 /* sort the am_entry in the order of attr so that the pin with a
4712 * higher attr will be selected when the jack is plugged.
4714 sort(spec
->am_entry
, num_pins
, sizeof(spec
->am_entry
[0]),
4715 compare_attr
, NULL
);
4717 if (!auto_mic_check_imux(codec
))
4721 spec
->num_adc_nids
= 1;
4722 spec
->cur_mux
[0] = spec
->am_entry
[0].idx
;
4723 codec_dbg(codec
, "Enable auto-mic switch on NID 0x%x/0x%x/0x%x\n",
4724 spec
->am_entry
[0].pin
,
4725 spec
->am_entry
[1].pin
,
4726 spec
->am_entry
[2].pin
);
4732 * snd_hda_gen_path_power_filter - power_filter hook to make inactive widgets
4734 * @codec: the HDA codec
4735 * @nid: NID to evalute
4736 * @power_state: target power state
4738 unsigned int snd_hda_gen_path_power_filter(struct hda_codec
*codec
,
4740 unsigned int power_state
)
4742 struct hda_gen_spec
*spec
= codec
->spec
;
4744 if (!spec
->power_down_unused
&& !codec
->power_save_node
)
4746 if (power_state
!= AC_PWRST_D0
|| nid
== codec
->core
.afg
)
4748 if (get_wcaps_type(get_wcaps(codec
, nid
)) >= AC_WID_POWER
)
4750 if (is_active_nid_for_any(codec
, nid
))
4754 EXPORT_SYMBOL_GPL(snd_hda_gen_path_power_filter
);
4756 /* mute all aamix inputs initially; parse up to the first leaves */
4757 static void mute_all_mixer_nid(struct hda_codec
*codec
, hda_nid_t mix
)
4760 const hda_nid_t
*conn
;
4763 nums
= snd_hda_get_conn_list(codec
, mix
, &conn
);
4764 has_amp
= nid_has_mute(codec
, mix
, HDA_INPUT
);
4765 for (i
= 0; i
< nums
; i
++) {
4767 update_amp(codec
, mix
, HDA_INPUT
, i
,
4768 0xff, HDA_AMP_MUTE
);
4769 else if (nid_has_volume(codec
, conn
[i
], HDA_OUTPUT
))
4770 update_amp(codec
, conn
[i
], HDA_OUTPUT
, 0,
4771 0xff, HDA_AMP_MUTE
);
4776 * snd_hda_gen_stream_pm - Stream power management callback
4777 * @codec: the HDA codec
4778 * @nid: audio widget
4779 * @on: power on/off flag
4781 * Set this in patch_ops.stream_pm. Only valid with power_save_node flag.
4783 void snd_hda_gen_stream_pm(struct hda_codec
*codec
, hda_nid_t nid
, bool on
)
4785 if (codec
->power_save_node
)
4786 set_path_power(codec
, nid
, -1, on
);
4788 EXPORT_SYMBOL_GPL(snd_hda_gen_stream_pm
);
4791 * snd_hda_gen_parse_auto_config - Parse the given BIOS configuration and
4792 * set up the hda_gen_spec
4793 * @codec: the HDA codec
4794 * @cfg: Parsed pin configuration
4796 * return 1 if successful, 0 if the proper config is not found,
4797 * or a negative error code
4799 int snd_hda_gen_parse_auto_config(struct hda_codec
*codec
,
4800 struct auto_pin_cfg
*cfg
)
4802 struct hda_gen_spec
*spec
= codec
->spec
;
4805 parse_user_hints(codec
);
4807 if (spec
->mixer_nid
&& !spec
->mixer_merge_nid
)
4808 spec
->mixer_merge_nid
= spec
->mixer_nid
;
4810 if (cfg
!= &spec
->autocfg
) {
4811 spec
->autocfg
= *cfg
;
4812 cfg
= &spec
->autocfg
;
4815 if (!spec
->main_out_badness
)
4816 spec
->main_out_badness
= &hda_main_out_badness
;
4817 if (!spec
->extra_out_badness
)
4818 spec
->extra_out_badness
= &hda_extra_out_badness
;
4820 fill_all_dac_nids(codec
);
4822 if (!cfg
->line_outs
) {
4823 if (cfg
->dig_outs
|| cfg
->dig_in_pin
) {
4824 spec
->multiout
.max_channels
= 2;
4825 spec
->no_analog
= 1;
4828 if (!cfg
->num_inputs
&& !cfg
->dig_in_pin
)
4829 return 0; /* can't find valid BIOS pin config */
4832 if (!spec
->no_primary_hp
&&
4833 cfg
->line_out_type
== AUTO_PIN_SPEAKER_OUT
&&
4834 cfg
->line_outs
<= cfg
->hp_outs
) {
4835 /* use HP as primary out */
4836 cfg
->speaker_outs
= cfg
->line_outs
;
4837 memcpy(cfg
->speaker_pins
, cfg
->line_out_pins
,
4838 sizeof(cfg
->speaker_pins
));
4839 cfg
->line_outs
= cfg
->hp_outs
;
4840 memcpy(cfg
->line_out_pins
, cfg
->hp_pins
, sizeof(cfg
->hp_pins
));
4842 memset(cfg
->hp_pins
, 0, sizeof(cfg
->hp_pins
));
4843 cfg
->line_out_type
= AUTO_PIN_HP_OUT
;
4846 err
= parse_output_paths(codec
);
4849 err
= create_multi_channel_mode(codec
);
4852 err
= create_multi_out_ctls(codec
, cfg
);
4855 err
= create_hp_out_ctls(codec
);
4858 err
= create_speaker_out_ctls(codec
);
4861 err
= create_indep_hp_ctls(codec
);
4864 err
= create_loopback_mixing_ctl(codec
);
4867 err
= create_hp_mic(codec
);
4870 err
= create_input_ctls(codec
);
4874 /* add power-down pin callbacks at first */
4875 add_all_pin_power_ctls(codec
, false);
4877 spec
->const_channel_count
= spec
->ext_channel_count
;
4878 /* check the multiple speaker and headphone pins */
4879 if (cfg
->line_out_type
!= AUTO_PIN_SPEAKER_OUT
)
4880 spec
->const_channel_count
= max(spec
->const_channel_count
,
4881 cfg
->speaker_outs
* 2);
4882 if (cfg
->line_out_type
!= AUTO_PIN_HP_OUT
)
4883 spec
->const_channel_count
= max(spec
->const_channel_count
,
4885 spec
->multiout
.max_channels
= max(spec
->ext_channel_count
,
4886 spec
->const_channel_count
);
4888 err
= check_auto_mute_availability(codec
);
4892 err
= check_dyn_adc_switch(codec
);
4896 err
= check_auto_mic_availability(codec
);
4900 /* add stereo mix if available and not enabled yet */
4901 if (!spec
->auto_mic
&& spec
->mixer_nid
&&
4902 spec
->add_stereo_mix_input
== HDA_HINT_STEREO_MIX_AUTO
&&
4903 spec
->input_mux
.num_items
> 1) {
4904 err
= parse_capture_source(codec
, spec
->mixer_nid
,
4905 CFG_IDX_MIX
, spec
->num_all_adcs
,
4912 err
= create_capture_mixers(codec
);
4916 err
= parse_mic_boost(codec
);
4920 /* create "Headphone Mic Jack Mode" if no input selection is
4921 * available (or user specifies add_jack_modes hint)
4923 if (spec
->hp_mic_pin
&&
4924 (spec
->auto_mic
|| spec
->input_mux
.num_items
== 1 ||
4925 spec
->add_jack_modes
)) {
4926 err
= create_hp_mic_jack_mode(codec
, spec
->hp_mic_pin
);
4931 if (spec
->add_jack_modes
) {
4932 if (cfg
->line_out_type
!= AUTO_PIN_SPEAKER_OUT
) {
4933 err
= create_out_jack_modes(codec
, cfg
->line_outs
,
4934 cfg
->line_out_pins
);
4938 if (cfg
->line_out_type
!= AUTO_PIN_HP_OUT
) {
4939 err
= create_out_jack_modes(codec
, cfg
->hp_outs
,
4946 /* add power-up pin callbacks at last */
4947 add_all_pin_power_ctls(codec
, true);
4949 /* mute all aamix input initially */
4950 if (spec
->mixer_nid
)
4951 mute_all_mixer_nid(codec
, spec
->mixer_nid
);
4954 parse_digital(codec
);
4956 if (spec
->power_down_unused
|| codec
->power_save_node
) {
4957 if (!codec
->power_filter
)
4958 codec
->power_filter
= snd_hda_gen_path_power_filter
;
4959 if (!codec
->patch_ops
.stream_pm
)
4960 codec
->patch_ops
.stream_pm
= snd_hda_gen_stream_pm
;
4963 if (!spec
->no_analog
&& spec
->beep_nid
) {
4964 err
= snd_hda_attach_beep_device(codec
, spec
->beep_nid
);
4967 if (codec
->beep
&& codec
->power_save_node
) {
4968 err
= add_fake_beep_paths(codec
);
4971 codec
->beep
->power_hook
= beep_power_hook
;
4977 EXPORT_SYMBOL_GPL(snd_hda_gen_parse_auto_config
);
4981 * Build control elements
4984 /* slave controls for virtual master */
4985 static const char * const slave_pfxs
[] = {
4986 "Front", "Surround", "Center", "LFE", "Side",
4987 "Headphone", "Speaker", "Mono", "Line Out",
4988 "CLFE", "Bass Speaker", "PCM",
4989 "Speaker Front", "Speaker Surround", "Speaker CLFE", "Speaker Side",
4990 "Headphone Front", "Headphone Surround", "Headphone CLFE",
4991 "Headphone Side", "Headphone+LO", "Speaker+LO",
4996 * snd_hda_gen_build_controls - Build controls from the parsed results
4997 * @codec: the HDA codec
4999 * Pass this to build_controls patch_ops.
5001 int snd_hda_gen_build_controls(struct hda_codec
*codec
)
5003 struct hda_gen_spec
*spec
= codec
->spec
;
5006 if (spec
->kctls
.used
) {
5007 err
= snd_hda_add_new_ctls(codec
, spec
->kctls
.list
);
5012 if (spec
->multiout
.dig_out_nid
) {
5013 err
= snd_hda_create_dig_out_ctls(codec
,
5014 spec
->multiout
.dig_out_nid
,
5015 spec
->multiout
.dig_out_nid
,
5016 spec
->pcm_rec
[1]->pcm_type
);
5019 if (!spec
->no_analog
) {
5020 err
= snd_hda_create_spdif_share_sw(codec
,
5024 spec
->multiout
.share_spdif
= 1;
5027 if (spec
->dig_in_nid
) {
5028 err
= snd_hda_create_spdif_in_ctls(codec
, spec
->dig_in_nid
);
5033 /* if we have no master control, let's create it */
5034 if (!spec
->no_analog
&&
5035 !snd_hda_find_mixer_ctl(codec
, "Master Playback Volume")) {
5036 err
= snd_hda_add_vmaster(codec
, "Master Playback Volume",
5037 spec
->vmaster_tlv
, slave_pfxs
,
5042 if (!spec
->no_analog
&&
5043 !snd_hda_find_mixer_ctl(codec
, "Master Playback Switch")) {
5044 err
= __snd_hda_add_vmaster(codec
, "Master Playback Switch",
5047 true, &spec
->vmaster_mute
.sw_kctl
);
5050 if (spec
->vmaster_mute
.hook
) {
5051 snd_hda_add_vmaster_hook(codec
, &spec
->vmaster_mute
,
5052 spec
->vmaster_mute_enum
);
5053 snd_hda_sync_vmaster_hook(&spec
->vmaster_mute
);
5057 free_kctls(spec
); /* no longer needed */
5059 err
= snd_hda_jack_add_kctls(codec
, &spec
->autocfg
);
5065 EXPORT_SYMBOL_GPL(snd_hda_gen_build_controls
);
5072 static void call_pcm_playback_hook(struct hda_pcm_stream
*hinfo
,
5073 struct hda_codec
*codec
,
5074 struct snd_pcm_substream
*substream
,
5077 struct hda_gen_spec
*spec
= codec
->spec
;
5078 if (spec
->pcm_playback_hook
)
5079 spec
->pcm_playback_hook(hinfo
, codec
, substream
, action
);
5082 static void call_pcm_capture_hook(struct hda_pcm_stream
*hinfo
,
5083 struct hda_codec
*codec
,
5084 struct snd_pcm_substream
*substream
,
5087 struct hda_gen_spec
*spec
= codec
->spec
;
5088 if (spec
->pcm_capture_hook
)
5089 spec
->pcm_capture_hook(hinfo
, codec
, substream
, action
);
5093 * Analog playback callbacks
5095 static int playback_pcm_open(struct hda_pcm_stream
*hinfo
,
5096 struct hda_codec
*codec
,
5097 struct snd_pcm_substream
*substream
)
5099 struct hda_gen_spec
*spec
= codec
->spec
;
5102 mutex_lock(&spec
->pcm_mutex
);
5103 err
= snd_hda_multi_out_analog_open(codec
,
5104 &spec
->multiout
, substream
,
5107 spec
->active_streams
|= 1 << STREAM_MULTI_OUT
;
5108 call_pcm_playback_hook(hinfo
, codec
, substream
,
5109 HDA_GEN_PCM_ACT_OPEN
);
5111 mutex_unlock(&spec
->pcm_mutex
);
5115 static int playback_pcm_prepare(struct hda_pcm_stream
*hinfo
,
5116 struct hda_codec
*codec
,
5117 unsigned int stream_tag
,
5118 unsigned int format
,
5119 struct snd_pcm_substream
*substream
)
5121 struct hda_gen_spec
*spec
= codec
->spec
;
5124 err
= snd_hda_multi_out_analog_prepare(codec
, &spec
->multiout
,
5125 stream_tag
, format
, substream
);
5127 call_pcm_playback_hook(hinfo
, codec
, substream
,
5128 HDA_GEN_PCM_ACT_PREPARE
);
5132 static int playback_pcm_cleanup(struct hda_pcm_stream
*hinfo
,
5133 struct hda_codec
*codec
,
5134 struct snd_pcm_substream
*substream
)
5136 struct hda_gen_spec
*spec
= codec
->spec
;
5139 err
= snd_hda_multi_out_analog_cleanup(codec
, &spec
->multiout
);
5141 call_pcm_playback_hook(hinfo
, codec
, substream
,
5142 HDA_GEN_PCM_ACT_CLEANUP
);
5146 static int playback_pcm_close(struct hda_pcm_stream
*hinfo
,
5147 struct hda_codec
*codec
,
5148 struct snd_pcm_substream
*substream
)
5150 struct hda_gen_spec
*spec
= codec
->spec
;
5151 mutex_lock(&spec
->pcm_mutex
);
5152 spec
->active_streams
&= ~(1 << STREAM_MULTI_OUT
);
5153 call_pcm_playback_hook(hinfo
, codec
, substream
,
5154 HDA_GEN_PCM_ACT_CLOSE
);
5155 mutex_unlock(&spec
->pcm_mutex
);
5159 static int capture_pcm_open(struct hda_pcm_stream
*hinfo
,
5160 struct hda_codec
*codec
,
5161 struct snd_pcm_substream
*substream
)
5163 call_pcm_capture_hook(hinfo
, codec
, substream
, HDA_GEN_PCM_ACT_OPEN
);
5167 static int capture_pcm_prepare(struct hda_pcm_stream
*hinfo
,
5168 struct hda_codec
*codec
,
5169 unsigned int stream_tag
,
5170 unsigned int format
,
5171 struct snd_pcm_substream
*substream
)
5173 snd_hda_codec_setup_stream(codec
, hinfo
->nid
, stream_tag
, 0, format
);
5174 call_pcm_capture_hook(hinfo
, codec
, substream
,
5175 HDA_GEN_PCM_ACT_PREPARE
);
5179 static int capture_pcm_cleanup(struct hda_pcm_stream
*hinfo
,
5180 struct hda_codec
*codec
,
5181 struct snd_pcm_substream
*substream
)
5183 snd_hda_codec_cleanup_stream(codec
, hinfo
->nid
);
5184 call_pcm_capture_hook(hinfo
, codec
, substream
,
5185 HDA_GEN_PCM_ACT_CLEANUP
);
5189 static int capture_pcm_close(struct hda_pcm_stream
*hinfo
,
5190 struct hda_codec
*codec
,
5191 struct snd_pcm_substream
*substream
)
5193 call_pcm_capture_hook(hinfo
, codec
, substream
, HDA_GEN_PCM_ACT_CLOSE
);
5197 static int alt_playback_pcm_open(struct hda_pcm_stream
*hinfo
,
5198 struct hda_codec
*codec
,
5199 struct snd_pcm_substream
*substream
)
5201 struct hda_gen_spec
*spec
= codec
->spec
;
5204 mutex_lock(&spec
->pcm_mutex
);
5205 if (spec
->indep_hp
&& !spec
->indep_hp_enabled
)
5208 spec
->active_streams
|= 1 << STREAM_INDEP_HP
;
5209 call_pcm_playback_hook(hinfo
, codec
, substream
,
5210 HDA_GEN_PCM_ACT_OPEN
);
5211 mutex_unlock(&spec
->pcm_mutex
);
5215 static int alt_playback_pcm_close(struct hda_pcm_stream
*hinfo
,
5216 struct hda_codec
*codec
,
5217 struct snd_pcm_substream
*substream
)
5219 struct hda_gen_spec
*spec
= codec
->spec
;
5220 mutex_lock(&spec
->pcm_mutex
);
5221 spec
->active_streams
&= ~(1 << STREAM_INDEP_HP
);
5222 call_pcm_playback_hook(hinfo
, codec
, substream
,
5223 HDA_GEN_PCM_ACT_CLOSE
);
5224 mutex_unlock(&spec
->pcm_mutex
);
5228 static int alt_playback_pcm_prepare(struct hda_pcm_stream
*hinfo
,
5229 struct hda_codec
*codec
,
5230 unsigned int stream_tag
,
5231 unsigned int format
,
5232 struct snd_pcm_substream
*substream
)
5234 snd_hda_codec_setup_stream(codec
, hinfo
->nid
, stream_tag
, 0, format
);
5235 call_pcm_playback_hook(hinfo
, codec
, substream
,
5236 HDA_GEN_PCM_ACT_PREPARE
);
5240 static int alt_playback_pcm_cleanup(struct hda_pcm_stream
*hinfo
,
5241 struct hda_codec
*codec
,
5242 struct snd_pcm_substream
*substream
)
5244 snd_hda_codec_cleanup_stream(codec
, hinfo
->nid
);
5245 call_pcm_playback_hook(hinfo
, codec
, substream
,
5246 HDA_GEN_PCM_ACT_CLEANUP
);
5253 static int dig_playback_pcm_open(struct hda_pcm_stream
*hinfo
,
5254 struct hda_codec
*codec
,
5255 struct snd_pcm_substream
*substream
)
5257 struct hda_gen_spec
*spec
= codec
->spec
;
5258 return snd_hda_multi_out_dig_open(codec
, &spec
->multiout
);
5261 static int dig_playback_pcm_prepare(struct hda_pcm_stream
*hinfo
,
5262 struct hda_codec
*codec
,
5263 unsigned int stream_tag
,
5264 unsigned int format
,
5265 struct snd_pcm_substream
*substream
)
5267 struct hda_gen_spec
*spec
= codec
->spec
;
5268 return snd_hda_multi_out_dig_prepare(codec
, &spec
->multiout
,
5269 stream_tag
, format
, substream
);
5272 static int dig_playback_pcm_cleanup(struct hda_pcm_stream
*hinfo
,
5273 struct hda_codec
*codec
,
5274 struct snd_pcm_substream
*substream
)
5276 struct hda_gen_spec
*spec
= codec
->spec
;
5277 return snd_hda_multi_out_dig_cleanup(codec
, &spec
->multiout
);
5280 static int dig_playback_pcm_close(struct hda_pcm_stream
*hinfo
,
5281 struct hda_codec
*codec
,
5282 struct snd_pcm_substream
*substream
)
5284 struct hda_gen_spec
*spec
= codec
->spec
;
5285 return snd_hda_multi_out_dig_close(codec
, &spec
->multiout
);
5291 #define alt_capture_pcm_open capture_pcm_open
5292 #define alt_capture_pcm_close capture_pcm_close
5294 static int alt_capture_pcm_prepare(struct hda_pcm_stream
*hinfo
,
5295 struct hda_codec
*codec
,
5296 unsigned int stream_tag
,
5297 unsigned int format
,
5298 struct snd_pcm_substream
*substream
)
5300 struct hda_gen_spec
*spec
= codec
->spec
;
5302 snd_hda_codec_setup_stream(codec
, spec
->adc_nids
[substream
->number
+ 1],
5303 stream_tag
, 0, format
);
5304 call_pcm_capture_hook(hinfo
, codec
, substream
,
5305 HDA_GEN_PCM_ACT_PREPARE
);
5309 static int alt_capture_pcm_cleanup(struct hda_pcm_stream
*hinfo
,
5310 struct hda_codec
*codec
,
5311 struct snd_pcm_substream
*substream
)
5313 struct hda_gen_spec
*spec
= codec
->spec
;
5315 snd_hda_codec_cleanup_stream(codec
,
5316 spec
->adc_nids
[substream
->number
+ 1]);
5317 call_pcm_capture_hook(hinfo
, codec
, substream
,
5318 HDA_GEN_PCM_ACT_CLEANUP
);
5324 static const struct hda_pcm_stream pcm_analog_playback
= {
5328 /* NID is set in build_pcms */
5330 .open
= playback_pcm_open
,
5331 .close
= playback_pcm_close
,
5332 .prepare
= playback_pcm_prepare
,
5333 .cleanup
= playback_pcm_cleanup
5337 static const struct hda_pcm_stream pcm_analog_capture
= {
5341 /* NID is set in build_pcms */
5343 .open
= capture_pcm_open
,
5344 .close
= capture_pcm_close
,
5345 .prepare
= capture_pcm_prepare
,
5346 .cleanup
= capture_pcm_cleanup
5350 static const struct hda_pcm_stream pcm_analog_alt_playback
= {
5354 /* NID is set in build_pcms */
5356 .open
= alt_playback_pcm_open
,
5357 .close
= alt_playback_pcm_close
,
5358 .prepare
= alt_playback_pcm_prepare
,
5359 .cleanup
= alt_playback_pcm_cleanup
5363 static const struct hda_pcm_stream pcm_analog_alt_capture
= {
5364 .substreams
= 2, /* can be overridden */
5367 /* NID is set in build_pcms */
5369 .open
= alt_capture_pcm_open
,
5370 .close
= alt_capture_pcm_close
,
5371 .prepare
= alt_capture_pcm_prepare
,
5372 .cleanup
= alt_capture_pcm_cleanup
5376 static const struct hda_pcm_stream pcm_digital_playback
= {
5380 /* NID is set in build_pcms */
5382 .open
= dig_playback_pcm_open
,
5383 .close
= dig_playback_pcm_close
,
5384 .prepare
= dig_playback_pcm_prepare
,
5385 .cleanup
= dig_playback_pcm_cleanup
5389 static const struct hda_pcm_stream pcm_digital_capture
= {
5393 /* NID is set in build_pcms */
5396 /* Used by build_pcms to flag that a PCM has no playback stream */
5397 static const struct hda_pcm_stream pcm_null_stream
= {
5404 * dynamic changing ADC PCM streams
5406 static bool dyn_adc_pcm_resetup(struct hda_codec
*codec
, int cur
)
5408 struct hda_gen_spec
*spec
= codec
->spec
;
5409 hda_nid_t new_adc
= spec
->adc_nids
[spec
->dyn_adc_idx
[cur
]];
5411 if (spec
->cur_adc
&& spec
->cur_adc
!= new_adc
) {
5412 /* stream is running, let's swap the current ADC */
5413 __snd_hda_codec_cleanup_stream(codec
, spec
->cur_adc
, 1);
5414 spec
->cur_adc
= new_adc
;
5415 snd_hda_codec_setup_stream(codec
, new_adc
,
5416 spec
->cur_adc_stream_tag
, 0,
5417 spec
->cur_adc_format
);
5423 /* analog capture with dynamic dual-adc changes */
5424 static int dyn_adc_capture_pcm_prepare(struct hda_pcm_stream
*hinfo
,
5425 struct hda_codec
*codec
,
5426 unsigned int stream_tag
,
5427 unsigned int format
,
5428 struct snd_pcm_substream
*substream
)
5430 struct hda_gen_spec
*spec
= codec
->spec
;
5431 spec
->cur_adc
= spec
->adc_nids
[spec
->dyn_adc_idx
[spec
->cur_mux
[0]]];
5432 spec
->cur_adc_stream_tag
= stream_tag
;
5433 spec
->cur_adc_format
= format
;
5434 snd_hda_codec_setup_stream(codec
, spec
->cur_adc
, stream_tag
, 0, format
);
5438 static int dyn_adc_capture_pcm_cleanup(struct hda_pcm_stream
*hinfo
,
5439 struct hda_codec
*codec
,
5440 struct snd_pcm_substream
*substream
)
5442 struct hda_gen_spec
*spec
= codec
->spec
;
5443 snd_hda_codec_cleanup_stream(codec
, spec
->cur_adc
);
5448 static const struct hda_pcm_stream dyn_adc_pcm_analog_capture
= {
5452 .nid
= 0, /* fill later */
5454 .prepare
= dyn_adc_capture_pcm_prepare
,
5455 .cleanup
= dyn_adc_capture_pcm_cleanup
5459 static void fill_pcm_stream_name(char *str
, size_t len
, const char *sfx
,
5460 const char *chip_name
)
5466 strlcpy(str
, chip_name
, len
);
5468 /* drop non-alnum chars after a space */
5469 for (p
= strchr(str
, ' '); p
; p
= strchr(p
+ 1, ' ')) {
5470 if (!isalnum(p
[1])) {
5475 strlcat(str
, sfx
, len
);
5478 /* copy PCM stream info from @default_str, and override non-NULL entries
5479 * from @spec_str and @nid
5481 static void setup_pcm_stream(struct hda_pcm_stream
*str
,
5482 const struct hda_pcm_stream
*default_str
,
5483 const struct hda_pcm_stream
*spec_str
,
5486 *str
= *default_str
;
5490 if (spec_str
->substreams
)
5491 str
->substreams
= spec_str
->substreams
;
5492 if (spec_str
->channels_min
)
5493 str
->channels_min
= spec_str
->channels_min
;
5494 if (spec_str
->channels_max
)
5495 str
->channels_max
= spec_str
->channels_max
;
5496 if (spec_str
->rates
)
5497 str
->rates
= spec_str
->rates
;
5498 if (spec_str
->formats
)
5499 str
->formats
= spec_str
->formats
;
5500 if (spec_str
->maxbps
)
5501 str
->maxbps
= spec_str
->maxbps
;
5506 * snd_hda_gen_build_pcms - build PCM streams based on the parsed results
5507 * @codec: the HDA codec
5509 * Pass this to build_pcms patch_ops.
5511 int snd_hda_gen_build_pcms(struct hda_codec
*codec
)
5513 struct hda_gen_spec
*spec
= codec
->spec
;
5514 struct hda_pcm
*info
;
5515 bool have_multi_adcs
;
5517 if (spec
->no_analog
)
5520 fill_pcm_stream_name(spec
->stream_name_analog
,
5521 sizeof(spec
->stream_name_analog
),
5522 " Analog", codec
->core
.chip_name
);
5523 info
= snd_hda_codec_pcm_new(codec
, "%s", spec
->stream_name_analog
);
5526 spec
->pcm_rec
[0] = info
;
5528 if (spec
->multiout
.num_dacs
> 0) {
5529 setup_pcm_stream(&info
->stream
[SNDRV_PCM_STREAM_PLAYBACK
],
5530 &pcm_analog_playback
,
5531 spec
->stream_analog_playback
,
5532 spec
->multiout
.dac_nids
[0]);
5533 info
->stream
[SNDRV_PCM_STREAM_PLAYBACK
].channels_max
=
5534 spec
->multiout
.max_channels
;
5535 if (spec
->autocfg
.line_out_type
== AUTO_PIN_SPEAKER_OUT
&&
5536 spec
->autocfg
.line_outs
== 2)
5537 info
->stream
[SNDRV_PCM_STREAM_PLAYBACK
].chmap
=
5540 if (spec
->num_adc_nids
) {
5541 setup_pcm_stream(&info
->stream
[SNDRV_PCM_STREAM_CAPTURE
],
5542 (spec
->dyn_adc_switch
?
5543 &dyn_adc_pcm_analog_capture
: &pcm_analog_capture
),
5544 spec
->stream_analog_capture
,
5549 /* SPDIF for stream index #1 */
5550 if (spec
->multiout
.dig_out_nid
|| spec
->dig_in_nid
) {
5551 fill_pcm_stream_name(spec
->stream_name_digital
,
5552 sizeof(spec
->stream_name_digital
),
5553 " Digital", codec
->core
.chip_name
);
5554 info
= snd_hda_codec_pcm_new(codec
, "%s",
5555 spec
->stream_name_digital
);
5558 codec
->slave_dig_outs
= spec
->multiout
.slave_dig_outs
;
5559 spec
->pcm_rec
[1] = info
;
5560 if (spec
->dig_out_type
)
5561 info
->pcm_type
= spec
->dig_out_type
;
5563 info
->pcm_type
= HDA_PCM_TYPE_SPDIF
;
5564 if (spec
->multiout
.dig_out_nid
)
5565 setup_pcm_stream(&info
->stream
[SNDRV_PCM_STREAM_PLAYBACK
],
5566 &pcm_digital_playback
,
5567 spec
->stream_digital_playback
,
5568 spec
->multiout
.dig_out_nid
);
5569 if (spec
->dig_in_nid
)
5570 setup_pcm_stream(&info
->stream
[SNDRV_PCM_STREAM_CAPTURE
],
5571 &pcm_digital_capture
,
5572 spec
->stream_digital_capture
,
5576 if (spec
->no_analog
)
5579 /* If the use of more than one ADC is requested for the current
5580 * model, configure a second analog capture-only PCM.
5582 have_multi_adcs
= (spec
->num_adc_nids
> 1) &&
5583 !spec
->dyn_adc_switch
&& !spec
->auto_mic
;
5584 /* Additional Analaog capture for index #2 */
5585 if (spec
->alt_dac_nid
|| have_multi_adcs
) {
5586 fill_pcm_stream_name(spec
->stream_name_alt_analog
,
5587 sizeof(spec
->stream_name_alt_analog
),
5588 " Alt Analog", codec
->core
.chip_name
);
5589 info
= snd_hda_codec_pcm_new(codec
, "%s",
5590 spec
->stream_name_alt_analog
);
5593 spec
->pcm_rec
[2] = info
;
5594 if (spec
->alt_dac_nid
)
5595 setup_pcm_stream(&info
->stream
[SNDRV_PCM_STREAM_PLAYBACK
],
5596 &pcm_analog_alt_playback
,
5597 spec
->stream_analog_alt_playback
,
5600 setup_pcm_stream(&info
->stream
[SNDRV_PCM_STREAM_PLAYBACK
],
5601 &pcm_null_stream
, NULL
, 0);
5602 if (have_multi_adcs
) {
5603 setup_pcm_stream(&info
->stream
[SNDRV_PCM_STREAM_CAPTURE
],
5604 &pcm_analog_alt_capture
,
5605 spec
->stream_analog_alt_capture
,
5607 info
->stream
[SNDRV_PCM_STREAM_CAPTURE
].substreams
=
5608 spec
->num_adc_nids
- 1;
5610 setup_pcm_stream(&info
->stream
[SNDRV_PCM_STREAM_CAPTURE
],
5611 &pcm_null_stream
, NULL
, 0);
5617 EXPORT_SYMBOL_GPL(snd_hda_gen_build_pcms
);
5621 * Standard auto-parser initializations
5624 /* configure the given path as a proper output */
5625 static void set_output_and_unmute(struct hda_codec
*codec
, int path_idx
)
5627 struct nid_path
*path
;
5630 path
= snd_hda_get_path_from_idx(codec
, path_idx
);
5631 if (!path
|| !path
->depth
)
5633 pin
= path
->path
[path
->depth
- 1];
5634 restore_pin_ctl(codec
, pin
);
5635 snd_hda_activate_path(codec
, path
, path
->active
,
5636 aamix_default(codec
->spec
));
5637 set_pin_eapd(codec
, pin
, path
->active
);
5640 /* initialize primary output paths */
5641 static void init_multi_out(struct hda_codec
*codec
)
5643 struct hda_gen_spec
*spec
= codec
->spec
;
5646 for (i
= 0; i
< spec
->autocfg
.line_outs
; i
++)
5647 set_output_and_unmute(codec
, spec
->out_paths
[i
]);
5651 static void __init_extra_out(struct hda_codec
*codec
, int num_outs
, int *paths
)
5655 for (i
= 0; i
< num_outs
; i
++)
5656 set_output_and_unmute(codec
, paths
[i
]);
5659 /* initialize hp and speaker paths */
5660 static void init_extra_out(struct hda_codec
*codec
)
5662 struct hda_gen_spec
*spec
= codec
->spec
;
5664 if (spec
->autocfg
.line_out_type
!= AUTO_PIN_HP_OUT
)
5665 __init_extra_out(codec
, spec
->autocfg
.hp_outs
, spec
->hp_paths
);
5666 if (spec
->autocfg
.line_out_type
!= AUTO_PIN_SPEAKER_OUT
)
5667 __init_extra_out(codec
, spec
->autocfg
.speaker_outs
,
5668 spec
->speaker_paths
);
5671 /* initialize multi-io paths */
5672 static void init_multi_io(struct hda_codec
*codec
)
5674 struct hda_gen_spec
*spec
= codec
->spec
;
5677 for (i
= 0; i
< spec
->multi_ios
; i
++) {
5678 hda_nid_t pin
= spec
->multi_io
[i
].pin
;
5679 struct nid_path
*path
;
5680 path
= get_multiio_path(codec
, i
);
5683 if (!spec
->multi_io
[i
].ctl_in
)
5684 spec
->multi_io
[i
].ctl_in
=
5685 snd_hda_codec_get_pin_target(codec
, pin
);
5686 snd_hda_activate_path(codec
, path
, path
->active
,
5687 aamix_default(spec
));
5691 static void init_aamix_paths(struct hda_codec
*codec
)
5693 struct hda_gen_spec
*spec
= codec
->spec
;
5695 if (!spec
->have_aamix_ctl
)
5697 if (!has_aamix_out_paths(spec
))
5699 update_aamix_paths(codec
, spec
->aamix_mode
, spec
->out_paths
[0],
5700 spec
->aamix_out_paths
[0],
5701 spec
->autocfg
.line_out_type
);
5702 update_aamix_paths(codec
, spec
->aamix_mode
, spec
->hp_paths
[0],
5703 spec
->aamix_out_paths
[1],
5705 update_aamix_paths(codec
, spec
->aamix_mode
, spec
->speaker_paths
[0],
5706 spec
->aamix_out_paths
[2],
5707 AUTO_PIN_SPEAKER_OUT
);
5710 /* set up input pins and loopback paths */
5711 static void init_analog_input(struct hda_codec
*codec
)
5713 struct hda_gen_spec
*spec
= codec
->spec
;
5714 struct auto_pin_cfg
*cfg
= &spec
->autocfg
;
5717 for (i
= 0; i
< cfg
->num_inputs
; i
++) {
5718 hda_nid_t nid
= cfg
->inputs
[i
].pin
;
5719 if (is_input_pin(codec
, nid
))
5720 restore_pin_ctl(codec
, nid
);
5722 /* init loopback inputs */
5723 if (spec
->mixer_nid
) {
5724 resume_path_from_idx(codec
, spec
->loopback_paths
[i
]);
5725 resume_path_from_idx(codec
, spec
->loopback_merge_path
);
5730 /* initialize ADC paths */
5731 static void init_input_src(struct hda_codec
*codec
)
5733 struct hda_gen_spec
*spec
= codec
->spec
;
5734 struct hda_input_mux
*imux
= &spec
->input_mux
;
5735 struct nid_path
*path
;
5738 if (spec
->dyn_adc_switch
)
5741 nums
= spec
->num_adc_nids
;
5743 for (c
= 0; c
< nums
; c
++) {
5744 for (i
= 0; i
< imux
->num_items
; i
++) {
5745 path
= get_input_path(codec
, c
, i
);
5747 bool active
= path
->active
;
5748 if (i
== spec
->cur_mux
[c
])
5750 snd_hda_activate_path(codec
, path
, active
, false);
5754 update_hp_mic(codec
, c
, true);
5757 if (spec
->cap_sync_hook
)
5758 spec
->cap_sync_hook(codec
, NULL
, NULL
);
5761 /* set right pin controls for digital I/O */
5762 static void init_digital(struct hda_codec
*codec
)
5764 struct hda_gen_spec
*spec
= codec
->spec
;
5768 for (i
= 0; i
< spec
->autocfg
.dig_outs
; i
++)
5769 set_output_and_unmute(codec
, spec
->digout_paths
[i
]);
5770 pin
= spec
->autocfg
.dig_in_pin
;
5772 restore_pin_ctl(codec
, pin
);
5773 resume_path_from_idx(codec
, spec
->digin_path
);
5777 /* clear unsol-event tags on unused pins; Conexant codecs seem to leave
5778 * invalid unsol tags by some reason
5780 static void clear_unsol_on_unused_pins(struct hda_codec
*codec
)
5784 for (i
= 0; i
< codec
->init_pins
.used
; i
++) {
5785 struct hda_pincfg
*pin
= snd_array_elem(&codec
->init_pins
, i
);
5786 hda_nid_t nid
= pin
->nid
;
5787 if (is_jack_detectable(codec
, nid
) &&
5788 !snd_hda_jack_tbl_get(codec
, nid
))
5789 snd_hda_codec_update_cache(codec
, nid
, 0,
5790 AC_VERB_SET_UNSOLICITED_ENABLE
, 0);
5795 * snd_hda_gen_init - initialize the generic spec
5796 * @codec: the HDA codec
5798 * This can be put as patch_ops init function.
5800 int snd_hda_gen_init(struct hda_codec
*codec
)
5802 struct hda_gen_spec
*spec
= codec
->spec
;
5804 if (spec
->init_hook
)
5805 spec
->init_hook(codec
);
5807 snd_hda_apply_verbs(codec
);
5809 init_multi_out(codec
);
5810 init_extra_out(codec
);
5811 init_multi_io(codec
);
5812 init_aamix_paths(codec
);
5813 init_analog_input(codec
);
5814 init_input_src(codec
);
5815 init_digital(codec
);
5817 clear_unsol_on_unused_pins(codec
);
5819 sync_all_pin_power_ctls(codec
);
5821 /* call init functions of standard auto-mute helpers */
5822 update_automute_all(codec
);
5824 regcache_sync(codec
->core
.regmap
);
5826 if (spec
->vmaster_mute
.sw_kctl
&& spec
->vmaster_mute
.hook
)
5827 snd_hda_sync_vmaster_hook(&spec
->vmaster_mute
);
5829 hda_call_check_power_status(codec
, 0x01);
5832 EXPORT_SYMBOL_GPL(snd_hda_gen_init
);
5835 * snd_hda_gen_free - free the generic spec
5836 * @codec: the HDA codec
5838 * This can be put as patch_ops free function.
5840 void snd_hda_gen_free(struct hda_codec
*codec
)
5842 snd_hda_apply_fixup(codec
, HDA_FIXUP_ACT_FREE
);
5843 snd_hda_gen_spec_free(codec
->spec
);
5847 EXPORT_SYMBOL_GPL(snd_hda_gen_free
);
5851 * snd_hda_gen_check_power_status - check the loopback power save state
5852 * @codec: the HDA codec
5853 * @nid: NID to inspect
5855 * This can be put as patch_ops check_power_status function.
5857 int snd_hda_gen_check_power_status(struct hda_codec
*codec
, hda_nid_t nid
)
5859 struct hda_gen_spec
*spec
= codec
->spec
;
5860 return snd_hda_check_amp_list_power(codec
, &spec
->loopback
, nid
);
5862 EXPORT_SYMBOL_GPL(snd_hda_gen_check_power_status
);
5867 * the generic codec support
5870 static const struct hda_codec_ops generic_patch_ops
= {
5871 .build_controls
= snd_hda_gen_build_controls
,
5872 .build_pcms
= snd_hda_gen_build_pcms
,
5873 .init
= snd_hda_gen_init
,
5874 .free
= snd_hda_gen_free
,
5875 .unsol_event
= snd_hda_jack_unsol_event
,
5877 .check_power_status
= snd_hda_gen_check_power_status
,
5882 * snd_hda_parse_generic_codec - Generic codec parser
5883 * @codec: the HDA codec
5885 static int snd_hda_parse_generic_codec(struct hda_codec
*codec
)
5887 struct hda_gen_spec
*spec
;
5890 spec
= kzalloc(sizeof(*spec
), GFP_KERNEL
);
5893 snd_hda_gen_spec_init(spec
);
5896 err
= snd_hda_parse_pin_defcfg(codec
, &spec
->autocfg
, NULL
, 0);
5900 err
= snd_hda_gen_parse_auto_config(codec
, &spec
->autocfg
);
5904 codec
->patch_ops
= generic_patch_ops
;
5908 snd_hda_gen_free(codec
);
5912 static const struct hda_device_id snd_hda_id_generic
[] = {
5913 HDA_CODEC_ENTRY(HDA_CODEC_ID_GENERIC
, "Generic", snd_hda_parse_generic_codec
),
5916 MODULE_DEVICE_TABLE(hdaudio
, snd_hda_id_generic
);
5918 static struct hda_codec_driver generic_driver
= {
5919 .id
= snd_hda_id_generic
,
5922 module_hda_codec_driver(generic_driver
);
5924 MODULE_LICENSE("GPL");
5925 MODULE_DESCRIPTION("Generic HD-audio codec parser");