2 * Universal Interface for Intel High Definition Audio Codec
4 * Generic widget tree parser
6 * Copyright (c) 2004 Takashi Iwai <tiwai@suse.de>
8 * This driver is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 2 of the License, or
11 * (at your option) any later version.
13 * This driver is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, write to the Free Software
20 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
23 #include <linux/init.h>
24 #include <linux/slab.h>
25 #include <linux/export.h>
26 #include <linux/sort.h>
27 #include <linux/delay.h>
28 #include <linux/ctype.h>
29 #include <linux/string.h>
30 #include <linux/bitops.h>
31 #include <sound/core.h>
32 #include <sound/jack.h>
33 #include "hda_codec.h"
34 #include "hda_local.h"
35 #include "hda_auto_parser.h"
38 #include "hda_generic.h"
41 /* initialize hda_gen_spec struct */
42 int snd_hda_gen_spec_init(struct hda_gen_spec
*spec
)
44 snd_array_init(&spec
->kctls
, sizeof(struct snd_kcontrol_new
), 32);
45 snd_array_init(&spec
->paths
, sizeof(struct nid_path
), 8);
46 snd_array_init(&spec
->loopback_list
, sizeof(struct hda_amp_list
), 8);
47 mutex_init(&spec
->pcm_mutex
);
50 EXPORT_SYMBOL_HDA(snd_hda_gen_spec_init
);
52 struct snd_kcontrol_new
*
53 snd_hda_gen_add_kctl(struct hda_gen_spec
*spec
, const char *name
,
54 const struct snd_kcontrol_new
*temp
)
56 struct snd_kcontrol_new
*knew
= snd_array_new(&spec
->kctls
);
61 knew
->name
= kstrdup(name
, GFP_KERNEL
);
63 knew
->name
= kstrdup(knew
->name
, GFP_KERNEL
);
68 EXPORT_SYMBOL_HDA(snd_hda_gen_add_kctl
);
70 static void free_kctls(struct hda_gen_spec
*spec
)
72 if (spec
->kctls
.list
) {
73 struct snd_kcontrol_new
*kctl
= spec
->kctls
.list
;
75 for (i
= 0; i
< spec
->kctls
.used
; i
++)
78 snd_array_free(&spec
->kctls
);
81 void snd_hda_gen_spec_free(struct hda_gen_spec
*spec
)
86 snd_array_free(&spec
->paths
);
87 snd_array_free(&spec
->loopback_list
);
89 EXPORT_SYMBOL_HDA(snd_hda_gen_spec_free
);
94 static void parse_user_hints(struct hda_codec
*codec
)
96 struct hda_gen_spec
*spec
= codec
->spec
;
99 val
= snd_hda_get_bool_hint(codec
, "jack_detect");
101 codec
->no_jack_detect
= !val
;
102 val
= snd_hda_get_bool_hint(codec
, "inv_jack_detect");
104 codec
->inv_jack_detect
= !!val
;
105 val
= snd_hda_get_bool_hint(codec
, "trigger_sense");
107 codec
->no_trigger_sense
= !val
;
108 val
= snd_hda_get_bool_hint(codec
, "inv_eapd");
110 codec
->inv_eapd
= !!val
;
111 val
= snd_hda_get_bool_hint(codec
, "pcm_format_first");
113 codec
->pcm_format_first
= !!val
;
114 val
= snd_hda_get_bool_hint(codec
, "sticky_stream");
116 codec
->no_sticky_stream
= !val
;
117 val
= snd_hda_get_bool_hint(codec
, "spdif_status_reset");
119 codec
->spdif_status_reset
= !!val
;
120 val
= snd_hda_get_bool_hint(codec
, "pin_amp_workaround");
122 codec
->pin_amp_workaround
= !!val
;
123 val
= snd_hda_get_bool_hint(codec
, "single_adc_amp");
125 codec
->single_adc_amp
= !!val
;
127 val
= snd_hda_get_bool_hint(codec
, "auto_mute");
129 spec
->suppress_auto_mute
= !val
;
130 val
= snd_hda_get_bool_hint(codec
, "auto_mic");
132 spec
->suppress_auto_mic
= !val
;
133 val
= snd_hda_get_bool_hint(codec
, "line_in_auto_switch");
135 spec
->line_in_auto_switch
= !!val
;
136 val
= snd_hda_get_bool_hint(codec
, "need_dac_fix");
138 spec
->need_dac_fix
= !!val
;
139 val
= snd_hda_get_bool_hint(codec
, "primary_hp");
141 spec
->no_primary_hp
= !val
;
142 val
= snd_hda_get_bool_hint(codec
, "multi_cap_vol");
144 spec
->multi_cap_vol
= !!val
;
145 val
= snd_hda_get_bool_hint(codec
, "inv_dmic_split");
147 spec
->inv_dmic_split
= !!val
;
148 val
= snd_hda_get_bool_hint(codec
, "indep_hp");
150 spec
->indep_hp
= !!val
;
151 val
= snd_hda_get_bool_hint(codec
, "add_stereo_mix_input");
153 spec
->add_stereo_mix_input
= !!val
;
154 /* the following two are just for compatibility */
155 val
= snd_hda_get_bool_hint(codec
, "add_out_jack_modes");
157 spec
->add_jack_modes
= !!val
;
158 val
= snd_hda_get_bool_hint(codec
, "add_in_jack_modes");
160 spec
->add_jack_modes
= !!val
;
161 val
= snd_hda_get_bool_hint(codec
, "add_jack_modes");
163 spec
->add_jack_modes
= !!val
;
164 val
= snd_hda_get_bool_hint(codec
, "power_down_unused");
166 spec
->power_down_unused
= !!val
;
167 val
= snd_hda_get_bool_hint(codec
, "add_hp_mic");
169 spec
->hp_mic
= !!val
;
170 val
= snd_hda_get_bool_hint(codec
, "hp_mic_detect");
172 spec
->suppress_hp_mic_detect
= !val
;
174 if (!snd_hda_get_int_hint(codec
, "mixer_nid", &val
))
175 spec
->mixer_nid
= val
;
179 * pin control value accesses
182 #define update_pin_ctl(codec, pin, val) \
183 snd_hda_codec_update_cache(codec, pin, 0, \
184 AC_VERB_SET_PIN_WIDGET_CONTROL, val)
186 /* restore the pinctl based on the cached value */
187 static inline void restore_pin_ctl(struct hda_codec
*codec
, hda_nid_t pin
)
189 update_pin_ctl(codec
, pin
, snd_hda_codec_get_pin_target(codec
, pin
));
192 /* set the pinctl target value and write it if requested */
193 static void set_pin_target(struct hda_codec
*codec
, hda_nid_t pin
,
194 unsigned int val
, bool do_write
)
198 val
= snd_hda_correct_pin_ctl(codec
, pin
, val
);
199 snd_hda_codec_set_pin_target(codec
, pin
, val
);
201 update_pin_ctl(codec
, pin
, val
);
204 /* set pinctl target values for all given pins */
205 static void set_pin_targets(struct hda_codec
*codec
, int num_pins
,
206 hda_nid_t
*pins
, unsigned int val
)
209 for (i
= 0; i
< num_pins
; i
++)
210 set_pin_target(codec
, pins
[i
], val
, false);
217 /* return the position of NID in the list, or -1 if not found */
218 static int find_idx_in_nid_list(hda_nid_t nid
, const hda_nid_t
*list
, int nums
)
221 for (i
= 0; i
< nums
; i
++)
227 /* return true if the given NID is contained in the path */
228 static bool is_nid_contained(struct nid_path
*path
, hda_nid_t nid
)
230 return find_idx_in_nid_list(nid
, path
->path
, path
->depth
) >= 0;
233 static struct nid_path
*get_nid_path(struct hda_codec
*codec
,
234 hda_nid_t from_nid
, hda_nid_t to_nid
,
237 struct hda_gen_spec
*spec
= codec
->spec
;
240 for (i
= 0; i
< spec
->paths
.used
; i
++) {
241 struct nid_path
*path
= snd_array_elem(&spec
->paths
, i
);
242 if (path
->depth
<= 0)
244 if ((!from_nid
|| path
->path
[0] == from_nid
) &&
245 (!to_nid
|| path
->path
[path
->depth
- 1] == to_nid
)) {
247 (anchor_nid
> 0 && is_nid_contained(path
, anchor_nid
)) ||
248 (anchor_nid
< 0 && !is_nid_contained(path
, anchor_nid
)))
255 /* get the path between the given NIDs;
256 * passing 0 to either @pin or @dac behaves as a wildcard
258 struct nid_path
*snd_hda_get_nid_path(struct hda_codec
*codec
,
259 hda_nid_t from_nid
, hda_nid_t to_nid
)
261 return get_nid_path(codec
, from_nid
, to_nid
, 0);
263 EXPORT_SYMBOL_HDA(snd_hda_get_nid_path
);
265 /* get the index number corresponding to the path instance;
266 * the index starts from 1, for easier checking the invalid value
268 int snd_hda_get_path_idx(struct hda_codec
*codec
, struct nid_path
*path
)
270 struct hda_gen_spec
*spec
= codec
->spec
;
271 struct nid_path
*array
= spec
->paths
.list
;
274 if (!spec
->paths
.used
)
277 if (idx
< 0 || idx
>= spec
->paths
.used
)
281 EXPORT_SYMBOL_HDA(snd_hda_get_path_idx
);
283 /* get the path instance corresponding to the given index number */
284 struct nid_path
*snd_hda_get_path_from_idx(struct hda_codec
*codec
, int idx
)
286 struct hda_gen_spec
*spec
= codec
->spec
;
288 if (idx
<= 0 || idx
> spec
->paths
.used
)
290 return snd_array_elem(&spec
->paths
, idx
- 1);
292 EXPORT_SYMBOL_HDA(snd_hda_get_path_from_idx
);
294 /* check whether the given DAC is already found in any existing paths */
295 static bool is_dac_already_used(struct hda_codec
*codec
, hda_nid_t nid
)
297 struct hda_gen_spec
*spec
= codec
->spec
;
300 for (i
= 0; i
< spec
->paths
.used
; i
++) {
301 struct nid_path
*path
= snd_array_elem(&spec
->paths
, i
);
302 if (path
->path
[0] == nid
)
308 /* check whether the given two widgets can be connected */
309 static bool is_reachable_path(struct hda_codec
*codec
,
310 hda_nid_t from_nid
, hda_nid_t to_nid
)
312 if (!from_nid
|| !to_nid
)
314 return snd_hda_get_conn_index(codec
, to_nid
, from_nid
, true) >= 0;
317 /* nid, dir and idx */
318 #define AMP_VAL_COMPARE_MASK (0xffff | (1U << 18) | (0x0f << 19))
320 /* check whether the given ctl is already assigned in any path elements */
321 static bool is_ctl_used(struct hda_codec
*codec
, unsigned int val
, int type
)
323 struct hda_gen_spec
*spec
= codec
->spec
;
326 val
&= AMP_VAL_COMPARE_MASK
;
327 for (i
= 0; i
< spec
->paths
.used
; i
++) {
328 struct nid_path
*path
= snd_array_elem(&spec
->paths
, i
);
329 if ((path
->ctls
[type
] & AMP_VAL_COMPARE_MASK
) == val
)
335 /* check whether a control with the given (nid, dir, idx) was assigned */
336 static bool is_ctl_associated(struct hda_codec
*codec
, hda_nid_t nid
,
337 int dir
, int idx
, int type
)
339 unsigned int val
= HDA_COMPOSE_AMP_VAL(nid
, 3, idx
, dir
);
340 return is_ctl_used(codec
, val
, type
);
343 static void print_nid_path(const char *pfx
, struct nid_path
*path
)
350 for (i
= 0; i
< path
->depth
; i
++) {
352 sprintf(tmp
, ":%02x", path
->path
[i
]);
353 strlcat(buf
, tmp
, sizeof(buf
));
355 snd_printdd("%s path: depth=%d %s\n", pfx
, path
->depth
, buf
);
358 /* called recursively */
359 static bool __parse_nid_path(struct hda_codec
*codec
,
360 hda_nid_t from_nid
, hda_nid_t to_nid
,
361 int anchor_nid
, struct nid_path
*path
,
364 const hda_nid_t
*conn
;
367 if (to_nid
== anchor_nid
)
368 anchor_nid
= 0; /* anchor passed */
369 else if (to_nid
== (hda_nid_t
)(-anchor_nid
))
370 return false; /* hit the exclusive nid */
372 nums
= snd_hda_get_conn_list(codec
, to_nid
, &conn
);
373 for (i
= 0; i
< nums
; i
++) {
374 if (conn
[i
] != from_nid
) {
375 /* special case: when from_nid is 0,
376 * try to find an empty DAC
379 get_wcaps_type(get_wcaps(codec
, conn
[i
])) != AC_WID_AUD_OUT
||
380 is_dac_already_used(codec
, conn
[i
]))
383 /* anchor is not requested or already passed? */
387 if (depth
>= MAX_NID_PATH_DEPTH
)
389 for (i
= 0; i
< nums
; i
++) {
391 type
= get_wcaps_type(get_wcaps(codec
, conn
[i
]));
392 if (type
== AC_WID_AUD_OUT
|| type
== AC_WID_AUD_IN
||
395 if (__parse_nid_path(codec
, from_nid
, conn
[i
],
396 anchor_nid
, path
, depth
+ 1))
402 path
->path
[path
->depth
] = conn
[i
];
403 path
->idx
[path
->depth
+ 1] = i
;
404 if (nums
> 1 && get_wcaps_type(get_wcaps(codec
, to_nid
)) != AC_WID_AUD_MIX
)
405 path
->multi
[path
->depth
+ 1] = 1;
410 /* parse the widget path from the given nid to the target nid;
411 * when @from_nid is 0, try to find an empty DAC;
412 * when @anchor_nid is set to a positive value, only paths through the widget
413 * with the given value are evaluated.
414 * when @anchor_nid is set to a negative value, paths through the widget
415 * with the negative of given value are excluded, only other paths are chosen.
416 * when @anchor_nid is zero, no special handling about path selection.
418 bool snd_hda_parse_nid_path(struct hda_codec
*codec
, hda_nid_t from_nid
,
419 hda_nid_t to_nid
, int anchor_nid
,
420 struct nid_path
*path
)
422 if (__parse_nid_path(codec
, from_nid
, to_nid
, anchor_nid
, path
, 1)) {
423 path
->path
[path
->depth
] = to_nid
;
429 EXPORT_SYMBOL_HDA(snd_hda_parse_nid_path
);
432 * parse the path between the given NIDs and add to the path list.
433 * if no valid path is found, return NULL
436 snd_hda_add_new_path(struct hda_codec
*codec
, hda_nid_t from_nid
,
437 hda_nid_t to_nid
, int anchor_nid
)
439 struct hda_gen_spec
*spec
= codec
->spec
;
440 struct nid_path
*path
;
442 if (from_nid
&& to_nid
&& !is_reachable_path(codec
, from_nid
, to_nid
))
445 /* check whether the path has been already added */
446 path
= get_nid_path(codec
, from_nid
, to_nid
, anchor_nid
);
450 path
= snd_array_new(&spec
->paths
);
453 memset(path
, 0, sizeof(*path
));
454 if (snd_hda_parse_nid_path(codec
, from_nid
, to_nid
, anchor_nid
, path
))
460 EXPORT_SYMBOL_HDA(snd_hda_add_new_path
);
462 /* clear the given path as invalid so that it won't be picked up later */
463 static void invalidate_nid_path(struct hda_codec
*codec
, int idx
)
465 struct nid_path
*path
= snd_hda_get_path_from_idx(codec
, idx
);
468 memset(path
, 0, sizeof(*path
));
471 /* return a DAC if paired to the given pin by codec driver */
472 static hda_nid_t
get_preferred_dac(struct hda_codec
*codec
, hda_nid_t pin
)
474 struct hda_gen_spec
*spec
= codec
->spec
;
475 const hda_nid_t
*list
= spec
->preferred_dacs
;
479 for (; *list
; list
+= 2)
485 /* look for an empty DAC slot */
486 static hda_nid_t
look_for_dac(struct hda_codec
*codec
, hda_nid_t pin
,
489 struct hda_gen_spec
*spec
= codec
->spec
;
493 for (i
= 0; i
< spec
->num_all_dacs
; i
++) {
494 hda_nid_t nid
= spec
->all_dacs
[i
];
495 if (!nid
|| is_dac_already_used(codec
, nid
))
497 cap_digital
= !!(get_wcaps(codec
, nid
) & AC_WCAP_DIGITAL
);
498 if (is_digital
!= cap_digital
)
500 if (is_reachable_path(codec
, nid
, pin
))
506 /* replace the channels in the composed amp value with the given number */
507 static unsigned int amp_val_replace_channels(unsigned int val
, unsigned int chs
)
509 val
&= ~(0x3U
<< 16);
514 /* check whether the widget has the given amp capability for the direction */
515 static bool check_amp_caps(struct hda_codec
*codec
, hda_nid_t nid
,
516 int dir
, unsigned int bits
)
520 if (get_wcaps(codec
, nid
) & (1 << (dir
+ 1)))
521 if (query_amp_caps(codec
, nid
, dir
) & bits
)
526 static bool same_amp_caps(struct hda_codec
*codec
, hda_nid_t nid1
,
527 hda_nid_t nid2
, int dir
)
529 if (!(get_wcaps(codec
, nid1
) & (1 << (dir
+ 1))))
530 return !(get_wcaps(codec
, nid2
) & (1 << (dir
+ 1)));
531 return (query_amp_caps(codec
, nid1
, dir
) ==
532 query_amp_caps(codec
, nid2
, dir
));
535 #define nid_has_mute(codec, nid, dir) \
536 check_amp_caps(codec, nid, dir, (AC_AMPCAP_MUTE | AC_AMPCAP_MIN_MUTE))
537 #define nid_has_volume(codec, nid, dir) \
538 check_amp_caps(codec, nid, dir, AC_AMPCAP_NUM_STEPS)
540 /* look for a widget suitable for assigning a mute switch in the path */
541 static hda_nid_t
look_for_out_mute_nid(struct hda_codec
*codec
,
542 struct nid_path
*path
)
546 for (i
= path
->depth
- 1; i
>= 0; i
--) {
547 if (nid_has_mute(codec
, path
->path
[i
], HDA_OUTPUT
))
548 return path
->path
[i
];
549 if (i
!= path
->depth
- 1 && i
!= 0 &&
550 nid_has_mute(codec
, path
->path
[i
], HDA_INPUT
))
551 return path
->path
[i
];
556 /* look for a widget suitable for assigning a volume ctl in the path */
557 static hda_nid_t
look_for_out_vol_nid(struct hda_codec
*codec
,
558 struct nid_path
*path
)
562 for (i
= path
->depth
- 1; i
>= 0; i
--) {
563 if (nid_has_volume(codec
, path
->path
[i
], HDA_OUTPUT
))
564 return path
->path
[i
];
570 * path activation / deactivation
573 /* can have the amp-in capability? */
574 static bool has_amp_in(struct hda_codec
*codec
, struct nid_path
*path
, int idx
)
576 hda_nid_t nid
= path
->path
[idx
];
577 unsigned int caps
= get_wcaps(codec
, nid
);
578 unsigned int type
= get_wcaps_type(caps
);
580 if (!(caps
& AC_WCAP_IN_AMP
))
582 if (type
== AC_WID_PIN
&& idx
> 0) /* only for input pins */
587 /* can have the amp-out capability? */
588 static bool has_amp_out(struct hda_codec
*codec
, struct nid_path
*path
, int idx
)
590 hda_nid_t nid
= path
->path
[idx
];
591 unsigned int caps
= get_wcaps(codec
, nid
);
592 unsigned int type
= get_wcaps_type(caps
);
594 if (!(caps
& AC_WCAP_OUT_AMP
))
596 if (type
== AC_WID_PIN
&& !idx
) /* only for output pins */
601 /* check whether the given (nid,dir,idx) is active */
602 static bool is_active_nid(struct hda_codec
*codec
, hda_nid_t nid
,
603 unsigned int dir
, unsigned int idx
)
605 struct hda_gen_spec
*spec
= codec
->spec
;
608 for (n
= 0; n
< spec
->paths
.used
; n
++) {
609 struct nid_path
*path
= snd_array_elem(&spec
->paths
, n
);
612 for (i
= 0; i
< path
->depth
; i
++) {
613 if (path
->path
[i
] == nid
) {
614 if (dir
== HDA_OUTPUT
|| path
->idx
[i
] == idx
)
623 /* check whether the NID is referred by any active paths */
624 #define is_active_nid_for_any(codec, nid) \
625 is_active_nid(codec, nid, HDA_OUTPUT, 0)
627 /* get the default amp value for the target state */
628 static int get_amp_val_to_activate(struct hda_codec
*codec
, hda_nid_t nid
,
629 int dir
, unsigned int caps
, bool enable
)
631 unsigned int val
= 0;
633 if (caps
& AC_AMPCAP_NUM_STEPS
) {
636 val
= (caps
& AC_AMPCAP_OFFSET
) >> AC_AMPCAP_OFFSET_SHIFT
;
638 if (caps
& (AC_AMPCAP_MUTE
| AC_AMPCAP_MIN_MUTE
)) {
645 /* is this a stereo widget or a stereo-to-mono mix? */
646 static bool is_stereo_amps(struct hda_codec
*codec
, hda_nid_t nid
, int dir
)
648 unsigned int wcaps
= get_wcaps(codec
, nid
);
651 if (wcaps
& AC_WCAP_STEREO
)
653 if (dir
!= HDA_INPUT
|| get_wcaps_type(wcaps
) != AC_WID_AUD_MIX
)
655 if (snd_hda_get_num_conns(codec
, nid
) != 1)
657 if (snd_hda_get_connections(codec
, nid
, &conn
, 1) < 0)
659 return !!(get_wcaps(codec
, conn
) & AC_WCAP_STEREO
);
662 /* initialize the amp value (only at the first time) */
663 static void init_amp(struct hda_codec
*codec
, hda_nid_t nid
, int dir
, int idx
)
665 unsigned int caps
= query_amp_caps(codec
, nid
, dir
);
666 int val
= get_amp_val_to_activate(codec
, nid
, dir
, caps
, false);
668 if (is_stereo_amps(codec
, nid
, dir
))
669 snd_hda_codec_amp_init_stereo(codec
, nid
, dir
, idx
, 0xff, val
);
671 snd_hda_codec_amp_init(codec
, nid
, 0, dir
, idx
, 0xff, val
);
674 /* update the amp, doing in stereo or mono depending on NID */
675 static int update_amp(struct hda_codec
*codec
, hda_nid_t nid
, int dir
, int idx
,
676 unsigned int mask
, unsigned int val
)
678 if (is_stereo_amps(codec
, nid
, dir
))
679 return snd_hda_codec_amp_stereo(codec
, nid
, dir
, idx
,
682 return snd_hda_codec_amp_update(codec
, nid
, 0, dir
, idx
,
686 /* calculate amp value mask we can modify;
687 * if the given amp is controlled by mixers, don't touch it
689 static unsigned int get_amp_mask_to_modify(struct hda_codec
*codec
,
690 hda_nid_t nid
, int dir
, int idx
,
693 unsigned int mask
= 0xff;
695 if (caps
& (AC_AMPCAP_MUTE
| AC_AMPCAP_MIN_MUTE
)) {
696 if (is_ctl_associated(codec
, nid
, dir
, idx
, NID_PATH_MUTE_CTL
))
699 if (caps
& AC_AMPCAP_NUM_STEPS
) {
700 if (is_ctl_associated(codec
, nid
, dir
, idx
, NID_PATH_VOL_CTL
) ||
701 is_ctl_associated(codec
, nid
, dir
, idx
, NID_PATH_BOOST_CTL
))
707 static void activate_amp(struct hda_codec
*codec
, hda_nid_t nid
, int dir
,
708 int idx
, int idx_to_check
, bool enable
)
711 unsigned int mask
, val
;
713 if (!enable
&& is_active_nid(codec
, nid
, dir
, idx_to_check
))
716 caps
= query_amp_caps(codec
, nid
, dir
);
717 val
= get_amp_val_to_activate(codec
, nid
, dir
, caps
, enable
);
718 mask
= get_amp_mask_to_modify(codec
, nid
, dir
, idx_to_check
, caps
);
723 update_amp(codec
, nid
, dir
, idx
, mask
, val
);
726 static void activate_amp_out(struct hda_codec
*codec
, struct nid_path
*path
,
729 hda_nid_t nid
= path
->path
[i
];
730 init_amp(codec
, nid
, HDA_OUTPUT
, 0);
731 activate_amp(codec
, nid
, HDA_OUTPUT
, 0, 0, enable
);
734 static void activate_amp_in(struct hda_codec
*codec
, struct nid_path
*path
,
735 int i
, bool enable
, bool add_aamix
)
737 struct hda_gen_spec
*spec
= codec
->spec
;
738 const hda_nid_t
*conn
;
741 hda_nid_t nid
= path
->path
[i
];
743 nums
= snd_hda_get_conn_list(codec
, nid
, &conn
);
744 type
= get_wcaps_type(get_wcaps(codec
, nid
));
745 if (type
== AC_WID_PIN
||
746 (type
== AC_WID_AUD_IN
&& codec
->single_adc_amp
)) {
752 for (n
= 0; n
< nums
; n
++)
753 init_amp(codec
, nid
, HDA_INPUT
, n
);
755 /* here is a little bit tricky in comparison with activate_amp_out();
756 * when aa-mixer is available, we need to enable the path as well
758 for (n
= 0; n
< nums
; n
++) {
759 if (n
!= idx
&& (!add_aamix
|| conn
[n
] != spec
->mixer_merge_nid
))
761 activate_amp(codec
, nid
, HDA_INPUT
, n
, idx
, enable
);
765 /* activate or deactivate the given path
766 * if @add_aamix is set, enable the input from aa-mix NID as well (if any)
768 void snd_hda_activate_path(struct hda_codec
*codec
, struct nid_path
*path
,
769 bool enable
, bool add_aamix
)
771 struct hda_gen_spec
*spec
= codec
->spec
;
775 path
->active
= false;
777 for (i
= path
->depth
- 1; i
>= 0; i
--) {
778 hda_nid_t nid
= path
->path
[i
];
779 if (enable
&& spec
->power_down_unused
) {
780 /* make sure the widget is powered up */
781 if (!snd_hda_check_power_state(codec
, nid
, AC_PWRST_D0
))
782 snd_hda_codec_write(codec
, nid
, 0,
783 AC_VERB_SET_POWER_STATE
,
786 if (enable
&& path
->multi
[i
])
787 snd_hda_codec_write_cache(codec
, nid
, 0,
788 AC_VERB_SET_CONNECT_SEL
,
790 if (has_amp_in(codec
, path
, i
))
791 activate_amp_in(codec
, path
, i
, enable
, add_aamix
);
792 if (has_amp_out(codec
, path
, i
))
793 activate_amp_out(codec
, path
, i
, enable
);
799 EXPORT_SYMBOL_HDA(snd_hda_activate_path
);
801 /* if the given path is inactive, put widgets into D3 (only if suitable) */
802 static void path_power_down_sync(struct hda_codec
*codec
, struct nid_path
*path
)
804 struct hda_gen_spec
*spec
= codec
->spec
;
805 bool changed
= false;
808 if (!spec
->power_down_unused
|| path
->active
)
811 for (i
= 0; i
< path
->depth
; i
++) {
812 hda_nid_t nid
= path
->path
[i
];
813 if (!snd_hda_check_power_state(codec
, nid
, AC_PWRST_D3
) &&
814 !is_active_nid_for_any(codec
, nid
)) {
815 snd_hda_codec_write(codec
, nid
, 0,
816 AC_VERB_SET_POWER_STATE
,
824 snd_hda_codec_read(codec
, path
->path
[0], 0,
825 AC_VERB_GET_POWER_STATE
, 0);
829 /* turn on/off EAPD on the given pin */
830 static void set_pin_eapd(struct hda_codec
*codec
, hda_nid_t pin
, bool enable
)
832 struct hda_gen_spec
*spec
= codec
->spec
;
833 if (spec
->own_eapd_ctl
||
834 !(snd_hda_query_pin_caps(codec
, pin
) & AC_PINCAP_EAPD
))
836 if (spec
->keep_eapd_on
&& !enable
)
840 snd_hda_codec_update_cache(codec
, pin
, 0,
841 AC_VERB_SET_EAPD_BTLENABLE
,
842 enable
? 0x02 : 0x00);
845 /* re-initialize the path specified by the given path index */
846 static void resume_path_from_idx(struct hda_codec
*codec
, int path_idx
)
848 struct nid_path
*path
= snd_hda_get_path_from_idx(codec
, path_idx
);
850 snd_hda_activate_path(codec
, path
, path
->active
, false);
855 * Helper functions for creating mixer ctl elements
863 static const struct snd_kcontrol_new control_templates
[] = {
864 HDA_CODEC_VOLUME(NULL
, 0, 0, 0),
865 HDA_CODEC_MUTE(NULL
, 0, 0, 0),
866 HDA_BIND_MUTE(NULL
, 0, 0, 0),
869 /* add dynamic controls from template */
870 static struct snd_kcontrol_new
*
871 add_control(struct hda_gen_spec
*spec
, int type
, const char *name
,
872 int cidx
, unsigned long val
)
874 struct snd_kcontrol_new
*knew
;
876 knew
= snd_hda_gen_add_kctl(spec
, name
, &control_templates
[type
]);
880 if (get_amp_nid_(val
))
881 knew
->subdevice
= HDA_SUBDEV_AMP_FLAG
;
882 knew
->private_value
= val
;
886 static int add_control_with_pfx(struct hda_gen_spec
*spec
, int type
,
887 const char *pfx
, const char *dir
,
888 const char *sfx
, int cidx
, unsigned long val
)
891 snprintf(name
, sizeof(name
), "%s %s %s", pfx
, dir
, sfx
);
892 if (!add_control(spec
, type
, name
, cidx
, val
))
897 #define add_pb_vol_ctrl(spec, type, pfx, val) \
898 add_control_with_pfx(spec, type, pfx, "Playback", "Volume", 0, val)
899 #define add_pb_sw_ctrl(spec, type, pfx, val) \
900 add_control_with_pfx(spec, type, pfx, "Playback", "Switch", 0, val)
901 #define __add_pb_vol_ctrl(spec, type, pfx, cidx, val) \
902 add_control_with_pfx(spec, type, pfx, "Playback", "Volume", cidx, val)
903 #define __add_pb_sw_ctrl(spec, type, pfx, cidx, val) \
904 add_control_with_pfx(spec, type, pfx, "Playback", "Switch", cidx, val)
906 static int add_vol_ctl(struct hda_codec
*codec
, const char *pfx
, int cidx
,
907 unsigned int chs
, struct nid_path
*path
)
912 val
= path
->ctls
[NID_PATH_VOL_CTL
];
915 val
= amp_val_replace_channels(val
, chs
);
916 return __add_pb_vol_ctrl(codec
->spec
, HDA_CTL_WIDGET_VOL
, pfx
, cidx
, val
);
919 /* return the channel bits suitable for the given path->ctls[] */
920 static int get_default_ch_nums(struct hda_codec
*codec
, struct nid_path
*path
,
923 int chs
= 1; /* mono (left only) */
925 hda_nid_t nid
= get_amp_nid_(path
->ctls
[type
]);
926 if (nid
&& (get_wcaps(codec
, nid
) & AC_WCAP_STEREO
))
927 chs
= 3; /* stereo */
932 static int add_stereo_vol(struct hda_codec
*codec
, const char *pfx
, int cidx
,
933 struct nid_path
*path
)
935 int chs
= get_default_ch_nums(codec
, path
, NID_PATH_VOL_CTL
);
936 return add_vol_ctl(codec
, pfx
, cidx
, chs
, path
);
939 /* create a mute-switch for the given mixer widget;
940 * if it has multiple sources (e.g. DAC and loopback), create a bind-mute
942 static int add_sw_ctl(struct hda_codec
*codec
, const char *pfx
, int cidx
,
943 unsigned int chs
, struct nid_path
*path
)
946 int type
= HDA_CTL_WIDGET_MUTE
;
950 val
= path
->ctls
[NID_PATH_MUTE_CTL
];
953 val
= amp_val_replace_channels(val
, chs
);
954 if (get_amp_direction_(val
) == HDA_INPUT
) {
955 hda_nid_t nid
= get_amp_nid_(val
);
956 int nums
= snd_hda_get_num_conns(codec
, nid
);
958 type
= HDA_CTL_BIND_MUTE
;
962 return __add_pb_sw_ctrl(codec
->spec
, type
, pfx
, cidx
, val
);
965 static int add_stereo_sw(struct hda_codec
*codec
, const char *pfx
,
966 int cidx
, struct nid_path
*path
)
968 int chs
= get_default_ch_nums(codec
, path
, NID_PATH_MUTE_CTL
);
969 return add_sw_ctl(codec
, pfx
, cidx
, chs
, path
);
972 /* any ctl assigned to the path with the given index? */
973 static bool path_has_mixer(struct hda_codec
*codec
, int path_idx
, int ctl_type
)
975 struct nid_path
*path
= snd_hda_get_path_from_idx(codec
, path_idx
);
976 return path
&& path
->ctls
[ctl_type
];
979 static const char * const channel_name
[4] = {
980 "Front", "Surround", "CLFE", "Side"
983 /* give some appropriate ctl name prefix for the given line out channel */
984 static const char *get_line_out_pfx(struct hda_codec
*codec
, int ch
,
985 int *index
, int ctl_type
)
987 struct hda_gen_spec
*spec
= codec
->spec
;
988 struct auto_pin_cfg
*cfg
= &spec
->autocfg
;
991 if (cfg
->line_outs
== 1 && !spec
->multi_ios
&&
992 !cfg
->hp_outs
&& !cfg
->speaker_outs
)
993 return spec
->vmaster_mute
.hook
? "PCM" : "Master";
995 /* if there is really a single DAC used in the whole output paths,
996 * use it master (or "PCM" if a vmaster hook is present)
998 if (spec
->multiout
.num_dacs
== 1 && !spec
->mixer_nid
&&
999 !spec
->multiout
.hp_out_nid
[0] && !spec
->multiout
.extra_out_nid
[0])
1000 return spec
->vmaster_mute
.hook
? "PCM" : "Master";
1002 /* multi-io channels */
1003 if (ch
>= cfg
->line_outs
)
1004 return channel_name
[ch
];
1006 switch (cfg
->line_out_type
) {
1007 case AUTO_PIN_SPEAKER_OUT
:
1008 /* if the primary channel vol/mute is shared with HP volume,
1009 * don't name it as Speaker
1011 if (!ch
&& cfg
->hp_outs
&&
1012 !path_has_mixer(codec
, spec
->hp_paths
[0], ctl_type
))
1014 if (cfg
->line_outs
== 1)
1016 if (cfg
->line_outs
== 2)
1017 return ch
? "Bass Speaker" : "Speaker";
1019 case AUTO_PIN_HP_OUT
:
1020 /* if the primary channel vol/mute is shared with spk volume,
1021 * don't name it as Headphone
1023 if (!ch
&& cfg
->speaker_outs
&&
1024 !path_has_mixer(codec
, spec
->speaker_paths
[0], ctl_type
))
1026 /* for multi-io case, only the primary out */
1027 if (ch
&& spec
->multi_ios
)
1033 /* for a single channel output, we don't have to name the channel */
1034 if (cfg
->line_outs
== 1 && !spec
->multi_ios
)
1037 if (ch
>= ARRAY_SIZE(channel_name
)) {
1042 return channel_name
[ch
];
1046 * Parse output paths
1049 /* badness definition */
1051 /* No primary DAC is found for the main output */
1052 BAD_NO_PRIMARY_DAC
= 0x10000,
1053 /* No DAC is found for the extra output */
1054 BAD_NO_DAC
= 0x4000,
1055 /* No possible multi-ios */
1056 BAD_MULTI_IO
= 0x120,
1057 /* No individual DAC for extra output */
1058 BAD_NO_EXTRA_DAC
= 0x102,
1059 /* No individual DAC for extra surrounds */
1060 BAD_NO_EXTRA_SURR_DAC
= 0x101,
1061 /* Primary DAC shared with main surrounds */
1062 BAD_SHARED_SURROUND
= 0x100,
1063 /* No independent HP possible */
1064 BAD_NO_INDEP_HP
= 0x10,
1065 /* Primary DAC shared with main CLFE */
1066 BAD_SHARED_CLFE
= 0x10,
1067 /* Primary DAC shared with extra surrounds */
1068 BAD_SHARED_EXTRA_SURROUND
= 0x10,
1069 /* Volume widget is shared */
1070 BAD_SHARED_VOL
= 0x10,
1073 /* look for widgets in the given path which are appropriate for
1074 * volume and mute controls, and assign the values to ctls[].
1076 * When no appropriate widget is found in the path, the badness value
1077 * is incremented depending on the situation. The function returns the
1078 * total badness for both volume and mute controls.
1080 static int assign_out_path_ctls(struct hda_codec
*codec
, struct nid_path
*path
)
1087 return BAD_SHARED_VOL
* 2;
1089 if (path
->ctls
[NID_PATH_VOL_CTL
] ||
1090 path
->ctls
[NID_PATH_MUTE_CTL
])
1091 return 0; /* already evaluated */
1093 nid
= look_for_out_vol_nid(codec
, path
);
1095 val
= HDA_COMPOSE_AMP_VAL(nid
, 3, 0, HDA_OUTPUT
);
1096 if (is_ctl_used(codec
, val
, NID_PATH_VOL_CTL
))
1097 badness
+= BAD_SHARED_VOL
;
1099 path
->ctls
[NID_PATH_VOL_CTL
] = val
;
1101 badness
+= BAD_SHARED_VOL
;
1102 nid
= look_for_out_mute_nid(codec
, path
);
1104 unsigned int wid_type
= get_wcaps_type(get_wcaps(codec
, nid
));
1105 if (wid_type
== AC_WID_PIN
|| wid_type
== AC_WID_AUD_OUT
||
1106 nid_has_mute(codec
, nid
, HDA_OUTPUT
))
1107 val
= HDA_COMPOSE_AMP_VAL(nid
, 3, 0, HDA_OUTPUT
);
1109 val
= HDA_COMPOSE_AMP_VAL(nid
, 3, 0, HDA_INPUT
);
1110 if (is_ctl_used(codec
, val
, NID_PATH_MUTE_CTL
))
1111 badness
+= BAD_SHARED_VOL
;
1113 path
->ctls
[NID_PATH_MUTE_CTL
] = val
;
1115 badness
+= BAD_SHARED_VOL
;
1119 const struct badness_table hda_main_out_badness
= {
1120 .no_primary_dac
= BAD_NO_PRIMARY_DAC
,
1121 .no_dac
= BAD_NO_DAC
,
1122 .shared_primary
= BAD_NO_PRIMARY_DAC
,
1123 .shared_surr
= BAD_SHARED_SURROUND
,
1124 .shared_clfe
= BAD_SHARED_CLFE
,
1125 .shared_surr_main
= BAD_SHARED_SURROUND
,
1127 EXPORT_SYMBOL_HDA(hda_main_out_badness
);
1129 const struct badness_table hda_extra_out_badness
= {
1130 .no_primary_dac
= BAD_NO_DAC
,
1131 .no_dac
= BAD_NO_DAC
,
1132 .shared_primary
= BAD_NO_EXTRA_DAC
,
1133 .shared_surr
= BAD_SHARED_EXTRA_SURROUND
,
1134 .shared_clfe
= BAD_SHARED_EXTRA_SURROUND
,
1135 .shared_surr_main
= BAD_NO_EXTRA_SURR_DAC
,
1137 EXPORT_SYMBOL_HDA(hda_extra_out_badness
);
1139 /* get the DAC of the primary output corresponding to the given array index */
1140 static hda_nid_t
get_primary_out(struct hda_codec
*codec
, int idx
)
1142 struct hda_gen_spec
*spec
= codec
->spec
;
1143 struct auto_pin_cfg
*cfg
= &spec
->autocfg
;
1145 if (cfg
->line_outs
> idx
)
1146 return spec
->private_dac_nids
[idx
];
1147 idx
-= cfg
->line_outs
;
1148 if (spec
->multi_ios
> idx
)
1149 return spec
->multi_io
[idx
].dac
;
1153 /* return the DAC if it's reachable, otherwise zero */
1154 static inline hda_nid_t
try_dac(struct hda_codec
*codec
,
1155 hda_nid_t dac
, hda_nid_t pin
)
1157 return is_reachable_path(codec
, dac
, pin
) ? dac
: 0;
1160 /* try to assign DACs to pins and return the resultant badness */
1161 static int try_assign_dacs(struct hda_codec
*codec
, int num_outs
,
1162 const hda_nid_t
*pins
, hda_nid_t
*dacs
,
1164 const struct badness_table
*bad
)
1166 struct hda_gen_spec
*spec
= codec
->spec
;
1174 for (i
= 0; i
< num_outs
; i
++) {
1175 struct nid_path
*path
;
1176 hda_nid_t pin
= pins
[i
];
1178 path
= snd_hda_get_path_from_idx(codec
, path_idx
[i
]);
1180 badness
+= assign_out_path_ctls(codec
, path
);
1184 dacs
[i
] = get_preferred_dac(codec
, pin
);
1186 if (is_dac_already_used(codec
, dacs
[i
]))
1187 badness
+= bad
->shared_primary
;
1191 dacs
[i
] = look_for_dac(codec
, pin
, false);
1192 if (!dacs
[i
] && !i
) {
1193 /* try to steal the DAC of surrounds for the front */
1194 for (j
= 1; j
< num_outs
; j
++) {
1195 if (is_reachable_path(codec
, dacs
[j
], pin
)) {
1198 invalidate_nid_path(codec
, path_idx
[j
]);
1207 dac
= try_dac(codec
, get_primary_out(codec
, i
), pin
);
1209 dac
= try_dac(codec
, dacs
[0], pin
);
1211 dac
= try_dac(codec
, get_primary_out(codec
, i
), pin
);
1214 badness
+= bad
->shared_primary
;
1216 badness
+= bad
->shared_surr
;
1218 badness
+= bad
->shared_clfe
;
1219 } else if (is_reachable_path(codec
, spec
->private_dac_nids
[0], pin
)) {
1220 dac
= spec
->private_dac_nids
[0];
1221 badness
+= bad
->shared_surr_main
;
1223 badness
+= bad
->no_primary_dac
;
1225 badness
+= bad
->no_dac
;
1229 path
= snd_hda_add_new_path(codec
, dac
, pin
, -spec
->mixer_nid
);
1230 if (!path
&& !i
&& spec
->mixer_nid
) {
1231 /* try with aamix */
1232 path
= snd_hda_add_new_path(codec
, dac
, pin
, 0);
1236 badness
+= bad
->no_dac
;
1238 /* print_nid_path("output", path); */
1239 path
->active
= true;
1240 path_idx
[i
] = snd_hda_get_path_idx(codec
, path
);
1241 badness
+= assign_out_path_ctls(codec
, path
);
1248 /* return NID if the given pin has only a single connection to a certain DAC */
1249 static hda_nid_t
get_dac_if_single(struct hda_codec
*codec
, hda_nid_t pin
)
1251 struct hda_gen_spec
*spec
= codec
->spec
;
1253 hda_nid_t nid_found
= 0;
1255 for (i
= 0; i
< spec
->num_all_dacs
; i
++) {
1256 hda_nid_t nid
= spec
->all_dacs
[i
];
1257 if (!nid
|| is_dac_already_used(codec
, nid
))
1259 if (is_reachable_path(codec
, nid
, pin
)) {
1268 /* check whether the given pin can be a multi-io pin */
1269 static bool can_be_multiio_pin(struct hda_codec
*codec
,
1270 unsigned int location
, hda_nid_t nid
)
1272 unsigned int defcfg
, caps
;
1274 defcfg
= snd_hda_codec_get_pincfg(codec
, nid
);
1275 if (get_defcfg_connect(defcfg
) != AC_JACK_PORT_COMPLEX
)
1277 if (location
&& get_defcfg_location(defcfg
) != location
)
1279 caps
= snd_hda_query_pin_caps(codec
, nid
);
1280 if (!(caps
& AC_PINCAP_OUT
))
1285 /* count the number of input pins that are capable to be multi-io */
1286 static int count_multiio_pins(struct hda_codec
*codec
, hda_nid_t reference_pin
)
1288 struct hda_gen_spec
*spec
= codec
->spec
;
1289 struct auto_pin_cfg
*cfg
= &spec
->autocfg
;
1290 unsigned int defcfg
= snd_hda_codec_get_pincfg(codec
, reference_pin
);
1291 unsigned int location
= get_defcfg_location(defcfg
);
1295 for (type
= AUTO_PIN_LINE_IN
; type
>= AUTO_PIN_MIC
; type
--) {
1296 for (i
= 0; i
< cfg
->num_inputs
; i
++) {
1297 if (cfg
->inputs
[i
].type
!= type
)
1299 if (can_be_multiio_pin(codec
, location
,
1300 cfg
->inputs
[i
].pin
))
1310 * When hardwired is set, try to fill ony hardwired pins, and returns
1311 * zero if any pins are filled, non-zero if nothing found.
1312 * When hardwired is off, try to fill possible input pins, and returns
1313 * the badness value.
1315 static int fill_multi_ios(struct hda_codec
*codec
,
1316 hda_nid_t reference_pin
,
1319 struct hda_gen_spec
*spec
= codec
->spec
;
1320 struct auto_pin_cfg
*cfg
= &spec
->autocfg
;
1321 int type
, i
, j
, num_pins
, old_pins
;
1322 unsigned int defcfg
= snd_hda_codec_get_pincfg(codec
, reference_pin
);
1323 unsigned int location
= get_defcfg_location(defcfg
);
1325 struct nid_path
*path
;
1327 old_pins
= spec
->multi_ios
;
1331 num_pins
= count_multiio_pins(codec
, reference_pin
);
1335 for (type
= AUTO_PIN_LINE_IN
; type
>= AUTO_PIN_MIC
; type
--) {
1336 for (i
= 0; i
< cfg
->num_inputs
; i
++) {
1337 hda_nid_t nid
= cfg
->inputs
[i
].pin
;
1340 if (cfg
->inputs
[i
].type
!= type
)
1342 if (!can_be_multiio_pin(codec
, location
, nid
))
1344 for (j
= 0; j
< spec
->multi_ios
; j
++) {
1345 if (nid
== spec
->multi_io
[j
].pin
)
1348 if (j
< spec
->multi_ios
)
1352 dac
= get_dac_if_single(codec
, nid
);
1354 dac
= look_for_dac(codec
, nid
, false);
1359 path
= snd_hda_add_new_path(codec
, dac
, nid
,
1365 /* print_nid_path("multiio", path); */
1366 spec
->multi_io
[spec
->multi_ios
].pin
= nid
;
1367 spec
->multi_io
[spec
->multi_ios
].dac
= dac
;
1368 spec
->out_paths
[cfg
->line_outs
+ spec
->multi_ios
] =
1369 snd_hda_get_path_idx(codec
, path
);
1371 if (spec
->multi_ios
>= 2)
1377 badness
= BAD_MULTI_IO
;
1378 if (old_pins
== spec
->multi_ios
) {
1380 return 1; /* nothing found */
1382 return badness
; /* no badness if nothing found */
1384 if (!hardwired
&& spec
->multi_ios
< 2) {
1385 /* cancel newly assigned paths */
1386 spec
->paths
.used
-= spec
->multi_ios
- old_pins
;
1387 spec
->multi_ios
= old_pins
;
1391 /* assign volume and mute controls */
1392 for (i
= old_pins
; i
< spec
->multi_ios
; i
++) {
1393 path
= snd_hda_get_path_from_idx(codec
, spec
->out_paths
[cfg
->line_outs
+ i
]);
1394 badness
+= assign_out_path_ctls(codec
, path
);
1400 /* map DACs for all pins in the list if they are single connections */
1401 static bool map_singles(struct hda_codec
*codec
, int outs
,
1402 const hda_nid_t
*pins
, hda_nid_t
*dacs
, int *path_idx
)
1404 struct hda_gen_spec
*spec
= codec
->spec
;
1407 for (i
= 0; i
< outs
; i
++) {
1408 struct nid_path
*path
;
1412 dac
= get_dac_if_single(codec
, pins
[i
]);
1415 path
= snd_hda_add_new_path(codec
, dac
, pins
[i
],
1417 if (!path
&& !i
&& spec
->mixer_nid
)
1418 path
= snd_hda_add_new_path(codec
, dac
, pins
[i
], 0);
1422 /* print_nid_path("output", path); */
1423 path
->active
= true;
1424 path_idx
[i
] = snd_hda_get_path_idx(codec
, path
);
1430 /* create a new path including aamix if available, and return its index */
1431 static int check_aamix_out_path(struct hda_codec
*codec
, int path_idx
)
1433 struct hda_gen_spec
*spec
= codec
->spec
;
1434 struct nid_path
*path
;
1435 hda_nid_t path_dac
, dac
, pin
;
1437 path
= snd_hda_get_path_from_idx(codec
, path_idx
);
1438 if (!path
|| !path
->depth
||
1439 is_nid_contained(path
, spec
->mixer_nid
))
1441 path_dac
= path
->path
[0];
1442 dac
= spec
->private_dac_nids
[0];
1443 pin
= path
->path
[path
->depth
- 1];
1444 path
= snd_hda_add_new_path(codec
, dac
, pin
, spec
->mixer_nid
);
1446 if (dac
!= path_dac
)
1448 else if (spec
->multiout
.hp_out_nid
[0])
1449 dac
= spec
->multiout
.hp_out_nid
[0];
1450 else if (spec
->multiout
.extra_out_nid
[0])
1451 dac
= spec
->multiout
.extra_out_nid
[0];
1455 path
= snd_hda_add_new_path(codec
, dac
, pin
,
1460 /* print_nid_path("output-aamix", path); */
1461 path
->active
= false; /* unused as default */
1462 return snd_hda_get_path_idx(codec
, path
);
1465 /* check whether the independent HP is available with the current config */
1466 static bool indep_hp_possible(struct hda_codec
*codec
)
1468 struct hda_gen_spec
*spec
= codec
->spec
;
1469 struct auto_pin_cfg
*cfg
= &spec
->autocfg
;
1470 struct nid_path
*path
;
1473 if (cfg
->line_out_type
== AUTO_PIN_HP_OUT
)
1474 idx
= spec
->out_paths
[0];
1476 idx
= spec
->hp_paths
[0];
1477 path
= snd_hda_get_path_from_idx(codec
, idx
);
1481 /* assume no path conflicts unless aamix is involved */
1482 if (!spec
->mixer_nid
|| !is_nid_contained(path
, spec
->mixer_nid
))
1485 /* check whether output paths contain aamix */
1486 for (i
= 0; i
< cfg
->line_outs
; i
++) {
1487 if (spec
->out_paths
[i
] == idx
)
1489 path
= snd_hda_get_path_from_idx(codec
, spec
->out_paths
[i
]);
1490 if (path
&& is_nid_contained(path
, spec
->mixer_nid
))
1493 for (i
= 0; i
< cfg
->speaker_outs
; i
++) {
1494 path
= snd_hda_get_path_from_idx(codec
, spec
->speaker_paths
[i
]);
1495 if (path
&& is_nid_contained(path
, spec
->mixer_nid
))
1502 /* fill the empty entries in the dac array for speaker/hp with the
1503 * shared dac pointed by the paths
1505 static void refill_shared_dacs(struct hda_codec
*codec
, int num_outs
,
1506 hda_nid_t
*dacs
, int *path_idx
)
1508 struct nid_path
*path
;
1511 for (i
= 0; i
< num_outs
; i
++) {
1514 path
= snd_hda_get_path_from_idx(codec
, path_idx
[i
]);
1517 dacs
[i
] = path
->path
[0];
1521 /* fill in the dac_nids table from the parsed pin configuration */
1522 static int fill_and_eval_dacs(struct hda_codec
*codec
,
1523 bool fill_hardwired
,
1524 bool fill_mio_first
)
1526 struct hda_gen_spec
*spec
= codec
->spec
;
1527 struct auto_pin_cfg
*cfg
= &spec
->autocfg
;
1528 int i
, err
, badness
;
1530 /* set num_dacs once to full for look_for_dac() */
1531 spec
->multiout
.num_dacs
= cfg
->line_outs
;
1532 spec
->multiout
.dac_nids
= spec
->private_dac_nids
;
1533 memset(spec
->private_dac_nids
, 0, sizeof(spec
->private_dac_nids
));
1534 memset(spec
->multiout
.hp_out_nid
, 0, sizeof(spec
->multiout
.hp_out_nid
));
1535 memset(spec
->multiout
.extra_out_nid
, 0, sizeof(spec
->multiout
.extra_out_nid
));
1536 spec
->multi_ios
= 0;
1537 snd_array_free(&spec
->paths
);
1539 /* clear path indices */
1540 memset(spec
->out_paths
, 0, sizeof(spec
->out_paths
));
1541 memset(spec
->hp_paths
, 0, sizeof(spec
->hp_paths
));
1542 memset(spec
->speaker_paths
, 0, sizeof(spec
->speaker_paths
));
1543 memset(spec
->aamix_out_paths
, 0, sizeof(spec
->aamix_out_paths
));
1544 memset(spec
->digout_paths
, 0, sizeof(spec
->digout_paths
));
1545 memset(spec
->input_paths
, 0, sizeof(spec
->input_paths
));
1546 memset(spec
->loopback_paths
, 0, sizeof(spec
->loopback_paths
));
1547 memset(&spec
->digin_path
, 0, sizeof(spec
->digin_path
));
1551 /* fill hard-wired DACs first */
1552 if (fill_hardwired
) {
1555 mapped
= map_singles(codec
, cfg
->line_outs
,
1557 spec
->private_dac_nids
,
1559 mapped
|= map_singles(codec
, cfg
->hp_outs
,
1561 spec
->multiout
.hp_out_nid
,
1563 mapped
|= map_singles(codec
, cfg
->speaker_outs
,
1565 spec
->multiout
.extra_out_nid
,
1566 spec
->speaker_paths
);
1567 if (fill_mio_first
&& cfg
->line_outs
== 1 &&
1568 cfg
->line_out_type
!= AUTO_PIN_SPEAKER_OUT
) {
1569 err
= fill_multi_ios(codec
, cfg
->line_out_pins
[0], true);
1576 badness
+= try_assign_dacs(codec
, cfg
->line_outs
, cfg
->line_out_pins
,
1577 spec
->private_dac_nids
, spec
->out_paths
,
1578 spec
->main_out_badness
);
1580 if (fill_mio_first
&&
1581 cfg
->line_outs
== 1 && cfg
->line_out_type
!= AUTO_PIN_SPEAKER_OUT
) {
1582 /* try to fill multi-io first */
1583 err
= fill_multi_ios(codec
, cfg
->line_out_pins
[0], false);
1586 /* we don't count badness at this stage yet */
1589 if (cfg
->line_out_type
!= AUTO_PIN_HP_OUT
) {
1590 err
= try_assign_dacs(codec
, cfg
->hp_outs
, cfg
->hp_pins
,
1591 spec
->multiout
.hp_out_nid
,
1593 spec
->extra_out_badness
);
1598 if (cfg
->line_out_type
!= AUTO_PIN_SPEAKER_OUT
) {
1599 err
= try_assign_dacs(codec
, cfg
->speaker_outs
,
1601 spec
->multiout
.extra_out_nid
,
1602 spec
->speaker_paths
,
1603 spec
->extra_out_badness
);
1608 if (cfg
->line_outs
== 1 && cfg
->line_out_type
!= AUTO_PIN_SPEAKER_OUT
) {
1609 err
= fill_multi_ios(codec
, cfg
->line_out_pins
[0], false);
1615 if (spec
->mixer_nid
) {
1616 spec
->aamix_out_paths
[0] =
1617 check_aamix_out_path(codec
, spec
->out_paths
[0]);
1618 if (cfg
->line_out_type
!= AUTO_PIN_HP_OUT
)
1619 spec
->aamix_out_paths
[1] =
1620 check_aamix_out_path(codec
, spec
->hp_paths
[0]);
1621 if (cfg
->line_out_type
!= AUTO_PIN_SPEAKER_OUT
)
1622 spec
->aamix_out_paths
[2] =
1623 check_aamix_out_path(codec
, spec
->speaker_paths
[0]);
1626 if (cfg
->hp_outs
&& cfg
->line_out_type
== AUTO_PIN_SPEAKER_OUT
)
1627 if (count_multiio_pins(codec
, cfg
->hp_pins
[0]) >= 2)
1628 spec
->multi_ios
= 1; /* give badness */
1630 /* re-count num_dacs and squash invalid entries */
1631 spec
->multiout
.num_dacs
= 0;
1632 for (i
= 0; i
< cfg
->line_outs
; i
++) {
1633 if (spec
->private_dac_nids
[i
])
1634 spec
->multiout
.num_dacs
++;
1636 memmove(spec
->private_dac_nids
+ i
,
1637 spec
->private_dac_nids
+ i
+ 1,
1638 sizeof(hda_nid_t
) * (cfg
->line_outs
- i
- 1));
1639 spec
->private_dac_nids
[cfg
->line_outs
- 1] = 0;
1643 spec
->ext_channel_count
= spec
->min_channel_count
=
1644 spec
->multiout
.num_dacs
* 2;
1646 if (spec
->multi_ios
== 2) {
1647 for (i
= 0; i
< 2; i
++)
1648 spec
->private_dac_nids
[spec
->multiout
.num_dacs
++] =
1649 spec
->multi_io
[i
].dac
;
1650 } else if (spec
->multi_ios
) {
1651 spec
->multi_ios
= 0;
1652 badness
+= BAD_MULTI_IO
;
1655 if (spec
->indep_hp
&& !indep_hp_possible(codec
))
1656 badness
+= BAD_NO_INDEP_HP
;
1658 /* re-fill the shared DAC for speaker / headphone */
1659 if (cfg
->line_out_type
!= AUTO_PIN_HP_OUT
)
1660 refill_shared_dacs(codec
, cfg
->hp_outs
,
1661 spec
->multiout
.hp_out_nid
,
1663 if (cfg
->line_out_type
!= AUTO_PIN_SPEAKER_OUT
)
1664 refill_shared_dacs(codec
, cfg
->speaker_outs
,
1665 spec
->multiout
.extra_out_nid
,
1666 spec
->speaker_paths
);
1671 #define DEBUG_BADNESS
1673 #ifdef DEBUG_BADNESS
1674 #define debug_badness snd_printdd
1676 #define debug_badness(...)
1679 #ifdef DEBUG_BADNESS
1680 static inline void print_nid_path_idx(struct hda_codec
*codec
,
1681 const char *pfx
, int idx
)
1683 struct nid_path
*path
;
1685 path
= snd_hda_get_path_from_idx(codec
, idx
);
1687 print_nid_path(pfx
, path
);
1690 static void debug_show_configs(struct hda_codec
*codec
,
1691 struct auto_pin_cfg
*cfg
)
1693 struct hda_gen_spec
*spec
= codec
->spec
;
1694 static const char * const lo_type
[3] = { "LO", "SP", "HP" };
1697 debug_badness("multi_outs = %x/%x/%x/%x : %x/%x/%x/%x (type %s)\n",
1698 cfg
->line_out_pins
[0], cfg
->line_out_pins
[1],
1699 cfg
->line_out_pins
[2], cfg
->line_out_pins
[3],
1700 spec
->multiout
.dac_nids
[0],
1701 spec
->multiout
.dac_nids
[1],
1702 spec
->multiout
.dac_nids
[2],
1703 spec
->multiout
.dac_nids
[3],
1704 lo_type
[cfg
->line_out_type
]);
1705 for (i
= 0; i
< cfg
->line_outs
; i
++)
1706 print_nid_path_idx(codec
, " out", spec
->out_paths
[i
]);
1707 if (spec
->multi_ios
> 0)
1708 debug_badness("multi_ios(%d) = %x/%x : %x/%x\n",
1710 spec
->multi_io
[0].pin
, spec
->multi_io
[1].pin
,
1711 spec
->multi_io
[0].dac
, spec
->multi_io
[1].dac
);
1712 for (i
= 0; i
< spec
->multi_ios
; i
++)
1713 print_nid_path_idx(codec
, " mio",
1714 spec
->out_paths
[cfg
->line_outs
+ i
]);
1716 debug_badness("hp_outs = %x/%x/%x/%x : %x/%x/%x/%x\n",
1717 cfg
->hp_pins
[0], cfg
->hp_pins
[1],
1718 cfg
->hp_pins
[2], cfg
->hp_pins
[3],
1719 spec
->multiout
.hp_out_nid
[0],
1720 spec
->multiout
.hp_out_nid
[1],
1721 spec
->multiout
.hp_out_nid
[2],
1722 spec
->multiout
.hp_out_nid
[3]);
1723 for (i
= 0; i
< cfg
->hp_outs
; i
++)
1724 print_nid_path_idx(codec
, " hp ", spec
->hp_paths
[i
]);
1725 if (cfg
->speaker_outs
)
1726 debug_badness("spk_outs = %x/%x/%x/%x : %x/%x/%x/%x\n",
1727 cfg
->speaker_pins
[0], cfg
->speaker_pins
[1],
1728 cfg
->speaker_pins
[2], cfg
->speaker_pins
[3],
1729 spec
->multiout
.extra_out_nid
[0],
1730 spec
->multiout
.extra_out_nid
[1],
1731 spec
->multiout
.extra_out_nid
[2],
1732 spec
->multiout
.extra_out_nid
[3]);
1733 for (i
= 0; i
< cfg
->speaker_outs
; i
++)
1734 print_nid_path_idx(codec
, " spk", spec
->speaker_paths
[i
]);
1735 for (i
= 0; i
< 3; i
++)
1736 print_nid_path_idx(codec
, " mix", spec
->aamix_out_paths
[i
]);
1739 #define debug_show_configs(codec, cfg) /* NOP */
1742 /* find all available DACs of the codec */
1743 static void fill_all_dac_nids(struct hda_codec
*codec
)
1745 struct hda_gen_spec
*spec
= codec
->spec
;
1747 hda_nid_t nid
= codec
->start_nid
;
1749 spec
->num_all_dacs
= 0;
1750 memset(spec
->all_dacs
, 0, sizeof(spec
->all_dacs
));
1751 for (i
= 0; i
< codec
->num_nodes
; i
++, nid
++) {
1752 if (get_wcaps_type(get_wcaps(codec
, nid
)) != AC_WID_AUD_OUT
)
1754 if (spec
->num_all_dacs
>= ARRAY_SIZE(spec
->all_dacs
)) {
1755 snd_printk(KERN_ERR
"hda: Too many DACs!\n");
1758 spec
->all_dacs
[spec
->num_all_dacs
++] = nid
;
1762 static int parse_output_paths(struct hda_codec
*codec
)
1764 struct hda_gen_spec
*spec
= codec
->spec
;
1765 struct auto_pin_cfg
*cfg
= &spec
->autocfg
;
1766 struct auto_pin_cfg
*best_cfg
;
1768 int best_badness
= INT_MAX
;
1770 bool fill_hardwired
= true, fill_mio_first
= true;
1771 bool best_wired
= true, best_mio
= true;
1772 bool hp_spk_swapped
= false;
1774 best_cfg
= kmalloc(sizeof(*best_cfg
), GFP_KERNEL
);
1780 badness
= fill_and_eval_dacs(codec
, fill_hardwired
,
1786 debug_badness("==> lo_type=%d, wired=%d, mio=%d, badness=0x%x\n",
1787 cfg
->line_out_type
, fill_hardwired
, fill_mio_first
,
1789 debug_show_configs(codec
, cfg
);
1790 if (badness
< best_badness
) {
1791 best_badness
= badness
;
1793 best_wired
= fill_hardwired
;
1794 best_mio
= fill_mio_first
;
1798 fill_mio_first
= !fill_mio_first
;
1799 if (!fill_mio_first
)
1801 fill_hardwired
= !fill_hardwired
;
1802 if (!fill_hardwired
)
1806 hp_spk_swapped
= true;
1807 if (cfg
->speaker_outs
> 0 &&
1808 cfg
->line_out_type
== AUTO_PIN_HP_OUT
) {
1809 cfg
->hp_outs
= cfg
->line_outs
;
1810 memcpy(cfg
->hp_pins
, cfg
->line_out_pins
,
1811 sizeof(cfg
->hp_pins
));
1812 cfg
->line_outs
= cfg
->speaker_outs
;
1813 memcpy(cfg
->line_out_pins
, cfg
->speaker_pins
,
1814 sizeof(cfg
->speaker_pins
));
1815 cfg
->speaker_outs
= 0;
1816 memset(cfg
->speaker_pins
, 0, sizeof(cfg
->speaker_pins
));
1817 cfg
->line_out_type
= AUTO_PIN_SPEAKER_OUT
;
1818 fill_hardwired
= true;
1821 if (cfg
->hp_outs
> 0 &&
1822 cfg
->line_out_type
== AUTO_PIN_SPEAKER_OUT
) {
1823 cfg
->speaker_outs
= cfg
->line_outs
;
1824 memcpy(cfg
->speaker_pins
, cfg
->line_out_pins
,
1825 sizeof(cfg
->speaker_pins
));
1826 cfg
->line_outs
= cfg
->hp_outs
;
1827 memcpy(cfg
->line_out_pins
, cfg
->hp_pins
,
1828 sizeof(cfg
->hp_pins
));
1830 memset(cfg
->hp_pins
, 0, sizeof(cfg
->hp_pins
));
1831 cfg
->line_out_type
= AUTO_PIN_HP_OUT
;
1832 fill_hardwired
= true;
1839 debug_badness("==> restoring best_cfg\n");
1841 fill_and_eval_dacs(codec
, best_wired
, best_mio
);
1843 debug_badness("==> Best config: lo_type=%d, wired=%d, mio=%d\n",
1844 cfg
->line_out_type
, best_wired
, best_mio
);
1845 debug_show_configs(codec
, cfg
);
1847 if (cfg
->line_out_pins
[0]) {
1848 struct nid_path
*path
;
1849 path
= snd_hda_get_path_from_idx(codec
, spec
->out_paths
[0]);
1851 spec
->vmaster_nid
= look_for_out_vol_nid(codec
, path
);
1852 if (spec
->vmaster_nid
)
1853 snd_hda_set_vmaster_tlv(codec
, spec
->vmaster_nid
,
1854 HDA_OUTPUT
, spec
->vmaster_tlv
);
1857 /* set initial pinctl targets */
1858 if (spec
->prefer_hp_amp
|| cfg
->line_out_type
== AUTO_PIN_HP_OUT
)
1862 set_pin_targets(codec
, cfg
->line_outs
, cfg
->line_out_pins
, val
);
1863 if (cfg
->line_out_type
!= AUTO_PIN_HP_OUT
)
1864 set_pin_targets(codec
, cfg
->hp_outs
, cfg
->hp_pins
, PIN_HP
);
1865 if (cfg
->line_out_type
!= AUTO_PIN_SPEAKER_OUT
) {
1866 val
= spec
->prefer_hp_amp
? PIN_HP
: PIN_OUT
;
1867 set_pin_targets(codec
, cfg
->speaker_outs
,
1868 cfg
->speaker_pins
, val
);
1871 /* clear indep_hp flag if not available */
1872 if (spec
->indep_hp
&& !indep_hp_possible(codec
))
1879 /* add playback controls from the parsed DAC table */
1880 static int create_multi_out_ctls(struct hda_codec
*codec
,
1881 const struct auto_pin_cfg
*cfg
)
1883 struct hda_gen_spec
*spec
= codec
->spec
;
1884 int i
, err
, noutputs
;
1886 noutputs
= cfg
->line_outs
;
1887 if (spec
->multi_ios
> 0 && cfg
->line_outs
< 3)
1888 noutputs
+= spec
->multi_ios
;
1890 for (i
= 0; i
< noutputs
; i
++) {
1893 struct nid_path
*path
;
1895 path
= snd_hda_get_path_from_idx(codec
, spec
->out_paths
[i
]);
1899 name
= get_line_out_pfx(codec
, i
, &index
, NID_PATH_VOL_CTL
);
1900 if (!name
|| !strcmp(name
, "CLFE")) {
1902 err
= add_vol_ctl(codec
, "Center", 0, 1, path
);
1905 err
= add_vol_ctl(codec
, "LFE", 0, 2, path
);
1909 err
= add_stereo_vol(codec
, name
, index
, path
);
1914 name
= get_line_out_pfx(codec
, i
, &index
, NID_PATH_MUTE_CTL
);
1915 if (!name
|| !strcmp(name
, "CLFE")) {
1916 err
= add_sw_ctl(codec
, "Center", 0, 1, path
);
1919 err
= add_sw_ctl(codec
, "LFE", 0, 2, path
);
1923 err
= add_stereo_sw(codec
, name
, index
, path
);
1931 static int create_extra_out(struct hda_codec
*codec
, int path_idx
,
1932 const char *pfx
, int cidx
)
1934 struct nid_path
*path
;
1937 path
= snd_hda_get_path_from_idx(codec
, path_idx
);
1940 err
= add_stereo_vol(codec
, pfx
, cidx
, path
);
1943 err
= add_stereo_sw(codec
, pfx
, cidx
, path
);
1949 /* add playback controls for speaker and HP outputs */
1950 static int create_extra_outs(struct hda_codec
*codec
, int num_pins
,
1951 const int *paths
, const char *pfx
)
1955 for (i
= 0; i
< num_pins
; i
++) {
1960 if (num_pins
== 2 && i
== 1 && !strcmp(pfx
, "Speaker"))
1961 name
= "Bass Speaker";
1962 else if (num_pins
>= 3) {
1963 snprintf(tmp
, sizeof(tmp
), "%s %s",
1964 pfx
, channel_name
[i
]);
1970 err
= create_extra_out(codec
, paths
[i
], name
, idx
);
1977 static int create_hp_out_ctls(struct hda_codec
*codec
)
1979 struct hda_gen_spec
*spec
= codec
->spec
;
1980 return create_extra_outs(codec
, spec
->autocfg
.hp_outs
,
1985 static int create_speaker_out_ctls(struct hda_codec
*codec
)
1987 struct hda_gen_spec
*spec
= codec
->spec
;
1988 return create_extra_outs(codec
, spec
->autocfg
.speaker_outs
,
1989 spec
->speaker_paths
,
1994 * independent HP controls
1997 static void call_hp_automute(struct hda_codec
*codec
, struct hda_jack_tbl
*jack
);
1998 static int indep_hp_info(struct snd_kcontrol
*kcontrol
,
1999 struct snd_ctl_elem_info
*uinfo
)
2001 return snd_hda_enum_bool_helper_info(kcontrol
, uinfo
);
2004 static int indep_hp_get(struct snd_kcontrol
*kcontrol
,
2005 struct snd_ctl_elem_value
*ucontrol
)
2007 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
2008 struct hda_gen_spec
*spec
= codec
->spec
;
2009 ucontrol
->value
.enumerated
.item
[0] = spec
->indep_hp_enabled
;
2013 static void update_aamix_paths(struct hda_codec
*codec
, bool do_mix
,
2014 int nomix_path_idx
, int mix_path_idx
,
2017 static int indep_hp_put(struct snd_kcontrol
*kcontrol
,
2018 struct snd_ctl_elem_value
*ucontrol
)
2020 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
2021 struct hda_gen_spec
*spec
= codec
->spec
;
2022 unsigned int select
= ucontrol
->value
.enumerated
.item
[0];
2025 mutex_lock(&spec
->pcm_mutex
);
2026 if (spec
->active_streams
) {
2031 if (spec
->indep_hp_enabled
!= select
) {
2033 if (spec
->autocfg
.line_out_type
== AUTO_PIN_HP_OUT
)
2034 dacp
= &spec
->private_dac_nids
[0];
2036 dacp
= &spec
->multiout
.hp_out_nid
[0];
2038 /* update HP aamix paths in case it conflicts with indep HP */
2039 if (spec
->have_aamix_ctl
) {
2040 if (spec
->autocfg
.line_out_type
== AUTO_PIN_HP_OUT
)
2041 update_aamix_paths(codec
, spec
->aamix_mode
,
2043 spec
->aamix_out_paths
[0],
2044 spec
->autocfg
.line_out_type
);
2046 update_aamix_paths(codec
, spec
->aamix_mode
,
2048 spec
->aamix_out_paths
[1],
2052 spec
->indep_hp_enabled
= select
;
2053 if (spec
->indep_hp_enabled
)
2056 *dacp
= spec
->alt_dac_nid
;
2058 call_hp_automute(codec
, NULL
);
2062 mutex_unlock(&spec
->pcm_mutex
);
2066 static const struct snd_kcontrol_new indep_hp_ctl
= {
2067 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
2068 .name
= "Independent HP",
2069 .info
= indep_hp_info
,
2070 .get
= indep_hp_get
,
2071 .put
= indep_hp_put
,
2075 static int create_indep_hp_ctls(struct hda_codec
*codec
)
2077 struct hda_gen_spec
*spec
= codec
->spec
;
2080 if (!spec
->indep_hp
)
2082 if (spec
->autocfg
.line_out_type
== AUTO_PIN_HP_OUT
)
2083 dac
= spec
->multiout
.dac_nids
[0];
2085 dac
= spec
->multiout
.hp_out_nid
[0];
2091 spec
->indep_hp_enabled
= false;
2092 spec
->alt_dac_nid
= dac
;
2093 if (!snd_hda_gen_add_kctl(spec
, NULL
, &indep_hp_ctl
))
2099 * channel mode enum control
2102 static int ch_mode_info(struct snd_kcontrol
*kcontrol
,
2103 struct snd_ctl_elem_info
*uinfo
)
2105 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
2106 struct hda_gen_spec
*spec
= codec
->spec
;
2109 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_ENUMERATED
;
2111 uinfo
->value
.enumerated
.items
= spec
->multi_ios
+ 1;
2112 if (uinfo
->value
.enumerated
.item
> spec
->multi_ios
)
2113 uinfo
->value
.enumerated
.item
= spec
->multi_ios
;
2114 chs
= uinfo
->value
.enumerated
.item
* 2 + spec
->min_channel_count
;
2115 sprintf(uinfo
->value
.enumerated
.name
, "%dch", chs
);
2119 static int ch_mode_get(struct snd_kcontrol
*kcontrol
,
2120 struct snd_ctl_elem_value
*ucontrol
)
2122 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
2123 struct hda_gen_spec
*spec
= codec
->spec
;
2124 ucontrol
->value
.enumerated
.item
[0] =
2125 (spec
->ext_channel_count
- spec
->min_channel_count
) / 2;
2129 static inline struct nid_path
*
2130 get_multiio_path(struct hda_codec
*codec
, int idx
)
2132 struct hda_gen_spec
*spec
= codec
->spec
;
2133 return snd_hda_get_path_from_idx(codec
,
2134 spec
->out_paths
[spec
->autocfg
.line_outs
+ idx
]);
2137 static void update_automute_all(struct hda_codec
*codec
);
2139 /* Default value to be passed as aamix argument for snd_hda_activate_path();
2140 * used for output paths
2142 static bool aamix_default(struct hda_gen_spec
*spec
)
2144 return !spec
->have_aamix_ctl
|| spec
->aamix_mode
;
2147 static int set_multi_io(struct hda_codec
*codec
, int idx
, bool output
)
2149 struct hda_gen_spec
*spec
= codec
->spec
;
2150 hda_nid_t nid
= spec
->multi_io
[idx
].pin
;
2151 struct nid_path
*path
;
2153 path
= get_multiio_path(codec
, idx
);
2157 if (path
->active
== output
)
2161 set_pin_target(codec
, nid
, PIN_OUT
, true);
2162 snd_hda_activate_path(codec
, path
, true, aamix_default(spec
));
2163 set_pin_eapd(codec
, nid
, true);
2165 set_pin_eapd(codec
, nid
, false);
2166 snd_hda_activate_path(codec
, path
, false, aamix_default(spec
));
2167 set_pin_target(codec
, nid
, spec
->multi_io
[idx
].ctl_in
, true);
2168 path_power_down_sync(codec
, path
);
2171 /* update jack retasking in case it modifies any of them */
2172 update_automute_all(codec
);
2177 static int ch_mode_put(struct snd_kcontrol
*kcontrol
,
2178 struct snd_ctl_elem_value
*ucontrol
)
2180 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
2181 struct hda_gen_spec
*spec
= codec
->spec
;
2184 ch
= ucontrol
->value
.enumerated
.item
[0];
2185 if (ch
< 0 || ch
> spec
->multi_ios
)
2187 if (ch
== (spec
->ext_channel_count
- spec
->min_channel_count
) / 2)
2189 spec
->ext_channel_count
= ch
* 2 + spec
->min_channel_count
;
2190 for (i
= 0; i
< spec
->multi_ios
; i
++)
2191 set_multi_io(codec
, i
, i
< ch
);
2192 spec
->multiout
.max_channels
= max(spec
->ext_channel_count
,
2193 spec
->const_channel_count
);
2194 if (spec
->need_dac_fix
)
2195 spec
->multiout
.num_dacs
= spec
->multiout
.max_channels
/ 2;
2199 static const struct snd_kcontrol_new channel_mode_enum
= {
2200 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
2201 .name
= "Channel Mode",
2202 .info
= ch_mode_info
,
2207 static int create_multi_channel_mode(struct hda_codec
*codec
)
2209 struct hda_gen_spec
*spec
= codec
->spec
;
2211 if (spec
->multi_ios
> 0) {
2212 if (!snd_hda_gen_add_kctl(spec
, NULL
, &channel_mode_enum
))
2219 * aamix loopback enable/disable switch
2222 #define loopback_mixing_info indep_hp_info
2224 static int loopback_mixing_get(struct snd_kcontrol
*kcontrol
,
2225 struct snd_ctl_elem_value
*ucontrol
)
2227 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
2228 struct hda_gen_spec
*spec
= codec
->spec
;
2229 ucontrol
->value
.enumerated
.item
[0] = spec
->aamix_mode
;
2233 static void update_aamix_paths(struct hda_codec
*codec
, bool do_mix
,
2234 int nomix_path_idx
, int mix_path_idx
,
2237 struct hda_gen_spec
*spec
= codec
->spec
;
2238 struct nid_path
*nomix_path
, *mix_path
;
2240 nomix_path
= snd_hda_get_path_from_idx(codec
, nomix_path_idx
);
2241 mix_path
= snd_hda_get_path_from_idx(codec
, mix_path_idx
);
2242 if (!nomix_path
|| !mix_path
)
2245 /* if HP aamix path is driven from a different DAC and the
2246 * independent HP mode is ON, can't turn on aamix path
2248 if (out_type
== AUTO_PIN_HP_OUT
&& spec
->indep_hp_enabled
&&
2249 mix_path
->path
[0] != spec
->alt_dac_nid
)
2253 snd_hda_activate_path(codec
, nomix_path
, false, true);
2254 snd_hda_activate_path(codec
, mix_path
, true, true);
2255 path_power_down_sync(codec
, nomix_path
);
2257 snd_hda_activate_path(codec
, mix_path
, false, false);
2258 snd_hda_activate_path(codec
, nomix_path
, true, false);
2259 path_power_down_sync(codec
, mix_path
);
2263 static int loopback_mixing_put(struct snd_kcontrol
*kcontrol
,
2264 struct snd_ctl_elem_value
*ucontrol
)
2266 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
2267 struct hda_gen_spec
*spec
= codec
->spec
;
2268 unsigned int val
= ucontrol
->value
.enumerated
.item
[0];
2270 if (val
== spec
->aamix_mode
)
2272 spec
->aamix_mode
= val
;
2273 update_aamix_paths(codec
, val
, spec
->out_paths
[0],
2274 spec
->aamix_out_paths
[0],
2275 spec
->autocfg
.line_out_type
);
2276 update_aamix_paths(codec
, val
, spec
->hp_paths
[0],
2277 spec
->aamix_out_paths
[1],
2279 update_aamix_paths(codec
, val
, spec
->speaker_paths
[0],
2280 spec
->aamix_out_paths
[2],
2281 AUTO_PIN_SPEAKER_OUT
);
2285 static const struct snd_kcontrol_new loopback_mixing_enum
= {
2286 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
2287 .name
= "Loopback Mixing",
2288 .info
= loopback_mixing_info
,
2289 .get
= loopback_mixing_get
,
2290 .put
= loopback_mixing_put
,
2293 static int create_loopback_mixing_ctl(struct hda_codec
*codec
)
2295 struct hda_gen_spec
*spec
= codec
->spec
;
2297 if (!spec
->mixer_nid
)
2299 if (!(spec
->aamix_out_paths
[0] || spec
->aamix_out_paths
[1] ||
2300 spec
->aamix_out_paths
[2]))
2302 if (!snd_hda_gen_add_kctl(spec
, NULL
, &loopback_mixing_enum
))
2304 spec
->have_aamix_ctl
= 1;
2309 * shared headphone/mic handling
2312 static void call_update_outputs(struct hda_codec
*codec
);
2314 /* for shared I/O, change the pin-control accordingly */
2315 static void update_hp_mic(struct hda_codec
*codec
, int adc_mux
, bool force
)
2317 struct hda_gen_spec
*spec
= codec
->spec
;
2322 pin
= spec
->hp_mic_pin
;
2323 as_mic
= spec
->cur_mux
[adc_mux
] == spec
->hp_mic_mux_idx
;
2326 val
= snd_hda_codec_get_pin_target(codec
, pin
);
2336 val
= snd_hda_get_default_vref(codec
, pin
);
2337 /* if the HP pin doesn't support VREF and the codec driver gives an
2338 * alternative pin, set up the VREF on that pin instead
2340 if (val
== AC_PINCTL_VREF_HIZ
&& spec
->shared_mic_vref_pin
) {
2341 const hda_nid_t vref_pin
= spec
->shared_mic_vref_pin
;
2342 unsigned int vref_val
= snd_hda_get_default_vref(codec
, vref_pin
);
2343 if (vref_val
!= AC_PINCTL_VREF_HIZ
)
2344 snd_hda_set_pin_ctl_cache(codec
, vref_pin
,
2345 PIN_IN
| (as_mic
? vref_val
: 0));
2348 if (!spec
->hp_mic_jack_modes
) {
2353 set_pin_target(codec
, pin
, val
, true);
2354 call_hp_automute(codec
, NULL
);
2358 /* create a shared input with the headphone out */
2359 static int create_hp_mic(struct hda_codec
*codec
)
2361 struct hda_gen_spec
*spec
= codec
->spec
;
2362 struct auto_pin_cfg
*cfg
= &spec
->autocfg
;
2363 unsigned int defcfg
;
2366 if (!spec
->hp_mic
) {
2367 if (spec
->suppress_hp_mic_detect
)
2369 /* automatic detection: only if no input or a single internal
2370 * input pin is found, try to detect the shared hp/mic
2372 if (cfg
->num_inputs
> 1)
2374 else if (cfg
->num_inputs
== 1) {
2375 defcfg
= snd_hda_codec_get_pincfg(codec
, cfg
->inputs
[0].pin
);
2376 if (snd_hda_get_input_pin_attr(defcfg
) != INPUT_PIN_ATTR_INT
)
2381 spec
->hp_mic
= 0; /* clear once */
2382 if (cfg
->num_inputs
>= AUTO_CFG_MAX_INS
)
2386 if (cfg
->line_out_type
== AUTO_PIN_HP_OUT
&& cfg
->line_outs
> 0)
2387 nid
= cfg
->line_out_pins
[0];
2388 else if (cfg
->hp_outs
> 0)
2389 nid
= cfg
->hp_pins
[0];
2393 if (!(snd_hda_query_pin_caps(codec
, nid
) & AC_PINCAP_IN
))
2394 return 0; /* no input */
2396 cfg
->inputs
[cfg
->num_inputs
].pin
= nid
;
2397 cfg
->inputs
[cfg
->num_inputs
].type
= AUTO_PIN_MIC
;
2398 cfg
->inputs
[cfg
->num_inputs
].is_headphone_mic
= 1;
2401 spec
->hp_mic_pin
= nid
;
2402 /* we can't handle auto-mic together with HP-mic */
2403 spec
->suppress_auto_mic
= 1;
2404 snd_printdd("hda-codec: Enable shared I/O jack on NID 0x%x\n", nid
);
2412 static int create_hp_mic_jack_mode(struct hda_codec
*codec
, hda_nid_t pin
);
2414 static const char * const out_jack_texts
[] = {
2415 "Line Out", "Headphone Out",
2418 static int out_jack_mode_info(struct snd_kcontrol
*kcontrol
,
2419 struct snd_ctl_elem_info
*uinfo
)
2421 return snd_hda_enum_helper_info(kcontrol
, uinfo
, 2, out_jack_texts
);
2424 static int out_jack_mode_get(struct snd_kcontrol
*kcontrol
,
2425 struct snd_ctl_elem_value
*ucontrol
)
2427 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
2428 hda_nid_t nid
= kcontrol
->private_value
;
2429 if (snd_hda_codec_get_pin_target(codec
, nid
) == PIN_HP
)
2430 ucontrol
->value
.enumerated
.item
[0] = 1;
2432 ucontrol
->value
.enumerated
.item
[0] = 0;
2436 static int out_jack_mode_put(struct snd_kcontrol
*kcontrol
,
2437 struct snd_ctl_elem_value
*ucontrol
)
2439 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
2440 hda_nid_t nid
= kcontrol
->private_value
;
2443 val
= ucontrol
->value
.enumerated
.item
[0] ? PIN_HP
: PIN_OUT
;
2444 if (snd_hda_codec_get_pin_target(codec
, nid
) == val
)
2446 snd_hda_set_pin_ctl_cache(codec
, nid
, val
);
2450 static const struct snd_kcontrol_new out_jack_mode_enum
= {
2451 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
2452 .info
= out_jack_mode_info
,
2453 .get
= out_jack_mode_get
,
2454 .put
= out_jack_mode_put
,
2457 static bool find_kctl_name(struct hda_codec
*codec
, const char *name
, int idx
)
2459 struct hda_gen_spec
*spec
= codec
->spec
;
2462 for (i
= 0; i
< spec
->kctls
.used
; i
++) {
2463 struct snd_kcontrol_new
*kctl
= snd_array_elem(&spec
->kctls
, i
);
2464 if (!strcmp(kctl
->name
, name
) && kctl
->index
== idx
)
2470 static void get_jack_mode_name(struct hda_codec
*codec
, hda_nid_t pin
,
2471 char *name
, size_t name_len
)
2473 struct hda_gen_spec
*spec
= codec
->spec
;
2476 snd_hda_get_pin_label(codec
, pin
, &spec
->autocfg
, name
, name_len
, &idx
);
2477 strlcat(name
, " Jack Mode", name_len
);
2479 for (; find_kctl_name(codec
, name
, idx
); idx
++)
2483 static int get_out_jack_num_items(struct hda_codec
*codec
, hda_nid_t pin
)
2485 struct hda_gen_spec
*spec
= codec
->spec
;
2486 if (spec
->add_jack_modes
) {
2487 unsigned int pincap
= snd_hda_query_pin_caps(codec
, pin
);
2488 if ((pincap
& AC_PINCAP_OUT
) && (pincap
& AC_PINCAP_HP_DRV
))
2494 static int create_out_jack_modes(struct hda_codec
*codec
, int num_pins
,
2497 struct hda_gen_spec
*spec
= codec
->spec
;
2500 for (i
= 0; i
< num_pins
; i
++) {
2501 hda_nid_t pin
= pins
[i
];
2502 if (pin
== spec
->hp_mic_pin
)
2504 if (get_out_jack_num_items(codec
, pin
) > 1) {
2505 struct snd_kcontrol_new
*knew
;
2507 get_jack_mode_name(codec
, pin
, name
, sizeof(name
));
2508 knew
= snd_hda_gen_add_kctl(spec
, name
,
2509 &out_jack_mode_enum
);
2512 knew
->private_value
= pin
;
2523 /* from AC_PINCTL_VREF_HIZ to AC_PINCTL_VREF_100 */
2526 static const char * const vref_texts
[NUM_VREFS
] = {
2527 "Line In", "Mic 50pc Bias", "Mic 0V Bias",
2528 "", "Mic 80pc Bias", "Mic 100pc Bias"
2531 static unsigned int get_vref_caps(struct hda_codec
*codec
, hda_nid_t pin
)
2533 unsigned int pincap
;
2535 pincap
= snd_hda_query_pin_caps(codec
, pin
);
2536 pincap
= (pincap
& AC_PINCAP_VREF
) >> AC_PINCAP_VREF_SHIFT
;
2537 /* filter out unusual vrefs */
2538 pincap
&= ~(AC_PINCAP_VREF_GRD
| AC_PINCAP_VREF_100
);
2542 /* convert from the enum item index to the vref ctl index (0=HIZ, 1=50%...) */
2543 static int get_vref_idx(unsigned int vref_caps
, unsigned int item_idx
)
2545 unsigned int i
, n
= 0;
2547 for (i
= 0; i
< NUM_VREFS
; i
++) {
2548 if (vref_caps
& (1 << i
)) {
2557 /* convert back from the vref ctl index to the enum item index */
2558 static int cvt_from_vref_idx(unsigned int vref_caps
, unsigned int idx
)
2560 unsigned int i
, n
= 0;
2562 for (i
= 0; i
< NUM_VREFS
; i
++) {
2565 if (vref_caps
& (1 << i
))
2571 static int in_jack_mode_info(struct snd_kcontrol
*kcontrol
,
2572 struct snd_ctl_elem_info
*uinfo
)
2574 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
2575 hda_nid_t nid
= kcontrol
->private_value
;
2576 unsigned int vref_caps
= get_vref_caps(codec
, nid
);
2578 snd_hda_enum_helper_info(kcontrol
, uinfo
, hweight32(vref_caps
),
2580 /* set the right text */
2581 strcpy(uinfo
->value
.enumerated
.name
,
2582 vref_texts
[get_vref_idx(vref_caps
, uinfo
->value
.enumerated
.item
)]);
2586 static int in_jack_mode_get(struct snd_kcontrol
*kcontrol
,
2587 struct snd_ctl_elem_value
*ucontrol
)
2589 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
2590 hda_nid_t nid
= kcontrol
->private_value
;
2591 unsigned int vref_caps
= get_vref_caps(codec
, nid
);
2594 idx
= snd_hda_codec_get_pin_target(codec
, nid
) & AC_PINCTL_VREFEN
;
2595 ucontrol
->value
.enumerated
.item
[0] = cvt_from_vref_idx(vref_caps
, idx
);
2599 static int in_jack_mode_put(struct snd_kcontrol
*kcontrol
,
2600 struct snd_ctl_elem_value
*ucontrol
)
2602 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
2603 hda_nid_t nid
= kcontrol
->private_value
;
2604 unsigned int vref_caps
= get_vref_caps(codec
, nid
);
2605 unsigned int val
, idx
;
2607 val
= snd_hda_codec_get_pin_target(codec
, nid
);
2608 idx
= cvt_from_vref_idx(vref_caps
, val
& AC_PINCTL_VREFEN
);
2609 if (idx
== ucontrol
->value
.enumerated
.item
[0])
2612 val
&= ~AC_PINCTL_VREFEN
;
2613 val
|= get_vref_idx(vref_caps
, ucontrol
->value
.enumerated
.item
[0]);
2614 snd_hda_set_pin_ctl_cache(codec
, nid
, val
);
2618 static const struct snd_kcontrol_new in_jack_mode_enum
= {
2619 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
2620 .info
= in_jack_mode_info
,
2621 .get
= in_jack_mode_get
,
2622 .put
= in_jack_mode_put
,
2625 static int get_in_jack_num_items(struct hda_codec
*codec
, hda_nid_t pin
)
2627 struct hda_gen_spec
*spec
= codec
->spec
;
2629 if (spec
->add_jack_modes
)
2630 nitems
= hweight32(get_vref_caps(codec
, pin
));
2631 return nitems
? nitems
: 1;
2634 static int create_in_jack_mode(struct hda_codec
*codec
, hda_nid_t pin
)
2636 struct hda_gen_spec
*spec
= codec
->spec
;
2637 struct snd_kcontrol_new
*knew
;
2639 unsigned int defcfg
;
2641 if (pin
== spec
->hp_mic_pin
)
2642 return 0; /* already done in create_out_jack_mode() */
2644 /* no jack mode for fixed pins */
2645 defcfg
= snd_hda_codec_get_pincfg(codec
, pin
);
2646 if (snd_hda_get_input_pin_attr(defcfg
) == INPUT_PIN_ATTR_INT
)
2649 /* no multiple vref caps? */
2650 if (get_in_jack_num_items(codec
, pin
) <= 1)
2653 get_jack_mode_name(codec
, pin
, name
, sizeof(name
));
2654 knew
= snd_hda_gen_add_kctl(spec
, name
, &in_jack_mode_enum
);
2657 knew
->private_value
= pin
;
2662 * HP/mic shared jack mode
2664 static int hp_mic_jack_mode_info(struct snd_kcontrol
*kcontrol
,
2665 struct snd_ctl_elem_info
*uinfo
)
2667 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
2668 hda_nid_t nid
= kcontrol
->private_value
;
2669 int out_jacks
= get_out_jack_num_items(codec
, nid
);
2670 int in_jacks
= get_in_jack_num_items(codec
, nid
);
2671 const char *text
= NULL
;
2674 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_ENUMERATED
;
2676 uinfo
->value
.enumerated
.items
= out_jacks
+ in_jacks
;
2677 if (uinfo
->value
.enumerated
.item
>= uinfo
->value
.enumerated
.items
)
2678 uinfo
->value
.enumerated
.item
= uinfo
->value
.enumerated
.items
- 1;
2679 idx
= uinfo
->value
.enumerated
.item
;
2680 if (idx
< out_jacks
) {
2682 text
= out_jack_texts
[idx
];
2684 text
= "Headphone Out";
2688 unsigned int vref_caps
= get_vref_caps(codec
, nid
);
2689 text
= vref_texts
[get_vref_idx(vref_caps
, idx
)];
2694 strcpy(uinfo
->value
.enumerated
.name
, text
);
2698 static int get_cur_hp_mic_jack_mode(struct hda_codec
*codec
, hda_nid_t nid
)
2700 int out_jacks
= get_out_jack_num_items(codec
, nid
);
2701 int in_jacks
= get_in_jack_num_items(codec
, nid
);
2702 unsigned int val
= snd_hda_codec_get_pin_target(codec
, nid
);
2705 if (val
& PIN_OUT
) {
2706 if (out_jacks
> 1 && val
== PIN_HP
)
2708 } else if (val
& PIN_IN
) {
2711 unsigned int vref_caps
= get_vref_caps(codec
, nid
);
2712 val
&= AC_PINCTL_VREFEN
;
2713 idx
+= cvt_from_vref_idx(vref_caps
, val
);
2719 static int hp_mic_jack_mode_get(struct snd_kcontrol
*kcontrol
,
2720 struct snd_ctl_elem_value
*ucontrol
)
2722 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
2723 hda_nid_t nid
= kcontrol
->private_value
;
2724 ucontrol
->value
.enumerated
.item
[0] =
2725 get_cur_hp_mic_jack_mode(codec
, nid
);
2729 static int hp_mic_jack_mode_put(struct snd_kcontrol
*kcontrol
,
2730 struct snd_ctl_elem_value
*ucontrol
)
2732 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
2733 hda_nid_t nid
= kcontrol
->private_value
;
2734 int out_jacks
= get_out_jack_num_items(codec
, nid
);
2735 int in_jacks
= get_in_jack_num_items(codec
, nid
);
2736 unsigned int val
, oldval
, idx
;
2738 oldval
= get_cur_hp_mic_jack_mode(codec
, nid
);
2739 idx
= ucontrol
->value
.enumerated
.item
[0];
2743 if (idx
< out_jacks
) {
2745 val
= idx
? PIN_HP
: PIN_OUT
;
2751 unsigned int vref_caps
= get_vref_caps(codec
, nid
);
2752 val
= snd_hda_codec_get_pin_target(codec
, nid
);
2753 val
&= ~(AC_PINCTL_VREFEN
| PIN_HP
);
2754 val
|= get_vref_idx(vref_caps
, idx
) | PIN_IN
;
2756 val
= snd_hda_get_default_vref(codec
, nid
) | PIN_IN
;
2758 snd_hda_set_pin_ctl_cache(codec
, nid
, val
);
2759 call_hp_automute(codec
, NULL
);
2764 static const struct snd_kcontrol_new hp_mic_jack_mode_enum
= {
2765 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
2766 .info
= hp_mic_jack_mode_info
,
2767 .get
= hp_mic_jack_mode_get
,
2768 .put
= hp_mic_jack_mode_put
,
2771 static int create_hp_mic_jack_mode(struct hda_codec
*codec
, hda_nid_t pin
)
2773 struct hda_gen_spec
*spec
= codec
->spec
;
2774 struct snd_kcontrol_new
*knew
;
2776 knew
= snd_hda_gen_add_kctl(spec
, "Headphone Mic Jack Mode",
2777 &hp_mic_jack_mode_enum
);
2780 knew
->private_value
= pin
;
2781 spec
->hp_mic_jack_modes
= 1;
2789 /* add the powersave loopback-list entry */
2790 static int add_loopback_list(struct hda_gen_spec
*spec
, hda_nid_t mix
, int idx
)
2792 struct hda_amp_list
*list
;
2794 list
= snd_array_new(&spec
->loopback_list
);
2798 list
->dir
= HDA_INPUT
;
2800 spec
->loopback
.amplist
= spec
->loopback_list
.list
;
2804 /* return true if either a volume or a mute amp is found for the given
2805 * aamix path; the amp has to be either in the mixer node or its direct leaf
2807 static bool look_for_mix_leaf_ctls(struct hda_codec
*codec
, hda_nid_t mix_nid
,
2808 hda_nid_t pin
, unsigned int *mix_val
,
2809 unsigned int *mute_val
)
2812 const hda_nid_t
*list
;
2815 idx
= snd_hda_get_conn_index(codec
, mix_nid
, pin
, true);
2819 *mix_val
= *mute_val
= 0;
2820 if (nid_has_volume(codec
, mix_nid
, HDA_INPUT
))
2821 *mix_val
= HDA_COMPOSE_AMP_VAL(mix_nid
, 3, idx
, HDA_INPUT
);
2822 if (nid_has_mute(codec
, mix_nid
, HDA_INPUT
))
2823 *mute_val
= HDA_COMPOSE_AMP_VAL(mix_nid
, 3, idx
, HDA_INPUT
);
2824 if (*mix_val
&& *mute_val
)
2827 /* check leaf node */
2828 num_conns
= snd_hda_get_conn_list(codec
, mix_nid
, &list
);
2829 if (num_conns
< idx
)
2832 if (!*mix_val
&& nid_has_volume(codec
, nid
, HDA_OUTPUT
) &&
2833 !is_ctl_associated(codec
, nid
, HDA_OUTPUT
, 0, NID_PATH_VOL_CTL
))
2834 *mix_val
= HDA_COMPOSE_AMP_VAL(nid
, 3, 0, HDA_OUTPUT
);
2835 if (!*mute_val
&& nid_has_mute(codec
, nid
, HDA_OUTPUT
) &&
2836 !is_ctl_associated(codec
, nid
, HDA_OUTPUT
, 0, NID_PATH_MUTE_CTL
))
2837 *mute_val
= HDA_COMPOSE_AMP_VAL(nid
, 3, 0, HDA_OUTPUT
);
2839 return *mix_val
|| *mute_val
;
2842 /* create input playback/capture controls for the given pin */
2843 static int new_analog_input(struct hda_codec
*codec
, int input_idx
,
2844 hda_nid_t pin
, const char *ctlname
, int ctlidx
,
2847 struct hda_gen_spec
*spec
= codec
->spec
;
2848 struct nid_path
*path
;
2849 unsigned int mix_val
, mute_val
;
2852 if (!look_for_mix_leaf_ctls(codec
, mix_nid
, pin
, &mix_val
, &mute_val
))
2855 path
= snd_hda_add_new_path(codec
, pin
, mix_nid
, 0);
2858 print_nid_path("loopback", path
);
2859 spec
->loopback_paths
[input_idx
] = snd_hda_get_path_idx(codec
, path
);
2861 idx
= path
->idx
[path
->depth
- 1];
2863 err
= __add_pb_vol_ctrl(spec
, HDA_CTL_WIDGET_VOL
, ctlname
, ctlidx
, mix_val
);
2866 path
->ctls
[NID_PATH_VOL_CTL
] = mix_val
;
2870 err
= __add_pb_sw_ctrl(spec
, HDA_CTL_WIDGET_MUTE
, ctlname
, ctlidx
, mute_val
);
2873 path
->ctls
[NID_PATH_MUTE_CTL
] = mute_val
;
2876 path
->active
= true;
2877 err
= add_loopback_list(spec
, mix_nid
, idx
);
2881 if (spec
->mixer_nid
!= spec
->mixer_merge_nid
&&
2882 !spec
->loopback_merge_path
) {
2883 path
= snd_hda_add_new_path(codec
, spec
->mixer_nid
,
2884 spec
->mixer_merge_nid
, 0);
2886 print_nid_path("loopback-merge", path
);
2887 path
->active
= true;
2888 spec
->loopback_merge_path
=
2889 snd_hda_get_path_idx(codec
, path
);
2896 static int is_input_pin(struct hda_codec
*codec
, hda_nid_t nid
)
2898 unsigned int pincap
= snd_hda_query_pin_caps(codec
, nid
);
2899 return (pincap
& AC_PINCAP_IN
) != 0;
2902 /* Parse the codec tree and retrieve ADCs */
2903 static int fill_adc_nids(struct hda_codec
*codec
)
2905 struct hda_gen_spec
*spec
= codec
->spec
;
2907 hda_nid_t
*adc_nids
= spec
->adc_nids
;
2908 int max_nums
= ARRAY_SIZE(spec
->adc_nids
);
2911 nid
= codec
->start_nid
;
2912 for (i
= 0; i
< codec
->num_nodes
; i
++, nid
++) {
2913 unsigned int caps
= get_wcaps(codec
, nid
);
2914 int type
= get_wcaps_type(caps
);
2916 if (type
!= AC_WID_AUD_IN
|| (caps
& AC_WCAP_DIGITAL
))
2918 adc_nids
[nums
] = nid
;
2919 if (++nums
>= max_nums
)
2922 spec
->num_adc_nids
= nums
;
2924 /* copy the detected ADCs to all_adcs[] */
2925 spec
->num_all_adcs
= nums
;
2926 memcpy(spec
->all_adcs
, spec
->adc_nids
, nums
* sizeof(hda_nid_t
));
2931 /* filter out invalid adc_nids that don't give all active input pins;
2932 * if needed, check whether dynamic ADC-switching is available
2934 static int check_dyn_adc_switch(struct hda_codec
*codec
)
2936 struct hda_gen_spec
*spec
= codec
->spec
;
2937 struct hda_input_mux
*imux
= &spec
->input_mux
;
2938 unsigned int ok_bits
;
2943 for (n
= 0; n
< spec
->num_adc_nids
; n
++) {
2944 for (i
= 0; i
< imux
->num_items
; i
++) {
2945 if (!spec
->input_paths
[i
][n
])
2948 if (i
>= imux
->num_items
) {
2949 ok_bits
|= (1 << n
);
2955 /* check whether ADC-switch is possible */
2956 for (i
= 0; i
< imux
->num_items
; i
++) {
2957 for (n
= 0; n
< spec
->num_adc_nids
; n
++) {
2958 if (spec
->input_paths
[i
][n
]) {
2959 spec
->dyn_adc_idx
[i
] = n
;
2965 snd_printdd("hda-codec: enabling ADC switching\n");
2966 spec
->dyn_adc_switch
= 1;
2967 } else if (nums
!= spec
->num_adc_nids
) {
2968 /* shrink the invalid adcs and input paths */
2970 for (n
= 0; n
< spec
->num_adc_nids
; n
++) {
2971 if (!(ok_bits
& (1 << n
)))
2974 spec
->adc_nids
[nums
] = spec
->adc_nids
[n
];
2975 for (i
= 0; i
< imux
->num_items
; i
++) {
2976 invalidate_nid_path(codec
,
2977 spec
->input_paths
[i
][nums
]);
2978 spec
->input_paths
[i
][nums
] =
2979 spec
->input_paths
[i
][n
];
2984 spec
->num_adc_nids
= nums
;
2987 if (imux
->num_items
== 1 ||
2988 (imux
->num_items
== 2 && spec
->hp_mic
)) {
2989 snd_printdd("hda-codec: reducing to a single ADC\n");
2990 spec
->num_adc_nids
= 1; /* reduce to a single ADC */
2993 /* single index for individual volumes ctls */
2994 if (!spec
->dyn_adc_switch
&& spec
->multi_cap_vol
)
2995 spec
->num_adc_nids
= 1;
3000 /* parse capture source paths from the given pin and create imux items */
3001 static int parse_capture_source(struct hda_codec
*codec
, hda_nid_t pin
,
3002 int cfg_idx
, int num_adcs
,
3003 const char *label
, int anchor
)
3005 struct hda_gen_spec
*spec
= codec
->spec
;
3006 struct hda_input_mux
*imux
= &spec
->input_mux
;
3007 int imux_idx
= imux
->num_items
;
3008 bool imux_added
= false;
3011 for (c
= 0; c
< num_adcs
; c
++) {
3012 struct nid_path
*path
;
3013 hda_nid_t adc
= spec
->adc_nids
[c
];
3015 if (!is_reachable_path(codec
, pin
, adc
))
3017 path
= snd_hda_add_new_path(codec
, pin
, adc
, anchor
);
3020 print_nid_path("input", path
);
3021 spec
->input_paths
[imux_idx
][c
] =
3022 snd_hda_get_path_idx(codec
, path
);
3025 if (spec
->hp_mic_pin
== pin
)
3026 spec
->hp_mic_mux_idx
= imux
->num_items
;
3027 spec
->imux_pins
[imux
->num_items
] = pin
;
3028 snd_hda_add_imux_item(imux
, label
, cfg_idx
, NULL
);
3037 * create playback/capture controls for input pins
3040 /* fill the label for each input at first */
3041 static int fill_input_pin_labels(struct hda_codec
*codec
)
3043 struct hda_gen_spec
*spec
= codec
->spec
;
3044 const struct auto_pin_cfg
*cfg
= &spec
->autocfg
;
3047 for (i
= 0; i
< cfg
->num_inputs
; i
++) {
3048 hda_nid_t pin
= cfg
->inputs
[i
].pin
;
3052 if (!is_input_pin(codec
, pin
))
3055 label
= hda_get_autocfg_input_label(codec
, cfg
, i
);
3057 for (j
= i
- 1; j
>= 0; j
--) {
3058 if (spec
->input_labels
[j
] &&
3059 !strcmp(spec
->input_labels
[j
], label
)) {
3060 idx
= spec
->input_label_idxs
[j
] + 1;
3065 spec
->input_labels
[i
] = label
;
3066 spec
->input_label_idxs
[i
] = idx
;
3072 #define CFG_IDX_MIX 99 /* a dummy cfg->input idx for stereo mix */
3074 static int create_input_ctls(struct hda_codec
*codec
)
3076 struct hda_gen_spec
*spec
= codec
->spec
;
3077 const struct auto_pin_cfg
*cfg
= &spec
->autocfg
;
3078 hda_nid_t mixer
= spec
->mixer_nid
;
3083 num_adcs
= fill_adc_nids(codec
);
3087 err
= fill_input_pin_labels(codec
);
3091 for (i
= 0; i
< cfg
->num_inputs
; i
++) {
3094 pin
= cfg
->inputs
[i
].pin
;
3095 if (!is_input_pin(codec
, pin
))
3099 if (cfg
->inputs
[i
].type
== AUTO_PIN_MIC
)
3100 val
|= snd_hda_get_default_vref(codec
, pin
);
3101 if (pin
!= spec
->hp_mic_pin
)
3102 set_pin_target(codec
, pin
, val
, false);
3105 if (is_reachable_path(codec
, pin
, mixer
)) {
3106 err
= new_analog_input(codec
, i
, pin
,
3107 spec
->input_labels
[i
],
3108 spec
->input_label_idxs
[i
],
3115 err
= parse_capture_source(codec
, pin
, i
, num_adcs
,
3116 spec
->input_labels
[i
], -mixer
);
3120 if (spec
->add_jack_modes
) {
3121 err
= create_in_jack_mode(codec
, pin
);
3127 if (mixer
&& spec
->add_stereo_mix_input
) {
3128 err
= parse_capture_source(codec
, mixer
, CFG_IDX_MIX
, num_adcs
,
3142 /* get the input path specified by the given adc and imux indices */
3143 static struct nid_path
*get_input_path(struct hda_codec
*codec
, int adc_idx
, int imux_idx
)
3145 struct hda_gen_spec
*spec
= codec
->spec
;
3146 if (imux_idx
< 0 || imux_idx
>= HDA_MAX_NUM_INPUTS
) {
3150 if (spec
->dyn_adc_switch
)
3151 adc_idx
= spec
->dyn_adc_idx
[imux_idx
];
3152 if (adc_idx
< 0 || adc_idx
>= AUTO_CFG_MAX_INS
) {
3156 return snd_hda_get_path_from_idx(codec
, spec
->input_paths
[imux_idx
][adc_idx
]);
3159 static int mux_select(struct hda_codec
*codec
, unsigned int adc_idx
,
3162 static int mux_enum_info(struct snd_kcontrol
*kcontrol
,
3163 struct snd_ctl_elem_info
*uinfo
)
3165 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
3166 struct hda_gen_spec
*spec
= codec
->spec
;
3167 return snd_hda_input_mux_info(&spec
->input_mux
, uinfo
);
3170 static int mux_enum_get(struct snd_kcontrol
*kcontrol
,
3171 struct snd_ctl_elem_value
*ucontrol
)
3173 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
3174 struct hda_gen_spec
*spec
= codec
->spec
;
3175 /* the ctls are created at once with multiple counts */
3176 unsigned int adc_idx
= snd_ctl_get_ioffidx(kcontrol
, &ucontrol
->id
);
3178 ucontrol
->value
.enumerated
.item
[0] = spec
->cur_mux
[adc_idx
];
3182 static int mux_enum_put(struct snd_kcontrol
*kcontrol
,
3183 struct snd_ctl_elem_value
*ucontrol
)
3185 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
3186 unsigned int adc_idx
= snd_ctl_get_ioffidx(kcontrol
, &ucontrol
->id
);
3187 return mux_select(codec
, adc_idx
,
3188 ucontrol
->value
.enumerated
.item
[0]);
3191 static const struct snd_kcontrol_new cap_src_temp
= {
3192 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
3193 .name
= "Input Source",
3194 .info
= mux_enum_info
,
3195 .get
= mux_enum_get
,
3196 .put
= mux_enum_put
,
3200 * capture volume and capture switch ctls
3203 typedef int (*put_call_t
)(struct snd_kcontrol
*kcontrol
,
3204 struct snd_ctl_elem_value
*ucontrol
);
3206 /* call the given amp update function for all amps in the imux list at once */
3207 static int cap_put_caller(struct snd_kcontrol
*kcontrol
,
3208 struct snd_ctl_elem_value
*ucontrol
,
3209 put_call_t func
, int type
)
3211 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
3212 struct hda_gen_spec
*spec
= codec
->spec
;
3213 const struct hda_input_mux
*imux
;
3214 struct nid_path
*path
;
3215 int i
, adc_idx
, err
= 0;
3217 imux
= &spec
->input_mux
;
3218 adc_idx
= kcontrol
->id
.index
;
3219 mutex_lock(&codec
->control_mutex
);
3220 /* we use the cache-only update at first since multiple input paths
3221 * may shared the same amp; by updating only caches, the redundant
3222 * writes to hardware can be reduced.
3224 codec
->cached_write
= 1;
3225 for (i
= 0; i
< imux
->num_items
; i
++) {
3226 path
= get_input_path(codec
, adc_idx
, i
);
3227 if (!path
|| !path
->ctls
[type
])
3229 kcontrol
->private_value
= path
->ctls
[type
];
3230 err
= func(kcontrol
, ucontrol
);
3235 codec
->cached_write
= 0;
3236 mutex_unlock(&codec
->control_mutex
);
3237 snd_hda_codec_flush_cache(codec
); /* flush the updates */
3238 if (err
>= 0 && spec
->cap_sync_hook
)
3239 spec
->cap_sync_hook(codec
, ucontrol
);
3243 /* capture volume ctl callbacks */
3244 #define cap_vol_info snd_hda_mixer_amp_volume_info
3245 #define cap_vol_get snd_hda_mixer_amp_volume_get
3246 #define cap_vol_tlv snd_hda_mixer_amp_tlv
3248 static int cap_vol_put(struct snd_kcontrol
*kcontrol
,
3249 struct snd_ctl_elem_value
*ucontrol
)
3251 return cap_put_caller(kcontrol
, ucontrol
,
3252 snd_hda_mixer_amp_volume_put
,
3256 static const struct snd_kcontrol_new cap_vol_temp
= {
3257 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
3258 .name
= "Capture Volume",
3259 .access
= (SNDRV_CTL_ELEM_ACCESS_READWRITE
|
3260 SNDRV_CTL_ELEM_ACCESS_TLV_READ
|
3261 SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK
),
3262 .info
= cap_vol_info
,
3265 .tlv
= { .c
= cap_vol_tlv
},
3268 /* capture switch ctl callbacks */
3269 #define cap_sw_info snd_ctl_boolean_stereo_info
3270 #define cap_sw_get snd_hda_mixer_amp_switch_get
3272 static int cap_sw_put(struct snd_kcontrol
*kcontrol
,
3273 struct snd_ctl_elem_value
*ucontrol
)
3275 return cap_put_caller(kcontrol
, ucontrol
,
3276 snd_hda_mixer_amp_switch_put
,
3280 static const struct snd_kcontrol_new cap_sw_temp
= {
3281 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
3282 .name
= "Capture Switch",
3283 .info
= cap_sw_info
,
3288 static int parse_capvol_in_path(struct hda_codec
*codec
, struct nid_path
*path
)
3293 path
->ctls
[NID_PATH_VOL_CTL
] = path
->ctls
[NID_PATH_MUTE_CTL
] = 0;
3294 for (depth
= 0; depth
< 3; depth
++) {
3295 if (depth
>= path
->depth
)
3297 i
= path
->depth
- depth
- 1;
3298 nid
= path
->path
[i
];
3299 if (!path
->ctls
[NID_PATH_VOL_CTL
]) {
3300 if (nid_has_volume(codec
, nid
, HDA_OUTPUT
))
3301 path
->ctls
[NID_PATH_VOL_CTL
] =
3302 HDA_COMPOSE_AMP_VAL(nid
, 3, 0, HDA_OUTPUT
);
3303 else if (nid_has_volume(codec
, nid
, HDA_INPUT
)) {
3304 int idx
= path
->idx
[i
];
3305 if (!depth
&& codec
->single_adc_amp
)
3307 path
->ctls
[NID_PATH_VOL_CTL
] =
3308 HDA_COMPOSE_AMP_VAL(nid
, 3, idx
, HDA_INPUT
);
3311 if (!path
->ctls
[NID_PATH_MUTE_CTL
]) {
3312 if (nid_has_mute(codec
, nid
, HDA_OUTPUT
))
3313 path
->ctls
[NID_PATH_MUTE_CTL
] =
3314 HDA_COMPOSE_AMP_VAL(nid
, 3, 0, HDA_OUTPUT
);
3315 else if (nid_has_mute(codec
, nid
, HDA_INPUT
)) {
3316 int idx
= path
->idx
[i
];
3317 if (!depth
&& codec
->single_adc_amp
)
3319 path
->ctls
[NID_PATH_MUTE_CTL
] =
3320 HDA_COMPOSE_AMP_VAL(nid
, 3, idx
, HDA_INPUT
);
3327 static bool is_inv_dmic_pin(struct hda_codec
*codec
, hda_nid_t nid
)
3329 struct hda_gen_spec
*spec
= codec
->spec
;
3330 struct auto_pin_cfg
*cfg
= &spec
->autocfg
;
3334 if (!spec
->inv_dmic_split
)
3336 for (i
= 0; i
< cfg
->num_inputs
; i
++) {
3337 if (cfg
->inputs
[i
].pin
!= nid
)
3339 if (cfg
->inputs
[i
].type
!= AUTO_PIN_MIC
)
3341 val
= snd_hda_codec_get_pincfg(codec
, nid
);
3342 return snd_hda_get_input_pin_attr(val
) == INPUT_PIN_ATTR_INT
;
3347 /* capture switch put callback for a single control with hook call */
3348 static int cap_single_sw_put(struct snd_kcontrol
*kcontrol
,
3349 struct snd_ctl_elem_value
*ucontrol
)
3351 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
3352 struct hda_gen_spec
*spec
= codec
->spec
;
3355 ret
= snd_hda_mixer_amp_switch_put(kcontrol
, ucontrol
);
3359 if (spec
->cap_sync_hook
)
3360 spec
->cap_sync_hook(codec
, ucontrol
);
3365 static int add_single_cap_ctl(struct hda_codec
*codec
, const char *label
,
3366 int idx
, bool is_switch
, unsigned int ctl
,
3369 struct hda_gen_spec
*spec
= codec
->spec
;
3371 int type
= is_switch
? HDA_CTL_WIDGET_MUTE
: HDA_CTL_WIDGET_VOL
;
3372 const char *sfx
= is_switch
? "Switch" : "Volume";
3373 unsigned int chs
= inv_dmic
? 1 : 3;
3374 struct snd_kcontrol_new
*knew
;
3380 snprintf(tmpname
, sizeof(tmpname
),
3381 "%s Capture %s", label
, sfx
);
3383 snprintf(tmpname
, sizeof(tmpname
),
3385 knew
= add_control(spec
, type
, tmpname
, idx
,
3386 amp_val_replace_channels(ctl
, chs
));
3390 knew
->put
= cap_single_sw_put
;
3394 /* Make independent right kcontrol */
3396 snprintf(tmpname
, sizeof(tmpname
),
3397 "Inverted %s Capture %s", label
, sfx
);
3399 snprintf(tmpname
, sizeof(tmpname
),
3400 "Inverted Capture %s", sfx
);
3401 knew
= add_control(spec
, type
, tmpname
, idx
,
3402 amp_val_replace_channels(ctl
, 2));
3406 knew
->put
= cap_single_sw_put
;
3410 /* create single (and simple) capture volume and switch controls */
3411 static int create_single_cap_vol_ctl(struct hda_codec
*codec
, int idx
,
3412 unsigned int vol_ctl
, unsigned int sw_ctl
,
3416 err
= add_single_cap_ctl(codec
, NULL
, idx
, false, vol_ctl
, inv_dmic
);
3419 err
= add_single_cap_ctl(codec
, NULL
, idx
, true, sw_ctl
, inv_dmic
);
3425 /* create bound capture volume and switch controls */
3426 static int create_bind_cap_vol_ctl(struct hda_codec
*codec
, int idx
,
3427 unsigned int vol_ctl
, unsigned int sw_ctl
)
3429 struct hda_gen_spec
*spec
= codec
->spec
;
3430 struct snd_kcontrol_new
*knew
;
3433 knew
= snd_hda_gen_add_kctl(spec
, NULL
, &cap_vol_temp
);
3437 knew
->private_value
= vol_ctl
;
3438 knew
->subdevice
= HDA_SUBDEV_AMP_FLAG
;
3441 knew
= snd_hda_gen_add_kctl(spec
, NULL
, &cap_sw_temp
);
3445 knew
->private_value
= sw_ctl
;
3446 knew
->subdevice
= HDA_SUBDEV_AMP_FLAG
;
3451 /* return the vol ctl when used first in the imux list */
3452 static unsigned int get_first_cap_ctl(struct hda_codec
*codec
, int idx
, int type
)
3454 struct nid_path
*path
;
3458 path
= get_input_path(codec
, 0, idx
);
3461 ctl
= path
->ctls
[type
];
3464 for (i
= 0; i
< idx
- 1; i
++) {
3465 path
= get_input_path(codec
, 0, i
);
3466 if (path
&& path
->ctls
[type
] == ctl
)
3472 /* create individual capture volume and switch controls per input */
3473 static int create_multi_cap_vol_ctl(struct hda_codec
*codec
)
3475 struct hda_gen_spec
*spec
= codec
->spec
;
3476 struct hda_input_mux
*imux
= &spec
->input_mux
;
3479 for (i
= 0; i
< imux
->num_items
; i
++) {
3483 idx
= imux
->items
[i
].index
;
3484 if (idx
>= spec
->autocfg
.num_inputs
)
3486 inv_dmic
= is_inv_dmic_pin(codec
, spec
->imux_pins
[i
]);
3488 for (type
= 0; type
< 2; type
++) {
3489 err
= add_single_cap_ctl(codec
,
3490 spec
->input_labels
[idx
],
3491 spec
->input_label_idxs
[idx
],
3493 get_first_cap_ctl(codec
, i
, type
),
3502 static int create_capture_mixers(struct hda_codec
*codec
)
3504 struct hda_gen_spec
*spec
= codec
->spec
;
3505 struct hda_input_mux
*imux
= &spec
->input_mux
;
3506 int i
, n
, nums
, err
;
3508 if (spec
->dyn_adc_switch
)
3511 nums
= spec
->num_adc_nids
;
3513 if (!spec
->auto_mic
&& imux
->num_items
> 1) {
3514 struct snd_kcontrol_new
*knew
;
3516 name
= nums
> 1 ? "Input Source" : "Capture Source";
3517 knew
= snd_hda_gen_add_kctl(spec
, name
, &cap_src_temp
);
3523 for (n
= 0; n
< nums
; n
++) {
3525 bool multi_cap_vol
= spec
->multi_cap_vol
;
3526 bool inv_dmic
= false;
3530 for (i
= 0; i
< imux
->num_items
; i
++) {
3531 struct nid_path
*path
;
3532 path
= get_input_path(codec
, n
, i
);
3535 parse_capvol_in_path(codec
, path
);
3537 vol
= path
->ctls
[NID_PATH_VOL_CTL
];
3538 else if (vol
!= path
->ctls
[NID_PATH_VOL_CTL
]) {
3540 if (!same_amp_caps(codec
, vol
,
3541 path
->ctls
[NID_PATH_VOL_CTL
], HDA_INPUT
))
3542 multi_cap_vol
= true;
3545 sw
= path
->ctls
[NID_PATH_MUTE_CTL
];
3546 else if (sw
!= path
->ctls
[NID_PATH_MUTE_CTL
]) {
3548 if (!same_amp_caps(codec
, sw
,
3549 path
->ctls
[NID_PATH_MUTE_CTL
], HDA_INPUT
))
3550 multi_cap_vol
= true;
3552 if (is_inv_dmic_pin(codec
, spec
->imux_pins
[i
]))
3557 err
= create_single_cap_vol_ctl(codec
, n
, vol
, sw
,
3559 else if (!multi_cap_vol
&& !inv_dmic
)
3560 err
= create_bind_cap_vol_ctl(codec
, n
, vol
, sw
);
3562 err
= create_multi_cap_vol_ctl(codec
);
3571 * add mic boosts if needed
3574 /* check whether the given amp is feasible as a boost volume */
3575 static bool check_boost_vol(struct hda_codec
*codec
, hda_nid_t nid
,
3580 if (!nid_has_volume(codec
, nid
, dir
) ||
3581 is_ctl_associated(codec
, nid
, dir
, idx
, NID_PATH_VOL_CTL
) ||
3582 is_ctl_associated(codec
, nid
, dir
, idx
, NID_PATH_BOOST_CTL
))
3585 step
= (query_amp_caps(codec
, nid
, dir
) & AC_AMPCAP_STEP_SIZE
)
3586 >> AC_AMPCAP_STEP_SIZE_SHIFT
;
3592 /* look for a boost amp in a widget close to the pin */
3593 static unsigned int look_for_boost_amp(struct hda_codec
*codec
,
3594 struct nid_path
*path
)
3596 unsigned int val
= 0;
3600 for (depth
= 0; depth
< 3; depth
++) {
3601 if (depth
>= path
->depth
- 1)
3603 nid
= path
->path
[depth
];
3604 if (depth
&& check_boost_vol(codec
, nid
, HDA_OUTPUT
, 0)) {
3605 val
= HDA_COMPOSE_AMP_VAL(nid
, 3, 0, HDA_OUTPUT
);
3607 } else if (check_boost_vol(codec
, nid
, HDA_INPUT
,
3608 path
->idx
[depth
])) {
3609 val
= HDA_COMPOSE_AMP_VAL(nid
, 3, path
->idx
[depth
],
3618 static int parse_mic_boost(struct hda_codec
*codec
)
3620 struct hda_gen_spec
*spec
= codec
->spec
;
3621 struct auto_pin_cfg
*cfg
= &spec
->autocfg
;
3622 struct hda_input_mux
*imux
= &spec
->input_mux
;
3625 if (!spec
->num_adc_nids
)
3628 for (i
= 0; i
< imux
->num_items
; i
++) {
3629 struct nid_path
*path
;
3632 char boost_label
[44];
3634 idx
= imux
->items
[i
].index
;
3635 if (idx
>= imux
->num_items
)
3638 /* check only line-in and mic pins */
3639 if (cfg
->inputs
[idx
].type
> AUTO_PIN_LINE_IN
)
3642 path
= get_input_path(codec
, 0, i
);
3646 val
= look_for_boost_amp(codec
, path
);
3650 /* create a boost control */
3651 snprintf(boost_label
, sizeof(boost_label
),
3652 "%s Boost Volume", spec
->input_labels
[idx
]);
3653 if (!add_control(spec
, HDA_CTL_WIDGET_VOL
, boost_label
,
3654 spec
->input_label_idxs
[idx
], val
))
3657 path
->ctls
[NID_PATH_BOOST_CTL
] = val
;
3663 * parse digital I/Os and set up NIDs in BIOS auto-parse mode
3665 static void parse_digital(struct hda_codec
*codec
)
3667 struct hda_gen_spec
*spec
= codec
->spec
;
3668 struct nid_path
*path
;
3670 hda_nid_t dig_nid
, pin
;
3672 /* support multiple SPDIFs; the secondary is set up as a slave */
3674 for (i
= 0; i
< spec
->autocfg
.dig_outs
; i
++) {
3675 pin
= spec
->autocfg
.dig_out_pins
[i
];
3676 dig_nid
= look_for_dac(codec
, pin
, true);
3679 path
= snd_hda_add_new_path(codec
, dig_nid
, pin
, 0);
3682 print_nid_path("digout", path
);
3683 path
->active
= true;
3684 spec
->digout_paths
[i
] = snd_hda_get_path_idx(codec
, path
);
3685 set_pin_target(codec
, pin
, PIN_OUT
, false);
3687 spec
->multiout
.dig_out_nid
= dig_nid
;
3688 spec
->dig_out_type
= spec
->autocfg
.dig_out_type
[0];
3690 spec
->multiout
.slave_dig_outs
= spec
->slave_dig_outs
;
3691 if (nums
>= ARRAY_SIZE(spec
->slave_dig_outs
) - 1)
3693 spec
->slave_dig_outs
[nums
- 1] = dig_nid
;
3698 if (spec
->autocfg
.dig_in_pin
) {
3699 pin
= spec
->autocfg
.dig_in_pin
;
3700 dig_nid
= codec
->start_nid
;
3701 for (i
= 0; i
< codec
->num_nodes
; i
++, dig_nid
++) {
3702 unsigned int wcaps
= get_wcaps(codec
, dig_nid
);
3703 if (get_wcaps_type(wcaps
) != AC_WID_AUD_IN
)
3705 if (!(wcaps
& AC_WCAP_DIGITAL
))
3707 path
= snd_hda_add_new_path(codec
, pin
, dig_nid
, 0);
3709 print_nid_path("digin", path
);
3710 path
->active
= true;
3711 spec
->dig_in_nid
= dig_nid
;
3712 spec
->digin_path
= snd_hda_get_path_idx(codec
, path
);
3713 set_pin_target(codec
, pin
, PIN_IN
, false);
3722 * input MUX handling
3725 static bool dyn_adc_pcm_resetup(struct hda_codec
*codec
, int cur
);
3727 /* select the given imux item; either unmute exclusively or select the route */
3728 static int mux_select(struct hda_codec
*codec
, unsigned int adc_idx
,
3731 struct hda_gen_spec
*spec
= codec
->spec
;
3732 const struct hda_input_mux
*imux
;
3733 struct nid_path
*old_path
, *path
;
3735 imux
= &spec
->input_mux
;
3736 if (!imux
->num_items
)
3739 if (idx
>= imux
->num_items
)
3740 idx
= imux
->num_items
- 1;
3741 if (spec
->cur_mux
[adc_idx
] == idx
)
3744 old_path
= get_input_path(codec
, adc_idx
, spec
->cur_mux
[adc_idx
]);
3747 if (old_path
->active
)
3748 snd_hda_activate_path(codec
, old_path
, false, false);
3750 spec
->cur_mux
[adc_idx
] = idx
;
3753 update_hp_mic(codec
, adc_idx
, false);
3755 if (spec
->dyn_adc_switch
)
3756 dyn_adc_pcm_resetup(codec
, idx
);
3758 path
= get_input_path(codec
, adc_idx
, idx
);
3763 snd_hda_activate_path(codec
, path
, true, false);
3764 if (spec
->cap_sync_hook
)
3765 spec
->cap_sync_hook(codec
, NULL
);
3766 path_power_down_sync(codec
, old_path
);
3772 * Jack detections for HP auto-mute and mic-switch
3775 /* check each pin in the given array; returns true if any of them is plugged */
3776 static bool detect_jacks(struct hda_codec
*codec
, int num_pins
, hda_nid_t
*pins
)
3780 for (i
= 0; i
< num_pins
; i
++) {
3781 hda_nid_t nid
= pins
[i
];
3784 /* don't detect pins retasked as inputs */
3785 if (snd_hda_codec_get_pin_target(codec
, nid
) & AC_PINCTL_IN_EN
)
3787 present
|= snd_hda_jack_detect(codec
, nid
);
3792 /* standard HP/line-out auto-mute helper */
3793 static void do_automute(struct hda_codec
*codec
, int num_pins
, hda_nid_t
*pins
,
3796 struct hda_gen_spec
*spec
= codec
->spec
;
3799 for (i
= 0; i
< num_pins
; i
++) {
3800 hda_nid_t nid
= pins
[i
];
3801 unsigned int val
, oldval
;
3804 oldval
= snd_hda_codec_get_pin_target(codec
, nid
);
3805 if (oldval
& PIN_IN
)
3806 continue; /* no mute for inputs */
3807 /* don't reset VREF value in case it's controlling
3808 * the amp (see alc861_fixup_asus_amp_vref_0f())
3810 if (spec
->keep_vref_in_automute
)
3811 val
= oldval
& ~PIN_HP
;
3816 /* here we call update_pin_ctl() so that the pinctl is changed
3817 * without changing the pinctl target value;
3818 * the original target value will be still referred at the
3819 * init / resume again
3821 update_pin_ctl(codec
, nid
, val
);
3822 set_pin_eapd(codec
, nid
, !mute
);
3826 /* Toggle outputs muting */
3827 void snd_hda_gen_update_outputs(struct hda_codec
*codec
)
3829 struct hda_gen_spec
*spec
= codec
->spec
;
3832 /* Control HP pins/amps depending on master_mute state;
3833 * in general, HP pins/amps control should be enabled in all cases,
3834 * but currently set only for master_mute, just to be safe
3836 do_automute(codec
, ARRAY_SIZE(spec
->autocfg
.hp_pins
),
3837 spec
->autocfg
.hp_pins
, spec
->master_mute
);
3839 if (!spec
->automute_speaker
)
3842 on
= spec
->hp_jack_present
| spec
->line_jack_present
;
3843 on
|= spec
->master_mute
;
3844 spec
->speaker_muted
= on
;
3845 do_automute(codec
, ARRAY_SIZE(spec
->autocfg
.speaker_pins
),
3846 spec
->autocfg
.speaker_pins
, on
);
3848 /* toggle line-out mutes if needed, too */
3849 /* if LO is a copy of either HP or Speaker, don't need to handle it */
3850 if (spec
->autocfg
.line_out_pins
[0] == spec
->autocfg
.hp_pins
[0] ||
3851 spec
->autocfg
.line_out_pins
[0] == spec
->autocfg
.speaker_pins
[0])
3853 if (!spec
->automute_lo
)
3856 on
= spec
->hp_jack_present
;
3857 on
|= spec
->master_mute
;
3858 spec
->line_out_muted
= on
;
3859 do_automute(codec
, ARRAY_SIZE(spec
->autocfg
.line_out_pins
),
3860 spec
->autocfg
.line_out_pins
, on
);
3862 EXPORT_SYMBOL_HDA(snd_hda_gen_update_outputs
);
3864 static void call_update_outputs(struct hda_codec
*codec
)
3866 struct hda_gen_spec
*spec
= codec
->spec
;
3867 if (spec
->automute_hook
)
3868 spec
->automute_hook(codec
);
3870 snd_hda_gen_update_outputs(codec
);
3873 /* standard HP-automute helper */
3874 void snd_hda_gen_hp_automute(struct hda_codec
*codec
, struct hda_jack_tbl
*jack
)
3876 struct hda_gen_spec
*spec
= codec
->spec
;
3877 hda_nid_t
*pins
= spec
->autocfg
.hp_pins
;
3878 int num_pins
= ARRAY_SIZE(spec
->autocfg
.hp_pins
);
3880 /* No detection for the first HP jack during indep-HP mode */
3881 if (spec
->indep_hp_enabled
) {
3886 spec
->hp_jack_present
= detect_jacks(codec
, num_pins
, pins
);
3887 if (!spec
->detect_hp
|| (!spec
->automute_speaker
&& !spec
->automute_lo
))
3889 call_update_outputs(codec
);
3891 EXPORT_SYMBOL_HDA(snd_hda_gen_hp_automute
);
3893 /* standard line-out-automute helper */
3894 void snd_hda_gen_line_automute(struct hda_codec
*codec
, struct hda_jack_tbl
*jack
)
3896 struct hda_gen_spec
*spec
= codec
->spec
;
3898 if (spec
->autocfg
.line_out_type
== AUTO_PIN_SPEAKER_OUT
)
3900 /* check LO jack only when it's different from HP */
3901 if (spec
->autocfg
.line_out_pins
[0] == spec
->autocfg
.hp_pins
[0])
3904 spec
->line_jack_present
=
3905 detect_jacks(codec
, ARRAY_SIZE(spec
->autocfg
.line_out_pins
),
3906 spec
->autocfg
.line_out_pins
);
3907 if (!spec
->automute_speaker
|| !spec
->detect_lo
)
3909 call_update_outputs(codec
);
3911 EXPORT_SYMBOL_HDA(snd_hda_gen_line_automute
);
3913 /* standard mic auto-switch helper */
3914 void snd_hda_gen_mic_autoswitch(struct hda_codec
*codec
, struct hda_jack_tbl
*jack
)
3916 struct hda_gen_spec
*spec
= codec
->spec
;
3919 if (!spec
->auto_mic
)
3922 for (i
= spec
->am_num_entries
- 1; i
> 0; i
--) {
3923 hda_nid_t pin
= spec
->am_entry
[i
].pin
;
3924 /* don't detect pins retasked as outputs */
3925 if (snd_hda_codec_get_pin_target(codec
, pin
) & AC_PINCTL_OUT_EN
)
3927 if (snd_hda_jack_detect(codec
, pin
)) {
3928 mux_select(codec
, 0, spec
->am_entry
[i
].idx
);
3932 mux_select(codec
, 0, spec
->am_entry
[0].idx
);
3934 EXPORT_SYMBOL_HDA(snd_hda_gen_mic_autoswitch
);
3936 /* call appropriate hooks */
3937 static void call_hp_automute(struct hda_codec
*codec
, struct hda_jack_tbl
*jack
)
3939 struct hda_gen_spec
*spec
= codec
->spec
;
3940 if (spec
->hp_automute_hook
)
3941 spec
->hp_automute_hook(codec
, jack
);
3943 snd_hda_gen_hp_automute(codec
, jack
);
3946 static void call_line_automute(struct hda_codec
*codec
,
3947 struct hda_jack_tbl
*jack
)
3949 struct hda_gen_spec
*spec
= codec
->spec
;
3950 if (spec
->line_automute_hook
)
3951 spec
->line_automute_hook(codec
, jack
);
3953 snd_hda_gen_line_automute(codec
, jack
);
3956 static void call_mic_autoswitch(struct hda_codec
*codec
,
3957 struct hda_jack_tbl
*jack
)
3959 struct hda_gen_spec
*spec
= codec
->spec
;
3960 if (spec
->mic_autoswitch_hook
)
3961 spec
->mic_autoswitch_hook(codec
, jack
);
3963 snd_hda_gen_mic_autoswitch(codec
, jack
);
3966 /* update jack retasking */
3967 static void update_automute_all(struct hda_codec
*codec
)
3969 call_hp_automute(codec
, NULL
);
3970 call_line_automute(codec
, NULL
);
3971 call_mic_autoswitch(codec
, NULL
);
3975 * Auto-Mute mode mixer enum support
3977 static int automute_mode_info(struct snd_kcontrol
*kcontrol
,
3978 struct snd_ctl_elem_info
*uinfo
)
3980 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
3981 struct hda_gen_spec
*spec
= codec
->spec
;
3982 static const char * const texts3
[] = {
3983 "Disabled", "Speaker Only", "Line Out+Speaker"
3986 if (spec
->automute_speaker_possible
&& spec
->automute_lo_possible
)
3987 return snd_hda_enum_helper_info(kcontrol
, uinfo
, 3, texts3
);
3988 return snd_hda_enum_bool_helper_info(kcontrol
, uinfo
);
3991 static int automute_mode_get(struct snd_kcontrol
*kcontrol
,
3992 struct snd_ctl_elem_value
*ucontrol
)
3994 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
3995 struct hda_gen_spec
*spec
= codec
->spec
;
3996 unsigned int val
= 0;
3997 if (spec
->automute_speaker
)
3999 if (spec
->automute_lo
)
4002 ucontrol
->value
.enumerated
.item
[0] = val
;
4006 static int automute_mode_put(struct snd_kcontrol
*kcontrol
,
4007 struct snd_ctl_elem_value
*ucontrol
)
4009 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
4010 struct hda_gen_spec
*spec
= codec
->spec
;
4012 switch (ucontrol
->value
.enumerated
.item
[0]) {
4014 if (!spec
->automute_speaker
&& !spec
->automute_lo
)
4016 spec
->automute_speaker
= 0;
4017 spec
->automute_lo
= 0;
4020 if (spec
->automute_speaker_possible
) {
4021 if (!spec
->automute_lo
&& spec
->automute_speaker
)
4023 spec
->automute_speaker
= 1;
4024 spec
->automute_lo
= 0;
4025 } else if (spec
->automute_lo_possible
) {
4026 if (spec
->automute_lo
)
4028 spec
->automute_lo
= 1;
4033 if (!spec
->automute_lo_possible
|| !spec
->automute_speaker_possible
)
4035 if (spec
->automute_speaker
&& spec
->automute_lo
)
4037 spec
->automute_speaker
= 1;
4038 spec
->automute_lo
= 1;
4043 call_update_outputs(codec
);
4047 static const struct snd_kcontrol_new automute_mode_enum
= {
4048 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
4049 .name
= "Auto-Mute Mode",
4050 .info
= automute_mode_info
,
4051 .get
= automute_mode_get
,
4052 .put
= automute_mode_put
,
4055 static int add_automute_mode_enum(struct hda_codec
*codec
)
4057 struct hda_gen_spec
*spec
= codec
->spec
;
4059 if (!snd_hda_gen_add_kctl(spec
, NULL
, &automute_mode_enum
))
4065 * Check the availability of HP/line-out auto-mute;
4066 * Set up appropriately if really supported
4068 static int check_auto_mute_availability(struct hda_codec
*codec
)
4070 struct hda_gen_spec
*spec
= codec
->spec
;
4071 struct auto_pin_cfg
*cfg
= &spec
->autocfg
;
4075 if (spec
->suppress_auto_mute
)
4078 if (cfg
->hp_pins
[0])
4080 if (cfg
->line_out_pins
[0])
4082 if (cfg
->speaker_pins
[0])
4084 if (present
< 2) /* need two different output types */
4087 if (!cfg
->speaker_pins
[0] &&
4088 cfg
->line_out_type
== AUTO_PIN_SPEAKER_OUT
) {
4089 memcpy(cfg
->speaker_pins
, cfg
->line_out_pins
,
4090 sizeof(cfg
->speaker_pins
));
4091 cfg
->speaker_outs
= cfg
->line_outs
;
4094 if (!cfg
->hp_pins
[0] &&
4095 cfg
->line_out_type
== AUTO_PIN_HP_OUT
) {
4096 memcpy(cfg
->hp_pins
, cfg
->line_out_pins
,
4097 sizeof(cfg
->hp_pins
));
4098 cfg
->hp_outs
= cfg
->line_outs
;
4101 for (i
= 0; i
< cfg
->hp_outs
; i
++) {
4102 hda_nid_t nid
= cfg
->hp_pins
[i
];
4103 if (!is_jack_detectable(codec
, nid
))
4105 snd_printdd("hda-codec: Enable HP auto-muting on NID 0x%x\n",
4107 snd_hda_jack_detect_enable_callback(codec
, nid
, HDA_GEN_HP_EVENT
,
4109 spec
->detect_hp
= 1;
4112 if (cfg
->line_out_type
== AUTO_PIN_LINE_OUT
&& cfg
->line_outs
) {
4113 if (cfg
->speaker_outs
)
4114 for (i
= 0; i
< cfg
->line_outs
; i
++) {
4115 hda_nid_t nid
= cfg
->line_out_pins
[i
];
4116 if (!is_jack_detectable(codec
, nid
))
4118 snd_printdd("hda-codec: Enable Line-Out auto-muting on NID 0x%x\n", nid
);
4119 snd_hda_jack_detect_enable_callback(codec
, nid
,
4120 HDA_GEN_FRONT_EVENT
,
4121 call_line_automute
);
4122 spec
->detect_lo
= 1;
4124 spec
->automute_lo_possible
= spec
->detect_hp
;
4127 spec
->automute_speaker_possible
= cfg
->speaker_outs
&&
4128 (spec
->detect_hp
|| spec
->detect_lo
);
4130 spec
->automute_lo
= spec
->automute_lo_possible
;
4131 spec
->automute_speaker
= spec
->automute_speaker_possible
;
4133 if (spec
->automute_speaker_possible
|| spec
->automute_lo_possible
) {
4134 /* create a control for automute mode */
4135 err
= add_automute_mode_enum(codec
);
4142 /* check whether all auto-mic pins are valid; setup indices if OK */
4143 static bool auto_mic_check_imux(struct hda_codec
*codec
)
4145 struct hda_gen_spec
*spec
= codec
->spec
;
4146 const struct hda_input_mux
*imux
;
4149 imux
= &spec
->input_mux
;
4150 for (i
= 0; i
< spec
->am_num_entries
; i
++) {
4151 spec
->am_entry
[i
].idx
=
4152 find_idx_in_nid_list(spec
->am_entry
[i
].pin
,
4153 spec
->imux_pins
, imux
->num_items
);
4154 if (spec
->am_entry
[i
].idx
< 0)
4155 return false; /* no corresponding imux */
4158 /* we don't need the jack detection for the first pin */
4159 for (i
= 1; i
< spec
->am_num_entries
; i
++)
4160 snd_hda_jack_detect_enable_callback(codec
,
4161 spec
->am_entry
[i
].pin
,
4163 call_mic_autoswitch
);
4167 static int compare_attr(const void *ap
, const void *bp
)
4169 const struct automic_entry
*a
= ap
;
4170 const struct automic_entry
*b
= bp
;
4171 return (int)(a
->attr
- b
->attr
);
4175 * Check the availability of auto-mic switch;
4176 * Set up if really supported
4178 static int check_auto_mic_availability(struct hda_codec
*codec
)
4180 struct hda_gen_spec
*spec
= codec
->spec
;
4181 struct auto_pin_cfg
*cfg
= &spec
->autocfg
;
4185 if (spec
->suppress_auto_mic
)
4190 for (i
= 0; i
< cfg
->num_inputs
; i
++) {
4191 hda_nid_t nid
= cfg
->inputs
[i
].pin
;
4193 attr
= snd_hda_codec_get_pincfg(codec
, nid
);
4194 attr
= snd_hda_get_input_pin_attr(attr
);
4195 if (types
& (1 << attr
))
4196 return 0; /* already occupied */
4198 case INPUT_PIN_ATTR_INT
:
4199 if (cfg
->inputs
[i
].type
!= AUTO_PIN_MIC
)
4200 return 0; /* invalid type */
4202 case INPUT_PIN_ATTR_UNUSED
:
4203 return 0; /* invalid entry */
4205 if (cfg
->inputs
[i
].type
> AUTO_PIN_LINE_IN
)
4206 return 0; /* invalid type */
4207 if (!spec
->line_in_auto_switch
&&
4208 cfg
->inputs
[i
].type
!= AUTO_PIN_MIC
)
4209 return 0; /* only mic is allowed */
4210 if (!is_jack_detectable(codec
, nid
))
4211 return 0; /* no unsol support */
4214 if (num_pins
>= MAX_AUTO_MIC_PINS
)
4216 types
|= (1 << attr
);
4217 spec
->am_entry
[num_pins
].pin
= nid
;
4218 spec
->am_entry
[num_pins
].attr
= attr
;
4225 spec
->am_num_entries
= num_pins
;
4226 /* sort the am_entry in the order of attr so that the pin with a
4227 * higher attr will be selected when the jack is plugged.
4229 sort(spec
->am_entry
, num_pins
, sizeof(spec
->am_entry
[0]),
4230 compare_attr
, NULL
);
4232 if (!auto_mic_check_imux(codec
))
4236 spec
->num_adc_nids
= 1;
4237 spec
->cur_mux
[0] = spec
->am_entry
[0].idx
;
4238 snd_printdd("hda-codec: Enable auto-mic switch on NID 0x%x/0x%x/0x%x\n",
4239 spec
->am_entry
[0].pin
,
4240 spec
->am_entry
[1].pin
,
4241 spec
->am_entry
[2].pin
);
4246 /* power_filter hook; make inactive widgets into power down */
4247 static unsigned int snd_hda_gen_path_power_filter(struct hda_codec
*codec
,
4249 unsigned int power_state
)
4251 if (power_state
!= AC_PWRST_D0
)
4253 if (get_wcaps_type(get_wcaps(codec
, nid
)) >= AC_WID_POWER
)
4255 if (is_active_nid_for_any(codec
, nid
))
4260 /* mute all aamix inputs initially; parse up to the first leaves */
4261 static void mute_all_mixer_nid(struct hda_codec
*codec
, hda_nid_t mix
)
4264 const hda_nid_t
*conn
;
4267 nums
= snd_hda_get_conn_list(codec
, mix
, &conn
);
4268 has_amp
= nid_has_mute(codec
, mix
, HDA_INPUT
);
4269 for (i
= 0; i
< nums
; i
++) {
4271 update_amp(codec
, mix
, HDA_INPUT
, i
,
4272 0xff, HDA_AMP_MUTE
);
4273 else if (nid_has_volume(codec
, conn
[i
], HDA_OUTPUT
))
4274 update_amp(codec
, conn
[i
], HDA_OUTPUT
, 0,
4275 0xff, HDA_AMP_MUTE
);
4280 * Parse the given BIOS configuration and set up the hda_gen_spec
4282 * return 1 if successful, 0 if the proper config is not found,
4283 * or a negative error code
4285 int snd_hda_gen_parse_auto_config(struct hda_codec
*codec
,
4286 struct auto_pin_cfg
*cfg
)
4288 struct hda_gen_spec
*spec
= codec
->spec
;
4291 parse_user_hints(codec
);
4293 if (spec
->mixer_nid
&& !spec
->mixer_merge_nid
)
4294 spec
->mixer_merge_nid
= spec
->mixer_nid
;
4296 if (cfg
!= &spec
->autocfg
) {
4297 spec
->autocfg
= *cfg
;
4298 cfg
= &spec
->autocfg
;
4301 if (!spec
->main_out_badness
)
4302 spec
->main_out_badness
= &hda_main_out_badness
;
4303 if (!spec
->extra_out_badness
)
4304 spec
->extra_out_badness
= &hda_extra_out_badness
;
4306 fill_all_dac_nids(codec
);
4308 if (!cfg
->line_outs
) {
4309 if (cfg
->dig_outs
|| cfg
->dig_in_pin
) {
4310 spec
->multiout
.max_channels
= 2;
4311 spec
->no_analog
= 1;
4314 return 0; /* can't find valid BIOS pin config */
4317 if (!spec
->no_primary_hp
&&
4318 cfg
->line_out_type
== AUTO_PIN_SPEAKER_OUT
&&
4319 cfg
->line_outs
<= cfg
->hp_outs
) {
4320 /* use HP as primary out */
4321 cfg
->speaker_outs
= cfg
->line_outs
;
4322 memcpy(cfg
->speaker_pins
, cfg
->line_out_pins
,
4323 sizeof(cfg
->speaker_pins
));
4324 cfg
->line_outs
= cfg
->hp_outs
;
4325 memcpy(cfg
->line_out_pins
, cfg
->hp_pins
, sizeof(cfg
->hp_pins
));
4327 memset(cfg
->hp_pins
, 0, sizeof(cfg
->hp_pins
));
4328 cfg
->line_out_type
= AUTO_PIN_HP_OUT
;
4331 err
= parse_output_paths(codec
);
4334 err
= create_multi_channel_mode(codec
);
4337 err
= create_multi_out_ctls(codec
, cfg
);
4340 err
= create_hp_out_ctls(codec
);
4343 err
= create_speaker_out_ctls(codec
);
4346 err
= create_indep_hp_ctls(codec
);
4349 err
= create_loopback_mixing_ctl(codec
);
4352 err
= create_hp_mic(codec
);
4355 err
= create_input_ctls(codec
);
4359 spec
->const_channel_count
= spec
->ext_channel_count
;
4360 /* check the multiple speaker and headphone pins */
4361 if (cfg
->line_out_type
!= AUTO_PIN_SPEAKER_OUT
)
4362 spec
->const_channel_count
= max(spec
->const_channel_count
,
4363 cfg
->speaker_outs
* 2);
4364 if (cfg
->line_out_type
!= AUTO_PIN_HP_OUT
)
4365 spec
->const_channel_count
= max(spec
->const_channel_count
,
4367 spec
->multiout
.max_channels
= max(spec
->ext_channel_count
,
4368 spec
->const_channel_count
);
4370 err
= check_auto_mute_availability(codec
);
4374 err
= check_dyn_adc_switch(codec
);
4378 err
= check_auto_mic_availability(codec
);
4382 err
= create_capture_mixers(codec
);
4386 err
= parse_mic_boost(codec
);
4390 /* create "Headphone Mic Jack Mode" if no input selection is
4391 * available (or user specifies add_jack_modes hint)
4393 if (spec
->hp_mic_pin
&&
4394 (spec
->auto_mic
|| spec
->input_mux
.num_items
== 1 ||
4395 spec
->add_jack_modes
)) {
4396 err
= create_hp_mic_jack_mode(codec
, spec
->hp_mic_pin
);
4401 if (spec
->add_jack_modes
) {
4402 if (cfg
->line_out_type
!= AUTO_PIN_SPEAKER_OUT
) {
4403 err
= create_out_jack_modes(codec
, cfg
->line_outs
,
4404 cfg
->line_out_pins
);
4408 if (cfg
->line_out_type
!= AUTO_PIN_HP_OUT
) {
4409 err
= create_out_jack_modes(codec
, cfg
->hp_outs
,
4416 /* mute all aamix input initially */
4417 if (spec
->mixer_nid
)
4418 mute_all_mixer_nid(codec
, spec
->mixer_nid
);
4421 parse_digital(codec
);
4423 if (spec
->power_down_unused
)
4424 codec
->power_filter
= snd_hda_gen_path_power_filter
;
4426 if (!spec
->no_analog
&& spec
->beep_nid
) {
4427 err
= snd_hda_attach_beep_device(codec
, spec
->beep_nid
);
4434 EXPORT_SYMBOL_HDA(snd_hda_gen_parse_auto_config
);
4438 * Build control elements
4441 /* slave controls for virtual master */
4442 static const char * const slave_pfxs
[] = {
4443 "Front", "Surround", "Center", "LFE", "Side",
4444 "Headphone", "Speaker", "Mono", "Line Out",
4445 "CLFE", "Bass Speaker", "PCM",
4446 "Speaker Front", "Speaker Surround", "Speaker CLFE", "Speaker Side",
4447 "Headphone Front", "Headphone Surround", "Headphone CLFE",
4452 int snd_hda_gen_build_controls(struct hda_codec
*codec
)
4454 struct hda_gen_spec
*spec
= codec
->spec
;
4457 if (spec
->kctls
.used
) {
4458 err
= snd_hda_add_new_ctls(codec
, spec
->kctls
.list
);
4463 if (spec
->multiout
.dig_out_nid
) {
4464 err
= snd_hda_create_dig_out_ctls(codec
,
4465 spec
->multiout
.dig_out_nid
,
4466 spec
->multiout
.dig_out_nid
,
4467 spec
->pcm_rec
[1].pcm_type
);
4470 if (!spec
->no_analog
) {
4471 err
= snd_hda_create_spdif_share_sw(codec
,
4475 spec
->multiout
.share_spdif
= 1;
4478 if (spec
->dig_in_nid
) {
4479 err
= snd_hda_create_spdif_in_ctls(codec
, spec
->dig_in_nid
);
4484 /* if we have no master control, let's create it */
4485 if (!spec
->no_analog
&&
4486 !snd_hda_find_mixer_ctl(codec
, "Master Playback Volume")) {
4487 err
= snd_hda_add_vmaster(codec
, "Master Playback Volume",
4488 spec
->vmaster_tlv
, slave_pfxs
,
4493 if (!spec
->no_analog
&&
4494 !snd_hda_find_mixer_ctl(codec
, "Master Playback Switch")) {
4495 err
= __snd_hda_add_vmaster(codec
, "Master Playback Switch",
4498 true, &spec
->vmaster_mute
.sw_kctl
);
4501 if (spec
->vmaster_mute
.hook
) {
4502 snd_hda_add_vmaster_hook(codec
, &spec
->vmaster_mute
,
4503 spec
->vmaster_mute_enum
);
4504 snd_hda_sync_vmaster_hook(&spec
->vmaster_mute
);
4508 free_kctls(spec
); /* no longer needed */
4510 err
= snd_hda_jack_add_kctls(codec
, &spec
->autocfg
);
4516 EXPORT_SYMBOL_HDA(snd_hda_gen_build_controls
);
4523 static void call_pcm_playback_hook(struct hda_pcm_stream
*hinfo
,
4524 struct hda_codec
*codec
,
4525 struct snd_pcm_substream
*substream
,
4528 struct hda_gen_spec
*spec
= codec
->spec
;
4529 if (spec
->pcm_playback_hook
)
4530 spec
->pcm_playback_hook(hinfo
, codec
, substream
, action
);
4533 static void call_pcm_capture_hook(struct hda_pcm_stream
*hinfo
,
4534 struct hda_codec
*codec
,
4535 struct snd_pcm_substream
*substream
,
4538 struct hda_gen_spec
*spec
= codec
->spec
;
4539 if (spec
->pcm_capture_hook
)
4540 spec
->pcm_capture_hook(hinfo
, codec
, substream
, action
);
4544 * Analog playback callbacks
4546 static int playback_pcm_open(struct hda_pcm_stream
*hinfo
,
4547 struct hda_codec
*codec
,
4548 struct snd_pcm_substream
*substream
)
4550 struct hda_gen_spec
*spec
= codec
->spec
;
4553 mutex_lock(&spec
->pcm_mutex
);
4554 err
= snd_hda_multi_out_analog_open(codec
,
4555 &spec
->multiout
, substream
,
4558 spec
->active_streams
|= 1 << STREAM_MULTI_OUT
;
4559 call_pcm_playback_hook(hinfo
, codec
, substream
,
4560 HDA_GEN_PCM_ACT_OPEN
);
4562 mutex_unlock(&spec
->pcm_mutex
);
4566 static int playback_pcm_prepare(struct hda_pcm_stream
*hinfo
,
4567 struct hda_codec
*codec
,
4568 unsigned int stream_tag
,
4569 unsigned int format
,
4570 struct snd_pcm_substream
*substream
)
4572 struct hda_gen_spec
*spec
= codec
->spec
;
4575 err
= snd_hda_multi_out_analog_prepare(codec
, &spec
->multiout
,
4576 stream_tag
, format
, substream
);
4578 call_pcm_playback_hook(hinfo
, codec
, substream
,
4579 HDA_GEN_PCM_ACT_PREPARE
);
4583 static int playback_pcm_cleanup(struct hda_pcm_stream
*hinfo
,
4584 struct hda_codec
*codec
,
4585 struct snd_pcm_substream
*substream
)
4587 struct hda_gen_spec
*spec
= codec
->spec
;
4590 err
= snd_hda_multi_out_analog_cleanup(codec
, &spec
->multiout
);
4592 call_pcm_playback_hook(hinfo
, codec
, substream
,
4593 HDA_GEN_PCM_ACT_CLEANUP
);
4597 static int playback_pcm_close(struct hda_pcm_stream
*hinfo
,
4598 struct hda_codec
*codec
,
4599 struct snd_pcm_substream
*substream
)
4601 struct hda_gen_spec
*spec
= codec
->spec
;
4602 mutex_lock(&spec
->pcm_mutex
);
4603 spec
->active_streams
&= ~(1 << STREAM_MULTI_OUT
);
4604 call_pcm_playback_hook(hinfo
, codec
, substream
,
4605 HDA_GEN_PCM_ACT_CLOSE
);
4606 mutex_unlock(&spec
->pcm_mutex
);
4610 static int capture_pcm_open(struct hda_pcm_stream
*hinfo
,
4611 struct hda_codec
*codec
,
4612 struct snd_pcm_substream
*substream
)
4614 call_pcm_capture_hook(hinfo
, codec
, substream
, HDA_GEN_PCM_ACT_OPEN
);
4618 static int capture_pcm_prepare(struct hda_pcm_stream
*hinfo
,
4619 struct hda_codec
*codec
,
4620 unsigned int stream_tag
,
4621 unsigned int format
,
4622 struct snd_pcm_substream
*substream
)
4624 snd_hda_codec_setup_stream(codec
, hinfo
->nid
, stream_tag
, 0, format
);
4625 call_pcm_capture_hook(hinfo
, codec
, substream
,
4626 HDA_GEN_PCM_ACT_PREPARE
);
4630 static int capture_pcm_cleanup(struct hda_pcm_stream
*hinfo
,
4631 struct hda_codec
*codec
,
4632 struct snd_pcm_substream
*substream
)
4634 snd_hda_codec_cleanup_stream(codec
, hinfo
->nid
);
4635 call_pcm_capture_hook(hinfo
, codec
, substream
,
4636 HDA_GEN_PCM_ACT_CLEANUP
);
4640 static int capture_pcm_close(struct hda_pcm_stream
*hinfo
,
4641 struct hda_codec
*codec
,
4642 struct snd_pcm_substream
*substream
)
4644 call_pcm_capture_hook(hinfo
, codec
, substream
, HDA_GEN_PCM_ACT_CLOSE
);
4648 static int alt_playback_pcm_open(struct hda_pcm_stream
*hinfo
,
4649 struct hda_codec
*codec
,
4650 struct snd_pcm_substream
*substream
)
4652 struct hda_gen_spec
*spec
= codec
->spec
;
4655 mutex_lock(&spec
->pcm_mutex
);
4656 if (!spec
->indep_hp_enabled
)
4659 spec
->active_streams
|= 1 << STREAM_INDEP_HP
;
4660 call_pcm_playback_hook(hinfo
, codec
, substream
,
4661 HDA_GEN_PCM_ACT_OPEN
);
4662 mutex_unlock(&spec
->pcm_mutex
);
4666 static int alt_playback_pcm_close(struct hda_pcm_stream
*hinfo
,
4667 struct hda_codec
*codec
,
4668 struct snd_pcm_substream
*substream
)
4670 struct hda_gen_spec
*spec
= codec
->spec
;
4671 mutex_lock(&spec
->pcm_mutex
);
4672 spec
->active_streams
&= ~(1 << STREAM_INDEP_HP
);
4673 call_pcm_playback_hook(hinfo
, codec
, substream
,
4674 HDA_GEN_PCM_ACT_CLOSE
);
4675 mutex_unlock(&spec
->pcm_mutex
);
4679 static int alt_playback_pcm_prepare(struct hda_pcm_stream
*hinfo
,
4680 struct hda_codec
*codec
,
4681 unsigned int stream_tag
,
4682 unsigned int format
,
4683 struct snd_pcm_substream
*substream
)
4685 snd_hda_codec_setup_stream(codec
, hinfo
->nid
, stream_tag
, 0, format
);
4686 call_pcm_playback_hook(hinfo
, codec
, substream
,
4687 HDA_GEN_PCM_ACT_PREPARE
);
4691 static int alt_playback_pcm_cleanup(struct hda_pcm_stream
*hinfo
,
4692 struct hda_codec
*codec
,
4693 struct snd_pcm_substream
*substream
)
4695 snd_hda_codec_cleanup_stream(codec
, hinfo
->nid
);
4696 call_pcm_playback_hook(hinfo
, codec
, substream
,
4697 HDA_GEN_PCM_ACT_CLEANUP
);
4704 static int dig_playback_pcm_open(struct hda_pcm_stream
*hinfo
,
4705 struct hda_codec
*codec
,
4706 struct snd_pcm_substream
*substream
)
4708 struct hda_gen_spec
*spec
= codec
->spec
;
4709 return snd_hda_multi_out_dig_open(codec
, &spec
->multiout
);
4712 static int dig_playback_pcm_prepare(struct hda_pcm_stream
*hinfo
,
4713 struct hda_codec
*codec
,
4714 unsigned int stream_tag
,
4715 unsigned int format
,
4716 struct snd_pcm_substream
*substream
)
4718 struct hda_gen_spec
*spec
= codec
->spec
;
4719 return snd_hda_multi_out_dig_prepare(codec
, &spec
->multiout
,
4720 stream_tag
, format
, substream
);
4723 static int dig_playback_pcm_cleanup(struct hda_pcm_stream
*hinfo
,
4724 struct hda_codec
*codec
,
4725 struct snd_pcm_substream
*substream
)
4727 struct hda_gen_spec
*spec
= codec
->spec
;
4728 return snd_hda_multi_out_dig_cleanup(codec
, &spec
->multiout
);
4731 static int dig_playback_pcm_close(struct hda_pcm_stream
*hinfo
,
4732 struct hda_codec
*codec
,
4733 struct snd_pcm_substream
*substream
)
4735 struct hda_gen_spec
*spec
= codec
->spec
;
4736 return snd_hda_multi_out_dig_close(codec
, &spec
->multiout
);
4742 #define alt_capture_pcm_open capture_pcm_open
4743 #define alt_capture_pcm_close capture_pcm_close
4745 static int alt_capture_pcm_prepare(struct hda_pcm_stream
*hinfo
,
4746 struct hda_codec
*codec
,
4747 unsigned int stream_tag
,
4748 unsigned int format
,
4749 struct snd_pcm_substream
*substream
)
4751 struct hda_gen_spec
*spec
= codec
->spec
;
4753 snd_hda_codec_setup_stream(codec
, spec
->adc_nids
[substream
->number
+ 1],
4754 stream_tag
, 0, format
);
4755 call_pcm_capture_hook(hinfo
, codec
, substream
,
4756 HDA_GEN_PCM_ACT_PREPARE
);
4760 static int alt_capture_pcm_cleanup(struct hda_pcm_stream
*hinfo
,
4761 struct hda_codec
*codec
,
4762 struct snd_pcm_substream
*substream
)
4764 struct hda_gen_spec
*spec
= codec
->spec
;
4766 snd_hda_codec_cleanup_stream(codec
,
4767 spec
->adc_nids
[substream
->number
+ 1]);
4768 call_pcm_capture_hook(hinfo
, codec
, substream
,
4769 HDA_GEN_PCM_ACT_CLEANUP
);
4775 static const struct hda_pcm_stream pcm_analog_playback
= {
4779 /* NID is set in build_pcms */
4781 .open
= playback_pcm_open
,
4782 .close
= playback_pcm_close
,
4783 .prepare
= playback_pcm_prepare
,
4784 .cleanup
= playback_pcm_cleanup
4788 static const struct hda_pcm_stream pcm_analog_capture
= {
4792 /* NID is set in build_pcms */
4794 .open
= capture_pcm_open
,
4795 .close
= capture_pcm_close
,
4796 .prepare
= capture_pcm_prepare
,
4797 .cleanup
= capture_pcm_cleanup
4801 static const struct hda_pcm_stream pcm_analog_alt_playback
= {
4805 /* NID is set in build_pcms */
4807 .open
= alt_playback_pcm_open
,
4808 .close
= alt_playback_pcm_close
,
4809 .prepare
= alt_playback_pcm_prepare
,
4810 .cleanup
= alt_playback_pcm_cleanup
4814 static const struct hda_pcm_stream pcm_analog_alt_capture
= {
4815 .substreams
= 2, /* can be overridden */
4818 /* NID is set in build_pcms */
4820 .open
= alt_capture_pcm_open
,
4821 .close
= alt_capture_pcm_close
,
4822 .prepare
= alt_capture_pcm_prepare
,
4823 .cleanup
= alt_capture_pcm_cleanup
4827 static const struct hda_pcm_stream pcm_digital_playback
= {
4831 /* NID is set in build_pcms */
4833 .open
= dig_playback_pcm_open
,
4834 .close
= dig_playback_pcm_close
,
4835 .prepare
= dig_playback_pcm_prepare
,
4836 .cleanup
= dig_playback_pcm_cleanup
4840 static const struct hda_pcm_stream pcm_digital_capture
= {
4844 /* NID is set in build_pcms */
4847 /* Used by build_pcms to flag that a PCM has no playback stream */
4848 static const struct hda_pcm_stream pcm_null_stream
= {
4855 * dynamic changing ADC PCM streams
4857 static bool dyn_adc_pcm_resetup(struct hda_codec
*codec
, int cur
)
4859 struct hda_gen_spec
*spec
= codec
->spec
;
4860 hda_nid_t new_adc
= spec
->adc_nids
[spec
->dyn_adc_idx
[cur
]];
4862 if (spec
->cur_adc
&& spec
->cur_adc
!= new_adc
) {
4863 /* stream is running, let's swap the current ADC */
4864 __snd_hda_codec_cleanup_stream(codec
, spec
->cur_adc
, 1);
4865 spec
->cur_adc
= new_adc
;
4866 snd_hda_codec_setup_stream(codec
, new_adc
,
4867 spec
->cur_adc_stream_tag
, 0,
4868 spec
->cur_adc_format
);
4874 /* analog capture with dynamic dual-adc changes */
4875 static int dyn_adc_capture_pcm_prepare(struct hda_pcm_stream
*hinfo
,
4876 struct hda_codec
*codec
,
4877 unsigned int stream_tag
,
4878 unsigned int format
,
4879 struct snd_pcm_substream
*substream
)
4881 struct hda_gen_spec
*spec
= codec
->spec
;
4882 spec
->cur_adc
= spec
->adc_nids
[spec
->dyn_adc_idx
[spec
->cur_mux
[0]]];
4883 spec
->cur_adc_stream_tag
= stream_tag
;
4884 spec
->cur_adc_format
= format
;
4885 snd_hda_codec_setup_stream(codec
, spec
->cur_adc
, stream_tag
, 0, format
);
4889 static int dyn_adc_capture_pcm_cleanup(struct hda_pcm_stream
*hinfo
,
4890 struct hda_codec
*codec
,
4891 struct snd_pcm_substream
*substream
)
4893 struct hda_gen_spec
*spec
= codec
->spec
;
4894 snd_hda_codec_cleanup_stream(codec
, spec
->cur_adc
);
4899 static const struct hda_pcm_stream dyn_adc_pcm_analog_capture
= {
4903 .nid
= 0, /* fill later */
4905 .prepare
= dyn_adc_capture_pcm_prepare
,
4906 .cleanup
= dyn_adc_capture_pcm_cleanup
4910 static void fill_pcm_stream_name(char *str
, size_t len
, const char *sfx
,
4911 const char *chip_name
)
4917 strlcpy(str
, chip_name
, len
);
4919 /* drop non-alnum chars after a space */
4920 for (p
= strchr(str
, ' '); p
; p
= strchr(p
+ 1, ' ')) {
4921 if (!isalnum(p
[1])) {
4926 strlcat(str
, sfx
, len
);
4929 /* build PCM streams based on the parsed results */
4930 int snd_hda_gen_build_pcms(struct hda_codec
*codec
)
4932 struct hda_gen_spec
*spec
= codec
->spec
;
4933 struct hda_pcm
*info
= spec
->pcm_rec
;
4934 const struct hda_pcm_stream
*p
;
4935 bool have_multi_adcs
;
4937 codec
->num_pcms
= 1;
4938 codec
->pcm_info
= info
;
4940 if (spec
->no_analog
)
4943 fill_pcm_stream_name(spec
->stream_name_analog
,
4944 sizeof(spec
->stream_name_analog
),
4945 " Analog", codec
->chip_name
);
4946 info
->name
= spec
->stream_name_analog
;
4948 if (spec
->multiout
.num_dacs
> 0) {
4949 p
= spec
->stream_analog_playback
;
4951 p
= &pcm_analog_playback
;
4952 info
->stream
[SNDRV_PCM_STREAM_PLAYBACK
] = *p
;
4953 info
->stream
[SNDRV_PCM_STREAM_PLAYBACK
].nid
= spec
->multiout
.dac_nids
[0];
4954 info
->stream
[SNDRV_PCM_STREAM_PLAYBACK
].channels_max
=
4955 spec
->multiout
.max_channels
;
4956 if (spec
->autocfg
.line_out_type
== AUTO_PIN_SPEAKER_OUT
&&
4957 spec
->autocfg
.line_outs
== 2)
4958 info
->stream
[SNDRV_PCM_STREAM_PLAYBACK
].chmap
=
4961 if (spec
->num_adc_nids
) {
4962 p
= spec
->stream_analog_capture
;
4964 if (spec
->dyn_adc_switch
)
4965 p
= &dyn_adc_pcm_analog_capture
;
4967 p
= &pcm_analog_capture
;
4969 info
->stream
[SNDRV_PCM_STREAM_CAPTURE
] = *p
;
4970 info
->stream
[SNDRV_PCM_STREAM_CAPTURE
].nid
= spec
->adc_nids
[0];
4974 /* SPDIF for stream index #1 */
4975 if (spec
->multiout
.dig_out_nid
|| spec
->dig_in_nid
) {
4976 fill_pcm_stream_name(spec
->stream_name_digital
,
4977 sizeof(spec
->stream_name_digital
),
4978 " Digital", codec
->chip_name
);
4979 codec
->num_pcms
= 2;
4980 codec
->slave_dig_outs
= spec
->multiout
.slave_dig_outs
;
4981 info
= spec
->pcm_rec
+ 1;
4982 info
->name
= spec
->stream_name_digital
;
4983 if (spec
->dig_out_type
)
4984 info
->pcm_type
= spec
->dig_out_type
;
4986 info
->pcm_type
= HDA_PCM_TYPE_SPDIF
;
4987 if (spec
->multiout
.dig_out_nid
) {
4988 p
= spec
->stream_digital_playback
;
4990 p
= &pcm_digital_playback
;
4991 info
->stream
[SNDRV_PCM_STREAM_PLAYBACK
] = *p
;
4992 info
->stream
[SNDRV_PCM_STREAM_PLAYBACK
].nid
= spec
->multiout
.dig_out_nid
;
4994 if (spec
->dig_in_nid
) {
4995 p
= spec
->stream_digital_capture
;
4997 p
= &pcm_digital_capture
;
4998 info
->stream
[SNDRV_PCM_STREAM_CAPTURE
] = *p
;
4999 info
->stream
[SNDRV_PCM_STREAM_CAPTURE
].nid
= spec
->dig_in_nid
;
5003 if (spec
->no_analog
)
5006 /* If the use of more than one ADC is requested for the current
5007 * model, configure a second analog capture-only PCM.
5009 have_multi_adcs
= (spec
->num_adc_nids
> 1) &&
5010 !spec
->dyn_adc_switch
&& !spec
->auto_mic
;
5011 /* Additional Analaog capture for index #2 */
5012 if (spec
->alt_dac_nid
|| have_multi_adcs
) {
5013 fill_pcm_stream_name(spec
->stream_name_alt_analog
,
5014 sizeof(spec
->stream_name_alt_analog
),
5015 " Alt Analog", codec
->chip_name
);
5016 codec
->num_pcms
= 3;
5017 info
= spec
->pcm_rec
+ 2;
5018 info
->name
= spec
->stream_name_alt_analog
;
5019 if (spec
->alt_dac_nid
) {
5020 p
= spec
->stream_analog_alt_playback
;
5022 p
= &pcm_analog_alt_playback
;
5023 info
->stream
[SNDRV_PCM_STREAM_PLAYBACK
] = *p
;
5024 info
->stream
[SNDRV_PCM_STREAM_PLAYBACK
].nid
=
5027 info
->stream
[SNDRV_PCM_STREAM_PLAYBACK
] =
5029 info
->stream
[SNDRV_PCM_STREAM_PLAYBACK
].nid
= 0;
5031 if (have_multi_adcs
) {
5032 p
= spec
->stream_analog_alt_capture
;
5034 p
= &pcm_analog_alt_capture
;
5035 info
->stream
[SNDRV_PCM_STREAM_CAPTURE
] = *p
;
5036 info
->stream
[SNDRV_PCM_STREAM_CAPTURE
].nid
=
5038 info
->stream
[SNDRV_PCM_STREAM_CAPTURE
].substreams
=
5039 spec
->num_adc_nids
- 1;
5041 info
->stream
[SNDRV_PCM_STREAM_CAPTURE
] =
5043 info
->stream
[SNDRV_PCM_STREAM_CAPTURE
].nid
= 0;
5049 EXPORT_SYMBOL_HDA(snd_hda_gen_build_pcms
);
5053 * Standard auto-parser initializations
5056 /* configure the given path as a proper output */
5057 static void set_output_and_unmute(struct hda_codec
*codec
, int path_idx
)
5059 struct nid_path
*path
;
5062 path
= snd_hda_get_path_from_idx(codec
, path_idx
);
5063 if (!path
|| !path
->depth
)
5065 pin
= path
->path
[path
->depth
- 1];
5066 restore_pin_ctl(codec
, pin
);
5067 snd_hda_activate_path(codec
, path
, path
->active
,
5068 aamix_default(codec
->spec
));
5069 set_pin_eapd(codec
, pin
, path
->active
);
5072 /* initialize primary output paths */
5073 static void init_multi_out(struct hda_codec
*codec
)
5075 struct hda_gen_spec
*spec
= codec
->spec
;
5078 for (i
= 0; i
< spec
->autocfg
.line_outs
; i
++)
5079 set_output_and_unmute(codec
, spec
->out_paths
[i
]);
5083 static void __init_extra_out(struct hda_codec
*codec
, int num_outs
, int *paths
)
5087 for (i
= 0; i
< num_outs
; i
++)
5088 set_output_and_unmute(codec
, paths
[i
]);
5091 /* initialize hp and speaker paths */
5092 static void init_extra_out(struct hda_codec
*codec
)
5094 struct hda_gen_spec
*spec
= codec
->spec
;
5096 if (spec
->autocfg
.line_out_type
!= AUTO_PIN_HP_OUT
)
5097 __init_extra_out(codec
, spec
->autocfg
.hp_outs
, spec
->hp_paths
);
5098 if (spec
->autocfg
.line_out_type
!= AUTO_PIN_SPEAKER_OUT
)
5099 __init_extra_out(codec
, spec
->autocfg
.speaker_outs
,
5100 spec
->speaker_paths
);
5103 /* initialize multi-io paths */
5104 static void init_multi_io(struct hda_codec
*codec
)
5106 struct hda_gen_spec
*spec
= codec
->spec
;
5109 for (i
= 0; i
< spec
->multi_ios
; i
++) {
5110 hda_nid_t pin
= spec
->multi_io
[i
].pin
;
5111 struct nid_path
*path
;
5112 path
= get_multiio_path(codec
, i
);
5115 if (!spec
->multi_io
[i
].ctl_in
)
5116 spec
->multi_io
[i
].ctl_in
=
5117 snd_hda_codec_get_pin_target(codec
, pin
);
5118 snd_hda_activate_path(codec
, path
, path
->active
,
5119 aamix_default(spec
));
5123 /* set up input pins and loopback paths */
5124 static void init_analog_input(struct hda_codec
*codec
)
5126 struct hda_gen_spec
*spec
= codec
->spec
;
5127 struct auto_pin_cfg
*cfg
= &spec
->autocfg
;
5130 for (i
= 0; i
< cfg
->num_inputs
; i
++) {
5131 hda_nid_t nid
= cfg
->inputs
[i
].pin
;
5132 if (is_input_pin(codec
, nid
))
5133 restore_pin_ctl(codec
, nid
);
5135 /* init loopback inputs */
5136 if (spec
->mixer_nid
) {
5137 resume_path_from_idx(codec
, spec
->loopback_paths
[i
]);
5138 resume_path_from_idx(codec
, spec
->loopback_merge_path
);
5143 /* initialize ADC paths */
5144 static void init_input_src(struct hda_codec
*codec
)
5146 struct hda_gen_spec
*spec
= codec
->spec
;
5147 struct hda_input_mux
*imux
= &spec
->input_mux
;
5148 struct nid_path
*path
;
5151 if (spec
->dyn_adc_switch
)
5154 nums
= spec
->num_adc_nids
;
5156 for (c
= 0; c
< nums
; c
++) {
5157 for (i
= 0; i
< imux
->num_items
; i
++) {
5158 path
= get_input_path(codec
, c
, i
);
5160 bool active
= path
->active
;
5161 if (i
== spec
->cur_mux
[c
])
5163 snd_hda_activate_path(codec
, path
, active
, false);
5167 update_hp_mic(codec
, c
, true);
5170 if (spec
->cap_sync_hook
)
5171 spec
->cap_sync_hook(codec
, NULL
);
5174 /* set right pin controls for digital I/O */
5175 static void init_digital(struct hda_codec
*codec
)
5177 struct hda_gen_spec
*spec
= codec
->spec
;
5181 for (i
= 0; i
< spec
->autocfg
.dig_outs
; i
++)
5182 set_output_and_unmute(codec
, spec
->digout_paths
[i
]);
5183 pin
= spec
->autocfg
.dig_in_pin
;
5185 restore_pin_ctl(codec
, pin
);
5186 resume_path_from_idx(codec
, spec
->digin_path
);
5190 /* clear unsol-event tags on unused pins; Conexant codecs seem to leave
5191 * invalid unsol tags by some reason
5193 static void clear_unsol_on_unused_pins(struct hda_codec
*codec
)
5197 for (i
= 0; i
< codec
->init_pins
.used
; i
++) {
5198 struct hda_pincfg
*pin
= snd_array_elem(&codec
->init_pins
, i
);
5199 hda_nid_t nid
= pin
->nid
;
5200 if (is_jack_detectable(codec
, nid
) &&
5201 !snd_hda_jack_tbl_get(codec
, nid
))
5202 snd_hda_codec_update_cache(codec
, nid
, 0,
5203 AC_VERB_SET_UNSOLICITED_ENABLE
, 0);
5208 * initialize the generic spec;
5209 * this can be put as patch_ops.init function
5211 int snd_hda_gen_init(struct hda_codec
*codec
)
5213 struct hda_gen_spec
*spec
= codec
->spec
;
5215 if (spec
->init_hook
)
5216 spec
->init_hook(codec
);
5218 snd_hda_apply_verbs(codec
);
5220 codec
->cached_write
= 1;
5222 init_multi_out(codec
);
5223 init_extra_out(codec
);
5224 init_multi_io(codec
);
5225 init_analog_input(codec
);
5226 init_input_src(codec
);
5227 init_digital(codec
);
5229 clear_unsol_on_unused_pins(codec
);
5231 /* call init functions of standard auto-mute helpers */
5232 update_automute_all(codec
);
5234 snd_hda_codec_flush_cache(codec
);
5236 if (spec
->vmaster_mute
.sw_kctl
&& spec
->vmaster_mute
.hook
)
5237 snd_hda_sync_vmaster_hook(&spec
->vmaster_mute
);
5239 hda_call_check_power_status(codec
, 0x01);
5242 EXPORT_SYMBOL_HDA(snd_hda_gen_init
);
5245 * free the generic spec;
5246 * this can be put as patch_ops.free function
5248 void snd_hda_gen_free(struct hda_codec
*codec
)
5250 snd_hda_detach_beep_device(codec
);
5251 snd_hda_gen_spec_free(codec
->spec
);
5255 EXPORT_SYMBOL_HDA(snd_hda_gen_free
);
5259 * check the loopback power save state;
5260 * this can be put as patch_ops.check_power_status function
5262 int snd_hda_gen_check_power_status(struct hda_codec
*codec
, hda_nid_t nid
)
5264 struct hda_gen_spec
*spec
= codec
->spec
;
5265 return snd_hda_check_amp_list_power(codec
, &spec
->loopback
, nid
);
5267 EXPORT_SYMBOL_HDA(snd_hda_gen_check_power_status
);
5272 * the generic codec support
5275 static const struct hda_codec_ops generic_patch_ops
= {
5276 .build_controls
= snd_hda_gen_build_controls
,
5277 .build_pcms
= snd_hda_gen_build_pcms
,
5278 .init
= snd_hda_gen_init
,
5279 .free
= snd_hda_gen_free
,
5280 .unsol_event
= snd_hda_jack_unsol_event
,
5282 .check_power_status
= snd_hda_gen_check_power_status
,
5286 int snd_hda_parse_generic_codec(struct hda_codec
*codec
)
5288 struct hda_gen_spec
*spec
;
5291 spec
= kzalloc(sizeof(*spec
), GFP_KERNEL
);
5294 snd_hda_gen_spec_init(spec
);
5297 err
= snd_hda_parse_pin_defcfg(codec
, &spec
->autocfg
, NULL
, 0);
5301 err
= snd_hda_gen_parse_auto_config(codec
, &spec
->autocfg
);
5305 codec
->patch_ops
= generic_patch_ops
;
5309 snd_hda_gen_free(codec
);
5312 EXPORT_SYMBOL_HDA(snd_hda_parse_generic_codec
);