xref: /linux/sound/pci/hda/hda_generic.c (revision 6b779f8a8648848d74c24b07d0e2436c00211788)
1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3  * Universal Interface for Intel High Definition Audio Codec
4  *
5  * Generic widget tree parser
6  *
7  * Copyright (c) 2004 Takashi Iwai <tiwai@suse.de>
8  */
9 
10 #include <linux/init.h>
11 #include <linux/slab.h>
12 #include <linux/export.h>
13 #include <linux/sort.h>
14 #include <linux/delay.h>
15 #include <linux/ctype.h>
16 #include <linux/string.h>
17 #include <linux/bitops.h>
18 #include <linux/module.h>
19 #include <linux/leds.h>
20 #include <sound/core.h>
21 #include <sound/jack.h>
22 #include <sound/tlv.h>
23 #include <sound/hda_codec.h>
24 #include "hda_local.h"
25 #include "hda_auto_parser.h"
26 #include "hda_jack.h"
27 #include "hda_beep.h"
28 #include "hda_generic.h"
29 
30 
31 /**
32  * snd_hda_gen_spec_init - initialize hda_gen_spec struct
33  * @spec: hda_gen_spec object to initialize
34  *
35  * Initialize the given hda_gen_spec object.
36  */
snd_hda_gen_spec_init(struct hda_gen_spec * spec)37 int snd_hda_gen_spec_init(struct hda_gen_spec *spec)
38 {
39 	snd_array_init(&spec->kctls, sizeof(struct snd_kcontrol_new), 32);
40 	snd_array_init(&spec->paths, sizeof(struct nid_path), 8);
41 	snd_array_init(&spec->loopback_list, sizeof(struct hda_amp_list), 8);
42 	mutex_init(&spec->pcm_mutex);
43 	return 0;
44 }
45 EXPORT_SYMBOL_GPL(snd_hda_gen_spec_init);
46 
47 /**
48  * snd_hda_gen_add_kctl - Add a new kctl_new struct from the template
49  * @spec: hda_gen_spec object
50  * @name: name string to override the template, NULL if unchanged
51  * @temp: template for the new kctl
52  *
53  * Add a new kctl (actually snd_kcontrol_new to be instantiated later)
54  * element based on the given snd_kcontrol_new template @temp and the
55  * name string @name to the list in @spec.
56  * Returns the newly created object or NULL as error.
57  */
58 struct snd_kcontrol_new *
snd_hda_gen_add_kctl(struct hda_gen_spec * spec,const char * name,const struct snd_kcontrol_new * temp)59 snd_hda_gen_add_kctl(struct hda_gen_spec *spec, const char *name,
60 		     const struct snd_kcontrol_new *temp)
61 {
62 	struct snd_kcontrol_new *knew = snd_array_new(&spec->kctls);
63 	if (!knew)
64 		return NULL;
65 	*knew = *temp;
66 	if (name)
67 		knew->name = kstrdup(name, GFP_KERNEL);
68 	else if (knew->name)
69 		knew->name = kstrdup(knew->name, GFP_KERNEL);
70 	if (!knew->name)
71 		return NULL;
72 	return knew;
73 }
74 EXPORT_SYMBOL_GPL(snd_hda_gen_add_kctl);
75 
free_kctls(struct hda_gen_spec * spec)76 static void free_kctls(struct hda_gen_spec *spec)
77 {
78 	if (spec->kctls.list) {
79 		struct snd_kcontrol_new *kctl = spec->kctls.list;
80 		int i;
81 		for (i = 0; i < spec->kctls.used; i++)
82 			kfree(kctl[i].name);
83 	}
84 	snd_array_free(&spec->kctls);
85 }
86 
snd_hda_gen_spec_free(struct hda_gen_spec * spec)87 static void snd_hda_gen_spec_free(struct hda_gen_spec *spec)
88 {
89 	if (!spec)
90 		return;
91 	free_kctls(spec);
92 	snd_array_free(&spec->paths);
93 	snd_array_free(&spec->loopback_list);
94 #ifdef CONFIG_SND_HDA_GENERIC_LEDS
95 	if (spec->led_cdevs[LED_AUDIO_MUTE])
96 		led_classdev_unregister(spec->led_cdevs[LED_AUDIO_MUTE]);
97 	if (spec->led_cdevs[LED_AUDIO_MICMUTE])
98 		led_classdev_unregister(spec->led_cdevs[LED_AUDIO_MICMUTE]);
99 #endif
100 }
101 
102 /*
103  * store user hints
104  */
parse_user_hints(struct hda_codec * codec)105 static void parse_user_hints(struct hda_codec *codec)
106 {
107 	struct hda_gen_spec *spec = codec->spec;
108 	int val;
109 
110 	val = snd_hda_get_bool_hint(codec, "jack_detect");
111 	if (val >= 0)
112 		codec->no_jack_detect = !val;
113 	val = snd_hda_get_bool_hint(codec, "inv_jack_detect");
114 	if (val >= 0)
115 		codec->inv_jack_detect = !!val;
116 	val = snd_hda_get_bool_hint(codec, "trigger_sense");
117 	if (val >= 0)
118 		codec->no_trigger_sense = !val;
119 	val = snd_hda_get_bool_hint(codec, "inv_eapd");
120 	if (val >= 0)
121 		codec->inv_eapd = !!val;
122 	val = snd_hda_get_bool_hint(codec, "pcm_format_first");
123 	if (val >= 0)
124 		codec->pcm_format_first = !!val;
125 	val = snd_hda_get_bool_hint(codec, "sticky_stream");
126 	if (val >= 0)
127 		codec->no_sticky_stream = !val;
128 	val = snd_hda_get_bool_hint(codec, "spdif_status_reset");
129 	if (val >= 0)
130 		codec->spdif_status_reset = !!val;
131 	val = snd_hda_get_bool_hint(codec, "pin_amp_workaround");
132 	if (val >= 0)
133 		codec->pin_amp_workaround = !!val;
134 	val = snd_hda_get_bool_hint(codec, "single_adc_amp");
135 	if (val >= 0)
136 		codec->single_adc_amp = !!val;
137 	val = snd_hda_get_bool_hint(codec, "power_save_node");
138 	if (val >= 0)
139 		codec->power_save_node = !!val;
140 
141 	val = snd_hda_get_bool_hint(codec, "auto_mute");
142 	if (val >= 0)
143 		spec->suppress_auto_mute = !val;
144 	val = snd_hda_get_bool_hint(codec, "auto_mic");
145 	if (val >= 0)
146 		spec->suppress_auto_mic = !val;
147 	val = snd_hda_get_bool_hint(codec, "line_in_auto_switch");
148 	if (val >= 0)
149 		spec->line_in_auto_switch = !!val;
150 	val = snd_hda_get_bool_hint(codec, "auto_mute_via_amp");
151 	if (val >= 0)
152 		spec->auto_mute_via_amp = !!val;
153 	val = snd_hda_get_bool_hint(codec, "need_dac_fix");
154 	if (val >= 0)
155 		spec->need_dac_fix = !!val;
156 	val = snd_hda_get_bool_hint(codec, "primary_hp");
157 	if (val >= 0)
158 		spec->no_primary_hp = !val;
159 	val = snd_hda_get_bool_hint(codec, "multi_io");
160 	if (val >= 0)
161 		spec->no_multi_io = !val;
162 	val = snd_hda_get_bool_hint(codec, "multi_cap_vol");
163 	if (val >= 0)
164 		spec->multi_cap_vol = !!val;
165 	val = snd_hda_get_bool_hint(codec, "inv_dmic_split");
166 	if (val >= 0)
167 		spec->inv_dmic_split = !!val;
168 	val = snd_hda_get_bool_hint(codec, "indep_hp");
169 	if (val >= 0)
170 		spec->indep_hp = !!val;
171 	val = snd_hda_get_bool_hint(codec, "add_stereo_mix_input");
172 	if (val >= 0)
173 		spec->add_stereo_mix_input = !!val;
174 	/* the following two are just for compatibility */
175 	val = snd_hda_get_bool_hint(codec, "add_out_jack_modes");
176 	if (val >= 0)
177 		spec->add_jack_modes = !!val;
178 	val = snd_hda_get_bool_hint(codec, "add_in_jack_modes");
179 	if (val >= 0)
180 		spec->add_jack_modes = !!val;
181 	val = snd_hda_get_bool_hint(codec, "add_jack_modes");
182 	if (val >= 0)
183 		spec->add_jack_modes = !!val;
184 	val = snd_hda_get_bool_hint(codec, "power_down_unused");
185 	if (val >= 0)
186 		spec->power_down_unused = !!val;
187 	val = snd_hda_get_bool_hint(codec, "add_hp_mic");
188 	if (val >= 0)
189 		spec->hp_mic = !!val;
190 	val = snd_hda_get_bool_hint(codec, "hp_mic_detect");
191 	if (val >= 0)
192 		spec->suppress_hp_mic_detect = !val;
193 	val = snd_hda_get_bool_hint(codec, "vmaster");
194 	if (val >= 0)
195 		spec->suppress_vmaster = !val;
196 
197 	if (!snd_hda_get_int_hint(codec, "mixer_nid", &val))
198 		spec->mixer_nid = val;
199 }
200 
201 /*
202  * pin control value accesses
203  */
204 
205 #define update_pin_ctl(codec, pin, val) \
206 	snd_hda_codec_write_cache(codec, pin, 0, \
207 				   AC_VERB_SET_PIN_WIDGET_CONTROL, val)
208 
209 /* restore the pinctl based on the cached value */
restore_pin_ctl(struct hda_codec * codec,hda_nid_t pin)210 static inline void restore_pin_ctl(struct hda_codec *codec, hda_nid_t pin)
211 {
212 	update_pin_ctl(codec, pin, snd_hda_codec_get_pin_target(codec, pin));
213 }
214 
215 /* set the pinctl target value and write it if requested */
set_pin_target(struct hda_codec * codec,hda_nid_t pin,unsigned int val,bool do_write)216 static void set_pin_target(struct hda_codec *codec, hda_nid_t pin,
217 			   unsigned int val, bool do_write)
218 {
219 	if (!pin)
220 		return;
221 	val = snd_hda_correct_pin_ctl(codec, pin, val);
222 	snd_hda_codec_set_pin_target(codec, pin, val);
223 	if (do_write)
224 		update_pin_ctl(codec, pin, val);
225 }
226 
227 /* set pinctl target values for all given pins */
set_pin_targets(struct hda_codec * codec,int num_pins,hda_nid_t * pins,unsigned int val)228 static void set_pin_targets(struct hda_codec *codec, int num_pins,
229 			    hda_nid_t *pins, unsigned int val)
230 {
231 	int i;
232 	for (i = 0; i < num_pins; i++)
233 		set_pin_target(codec, pins[i], val, false);
234 }
235 
236 /*
237  * parsing paths
238  */
239 
240 /* return the position of NID in the list, or -1 if not found */
find_idx_in_nid_list(hda_nid_t nid,const hda_nid_t * list,int nums)241 static int find_idx_in_nid_list(hda_nid_t nid, const hda_nid_t *list, int nums)
242 {
243 	int i;
244 	for (i = 0; i < nums; i++)
245 		if (list[i] == nid)
246 			return i;
247 	return -1;
248 }
249 
250 /* return true if the given NID is contained in the path */
is_nid_contained(struct nid_path * path,hda_nid_t nid)251 static bool is_nid_contained(struct nid_path *path, hda_nid_t nid)
252 {
253 	return find_idx_in_nid_list(nid, path->path, path->depth) >= 0;
254 }
255 
get_nid_path(struct hda_codec * codec,hda_nid_t from_nid,hda_nid_t to_nid,int anchor_nid)256 static struct nid_path *get_nid_path(struct hda_codec *codec,
257 				     hda_nid_t from_nid, hda_nid_t to_nid,
258 				     int anchor_nid)
259 {
260 	struct hda_gen_spec *spec = codec->spec;
261 	struct nid_path *path;
262 	int i;
263 
264 	snd_array_for_each(&spec->paths, i, path) {
265 		if (path->depth <= 0)
266 			continue;
267 		if ((!from_nid || path->path[0] == from_nid) &&
268 		    (!to_nid || path->path[path->depth - 1] == to_nid)) {
269 			if (!anchor_nid ||
270 			    (anchor_nid > 0 && is_nid_contained(path, anchor_nid)) ||
271 			    (anchor_nid < 0 && !is_nid_contained(path, anchor_nid)))
272 				return path;
273 		}
274 	}
275 	return NULL;
276 }
277 
278 /**
279  * snd_hda_get_path_idx - get the index number corresponding to the path
280  * instance
281  * @codec: the HDA codec
282  * @path: nid_path object
283  *
284  * The returned index starts from 1, i.e. the actual array index with offset 1,
285  * and zero is handled as an invalid path
286  */
snd_hda_get_path_idx(struct hda_codec * codec,struct nid_path * path)287 int snd_hda_get_path_idx(struct hda_codec *codec, struct nid_path *path)
288 {
289 	struct hda_gen_spec *spec = codec->spec;
290 	struct nid_path *array = spec->paths.list;
291 	ssize_t idx;
292 
293 	if (!spec->paths.used)
294 		return 0;
295 	idx = path - array;
296 	if (idx < 0 || idx >= spec->paths.used)
297 		return 0;
298 	return idx + 1;
299 }
300 EXPORT_SYMBOL_GPL(snd_hda_get_path_idx);
301 
302 /**
303  * snd_hda_get_path_from_idx - get the path instance corresponding to the
304  * given index number
305  * @codec: the HDA codec
306  * @idx: the path index
307  */
snd_hda_get_path_from_idx(struct hda_codec * codec,int idx)308 struct nid_path *snd_hda_get_path_from_idx(struct hda_codec *codec, int idx)
309 {
310 	struct hda_gen_spec *spec = codec->spec;
311 
312 	if (idx <= 0 || idx > spec->paths.used)
313 		return NULL;
314 	return snd_array_elem(&spec->paths, idx - 1);
315 }
316 EXPORT_SYMBOL_GPL(snd_hda_get_path_from_idx);
317 
318 /* check whether the given DAC is already found in any existing paths */
is_dac_already_used(struct hda_codec * codec,hda_nid_t nid)319 static bool is_dac_already_used(struct hda_codec *codec, hda_nid_t nid)
320 {
321 	struct hda_gen_spec *spec = codec->spec;
322 	const struct nid_path *path;
323 	int i;
324 
325 	snd_array_for_each(&spec->paths, i, path) {
326 		if (path->path[0] == nid)
327 			return true;
328 	}
329 	return false;
330 }
331 
332 /* check whether the given two widgets can be connected */
is_reachable_path(struct hda_codec * codec,hda_nid_t from_nid,hda_nid_t to_nid)333 static bool is_reachable_path(struct hda_codec *codec,
334 			      hda_nid_t from_nid, hda_nid_t to_nid)
335 {
336 	if (!from_nid || !to_nid)
337 		return false;
338 	return snd_hda_get_conn_index(codec, to_nid, from_nid, true) >= 0;
339 }
340 
341 /* nid, dir and idx */
342 #define AMP_VAL_COMPARE_MASK	(0xffff | (1U << 18) | (0x0f << 19))
343 
344 /* check whether the given ctl is already assigned in any path elements */
is_ctl_used(struct hda_codec * codec,unsigned int val,int type)345 static bool is_ctl_used(struct hda_codec *codec, unsigned int val, int type)
346 {
347 	struct hda_gen_spec *spec = codec->spec;
348 	const struct nid_path *path;
349 	int i;
350 
351 	val &= AMP_VAL_COMPARE_MASK;
352 	snd_array_for_each(&spec->paths, i, path) {
353 		if ((path->ctls[type] & AMP_VAL_COMPARE_MASK) == val)
354 			return true;
355 	}
356 	return false;
357 }
358 
359 /* check whether a control with the given (nid, dir, idx) was assigned */
is_ctl_associated(struct hda_codec * codec,hda_nid_t nid,int dir,int idx,int type)360 static bool is_ctl_associated(struct hda_codec *codec, hda_nid_t nid,
361 			      int dir, int idx, int type)
362 {
363 	unsigned int val = HDA_COMPOSE_AMP_VAL(nid, 3, idx, dir);
364 	return is_ctl_used(codec, val, type);
365 }
366 
print_nid_path(struct hda_codec * codec,const char * pfx,struct nid_path * path)367 static void print_nid_path(struct hda_codec *codec,
368 			   const char *pfx, struct nid_path *path)
369 {
370 	char buf[40];
371 	char *pos = buf;
372 	int i;
373 
374 	*pos = 0;
375 	for (i = 0; i < path->depth; i++)
376 		pos += scnprintf(pos, sizeof(buf) - (pos - buf), "%s%02x",
377 				 pos != buf ? ":" : "",
378 				 path->path[i]);
379 
380 	codec_dbg(codec, "%s path: depth=%d '%s'\n", pfx, path->depth, buf);
381 }
382 
383 /* called recursively */
__parse_nid_path(struct hda_codec * codec,hda_nid_t from_nid,hda_nid_t to_nid,int anchor_nid,struct nid_path * path,int depth)384 static bool __parse_nid_path(struct hda_codec *codec,
385 			     hda_nid_t from_nid, hda_nid_t to_nid,
386 			     int anchor_nid, struct nid_path *path,
387 			     int depth)
388 {
389 	const hda_nid_t *conn;
390 	int i, nums;
391 
392 	if (to_nid == anchor_nid)
393 		anchor_nid = 0; /* anchor passed */
394 	else if (to_nid == (hda_nid_t)(-anchor_nid))
395 		return false; /* hit the exclusive nid */
396 
397 	nums = snd_hda_get_conn_list(codec, to_nid, &conn);
398 	for (i = 0; i < nums; i++) {
399 		if (conn[i] != from_nid) {
400 			/* special case: when from_nid is 0,
401 			 * try to find an empty DAC
402 			 */
403 			if (from_nid ||
404 			    get_wcaps_type(get_wcaps(codec, conn[i])) != AC_WID_AUD_OUT ||
405 			    is_dac_already_used(codec, conn[i]))
406 				continue;
407 		}
408 		/* anchor is not requested or already passed? */
409 		if (anchor_nid <= 0)
410 			goto found;
411 	}
412 	if (depth >= MAX_NID_PATH_DEPTH)
413 		return false;
414 	for (i = 0; i < nums; i++) {
415 		unsigned int type;
416 		type = get_wcaps_type(get_wcaps(codec, conn[i]));
417 		if (type == AC_WID_AUD_OUT || type == AC_WID_AUD_IN ||
418 		    type == AC_WID_PIN)
419 			continue;
420 		if (__parse_nid_path(codec, from_nid, conn[i],
421 				     anchor_nid, path, depth + 1))
422 			goto found;
423 	}
424 	return false;
425 
426  found:
427 	path->path[path->depth] = conn[i];
428 	path->idx[path->depth + 1] = i;
429 	if (nums > 1 && get_wcaps_type(get_wcaps(codec, to_nid)) != AC_WID_AUD_MIX)
430 		path->multi[path->depth + 1] = 1;
431 	path->depth++;
432 	return true;
433 }
434 
435 /*
436  * snd_hda_parse_nid_path - parse the widget path from the given nid to
437  * the target nid
438  * @codec: the HDA codec
439  * @from_nid: the NID where the path start from
440  * @to_nid: the NID where the path ends at
441  * @anchor_nid: the anchor indication
442  * @path: the path object to store the result
443  *
444  * Returns true if a matching path is found.
445  *
446  * The parsing behavior depends on parameters:
447  * when @from_nid is 0, try to find an empty DAC;
448  * when @anchor_nid is set to a positive value, only paths through the widget
449  * with the given value are evaluated.
450  * when @anchor_nid is set to a negative value, paths through the widget
451  * with the negative of given value are excluded, only other paths are chosen.
452  * when @anchor_nid is zero, no special handling about path selection.
453  */
snd_hda_parse_nid_path(struct hda_codec * codec,hda_nid_t from_nid,hda_nid_t to_nid,int anchor_nid,struct nid_path * path)454 static bool snd_hda_parse_nid_path(struct hda_codec *codec, hda_nid_t from_nid,
455 			    hda_nid_t to_nid, int anchor_nid,
456 			    struct nid_path *path)
457 {
458 	if (__parse_nid_path(codec, from_nid, to_nid, anchor_nid, path, 1)) {
459 		path->path[path->depth] = to_nid;
460 		path->depth++;
461 		return true;
462 	}
463 	return false;
464 }
465 
466 /**
467  * snd_hda_add_new_path - parse the path between the given NIDs and
468  * add to the path list
469  * @codec: the HDA codec
470  * @from_nid: the NID where the path start from
471  * @to_nid: the NID where the path ends at
472  * @anchor_nid: the anchor indication, see snd_hda_parse_nid_path()
473  *
474  * If no valid path is found, returns NULL.
475  */
476 struct nid_path *
snd_hda_add_new_path(struct hda_codec * codec,hda_nid_t from_nid,hda_nid_t to_nid,int anchor_nid)477 snd_hda_add_new_path(struct hda_codec *codec, hda_nid_t from_nid,
478 		     hda_nid_t to_nid, int anchor_nid)
479 {
480 	struct hda_gen_spec *spec = codec->spec;
481 	struct nid_path *path;
482 
483 	if (from_nid && to_nid && !is_reachable_path(codec, from_nid, to_nid))
484 		return NULL;
485 
486 	/* check whether the path has been already added */
487 	path = get_nid_path(codec, from_nid, to_nid, anchor_nid);
488 	if (path)
489 		return path;
490 
491 	path = snd_array_new(&spec->paths);
492 	if (!path)
493 		return NULL;
494 	memset(path, 0, sizeof(*path));
495 	if (snd_hda_parse_nid_path(codec, from_nid, to_nid, anchor_nid, path))
496 		return path;
497 	/* push back */
498 	spec->paths.used--;
499 	return NULL;
500 }
501 EXPORT_SYMBOL_GPL(snd_hda_add_new_path);
502 
503 /* clear the given path as invalid so that it won't be picked up later */
invalidate_nid_path(struct hda_codec * codec,int idx)504 static void invalidate_nid_path(struct hda_codec *codec, int idx)
505 {
506 	struct nid_path *path = snd_hda_get_path_from_idx(codec, idx);
507 	if (!path)
508 		return;
509 	memset(path, 0, sizeof(*path));
510 }
511 
512 /* return a DAC if paired to the given pin by codec driver */
get_preferred_dac(struct hda_codec * codec,hda_nid_t pin)513 static hda_nid_t get_preferred_dac(struct hda_codec *codec, hda_nid_t pin)
514 {
515 	struct hda_gen_spec *spec = codec->spec;
516 	const hda_nid_t *list = spec->preferred_dacs;
517 
518 	if (!list)
519 		return 0;
520 	for (; *list; list += 2)
521 		if (*list == pin)
522 			return list[1];
523 	return 0;
524 }
525 
526 /* look for an empty DAC slot */
look_for_dac(struct hda_codec * codec,hda_nid_t pin,bool is_digital)527 static hda_nid_t look_for_dac(struct hda_codec *codec, hda_nid_t pin,
528 			      bool is_digital)
529 {
530 	struct hda_gen_spec *spec = codec->spec;
531 	bool cap_digital;
532 	int i;
533 
534 	for (i = 0; i < spec->num_all_dacs; i++) {
535 		hda_nid_t nid = spec->all_dacs[i];
536 		if (!nid || is_dac_already_used(codec, nid))
537 			continue;
538 		cap_digital = !!(get_wcaps(codec, nid) & AC_WCAP_DIGITAL);
539 		if (is_digital != cap_digital)
540 			continue;
541 		if (is_reachable_path(codec, nid, pin))
542 			return nid;
543 	}
544 	return 0;
545 }
546 
547 /* replace the channels in the composed amp value with the given number */
amp_val_replace_channels(unsigned int val,unsigned int chs)548 static unsigned int amp_val_replace_channels(unsigned int val, unsigned int chs)
549 {
550 	val &= ~(0x3U << 16);
551 	val |= chs << 16;
552 	return val;
553 }
554 
same_amp_caps(struct hda_codec * codec,hda_nid_t nid1,hda_nid_t nid2,int dir)555 static bool same_amp_caps(struct hda_codec *codec, hda_nid_t nid1,
556 			  hda_nid_t nid2, int dir)
557 {
558 	if (!(get_wcaps(codec, nid1) & (1 << (dir + 1))))
559 		return !(get_wcaps(codec, nid2) & (1 << (dir + 1)));
560 	return (query_amp_caps(codec, nid1, dir) ==
561 		query_amp_caps(codec, nid2, dir));
562 }
563 
564 /* look for a widget suitable for assigning a mute switch in the path */
look_for_out_mute_nid(struct hda_codec * codec,struct nid_path * path)565 static hda_nid_t look_for_out_mute_nid(struct hda_codec *codec,
566 				       struct nid_path *path)
567 {
568 	int i;
569 
570 	for (i = path->depth - 1; i >= 0; i--) {
571 		if (nid_has_mute(codec, path->path[i], HDA_OUTPUT))
572 			return path->path[i];
573 		if (i != path->depth - 1 && i != 0 &&
574 		    nid_has_mute(codec, path->path[i], HDA_INPUT))
575 			return path->path[i];
576 	}
577 	return 0;
578 }
579 
580 /* look for a widget suitable for assigning a volume ctl in the path */
look_for_out_vol_nid(struct hda_codec * codec,struct nid_path * path)581 static hda_nid_t look_for_out_vol_nid(struct hda_codec *codec,
582 				      struct nid_path *path)
583 {
584 	struct hda_gen_spec *spec = codec->spec;
585 	int i;
586 
587 	for (i = path->depth - 1; i >= 0; i--) {
588 		hda_nid_t nid = path->path[i];
589 		if ((spec->out_vol_mask >> nid) & 1)
590 			continue;
591 		if (nid_has_volume(codec, nid, HDA_OUTPUT))
592 			return nid;
593 	}
594 	return 0;
595 }
596 
597 /*
598  * path activation / deactivation
599  */
600 
601 /* can have the amp-in capability? */
has_amp_in(struct hda_codec * codec,struct nid_path * path,int idx)602 static bool has_amp_in(struct hda_codec *codec, struct nid_path *path, int idx)
603 {
604 	hda_nid_t nid = path->path[idx];
605 	unsigned int caps = get_wcaps(codec, nid);
606 	unsigned int type = get_wcaps_type(caps);
607 
608 	if (!(caps & AC_WCAP_IN_AMP))
609 		return false;
610 	if (type == AC_WID_PIN && idx > 0) /* only for input pins */
611 		return false;
612 	return true;
613 }
614 
615 /* can have the amp-out capability? */
has_amp_out(struct hda_codec * codec,struct nid_path * path,int idx)616 static bool has_amp_out(struct hda_codec *codec, struct nid_path *path, int idx)
617 {
618 	hda_nid_t nid = path->path[idx];
619 	unsigned int caps = get_wcaps(codec, nid);
620 	unsigned int type = get_wcaps_type(caps);
621 
622 	if (!(caps & AC_WCAP_OUT_AMP))
623 		return false;
624 	if (type == AC_WID_PIN && !idx) /* only for output pins */
625 		return false;
626 	return true;
627 }
628 
629 /* check whether the given (nid,dir,idx) is active */
is_active_nid(struct hda_codec * codec,hda_nid_t nid,unsigned int dir,unsigned int idx)630 static bool is_active_nid(struct hda_codec *codec, hda_nid_t nid,
631 			  unsigned int dir, unsigned int idx)
632 {
633 	struct hda_gen_spec *spec = codec->spec;
634 	int type = get_wcaps_type(get_wcaps(codec, nid));
635 	const struct nid_path *path;
636 	int i, n;
637 
638 	if (nid == codec->core.afg)
639 		return true;
640 
641 	snd_array_for_each(&spec->paths, n, path) {
642 		if (!path->active)
643 			continue;
644 		if (codec->power_save_node) {
645 			if (!path->stream_enabled)
646 				continue;
647 			/* ignore unplugged paths except for DAC/ADC */
648 			if (!(path->pin_enabled || path->pin_fixed) &&
649 			    type != AC_WID_AUD_OUT && type != AC_WID_AUD_IN)
650 				continue;
651 		}
652 		for (i = 0; i < path->depth; i++) {
653 			if (path->path[i] == nid) {
654 				if (dir == HDA_OUTPUT || idx == -1 ||
655 				    path->idx[i] == idx)
656 					return true;
657 				break;
658 			}
659 		}
660 	}
661 	return false;
662 }
663 
664 /* check whether the NID is referred by any active paths */
665 #define is_active_nid_for_any(codec, nid) \
666 	is_active_nid(codec, nid, HDA_OUTPUT, -1)
667 
668 /* get the default amp value for the target state */
get_amp_val_to_activate(struct hda_codec * codec,hda_nid_t nid,int dir,unsigned int caps,bool enable)669 static int get_amp_val_to_activate(struct hda_codec *codec, hda_nid_t nid,
670 				   int dir, unsigned int caps, bool enable)
671 {
672 	unsigned int val = 0;
673 
674 	if (caps & AC_AMPCAP_NUM_STEPS) {
675 		/* set to 0dB */
676 		if (enable)
677 			val = (caps & AC_AMPCAP_OFFSET) >> AC_AMPCAP_OFFSET_SHIFT;
678 	}
679 	if (caps & (AC_AMPCAP_MUTE | AC_AMPCAP_MIN_MUTE)) {
680 		if (!enable)
681 			val |= HDA_AMP_MUTE;
682 	}
683 	return val;
684 }
685 
686 /* is this a stereo widget or a stereo-to-mono mix? */
is_stereo_amps(struct hda_codec * codec,hda_nid_t nid,int dir)687 static bool is_stereo_amps(struct hda_codec *codec, hda_nid_t nid, int dir)
688 {
689 	unsigned int wcaps = get_wcaps(codec, nid);
690 	hda_nid_t conn;
691 
692 	if (wcaps & AC_WCAP_STEREO)
693 		return true;
694 	if (dir != HDA_INPUT || get_wcaps_type(wcaps) != AC_WID_AUD_MIX)
695 		return false;
696 	if (snd_hda_get_num_conns(codec, nid) != 1)
697 		return false;
698 	if (snd_hda_get_connections(codec, nid, &conn, 1) < 0)
699 		return false;
700 	return !!(get_wcaps(codec, conn) & AC_WCAP_STEREO);
701 }
702 
703 /* initialize the amp value (only at the first time) */
init_amp(struct hda_codec * codec,hda_nid_t nid,int dir,int idx)704 static void init_amp(struct hda_codec *codec, hda_nid_t nid, int dir, int idx)
705 {
706 	unsigned int caps = query_amp_caps(codec, nid, dir);
707 	int val = get_amp_val_to_activate(codec, nid, dir, caps, false);
708 
709 	if (is_stereo_amps(codec, nid, dir))
710 		snd_hda_codec_amp_init_stereo(codec, nid, dir, idx, 0xff, val);
711 	else
712 		snd_hda_codec_amp_init(codec, nid, 0, dir, idx, 0xff, val);
713 }
714 
715 /* update the amp, doing in stereo or mono depending on NID */
update_amp(struct hda_codec * codec,hda_nid_t nid,int dir,int idx,unsigned int mask,unsigned int val)716 static int update_amp(struct hda_codec *codec, hda_nid_t nid, int dir, int idx,
717 		      unsigned int mask, unsigned int val)
718 {
719 	if (is_stereo_amps(codec, nid, dir))
720 		return snd_hda_codec_amp_stereo(codec, nid, dir, idx,
721 						mask, val);
722 	else
723 		return snd_hda_codec_amp_update(codec, nid, 0, dir, idx,
724 						mask, val);
725 }
726 
727 /* calculate amp value mask we can modify;
728  * if the given amp is controlled by mixers, don't touch it
729  */
get_amp_mask_to_modify(struct hda_codec * codec,hda_nid_t nid,int dir,int idx,unsigned int caps)730 static unsigned int get_amp_mask_to_modify(struct hda_codec *codec,
731 					   hda_nid_t nid, int dir, int idx,
732 					   unsigned int caps)
733 {
734 	unsigned int mask = 0xff;
735 
736 	if (caps & (AC_AMPCAP_MUTE | AC_AMPCAP_MIN_MUTE)) {
737 		if (is_ctl_associated(codec, nid, dir, idx, NID_PATH_MUTE_CTL))
738 			mask &= ~0x80;
739 	}
740 	if (caps & AC_AMPCAP_NUM_STEPS) {
741 		if (is_ctl_associated(codec, nid, dir, idx, NID_PATH_VOL_CTL) ||
742 		    is_ctl_associated(codec, nid, dir, idx, NID_PATH_BOOST_CTL))
743 			mask &= ~0x7f;
744 	}
745 	return mask;
746 }
747 
activate_amp(struct hda_codec * codec,hda_nid_t nid,int dir,int idx,int idx_to_check,bool enable)748 static void activate_amp(struct hda_codec *codec, hda_nid_t nid, int dir,
749 			 int idx, int idx_to_check, bool enable)
750 {
751 	unsigned int caps;
752 	unsigned int mask, val;
753 
754 	caps = query_amp_caps(codec, nid, dir);
755 	val = get_amp_val_to_activate(codec, nid, dir, caps, enable);
756 	mask = get_amp_mask_to_modify(codec, nid, dir, idx_to_check, caps);
757 	if (!mask)
758 		return;
759 
760 	val &= mask;
761 	update_amp(codec, nid, dir, idx, mask, val);
762 }
763 
check_and_activate_amp(struct hda_codec * codec,hda_nid_t nid,int dir,int idx,int idx_to_check,bool enable)764 static void check_and_activate_amp(struct hda_codec *codec, hda_nid_t nid,
765 				   int dir, int idx, int idx_to_check,
766 				   bool enable)
767 {
768 	/* check whether the given amp is still used by others */
769 	if (!enable && is_active_nid(codec, nid, dir, idx_to_check))
770 		return;
771 	activate_amp(codec, nid, dir, idx, idx_to_check, enable);
772 }
773 
activate_amp_out(struct hda_codec * codec,struct nid_path * path,int i,bool enable)774 static void activate_amp_out(struct hda_codec *codec, struct nid_path *path,
775 			     int i, bool enable)
776 {
777 	hda_nid_t nid = path->path[i];
778 	init_amp(codec, nid, HDA_OUTPUT, 0);
779 	check_and_activate_amp(codec, nid, HDA_OUTPUT, 0, 0, enable);
780 }
781 
activate_amp_in(struct hda_codec * codec,struct nid_path * path,int i,bool enable,bool add_aamix)782 static void activate_amp_in(struct hda_codec *codec, struct nid_path *path,
783 			    int i, bool enable, bool add_aamix)
784 {
785 	struct hda_gen_spec *spec = codec->spec;
786 	const hda_nid_t *conn;
787 	int n, nums, idx;
788 	int type;
789 	hda_nid_t nid = path->path[i];
790 
791 	nums = snd_hda_get_conn_list(codec, nid, &conn);
792 	if (nums < 0)
793 		return;
794 	type = get_wcaps_type(get_wcaps(codec, nid));
795 	if (type == AC_WID_PIN ||
796 	    (type == AC_WID_AUD_IN && codec->single_adc_amp)) {
797 		nums = 1;
798 		idx = 0;
799 	} else
800 		idx = path->idx[i];
801 
802 	for (n = 0; n < nums; n++)
803 		init_amp(codec, nid, HDA_INPUT, n);
804 
805 	/* here is a little bit tricky in comparison with activate_amp_out();
806 	 * when aa-mixer is available, we need to enable the path as well
807 	 */
808 	for (n = 0; n < nums; n++) {
809 		if (n != idx) {
810 			if (conn[n] != spec->mixer_merge_nid)
811 				continue;
812 			/* when aamix is disabled, force to off */
813 			if (!add_aamix) {
814 				activate_amp(codec, nid, HDA_INPUT, n, n, false);
815 				continue;
816 			}
817 		}
818 		check_and_activate_amp(codec, nid, HDA_INPUT, n, idx, enable);
819 	}
820 }
821 
822 /* sync power of each widget in the given path */
path_power_update(struct hda_codec * codec,struct nid_path * path,bool allow_powerdown)823 static hda_nid_t path_power_update(struct hda_codec *codec,
824 				   struct nid_path *path,
825 				   bool allow_powerdown)
826 {
827 	hda_nid_t nid, changed = 0;
828 	int i, state, power;
829 
830 	for (i = 0; i < path->depth; i++) {
831 		nid = path->path[i];
832 		if (!(get_wcaps(codec, nid) & AC_WCAP_POWER))
833 			continue;
834 		if (nid == codec->core.afg)
835 			continue;
836 		if (!allow_powerdown || is_active_nid_for_any(codec, nid))
837 			state = AC_PWRST_D0;
838 		else
839 			state = AC_PWRST_D3;
840 		power = snd_hda_codec_read(codec, nid, 0,
841 					   AC_VERB_GET_POWER_STATE, 0);
842 		if (power != (state | (state << 4))) {
843 			snd_hda_codec_write(codec, nid, 0,
844 					    AC_VERB_SET_POWER_STATE, state);
845 			changed = nid;
846 			/* all known codecs seem to be capable to handl
847 			 * widgets state even in D3, so far.
848 			 * if any new codecs need to restore the widget
849 			 * states after D0 transition, call the function
850 			 * below.
851 			 */
852 #if 0 /* disabled */
853 			if (state == AC_PWRST_D0)
854 				snd_hdac_regmap_sync_node(&codec->core, nid);
855 #endif
856 		}
857 	}
858 	return changed;
859 }
860 
861 /* do sync with the last power state change */
sync_power_state_change(struct hda_codec * codec,hda_nid_t nid)862 static void sync_power_state_change(struct hda_codec *codec, hda_nid_t nid)
863 {
864 	if (nid) {
865 		msleep(10);
866 		snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_POWER_STATE, 0);
867 	}
868 }
869 
870 /**
871  * snd_hda_activate_path - activate or deactivate the given path
872  * @codec: the HDA codec
873  * @path: the path to activate/deactivate
874  * @enable: flag to activate or not
875  * @add_aamix: enable the input from aamix NID
876  *
877  * If @add_aamix is set, enable the input from aa-mix NID as well (if any).
878  */
snd_hda_activate_path(struct hda_codec * codec,struct nid_path * path,bool enable,bool add_aamix)879 void snd_hda_activate_path(struct hda_codec *codec, struct nid_path *path,
880 			   bool enable, bool add_aamix)
881 {
882 	struct hda_gen_spec *spec = codec->spec;
883 	int i;
884 
885 	path->active = enable;
886 
887 	/* make sure the widget is powered up */
888 	if (enable && (spec->power_down_unused || codec->power_save_node))
889 		path_power_update(codec, path, codec->power_save_node);
890 
891 	for (i = path->depth - 1; i >= 0; i--) {
892 		hda_nid_t nid = path->path[i];
893 
894 		if (enable && path->multi[i])
895 			snd_hda_codec_write_cache(codec, nid, 0,
896 					    AC_VERB_SET_CONNECT_SEL,
897 					    path->idx[i]);
898 		if (has_amp_in(codec, path, i))
899 			activate_amp_in(codec, path, i, enable, add_aamix);
900 		if (has_amp_out(codec, path, i))
901 			activate_amp_out(codec, path, i, enable);
902 	}
903 }
904 EXPORT_SYMBOL_GPL(snd_hda_activate_path);
905 
906 /* if the given path is inactive, put widgets into D3 (only if suitable) */
path_power_down_sync(struct hda_codec * codec,struct nid_path * path)907 static void path_power_down_sync(struct hda_codec *codec, struct nid_path *path)
908 {
909 	struct hda_gen_spec *spec = codec->spec;
910 
911 	if (!(spec->power_down_unused || codec->power_save_node) || path->active)
912 		return;
913 	sync_power_state_change(codec, path_power_update(codec, path, true));
914 }
915 
916 /* turn on/off EAPD on the given pin */
set_pin_eapd(struct hda_codec * codec,hda_nid_t pin,bool enable)917 static void set_pin_eapd(struct hda_codec *codec, hda_nid_t pin, bool enable)
918 {
919 	struct hda_gen_spec *spec = codec->spec;
920 	if (spec->own_eapd_ctl ||
921 	    !(snd_hda_query_pin_caps(codec, pin) & AC_PINCAP_EAPD))
922 		return;
923 	if (spec->keep_eapd_on && !enable)
924 		return;
925 	if (codec->inv_eapd)
926 		enable = !enable;
927 	snd_hda_codec_write_cache(codec, pin, 0,
928 				   AC_VERB_SET_EAPD_BTLENABLE,
929 				   enable ? 0x02 : 0x00);
930 }
931 
932 /* re-initialize the path specified by the given path index */
resume_path_from_idx(struct hda_codec * codec,int path_idx)933 static void resume_path_from_idx(struct hda_codec *codec, int path_idx)
934 {
935 	struct nid_path *path = snd_hda_get_path_from_idx(codec, path_idx);
936 	if (path)
937 		snd_hda_activate_path(codec, path, path->active, false);
938 }
939 
940 
941 /*
942  * Helper functions for creating mixer ctl elements
943  */
944 
945 static int hda_gen_mixer_mute_put(struct snd_kcontrol *kcontrol,
946 				  struct snd_ctl_elem_value *ucontrol);
947 static int hda_gen_bind_mute_get(struct snd_kcontrol *kcontrol,
948 				 struct snd_ctl_elem_value *ucontrol);
949 static int hda_gen_bind_mute_put(struct snd_kcontrol *kcontrol,
950 				 struct snd_ctl_elem_value *ucontrol);
951 
952 enum {
953 	HDA_CTL_WIDGET_VOL,
954 	HDA_CTL_WIDGET_MUTE,
955 	HDA_CTL_BIND_MUTE,
956 };
957 static const struct snd_kcontrol_new control_templates[] = {
958 	HDA_CODEC_VOLUME(NULL, 0, 0, 0),
959 	/* only the put callback is replaced for handling the special mute */
960 	{
961 		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
962 		.subdevice = HDA_SUBDEV_AMP_FLAG,
963 		.info = snd_hda_mixer_amp_switch_info,
964 		.get = snd_hda_mixer_amp_switch_get,
965 		.put = hda_gen_mixer_mute_put, /* replaced */
966 		.private_value = HDA_COMPOSE_AMP_VAL(0, 3, 0, 0),
967 	},
968 	{
969 		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
970 		.info = snd_hda_mixer_amp_switch_info,
971 		.get = hda_gen_bind_mute_get,
972 		.put = hda_gen_bind_mute_put, /* replaced */
973 		.private_value = HDA_COMPOSE_AMP_VAL(0, 3, 0, 0),
974 	},
975 };
976 
977 /* add dynamic controls from template */
978 static struct snd_kcontrol_new *
add_control(struct hda_gen_spec * spec,int type,const char * name,int cidx,unsigned long val)979 add_control(struct hda_gen_spec *spec, int type, const char *name,
980 		       int cidx, unsigned long val)
981 {
982 	struct snd_kcontrol_new *knew;
983 
984 	knew = snd_hda_gen_add_kctl(spec, name, &control_templates[type]);
985 	if (!knew)
986 		return NULL;
987 	knew->index = cidx;
988 	if (get_amp_nid_(val))
989 		knew->subdevice = HDA_SUBDEV_AMP_FLAG;
990 	if (knew->access == 0)
991 		knew->access = SNDRV_CTL_ELEM_ACCESS_READWRITE;
992 	knew->private_value = val;
993 	return knew;
994 }
995 
add_control_with_pfx(struct hda_gen_spec * spec,int type,const char * pfx,const char * dir,const char * sfx,int cidx,unsigned long val)996 static int add_control_with_pfx(struct hda_gen_spec *spec, int type,
997 				const char *pfx, const char *dir,
998 				const char *sfx, int cidx, unsigned long val)
999 {
1000 	char name[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];
1001 	int len;
1002 
1003 	len = snprintf(name, sizeof(name), "%s %s %s", pfx, dir, sfx);
1004 	if (snd_BUG_ON(len >= sizeof(name)))
1005 		return -EINVAL;
1006 	if (!add_control(spec, type, name, cidx, val))
1007 		return -ENOMEM;
1008 	return 0;
1009 }
1010 
1011 #define add_pb_vol_ctrl(spec, type, pfx, val)			\
1012 	add_control_with_pfx(spec, type, pfx, "Playback", "Volume", 0, val)
1013 #define add_pb_sw_ctrl(spec, type, pfx, val)			\
1014 	add_control_with_pfx(spec, type, pfx, "Playback", "Switch", 0, val)
1015 #define __add_pb_vol_ctrl(spec, type, pfx, cidx, val)			\
1016 	add_control_with_pfx(spec, type, pfx, "Playback", "Volume", cidx, val)
1017 #define __add_pb_sw_ctrl(spec, type, pfx, cidx, val)			\
1018 	add_control_with_pfx(spec, type, pfx, "Playback", "Switch", cidx, val)
1019 
add_vol_ctl(struct hda_codec * codec,const char * pfx,int cidx,unsigned int chs,struct nid_path * path)1020 static int add_vol_ctl(struct hda_codec *codec, const char *pfx, int cidx,
1021 		       unsigned int chs, struct nid_path *path)
1022 {
1023 	unsigned int val;
1024 	if (!path)
1025 		return 0;
1026 	val = path->ctls[NID_PATH_VOL_CTL];
1027 	if (!val)
1028 		return 0;
1029 	val = amp_val_replace_channels(val, chs);
1030 	return __add_pb_vol_ctrl(codec->spec, HDA_CTL_WIDGET_VOL, pfx, cidx, val);
1031 }
1032 
1033 /* return the channel bits suitable for the given path->ctls[] */
get_default_ch_nums(struct hda_codec * codec,struct nid_path * path,int type)1034 static int get_default_ch_nums(struct hda_codec *codec, struct nid_path *path,
1035 			       int type)
1036 {
1037 	int chs = 1; /* mono (left only) */
1038 	if (path) {
1039 		hda_nid_t nid = get_amp_nid_(path->ctls[type]);
1040 		if (nid && (get_wcaps(codec, nid) & AC_WCAP_STEREO))
1041 			chs = 3; /* stereo */
1042 	}
1043 	return chs;
1044 }
1045 
add_stereo_vol(struct hda_codec * codec,const char * pfx,int cidx,struct nid_path * path)1046 static int add_stereo_vol(struct hda_codec *codec, const char *pfx, int cidx,
1047 			  struct nid_path *path)
1048 {
1049 	int chs = get_default_ch_nums(codec, path, NID_PATH_VOL_CTL);
1050 	return add_vol_ctl(codec, pfx, cidx, chs, path);
1051 }
1052 
1053 /* create a mute-switch for the given mixer widget;
1054  * if it has multiple sources (e.g. DAC and loopback), create a bind-mute
1055  */
add_sw_ctl(struct hda_codec * codec,const char * pfx,int cidx,unsigned int chs,struct nid_path * path)1056 static int add_sw_ctl(struct hda_codec *codec, const char *pfx, int cidx,
1057 		      unsigned int chs, struct nid_path *path)
1058 {
1059 	unsigned int val;
1060 	int type = HDA_CTL_WIDGET_MUTE;
1061 
1062 	if (!path)
1063 		return 0;
1064 	val = path->ctls[NID_PATH_MUTE_CTL];
1065 	if (!val)
1066 		return 0;
1067 	val = amp_val_replace_channels(val, chs);
1068 	if (get_amp_direction_(val) == HDA_INPUT) {
1069 		hda_nid_t nid = get_amp_nid_(val);
1070 		int nums = snd_hda_get_num_conns(codec, nid);
1071 		if (nums > 1) {
1072 			type = HDA_CTL_BIND_MUTE;
1073 			val |= nums << 19;
1074 		}
1075 	}
1076 	return __add_pb_sw_ctrl(codec->spec, type, pfx, cidx, val);
1077 }
1078 
add_stereo_sw(struct hda_codec * codec,const char * pfx,int cidx,struct nid_path * path)1079 static int add_stereo_sw(struct hda_codec *codec, const char *pfx,
1080 				  int cidx, struct nid_path *path)
1081 {
1082 	int chs = get_default_ch_nums(codec, path, NID_PATH_MUTE_CTL);
1083 	return add_sw_ctl(codec, pfx, cidx, chs, path);
1084 }
1085 
1086 /* playback mute control with the software mute bit check */
sync_auto_mute_bits(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)1087 static void sync_auto_mute_bits(struct snd_kcontrol *kcontrol,
1088 				struct snd_ctl_elem_value *ucontrol)
1089 {
1090 	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1091 	struct hda_gen_spec *spec = codec->spec;
1092 
1093 	if (spec->auto_mute_via_amp) {
1094 		hda_nid_t nid = get_amp_nid(kcontrol);
1095 		bool enabled = !((spec->mute_bits >> nid) & 1);
1096 		ucontrol->value.integer.value[0] &= enabled;
1097 		ucontrol->value.integer.value[1] &= enabled;
1098 	}
1099 }
1100 
hda_gen_mixer_mute_put(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)1101 static int hda_gen_mixer_mute_put(struct snd_kcontrol *kcontrol,
1102 				  struct snd_ctl_elem_value *ucontrol)
1103 {
1104 	sync_auto_mute_bits(kcontrol, ucontrol);
1105 	return snd_hda_mixer_amp_switch_put(kcontrol, ucontrol);
1106 }
1107 
1108 /*
1109  * Bound mute controls
1110  */
1111 #define AMP_VAL_IDX_SHIFT	19
1112 #define AMP_VAL_IDX_MASK	(0x0f<<19)
1113 
hda_gen_bind_mute_get(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)1114 static int hda_gen_bind_mute_get(struct snd_kcontrol *kcontrol,
1115 				 struct snd_ctl_elem_value *ucontrol)
1116 {
1117 	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1118 	unsigned long pval;
1119 	int err;
1120 
1121 	mutex_lock(&codec->control_mutex);
1122 	pval = kcontrol->private_value;
1123 	kcontrol->private_value = pval & ~AMP_VAL_IDX_MASK; /* index 0 */
1124 	err = snd_hda_mixer_amp_switch_get(kcontrol, ucontrol);
1125 	kcontrol->private_value = pval;
1126 	mutex_unlock(&codec->control_mutex);
1127 	return err;
1128 }
1129 
hda_gen_bind_mute_put(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)1130 static int hda_gen_bind_mute_put(struct snd_kcontrol *kcontrol,
1131 				 struct snd_ctl_elem_value *ucontrol)
1132 {
1133 	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1134 	unsigned long pval;
1135 	int i, indices, err = 0, change = 0;
1136 
1137 	sync_auto_mute_bits(kcontrol, ucontrol);
1138 
1139 	mutex_lock(&codec->control_mutex);
1140 	pval = kcontrol->private_value;
1141 	indices = (pval & AMP_VAL_IDX_MASK) >> AMP_VAL_IDX_SHIFT;
1142 	for (i = 0; i < indices; i++) {
1143 		kcontrol->private_value = (pval & ~AMP_VAL_IDX_MASK) |
1144 			(i << AMP_VAL_IDX_SHIFT);
1145 		err = snd_hda_mixer_amp_switch_put(kcontrol, ucontrol);
1146 		if (err < 0)
1147 			break;
1148 		change |= err;
1149 	}
1150 	kcontrol->private_value = pval;
1151 	mutex_unlock(&codec->control_mutex);
1152 	return err < 0 ? err : change;
1153 }
1154 
1155 /* any ctl assigned to the path with the given index? */
path_has_mixer(struct hda_codec * codec,int path_idx,int ctl_type)1156 static bool path_has_mixer(struct hda_codec *codec, int path_idx, int ctl_type)
1157 {
1158 	struct nid_path *path = snd_hda_get_path_from_idx(codec, path_idx);
1159 	return path && path->ctls[ctl_type];
1160 }
1161 
1162 static const char * const channel_name[] = {
1163 	"Front", "Surround", "CLFE", "Side", "Back",
1164 };
1165 
1166 /* give some appropriate ctl name prefix for the given line out channel */
get_line_out_pfx(struct hda_codec * codec,int ch,int * index,int ctl_type)1167 static const char *get_line_out_pfx(struct hda_codec *codec, int ch,
1168 				    int *index, int ctl_type)
1169 {
1170 	struct hda_gen_spec *spec = codec->spec;
1171 	struct auto_pin_cfg *cfg = &spec->autocfg;
1172 
1173 	*index = 0;
1174 	if (cfg->line_outs == 1 && !spec->multi_ios &&
1175 	    !codec->force_pin_prefix &&
1176 	    !cfg->hp_outs && !cfg->speaker_outs)
1177 		return spec->vmaster_mute.hook ? "PCM" : "Master";
1178 
1179 	/* if there is really a single DAC used in the whole output paths,
1180 	 * use it master (or "PCM" if a vmaster hook is present)
1181 	 */
1182 	if (spec->multiout.num_dacs == 1 && !spec->mixer_nid &&
1183 	    !codec->force_pin_prefix &&
1184 	    !spec->multiout.hp_out_nid[0] && !spec->multiout.extra_out_nid[0])
1185 		return spec->vmaster_mute.hook ? "PCM" : "Master";
1186 
1187 	/* multi-io channels */
1188 	if (ch >= cfg->line_outs)
1189 		goto fixed_name;
1190 
1191 	switch (cfg->line_out_type) {
1192 	case AUTO_PIN_SPEAKER_OUT:
1193 		/* if the primary channel vol/mute is shared with HP volume,
1194 		 * don't name it as Speaker
1195 		 */
1196 		if (!ch && cfg->hp_outs &&
1197 		    !path_has_mixer(codec, spec->hp_paths[0], ctl_type))
1198 			break;
1199 		if (cfg->line_outs == 1)
1200 			return "Speaker";
1201 		if (cfg->line_outs == 2)
1202 			return ch ? "Bass Speaker" : "Speaker";
1203 		break;
1204 	case AUTO_PIN_HP_OUT:
1205 		/* if the primary channel vol/mute is shared with spk volume,
1206 		 * don't name it as Headphone
1207 		 */
1208 		if (!ch && cfg->speaker_outs &&
1209 		    !path_has_mixer(codec, spec->speaker_paths[0], ctl_type))
1210 			break;
1211 		/* for multi-io case, only the primary out */
1212 		if (ch && spec->multi_ios)
1213 			break;
1214 		*index = ch;
1215 		return "Headphone";
1216 	case AUTO_PIN_LINE_OUT:
1217 		/* This deals with the case where one HP or one Speaker or
1218 		 * one HP + one Speaker need to share the DAC with LO
1219 		 */
1220 		if (!ch) {
1221 			bool hp_lo_shared = false, spk_lo_shared = false;
1222 
1223 			if (cfg->speaker_outs)
1224 				spk_lo_shared = !path_has_mixer(codec,
1225 								spec->speaker_paths[0],	ctl_type);
1226 			if (cfg->hp_outs)
1227 				hp_lo_shared = !path_has_mixer(codec, spec->hp_paths[0], ctl_type);
1228 			if (hp_lo_shared && spk_lo_shared)
1229 				return spec->vmaster_mute.hook ? "PCM" : "Master";
1230 			if (hp_lo_shared)
1231 				return "Headphone+LO";
1232 			if (spk_lo_shared)
1233 				return "Speaker+LO";
1234 		}
1235 	}
1236 
1237 	/* for a single channel output, we don't have to name the channel */
1238 	if (cfg->line_outs == 1 && !spec->multi_ios)
1239 		return "Line Out";
1240 
1241  fixed_name:
1242 	if (ch >= ARRAY_SIZE(channel_name)) {
1243 		snd_BUG();
1244 		return "PCM";
1245 	}
1246 
1247 	return channel_name[ch];
1248 }
1249 
1250 /*
1251  * Parse output paths
1252  */
1253 
1254 /* badness definition */
1255 enum {
1256 	/* No primary DAC is found for the main output */
1257 	BAD_NO_PRIMARY_DAC = 0x10000,
1258 	/* No DAC is found for the extra output */
1259 	BAD_NO_DAC = 0x4000,
1260 	/* No possible multi-ios */
1261 	BAD_MULTI_IO = 0x120,
1262 	/* No individual DAC for extra output */
1263 	BAD_NO_EXTRA_DAC = 0x102,
1264 	/* No individual DAC for extra surrounds */
1265 	BAD_NO_EXTRA_SURR_DAC = 0x101,
1266 	/* Primary DAC shared with main surrounds */
1267 	BAD_SHARED_SURROUND = 0x100,
1268 	/* No independent HP possible */
1269 	BAD_NO_INDEP_HP = 0x10,
1270 	/* Primary DAC shared with main CLFE */
1271 	BAD_SHARED_CLFE = 0x10,
1272 	/* Primary DAC shared with extra surrounds */
1273 	BAD_SHARED_EXTRA_SURROUND = 0x10,
1274 	/* Volume widget is shared */
1275 	BAD_SHARED_VOL = 0x10,
1276 };
1277 
1278 /* look for widgets in the given path which are appropriate for
1279  * volume and mute controls, and assign the values to ctls[].
1280  *
1281  * When no appropriate widget is found in the path, the badness value
1282  * is incremented depending on the situation.  The function returns the
1283  * total badness for both volume and mute controls.
1284  */
assign_out_path_ctls(struct hda_codec * codec,struct nid_path * path)1285 static int assign_out_path_ctls(struct hda_codec *codec, struct nid_path *path)
1286 {
1287 	struct hda_gen_spec *spec = codec->spec;
1288 	hda_nid_t nid;
1289 	unsigned int val;
1290 	int badness = 0;
1291 
1292 	if (!path)
1293 		return BAD_SHARED_VOL * 2;
1294 
1295 	if (path->ctls[NID_PATH_VOL_CTL] ||
1296 	    path->ctls[NID_PATH_MUTE_CTL])
1297 		return 0; /* already evaluated */
1298 
1299 	nid = look_for_out_vol_nid(codec, path);
1300 	if (nid) {
1301 		val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
1302 		if (spec->dac_min_mute)
1303 			val |= HDA_AMP_VAL_MIN_MUTE;
1304 		if (is_ctl_used(codec, val, NID_PATH_VOL_CTL))
1305 			badness += BAD_SHARED_VOL;
1306 		else
1307 			path->ctls[NID_PATH_VOL_CTL] = val;
1308 	} else
1309 		badness += BAD_SHARED_VOL;
1310 	nid = look_for_out_mute_nid(codec, path);
1311 	if (nid) {
1312 		unsigned int wid_type = get_wcaps_type(get_wcaps(codec, nid));
1313 		if (wid_type == AC_WID_PIN || wid_type == AC_WID_AUD_OUT ||
1314 		    nid_has_mute(codec, nid, HDA_OUTPUT))
1315 			val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
1316 		else
1317 			val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT);
1318 		if (is_ctl_used(codec, val, NID_PATH_MUTE_CTL))
1319 			badness += BAD_SHARED_VOL;
1320 		else
1321 			path->ctls[NID_PATH_MUTE_CTL] = val;
1322 	} else
1323 		badness += BAD_SHARED_VOL;
1324 	return badness;
1325 }
1326 
1327 const struct badness_table hda_main_out_badness = {
1328 	.no_primary_dac = BAD_NO_PRIMARY_DAC,
1329 	.no_dac = BAD_NO_DAC,
1330 	.shared_primary = BAD_NO_PRIMARY_DAC,
1331 	.shared_surr = BAD_SHARED_SURROUND,
1332 	.shared_clfe = BAD_SHARED_CLFE,
1333 	.shared_surr_main = BAD_SHARED_SURROUND,
1334 };
1335 EXPORT_SYMBOL_GPL(hda_main_out_badness);
1336 
1337 const struct badness_table hda_extra_out_badness = {
1338 	.no_primary_dac = BAD_NO_DAC,
1339 	.no_dac = BAD_NO_DAC,
1340 	.shared_primary = BAD_NO_EXTRA_DAC,
1341 	.shared_surr = BAD_SHARED_EXTRA_SURROUND,
1342 	.shared_clfe = BAD_SHARED_EXTRA_SURROUND,
1343 	.shared_surr_main = BAD_NO_EXTRA_SURR_DAC,
1344 };
1345 EXPORT_SYMBOL_GPL(hda_extra_out_badness);
1346 
1347 /* get the DAC of the primary output corresponding to the given array index */
get_primary_out(struct hda_codec * codec,int idx)1348 static hda_nid_t get_primary_out(struct hda_codec *codec, int idx)
1349 {
1350 	struct hda_gen_spec *spec = codec->spec;
1351 	struct auto_pin_cfg *cfg = &spec->autocfg;
1352 
1353 	if (cfg->line_outs > idx)
1354 		return spec->private_dac_nids[idx];
1355 	idx -= cfg->line_outs;
1356 	if (spec->multi_ios > idx)
1357 		return spec->multi_io[idx].dac;
1358 	return 0;
1359 }
1360 
1361 /* return the DAC if it's reachable, otherwise zero */
try_dac(struct hda_codec * codec,hda_nid_t dac,hda_nid_t pin)1362 static inline hda_nid_t try_dac(struct hda_codec *codec,
1363 				hda_nid_t dac, hda_nid_t pin)
1364 {
1365 	return is_reachable_path(codec, dac, pin) ? dac : 0;
1366 }
1367 
1368 /* try to assign DACs to pins and return the resultant badness */
try_assign_dacs(struct hda_codec * codec,int num_outs,const hda_nid_t * pins,hda_nid_t * dacs,int * path_idx,const struct badness_table * bad)1369 static int try_assign_dacs(struct hda_codec *codec, int num_outs,
1370 			   const hda_nid_t *pins, hda_nid_t *dacs,
1371 			   int *path_idx,
1372 			   const struct badness_table *bad)
1373 {
1374 	struct hda_gen_spec *spec = codec->spec;
1375 	int i, j;
1376 	int badness = 0;
1377 	hda_nid_t dac;
1378 
1379 	if (!num_outs)
1380 		return 0;
1381 
1382 	for (i = 0; i < num_outs; i++) {
1383 		struct nid_path *path;
1384 		hda_nid_t pin = pins[i];
1385 
1386 		if (!spec->obey_preferred_dacs) {
1387 			path = snd_hda_get_path_from_idx(codec, path_idx[i]);
1388 			if (path) {
1389 				badness += assign_out_path_ctls(codec, path);
1390 				continue;
1391 			}
1392 		}
1393 
1394 		dacs[i] = get_preferred_dac(codec, pin);
1395 		if (dacs[i]) {
1396 			if (is_dac_already_used(codec, dacs[i]))
1397 				badness += bad->shared_primary;
1398 		} else if (spec->obey_preferred_dacs) {
1399 			badness += BAD_NO_PRIMARY_DAC;
1400 		}
1401 
1402 		if (!dacs[i])
1403 			dacs[i] = look_for_dac(codec, pin, false);
1404 		if (!dacs[i] && !i) {
1405 			/* try to steal the DAC of surrounds for the front */
1406 			for (j = 1; j < num_outs; j++) {
1407 				if (is_reachable_path(codec, dacs[j], pin)) {
1408 					dacs[0] = dacs[j];
1409 					dacs[j] = 0;
1410 					invalidate_nid_path(codec, path_idx[j]);
1411 					path_idx[j] = 0;
1412 					break;
1413 				}
1414 			}
1415 		}
1416 		dac = dacs[i];
1417 		if (!dac) {
1418 			if (num_outs > 2)
1419 				dac = try_dac(codec, get_primary_out(codec, i), pin);
1420 			if (!dac)
1421 				dac = try_dac(codec, dacs[0], pin);
1422 			if (!dac)
1423 				dac = try_dac(codec, get_primary_out(codec, i), pin);
1424 			if (dac) {
1425 				if (!i)
1426 					badness += bad->shared_primary;
1427 				else if (i == 1)
1428 					badness += bad->shared_surr;
1429 				else
1430 					badness += bad->shared_clfe;
1431 			} else if (is_reachable_path(codec, spec->private_dac_nids[0], pin)) {
1432 				dac = spec->private_dac_nids[0];
1433 				badness += bad->shared_surr_main;
1434 			} else if (!i)
1435 				badness += bad->no_primary_dac;
1436 			else
1437 				badness += bad->no_dac;
1438 		}
1439 		if (!dac)
1440 			continue;
1441 		path = snd_hda_add_new_path(codec, dac, pin, -spec->mixer_nid);
1442 		if (!path && !i && spec->mixer_nid) {
1443 			/* try with aamix */
1444 			path = snd_hda_add_new_path(codec, dac, pin, 0);
1445 		}
1446 		if (!path) {
1447 			dacs[i] = 0;
1448 			badness += bad->no_dac;
1449 		} else {
1450 			/* print_nid_path(codec, "output", path); */
1451 			path->active = true;
1452 			path_idx[i] = snd_hda_get_path_idx(codec, path);
1453 			badness += assign_out_path_ctls(codec, path);
1454 		}
1455 	}
1456 
1457 	return badness;
1458 }
1459 
1460 /* return NID if the given pin has only a single connection to a certain DAC */
get_dac_if_single(struct hda_codec * codec,hda_nid_t pin)1461 static hda_nid_t get_dac_if_single(struct hda_codec *codec, hda_nid_t pin)
1462 {
1463 	struct hda_gen_spec *spec = codec->spec;
1464 	int i;
1465 	hda_nid_t nid_found = 0;
1466 
1467 	for (i = 0; i < spec->num_all_dacs; i++) {
1468 		hda_nid_t nid = spec->all_dacs[i];
1469 		if (!nid || is_dac_already_used(codec, nid))
1470 			continue;
1471 		if (is_reachable_path(codec, nid, pin)) {
1472 			if (nid_found)
1473 				return 0;
1474 			nid_found = nid;
1475 		}
1476 	}
1477 	return nid_found;
1478 }
1479 
1480 /* check whether the given pin can be a multi-io pin */
can_be_multiio_pin(struct hda_codec * codec,unsigned int location,hda_nid_t nid)1481 static bool can_be_multiio_pin(struct hda_codec *codec,
1482 			       unsigned int location, hda_nid_t nid)
1483 {
1484 	unsigned int defcfg, caps;
1485 
1486 	defcfg = snd_hda_codec_get_pincfg(codec, nid);
1487 	if (get_defcfg_connect(defcfg) != AC_JACK_PORT_COMPLEX)
1488 		return false;
1489 	if (location && get_defcfg_location(defcfg) != location)
1490 		return false;
1491 	caps = snd_hda_query_pin_caps(codec, nid);
1492 	if (!(caps & AC_PINCAP_OUT))
1493 		return false;
1494 	return true;
1495 }
1496 
1497 /* count the number of input pins that are capable to be multi-io */
count_multiio_pins(struct hda_codec * codec,hda_nid_t reference_pin)1498 static int count_multiio_pins(struct hda_codec *codec, hda_nid_t reference_pin)
1499 {
1500 	struct hda_gen_spec *spec = codec->spec;
1501 	struct auto_pin_cfg *cfg = &spec->autocfg;
1502 	unsigned int defcfg = snd_hda_codec_get_pincfg(codec, reference_pin);
1503 	unsigned int location = get_defcfg_location(defcfg);
1504 	int type, i;
1505 	int num_pins = 0;
1506 
1507 	for (type = AUTO_PIN_LINE_IN; type >= AUTO_PIN_MIC; type--) {
1508 		for (i = 0; i < cfg->num_inputs; i++) {
1509 			if (cfg->inputs[i].type != type)
1510 				continue;
1511 			if (can_be_multiio_pin(codec, location,
1512 					       cfg->inputs[i].pin))
1513 				num_pins++;
1514 		}
1515 	}
1516 	return num_pins;
1517 }
1518 
1519 /*
1520  * multi-io helper
1521  *
1522  * When hardwired is set, try to fill ony hardwired pins, and returns
1523  * zero if any pins are filled, non-zero if nothing found.
1524  * When hardwired is off, try to fill possible input pins, and returns
1525  * the badness value.
1526  */
fill_multi_ios(struct hda_codec * codec,hda_nid_t reference_pin,bool hardwired)1527 static int fill_multi_ios(struct hda_codec *codec,
1528 			  hda_nid_t reference_pin,
1529 			  bool hardwired)
1530 {
1531 	struct hda_gen_spec *spec = codec->spec;
1532 	struct auto_pin_cfg *cfg = &spec->autocfg;
1533 	int type, i, j, num_pins, old_pins;
1534 	unsigned int defcfg = snd_hda_codec_get_pincfg(codec, reference_pin);
1535 	unsigned int location = get_defcfg_location(defcfg);
1536 	int badness = 0;
1537 	struct nid_path *path;
1538 
1539 	old_pins = spec->multi_ios;
1540 	if (old_pins >= 2)
1541 		goto end_fill;
1542 
1543 	num_pins = count_multiio_pins(codec, reference_pin);
1544 	if (num_pins < 2)
1545 		goto end_fill;
1546 
1547 	for (type = AUTO_PIN_LINE_IN; type >= AUTO_PIN_MIC; type--) {
1548 		for (i = 0; i < cfg->num_inputs; i++) {
1549 			hda_nid_t nid = cfg->inputs[i].pin;
1550 			hda_nid_t dac = 0;
1551 
1552 			if (cfg->inputs[i].type != type)
1553 				continue;
1554 			if (!can_be_multiio_pin(codec, location, nid))
1555 				continue;
1556 			for (j = 0; j < spec->multi_ios; j++) {
1557 				if (nid == spec->multi_io[j].pin)
1558 					break;
1559 			}
1560 			if (j < spec->multi_ios)
1561 				continue;
1562 
1563 			if (hardwired)
1564 				dac = get_dac_if_single(codec, nid);
1565 			else if (!dac)
1566 				dac = look_for_dac(codec, nid, false);
1567 			if (!dac) {
1568 				badness++;
1569 				continue;
1570 			}
1571 			path = snd_hda_add_new_path(codec, dac, nid,
1572 						    -spec->mixer_nid);
1573 			if (!path) {
1574 				badness++;
1575 				continue;
1576 			}
1577 			/* print_nid_path(codec, "multiio", path); */
1578 			spec->multi_io[spec->multi_ios].pin = nid;
1579 			spec->multi_io[spec->multi_ios].dac = dac;
1580 			spec->out_paths[cfg->line_outs + spec->multi_ios] =
1581 				snd_hda_get_path_idx(codec, path);
1582 			spec->multi_ios++;
1583 			if (spec->multi_ios >= 2)
1584 				break;
1585 		}
1586 	}
1587  end_fill:
1588 	if (badness)
1589 		badness = BAD_MULTI_IO;
1590 	if (old_pins == spec->multi_ios) {
1591 		if (hardwired)
1592 			return 1; /* nothing found */
1593 		else
1594 			return badness; /* no badness if nothing found */
1595 	}
1596 	if (!hardwired && spec->multi_ios < 2) {
1597 		/* cancel newly assigned paths */
1598 		spec->paths.used -= spec->multi_ios - old_pins;
1599 		spec->multi_ios = old_pins;
1600 		return badness;
1601 	}
1602 
1603 	/* assign volume and mute controls */
1604 	for (i = old_pins; i < spec->multi_ios; i++) {
1605 		path = snd_hda_get_path_from_idx(codec, spec->out_paths[cfg->line_outs + i]);
1606 		badness += assign_out_path_ctls(codec, path);
1607 	}
1608 
1609 	return badness;
1610 }
1611 
1612 /* map DACs for all pins in the list if they are single connections */
map_singles(struct hda_codec * codec,int outs,const hda_nid_t * pins,hda_nid_t * dacs,int * path_idx)1613 static bool map_singles(struct hda_codec *codec, int outs,
1614 			const hda_nid_t *pins, hda_nid_t *dacs, int *path_idx)
1615 {
1616 	struct hda_gen_spec *spec = codec->spec;
1617 	int i;
1618 	bool found = false;
1619 	for (i = 0; i < outs; i++) {
1620 		struct nid_path *path;
1621 		hda_nid_t dac;
1622 		if (dacs[i])
1623 			continue;
1624 		dac = get_dac_if_single(codec, pins[i]);
1625 		if (!dac)
1626 			continue;
1627 		path = snd_hda_add_new_path(codec, dac, pins[i],
1628 					    -spec->mixer_nid);
1629 		if (!path && !i && spec->mixer_nid)
1630 			path = snd_hda_add_new_path(codec, dac, pins[i], 0);
1631 		if (path) {
1632 			dacs[i] = dac;
1633 			found = true;
1634 			/* print_nid_path(codec, "output", path); */
1635 			path->active = true;
1636 			path_idx[i] = snd_hda_get_path_idx(codec, path);
1637 		}
1638 	}
1639 	return found;
1640 }
1641 
has_aamix_out_paths(struct hda_gen_spec * spec)1642 static inline bool has_aamix_out_paths(struct hda_gen_spec *spec)
1643 {
1644 	return spec->aamix_out_paths[0] || spec->aamix_out_paths[1] ||
1645 		spec->aamix_out_paths[2];
1646 }
1647 
1648 /* create a new path including aamix if available, and return its index */
check_aamix_out_path(struct hda_codec * codec,int path_idx)1649 static int check_aamix_out_path(struct hda_codec *codec, int path_idx)
1650 {
1651 	struct hda_gen_spec *spec = codec->spec;
1652 	struct nid_path *path;
1653 	hda_nid_t path_dac, dac, pin;
1654 
1655 	path = snd_hda_get_path_from_idx(codec, path_idx);
1656 	if (!path || !path->depth ||
1657 	    is_nid_contained(path, spec->mixer_nid))
1658 		return 0;
1659 	path_dac = path->path[0];
1660 	dac = spec->private_dac_nids[0];
1661 	pin = path->path[path->depth - 1];
1662 	path = snd_hda_add_new_path(codec, dac, pin, spec->mixer_nid);
1663 	if (!path) {
1664 		if (dac != path_dac)
1665 			dac = path_dac;
1666 		else if (spec->multiout.hp_out_nid[0])
1667 			dac = spec->multiout.hp_out_nid[0];
1668 		else if (spec->multiout.extra_out_nid[0])
1669 			dac = spec->multiout.extra_out_nid[0];
1670 		else
1671 			dac = 0;
1672 		if (dac)
1673 			path = snd_hda_add_new_path(codec, dac, pin,
1674 						    spec->mixer_nid);
1675 	}
1676 	if (!path)
1677 		return 0;
1678 	/* print_nid_path(codec, "output-aamix", path); */
1679 	path->active = false; /* unused as default */
1680 	path->pin_fixed = true; /* static route */
1681 	return snd_hda_get_path_idx(codec, path);
1682 }
1683 
1684 /* check whether the independent HP is available with the current config */
indep_hp_possible(struct hda_codec * codec)1685 static bool indep_hp_possible(struct hda_codec *codec)
1686 {
1687 	struct hda_gen_spec *spec = codec->spec;
1688 	struct auto_pin_cfg *cfg = &spec->autocfg;
1689 	struct nid_path *path;
1690 	int i, idx;
1691 
1692 	if (cfg->line_out_type == AUTO_PIN_HP_OUT)
1693 		idx = spec->out_paths[0];
1694 	else
1695 		idx = spec->hp_paths[0];
1696 	path = snd_hda_get_path_from_idx(codec, idx);
1697 	if (!path)
1698 		return false;
1699 
1700 	/* assume no path conflicts unless aamix is involved */
1701 	if (!spec->mixer_nid || !is_nid_contained(path, spec->mixer_nid))
1702 		return true;
1703 
1704 	/* check whether output paths contain aamix */
1705 	for (i = 0; i < cfg->line_outs; i++) {
1706 		if (spec->out_paths[i] == idx)
1707 			break;
1708 		path = snd_hda_get_path_from_idx(codec, spec->out_paths[i]);
1709 		if (path && is_nid_contained(path, spec->mixer_nid))
1710 			return false;
1711 	}
1712 	for (i = 0; i < cfg->speaker_outs; i++) {
1713 		path = snd_hda_get_path_from_idx(codec, spec->speaker_paths[i]);
1714 		if (path && is_nid_contained(path, spec->mixer_nid))
1715 			return false;
1716 	}
1717 
1718 	return true;
1719 }
1720 
1721 /* fill the empty entries in the dac array for speaker/hp with the
1722  * shared dac pointed by the paths
1723  */
refill_shared_dacs(struct hda_codec * codec,int num_outs,hda_nid_t * dacs,int * path_idx)1724 static void refill_shared_dacs(struct hda_codec *codec, int num_outs,
1725 			       hda_nid_t *dacs, int *path_idx)
1726 {
1727 	struct nid_path *path;
1728 	int i;
1729 
1730 	for (i = 0; i < num_outs; i++) {
1731 		if (dacs[i])
1732 			continue;
1733 		path = snd_hda_get_path_from_idx(codec, path_idx[i]);
1734 		if (!path)
1735 			continue;
1736 		dacs[i] = path->path[0];
1737 	}
1738 }
1739 
1740 /* fill in the dac_nids table from the parsed pin configuration */
fill_and_eval_dacs(struct hda_codec * codec,bool fill_hardwired,bool fill_mio_first)1741 static int fill_and_eval_dacs(struct hda_codec *codec,
1742 			      bool fill_hardwired,
1743 			      bool fill_mio_first)
1744 {
1745 	struct hda_gen_spec *spec = codec->spec;
1746 	struct auto_pin_cfg *cfg = &spec->autocfg;
1747 	int i, err, badness;
1748 
1749 	/* set num_dacs once to full for look_for_dac() */
1750 	spec->multiout.num_dacs = cfg->line_outs;
1751 	spec->multiout.dac_nids = spec->private_dac_nids;
1752 	memset(spec->private_dac_nids, 0, sizeof(spec->private_dac_nids));
1753 	memset(spec->multiout.hp_out_nid, 0, sizeof(spec->multiout.hp_out_nid));
1754 	memset(spec->multiout.extra_out_nid, 0, sizeof(spec->multiout.extra_out_nid));
1755 	spec->multi_ios = 0;
1756 	snd_array_free(&spec->paths);
1757 
1758 	/* clear path indices */
1759 	memset(spec->out_paths, 0, sizeof(spec->out_paths));
1760 	memset(spec->hp_paths, 0, sizeof(spec->hp_paths));
1761 	memset(spec->speaker_paths, 0, sizeof(spec->speaker_paths));
1762 	memset(spec->aamix_out_paths, 0, sizeof(spec->aamix_out_paths));
1763 	memset(spec->digout_paths, 0, sizeof(spec->digout_paths));
1764 	memset(spec->input_paths, 0, sizeof(spec->input_paths));
1765 	memset(spec->loopback_paths, 0, sizeof(spec->loopback_paths));
1766 	memset(&spec->digin_path, 0, sizeof(spec->digin_path));
1767 
1768 	badness = 0;
1769 
1770 	/* fill hard-wired DACs first */
1771 	if (fill_hardwired) {
1772 		bool mapped;
1773 		do {
1774 			mapped = map_singles(codec, cfg->line_outs,
1775 					     cfg->line_out_pins,
1776 					     spec->private_dac_nids,
1777 					     spec->out_paths);
1778 			mapped |= map_singles(codec, cfg->hp_outs,
1779 					      cfg->hp_pins,
1780 					      spec->multiout.hp_out_nid,
1781 					      spec->hp_paths);
1782 			mapped |= map_singles(codec, cfg->speaker_outs,
1783 					      cfg->speaker_pins,
1784 					      spec->multiout.extra_out_nid,
1785 					      spec->speaker_paths);
1786 			if (!spec->no_multi_io &&
1787 			    fill_mio_first && cfg->line_outs == 1 &&
1788 			    cfg->line_out_type != AUTO_PIN_SPEAKER_OUT) {
1789 				err = fill_multi_ios(codec, cfg->line_out_pins[0], true);
1790 				if (!err)
1791 					mapped = true;
1792 			}
1793 		} while (mapped);
1794 	}
1795 
1796 	badness += try_assign_dacs(codec, cfg->line_outs, cfg->line_out_pins,
1797 				   spec->private_dac_nids, spec->out_paths,
1798 				   spec->main_out_badness);
1799 
1800 	if (!spec->no_multi_io && fill_mio_first &&
1801 	    cfg->line_outs == 1 && cfg->line_out_type != AUTO_PIN_SPEAKER_OUT) {
1802 		/* try to fill multi-io first */
1803 		err = fill_multi_ios(codec, cfg->line_out_pins[0], false);
1804 		if (err < 0)
1805 			return err;
1806 		/* we don't count badness at this stage yet */
1807 	}
1808 
1809 	if (cfg->line_out_type != AUTO_PIN_HP_OUT) {
1810 		err = try_assign_dacs(codec, cfg->hp_outs, cfg->hp_pins,
1811 				      spec->multiout.hp_out_nid,
1812 				      spec->hp_paths,
1813 				      spec->extra_out_badness);
1814 		if (err < 0)
1815 			return err;
1816 		badness += err;
1817 	}
1818 	if (cfg->line_out_type != AUTO_PIN_SPEAKER_OUT) {
1819 		err = try_assign_dacs(codec, cfg->speaker_outs,
1820 				      cfg->speaker_pins,
1821 				      spec->multiout.extra_out_nid,
1822 				      spec->speaker_paths,
1823 				      spec->extra_out_badness);
1824 		if (err < 0)
1825 			return err;
1826 		badness += err;
1827 	}
1828 	if (!spec->no_multi_io &&
1829 	    cfg->line_outs == 1 && cfg->line_out_type != AUTO_PIN_SPEAKER_OUT) {
1830 		err = fill_multi_ios(codec, cfg->line_out_pins[0], false);
1831 		if (err < 0)
1832 			return err;
1833 		badness += err;
1834 	}
1835 
1836 	if (spec->mixer_nid) {
1837 		spec->aamix_out_paths[0] =
1838 			check_aamix_out_path(codec, spec->out_paths[0]);
1839 		if (cfg->line_out_type != AUTO_PIN_HP_OUT)
1840 			spec->aamix_out_paths[1] =
1841 				check_aamix_out_path(codec, spec->hp_paths[0]);
1842 		if (cfg->line_out_type != AUTO_PIN_SPEAKER_OUT)
1843 			spec->aamix_out_paths[2] =
1844 				check_aamix_out_path(codec, spec->speaker_paths[0]);
1845 	}
1846 
1847 	if (!spec->no_multi_io &&
1848 	    cfg->hp_outs && cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
1849 		if (count_multiio_pins(codec, cfg->hp_pins[0]) >= 2)
1850 			spec->multi_ios = 1; /* give badness */
1851 
1852 	/* re-count num_dacs and squash invalid entries */
1853 	spec->multiout.num_dacs = 0;
1854 	for (i = 0; i < cfg->line_outs; i++) {
1855 		if (spec->private_dac_nids[i])
1856 			spec->multiout.num_dacs++;
1857 		else {
1858 			memmove(spec->private_dac_nids + i,
1859 				spec->private_dac_nids + i + 1,
1860 				sizeof(hda_nid_t) * (cfg->line_outs - i - 1));
1861 			spec->private_dac_nids[cfg->line_outs - 1] = 0;
1862 		}
1863 	}
1864 
1865 	spec->ext_channel_count = spec->min_channel_count =
1866 		spec->multiout.num_dacs * 2;
1867 
1868 	if (spec->multi_ios == 2) {
1869 		for (i = 0; i < 2; i++)
1870 			spec->private_dac_nids[spec->multiout.num_dacs++] =
1871 				spec->multi_io[i].dac;
1872 	} else if (spec->multi_ios) {
1873 		spec->multi_ios = 0;
1874 		badness += BAD_MULTI_IO;
1875 	}
1876 
1877 	if (spec->indep_hp && !indep_hp_possible(codec))
1878 		badness += BAD_NO_INDEP_HP;
1879 
1880 	/* re-fill the shared DAC for speaker / headphone */
1881 	if (cfg->line_out_type != AUTO_PIN_HP_OUT)
1882 		refill_shared_dacs(codec, cfg->hp_outs,
1883 				   spec->multiout.hp_out_nid,
1884 				   spec->hp_paths);
1885 	if (cfg->line_out_type != AUTO_PIN_SPEAKER_OUT)
1886 		refill_shared_dacs(codec, cfg->speaker_outs,
1887 				   spec->multiout.extra_out_nid,
1888 				   spec->speaker_paths);
1889 
1890 	return badness;
1891 }
1892 
1893 #define DEBUG_BADNESS
1894 
1895 #ifdef DEBUG_BADNESS
1896 #define debug_badness(fmt, ...)						\
1897 	codec_dbg(codec, fmt, ##__VA_ARGS__)
1898 #else
1899 #define debug_badness(fmt, ...)						\
1900 	do { if (0) codec_dbg(codec, fmt, ##__VA_ARGS__); } while (0)
1901 #endif
1902 
1903 #ifdef DEBUG_BADNESS
print_nid_path_idx(struct hda_codec * codec,const char * pfx,int idx)1904 static inline void print_nid_path_idx(struct hda_codec *codec,
1905 				      const char *pfx, int idx)
1906 {
1907 	struct nid_path *path;
1908 
1909 	path = snd_hda_get_path_from_idx(codec, idx);
1910 	if (path)
1911 		print_nid_path(codec, pfx, path);
1912 }
1913 
debug_show_configs(struct hda_codec * codec,struct auto_pin_cfg * cfg)1914 static void debug_show_configs(struct hda_codec *codec,
1915 			       struct auto_pin_cfg *cfg)
1916 {
1917 	struct hda_gen_spec *spec = codec->spec;
1918 	static const char * const lo_type[3] = { "LO", "SP", "HP" };
1919 	int i;
1920 
1921 	debug_badness("multi_outs = %x/%x/%x/%x : %x/%x/%x/%x (type %s)\n",
1922 		      cfg->line_out_pins[0], cfg->line_out_pins[1],
1923 		      cfg->line_out_pins[2], cfg->line_out_pins[3],
1924 		      spec->multiout.dac_nids[0],
1925 		      spec->multiout.dac_nids[1],
1926 		      spec->multiout.dac_nids[2],
1927 		      spec->multiout.dac_nids[3],
1928 		      lo_type[cfg->line_out_type]);
1929 	for (i = 0; i < cfg->line_outs; i++)
1930 		print_nid_path_idx(codec, "  out", spec->out_paths[i]);
1931 	if (spec->multi_ios > 0)
1932 		debug_badness("multi_ios(%d) = %x/%x : %x/%x\n",
1933 			      spec->multi_ios,
1934 			      spec->multi_io[0].pin, spec->multi_io[1].pin,
1935 			      spec->multi_io[0].dac, spec->multi_io[1].dac);
1936 	for (i = 0; i < spec->multi_ios; i++)
1937 		print_nid_path_idx(codec, "  mio",
1938 				   spec->out_paths[cfg->line_outs + i]);
1939 	if (cfg->hp_outs)
1940 		debug_badness("hp_outs = %x/%x/%x/%x : %x/%x/%x/%x\n",
1941 		      cfg->hp_pins[0], cfg->hp_pins[1],
1942 		      cfg->hp_pins[2], cfg->hp_pins[3],
1943 		      spec->multiout.hp_out_nid[0],
1944 		      spec->multiout.hp_out_nid[1],
1945 		      spec->multiout.hp_out_nid[2],
1946 		      spec->multiout.hp_out_nid[3]);
1947 	for (i = 0; i < cfg->hp_outs; i++)
1948 		print_nid_path_idx(codec, "  hp ", spec->hp_paths[i]);
1949 	if (cfg->speaker_outs)
1950 		debug_badness("spk_outs = %x/%x/%x/%x : %x/%x/%x/%x\n",
1951 		      cfg->speaker_pins[0], cfg->speaker_pins[1],
1952 		      cfg->speaker_pins[2], cfg->speaker_pins[3],
1953 		      spec->multiout.extra_out_nid[0],
1954 		      spec->multiout.extra_out_nid[1],
1955 		      spec->multiout.extra_out_nid[2],
1956 		      spec->multiout.extra_out_nid[3]);
1957 	for (i = 0; i < cfg->speaker_outs; i++)
1958 		print_nid_path_idx(codec, "  spk", spec->speaker_paths[i]);
1959 	for (i = 0; i < 3; i++)
1960 		print_nid_path_idx(codec, "  mix", spec->aamix_out_paths[i]);
1961 }
1962 #else
1963 #define debug_show_configs(codec, cfg) /* NOP */
1964 #endif
1965 
1966 /* find all available DACs of the codec */
fill_all_dac_nids(struct hda_codec * codec)1967 static void fill_all_dac_nids(struct hda_codec *codec)
1968 {
1969 	struct hda_gen_spec *spec = codec->spec;
1970 	hda_nid_t nid;
1971 
1972 	spec->num_all_dacs = 0;
1973 	memset(spec->all_dacs, 0, sizeof(spec->all_dacs));
1974 	for_each_hda_codec_node(nid, codec) {
1975 		if (get_wcaps_type(get_wcaps(codec, nid)) != AC_WID_AUD_OUT)
1976 			continue;
1977 		if (spec->num_all_dacs >= ARRAY_SIZE(spec->all_dacs)) {
1978 			codec_err(codec, "Too many DACs!\n");
1979 			break;
1980 		}
1981 		spec->all_dacs[spec->num_all_dacs++] = nid;
1982 	}
1983 }
1984 
parse_output_paths(struct hda_codec * codec)1985 static int parse_output_paths(struct hda_codec *codec)
1986 {
1987 	struct hda_gen_spec *spec = codec->spec;
1988 	struct auto_pin_cfg *cfg = &spec->autocfg;
1989 	struct auto_pin_cfg *best_cfg;
1990 	unsigned int val;
1991 	int best_badness = INT_MAX;
1992 	int badness;
1993 	bool fill_hardwired = true, fill_mio_first = true;
1994 	bool best_wired = true, best_mio = true;
1995 	bool hp_spk_swapped = false;
1996 
1997 	best_cfg = kmalloc(sizeof(*best_cfg), GFP_KERNEL);
1998 	if (!best_cfg)
1999 		return -ENOMEM;
2000 	*best_cfg = *cfg;
2001 
2002 	for (;;) {
2003 		badness = fill_and_eval_dacs(codec, fill_hardwired,
2004 					     fill_mio_first);
2005 		if (badness < 0) {
2006 			kfree(best_cfg);
2007 			return badness;
2008 		}
2009 		debug_badness("==> lo_type=%d, wired=%d, mio=%d, badness=0x%x\n",
2010 			      cfg->line_out_type, fill_hardwired, fill_mio_first,
2011 			      badness);
2012 		debug_show_configs(codec, cfg);
2013 		if (badness < best_badness) {
2014 			best_badness = badness;
2015 			*best_cfg = *cfg;
2016 			best_wired = fill_hardwired;
2017 			best_mio = fill_mio_first;
2018 		}
2019 		if (!badness)
2020 			break;
2021 		fill_mio_first = !fill_mio_first;
2022 		if (!fill_mio_first)
2023 			continue;
2024 		fill_hardwired = !fill_hardwired;
2025 		if (!fill_hardwired)
2026 			continue;
2027 		if (hp_spk_swapped)
2028 			break;
2029 		hp_spk_swapped = true;
2030 		if (cfg->speaker_outs > 0 &&
2031 		    cfg->line_out_type == AUTO_PIN_HP_OUT) {
2032 			cfg->hp_outs = cfg->line_outs;
2033 			memcpy(cfg->hp_pins, cfg->line_out_pins,
2034 			       sizeof(cfg->hp_pins));
2035 			cfg->line_outs = cfg->speaker_outs;
2036 			memcpy(cfg->line_out_pins, cfg->speaker_pins,
2037 			       sizeof(cfg->speaker_pins));
2038 			cfg->speaker_outs = 0;
2039 			memset(cfg->speaker_pins, 0, sizeof(cfg->speaker_pins));
2040 			cfg->line_out_type = AUTO_PIN_SPEAKER_OUT;
2041 			fill_hardwired = true;
2042 			continue;
2043 		}
2044 		if (cfg->hp_outs > 0 &&
2045 		    cfg->line_out_type == AUTO_PIN_SPEAKER_OUT) {
2046 			cfg->speaker_outs = cfg->line_outs;
2047 			memcpy(cfg->speaker_pins, cfg->line_out_pins,
2048 			       sizeof(cfg->speaker_pins));
2049 			cfg->line_outs = cfg->hp_outs;
2050 			memcpy(cfg->line_out_pins, cfg->hp_pins,
2051 			       sizeof(cfg->hp_pins));
2052 			cfg->hp_outs = 0;
2053 			memset(cfg->hp_pins, 0, sizeof(cfg->hp_pins));
2054 			cfg->line_out_type = AUTO_PIN_HP_OUT;
2055 			fill_hardwired = true;
2056 			continue;
2057 		}
2058 		break;
2059 	}
2060 
2061 	if (badness) {
2062 		debug_badness("==> restoring best_cfg\n");
2063 		*cfg = *best_cfg;
2064 		fill_and_eval_dacs(codec, best_wired, best_mio);
2065 	}
2066 	debug_badness("==> Best config: lo_type=%d, wired=%d, mio=%d\n",
2067 		      cfg->line_out_type, best_wired, best_mio);
2068 	debug_show_configs(codec, cfg);
2069 
2070 	if (cfg->line_out_pins[0]) {
2071 		struct nid_path *path;
2072 		path = snd_hda_get_path_from_idx(codec, spec->out_paths[0]);
2073 		if (path)
2074 			spec->vmaster_nid = look_for_out_vol_nid(codec, path);
2075 		if (spec->vmaster_nid) {
2076 			snd_hda_set_vmaster_tlv(codec, spec->vmaster_nid,
2077 						HDA_OUTPUT, spec->vmaster_tlv);
2078 			if (spec->dac_min_mute)
2079 				spec->vmaster_tlv[SNDRV_CTL_TLVO_DB_SCALE_MUTE_AND_STEP] |= TLV_DB_SCALE_MUTE;
2080 		}
2081 	}
2082 
2083 	/* set initial pinctl targets */
2084 	if (spec->prefer_hp_amp || cfg->line_out_type == AUTO_PIN_HP_OUT)
2085 		val = PIN_HP;
2086 	else
2087 		val = PIN_OUT;
2088 	set_pin_targets(codec, cfg->line_outs, cfg->line_out_pins, val);
2089 	if (cfg->line_out_type != AUTO_PIN_HP_OUT)
2090 		set_pin_targets(codec, cfg->hp_outs, cfg->hp_pins, PIN_HP);
2091 	if (cfg->line_out_type != AUTO_PIN_SPEAKER_OUT) {
2092 		val = spec->prefer_hp_amp ? PIN_HP : PIN_OUT;
2093 		set_pin_targets(codec, cfg->speaker_outs,
2094 				cfg->speaker_pins, val);
2095 	}
2096 
2097 	/* clear indep_hp flag if not available */
2098 	if (spec->indep_hp && !indep_hp_possible(codec))
2099 		spec->indep_hp = 0;
2100 
2101 	kfree(best_cfg);
2102 	return 0;
2103 }
2104 
2105 /* add playback controls from the parsed DAC table */
create_multi_out_ctls(struct hda_codec * codec,const struct auto_pin_cfg * cfg)2106 static int create_multi_out_ctls(struct hda_codec *codec,
2107 				 const struct auto_pin_cfg *cfg)
2108 {
2109 	struct hda_gen_spec *spec = codec->spec;
2110 	int i, err, noutputs;
2111 
2112 	noutputs = cfg->line_outs;
2113 	if (spec->multi_ios > 0 && cfg->line_outs < 3)
2114 		noutputs += spec->multi_ios;
2115 
2116 	for (i = 0; i < noutputs; i++) {
2117 		const char *name;
2118 		int index;
2119 		struct nid_path *path;
2120 
2121 		path = snd_hda_get_path_from_idx(codec, spec->out_paths[i]);
2122 		if (!path)
2123 			continue;
2124 
2125 		name = get_line_out_pfx(codec, i, &index, NID_PATH_VOL_CTL);
2126 		if (!name || !strcmp(name, "CLFE")) {
2127 			/* Center/LFE */
2128 			err = add_vol_ctl(codec, "Center", 0, 1, path);
2129 			if (err < 0)
2130 				return err;
2131 			err = add_vol_ctl(codec, "LFE", 0, 2, path);
2132 			if (err < 0)
2133 				return err;
2134 		} else {
2135 			err = add_stereo_vol(codec, name, index, path);
2136 			if (err < 0)
2137 				return err;
2138 		}
2139 
2140 		name = get_line_out_pfx(codec, i, &index, NID_PATH_MUTE_CTL);
2141 		if (!name || !strcmp(name, "CLFE")) {
2142 			err = add_sw_ctl(codec, "Center", 0, 1, path);
2143 			if (err < 0)
2144 				return err;
2145 			err = add_sw_ctl(codec, "LFE", 0, 2, path);
2146 			if (err < 0)
2147 				return err;
2148 		} else {
2149 			err = add_stereo_sw(codec, name, index, path);
2150 			if (err < 0)
2151 				return err;
2152 		}
2153 	}
2154 	return 0;
2155 }
2156 
create_extra_out(struct hda_codec * codec,int path_idx,const char * pfx,int cidx)2157 static int create_extra_out(struct hda_codec *codec, int path_idx,
2158 			    const char *pfx, int cidx)
2159 {
2160 	struct nid_path *path;
2161 	int err;
2162 
2163 	path = snd_hda_get_path_from_idx(codec, path_idx);
2164 	if (!path)
2165 		return 0;
2166 	err = add_stereo_vol(codec, pfx, cidx, path);
2167 	if (err < 0)
2168 		return err;
2169 	err = add_stereo_sw(codec, pfx, cidx, path);
2170 	if (err < 0)
2171 		return err;
2172 	return 0;
2173 }
2174 
2175 /* add playback controls for speaker and HP outputs */
create_extra_outs(struct hda_codec * codec,int num_pins,const int * paths,const char * pfx)2176 static int create_extra_outs(struct hda_codec *codec, int num_pins,
2177 			     const int *paths, const char *pfx)
2178 {
2179 	int i;
2180 
2181 	for (i = 0; i < num_pins; i++) {
2182 		const char *name;
2183 		char tmp[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];
2184 		int err, idx = 0;
2185 
2186 		if (num_pins == 2 && i == 1 && !strcmp(pfx, "Speaker"))
2187 			name = "Bass Speaker";
2188 		else if (num_pins >= 3) {
2189 			snprintf(tmp, sizeof(tmp), "%s %s",
2190 				 pfx, channel_name[i]);
2191 			name = tmp;
2192 		} else {
2193 			name = pfx;
2194 			idx = i;
2195 		}
2196 		err = create_extra_out(codec, paths[i], name, idx);
2197 		if (err < 0)
2198 			return err;
2199 	}
2200 	return 0;
2201 }
2202 
create_hp_out_ctls(struct hda_codec * codec)2203 static int create_hp_out_ctls(struct hda_codec *codec)
2204 {
2205 	struct hda_gen_spec *spec = codec->spec;
2206 	return create_extra_outs(codec, spec->autocfg.hp_outs,
2207 				 spec->hp_paths,
2208 				 "Headphone");
2209 }
2210 
create_speaker_out_ctls(struct hda_codec * codec)2211 static int create_speaker_out_ctls(struct hda_codec *codec)
2212 {
2213 	struct hda_gen_spec *spec = codec->spec;
2214 	return create_extra_outs(codec, spec->autocfg.speaker_outs,
2215 				 spec->speaker_paths,
2216 				 "Speaker");
2217 }
2218 
2219 /*
2220  * independent HP controls
2221  */
2222 
2223 static void call_hp_automute(struct hda_codec *codec,
2224 			     struct hda_jack_callback *jack);
indep_hp_info(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_info * uinfo)2225 static int indep_hp_info(struct snd_kcontrol *kcontrol,
2226 			 struct snd_ctl_elem_info *uinfo)
2227 {
2228 	return snd_hda_enum_bool_helper_info(kcontrol, uinfo);
2229 }
2230 
indep_hp_get(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)2231 static int indep_hp_get(struct snd_kcontrol *kcontrol,
2232 			struct snd_ctl_elem_value *ucontrol)
2233 {
2234 	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2235 	struct hda_gen_spec *spec = codec->spec;
2236 	ucontrol->value.enumerated.item[0] = spec->indep_hp_enabled;
2237 	return 0;
2238 }
2239 
2240 static void update_aamix_paths(struct hda_codec *codec, bool do_mix,
2241 			       int nomix_path_idx, int mix_path_idx,
2242 			       int out_type);
2243 
indep_hp_put(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)2244 static int indep_hp_put(struct snd_kcontrol *kcontrol,
2245 			struct snd_ctl_elem_value *ucontrol)
2246 {
2247 	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2248 	struct hda_gen_spec *spec = codec->spec;
2249 	unsigned int select = ucontrol->value.enumerated.item[0];
2250 	int ret = 0;
2251 
2252 	mutex_lock(&spec->pcm_mutex);
2253 	if (spec->active_streams) {
2254 		ret = -EBUSY;
2255 		goto unlock;
2256 	}
2257 
2258 	if (spec->indep_hp_enabled != select) {
2259 		hda_nid_t *dacp;
2260 		if (spec->autocfg.line_out_type == AUTO_PIN_HP_OUT)
2261 			dacp = &spec->private_dac_nids[0];
2262 		else
2263 			dacp = &spec->multiout.hp_out_nid[0];
2264 
2265 		/* update HP aamix paths in case it conflicts with indep HP */
2266 		if (spec->have_aamix_ctl) {
2267 			if (spec->autocfg.line_out_type == AUTO_PIN_HP_OUT)
2268 				update_aamix_paths(codec, spec->aamix_mode,
2269 						   spec->out_paths[0],
2270 						   spec->aamix_out_paths[0],
2271 						   spec->autocfg.line_out_type);
2272 			else
2273 				update_aamix_paths(codec, spec->aamix_mode,
2274 						   spec->hp_paths[0],
2275 						   spec->aamix_out_paths[1],
2276 						   AUTO_PIN_HP_OUT);
2277 		}
2278 
2279 		spec->indep_hp_enabled = select;
2280 		if (spec->indep_hp_enabled)
2281 			*dacp = 0;
2282 		else
2283 			*dacp = spec->alt_dac_nid;
2284 
2285 		call_hp_automute(codec, NULL);
2286 		ret = 1;
2287 	}
2288  unlock:
2289 	mutex_unlock(&spec->pcm_mutex);
2290 	return ret;
2291 }
2292 
2293 static const struct snd_kcontrol_new indep_hp_ctl = {
2294 	.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2295 	.name = "Independent HP",
2296 	.info = indep_hp_info,
2297 	.get = indep_hp_get,
2298 	.put = indep_hp_put,
2299 };
2300 
2301 
create_indep_hp_ctls(struct hda_codec * codec)2302 static int create_indep_hp_ctls(struct hda_codec *codec)
2303 {
2304 	struct hda_gen_spec *spec = codec->spec;
2305 	hda_nid_t dac;
2306 
2307 	if (!spec->indep_hp)
2308 		return 0;
2309 	if (spec->autocfg.line_out_type == AUTO_PIN_HP_OUT)
2310 		dac = spec->multiout.dac_nids[0];
2311 	else
2312 		dac = spec->multiout.hp_out_nid[0];
2313 	if (!dac) {
2314 		spec->indep_hp = 0;
2315 		return 0;
2316 	}
2317 
2318 	spec->indep_hp_enabled = false;
2319 	spec->alt_dac_nid = dac;
2320 	if (!snd_hda_gen_add_kctl(spec, NULL, &indep_hp_ctl))
2321 		return -ENOMEM;
2322 	return 0;
2323 }
2324 
2325 /*
2326  * channel mode enum control
2327  */
2328 
ch_mode_info(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_info * uinfo)2329 static int ch_mode_info(struct snd_kcontrol *kcontrol,
2330 			struct snd_ctl_elem_info *uinfo)
2331 {
2332 	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2333 	struct hda_gen_spec *spec = codec->spec;
2334 	int chs;
2335 
2336 	uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
2337 	uinfo->count = 1;
2338 	uinfo->value.enumerated.items = spec->multi_ios + 1;
2339 	if (uinfo->value.enumerated.item > spec->multi_ios)
2340 		uinfo->value.enumerated.item = spec->multi_ios;
2341 	chs = uinfo->value.enumerated.item * 2 + spec->min_channel_count;
2342 	sprintf(uinfo->value.enumerated.name, "%dch", chs);
2343 	return 0;
2344 }
2345 
ch_mode_get(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)2346 static int ch_mode_get(struct snd_kcontrol *kcontrol,
2347 		       struct snd_ctl_elem_value *ucontrol)
2348 {
2349 	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2350 	struct hda_gen_spec *spec = codec->spec;
2351 	ucontrol->value.enumerated.item[0] =
2352 		(spec->ext_channel_count - spec->min_channel_count) / 2;
2353 	return 0;
2354 }
2355 
2356 static inline struct nid_path *
get_multiio_path(struct hda_codec * codec,int idx)2357 get_multiio_path(struct hda_codec *codec, int idx)
2358 {
2359 	struct hda_gen_spec *spec = codec->spec;
2360 	return snd_hda_get_path_from_idx(codec,
2361 		spec->out_paths[spec->autocfg.line_outs + idx]);
2362 }
2363 
2364 static void update_automute_all(struct hda_codec *codec);
2365 
2366 /* Default value to be passed as aamix argument for snd_hda_activate_path();
2367  * used for output paths
2368  */
aamix_default(struct hda_gen_spec * spec)2369 static bool aamix_default(struct hda_gen_spec *spec)
2370 {
2371 	return !spec->have_aamix_ctl || spec->aamix_mode;
2372 }
2373 
set_multi_io(struct hda_codec * codec,int idx,bool output)2374 static int set_multi_io(struct hda_codec *codec, int idx, bool output)
2375 {
2376 	struct hda_gen_spec *spec = codec->spec;
2377 	hda_nid_t nid = spec->multi_io[idx].pin;
2378 	struct nid_path *path;
2379 
2380 	path = get_multiio_path(codec, idx);
2381 	if (!path)
2382 		return -EINVAL;
2383 
2384 	if (path->active == output)
2385 		return 0;
2386 
2387 	if (output) {
2388 		set_pin_target(codec, nid, PIN_OUT, true);
2389 		snd_hda_activate_path(codec, path, true, aamix_default(spec));
2390 		set_pin_eapd(codec, nid, true);
2391 	} else {
2392 		set_pin_eapd(codec, nid, false);
2393 		snd_hda_activate_path(codec, path, false, aamix_default(spec));
2394 		set_pin_target(codec, nid, spec->multi_io[idx].ctl_in, true);
2395 		path_power_down_sync(codec, path);
2396 	}
2397 
2398 	/* update jack retasking in case it modifies any of them */
2399 	update_automute_all(codec);
2400 
2401 	return 0;
2402 }
2403 
ch_mode_put(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)2404 static int ch_mode_put(struct snd_kcontrol *kcontrol,
2405 		       struct snd_ctl_elem_value *ucontrol)
2406 {
2407 	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2408 	struct hda_gen_spec *spec = codec->spec;
2409 	int i, ch;
2410 
2411 	ch = ucontrol->value.enumerated.item[0];
2412 	if (ch < 0 || ch > spec->multi_ios)
2413 		return -EINVAL;
2414 	if (ch == (spec->ext_channel_count - spec->min_channel_count) / 2)
2415 		return 0;
2416 	spec->ext_channel_count = ch * 2 + spec->min_channel_count;
2417 	for (i = 0; i < spec->multi_ios; i++)
2418 		set_multi_io(codec, i, i < ch);
2419 	spec->multiout.max_channels = max(spec->ext_channel_count,
2420 					  spec->const_channel_count);
2421 	if (spec->need_dac_fix)
2422 		spec->multiout.num_dacs = spec->multiout.max_channels / 2;
2423 	return 1;
2424 }
2425 
2426 static const struct snd_kcontrol_new channel_mode_enum = {
2427 	.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2428 	.name = "Channel Mode",
2429 	.info = ch_mode_info,
2430 	.get = ch_mode_get,
2431 	.put = ch_mode_put,
2432 };
2433 
create_multi_channel_mode(struct hda_codec * codec)2434 static int create_multi_channel_mode(struct hda_codec *codec)
2435 {
2436 	struct hda_gen_spec *spec = codec->spec;
2437 
2438 	if (spec->multi_ios > 0) {
2439 		if (!snd_hda_gen_add_kctl(spec, NULL, &channel_mode_enum))
2440 			return -ENOMEM;
2441 	}
2442 	return 0;
2443 }
2444 
2445 /*
2446  * aamix loopback enable/disable switch
2447  */
2448 
2449 #define loopback_mixing_info	indep_hp_info
2450 
loopback_mixing_get(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)2451 static int loopback_mixing_get(struct snd_kcontrol *kcontrol,
2452 			       struct snd_ctl_elem_value *ucontrol)
2453 {
2454 	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2455 	struct hda_gen_spec *spec = codec->spec;
2456 	ucontrol->value.enumerated.item[0] = spec->aamix_mode;
2457 	return 0;
2458 }
2459 
update_aamix_paths(struct hda_codec * codec,bool do_mix,int nomix_path_idx,int mix_path_idx,int out_type)2460 static void update_aamix_paths(struct hda_codec *codec, bool do_mix,
2461 			       int nomix_path_idx, int mix_path_idx,
2462 			       int out_type)
2463 {
2464 	struct hda_gen_spec *spec = codec->spec;
2465 	struct nid_path *nomix_path, *mix_path;
2466 
2467 	nomix_path = snd_hda_get_path_from_idx(codec, nomix_path_idx);
2468 	mix_path = snd_hda_get_path_from_idx(codec, mix_path_idx);
2469 	if (!nomix_path || !mix_path)
2470 		return;
2471 
2472 	/* if HP aamix path is driven from a different DAC and the
2473 	 * independent HP mode is ON, can't turn on aamix path
2474 	 */
2475 	if (out_type == AUTO_PIN_HP_OUT && spec->indep_hp_enabled &&
2476 	    mix_path->path[0] != spec->alt_dac_nid)
2477 		do_mix = false;
2478 
2479 	if (do_mix) {
2480 		snd_hda_activate_path(codec, nomix_path, false, true);
2481 		snd_hda_activate_path(codec, mix_path, true, true);
2482 		path_power_down_sync(codec, nomix_path);
2483 	} else {
2484 		snd_hda_activate_path(codec, mix_path, false, false);
2485 		snd_hda_activate_path(codec, nomix_path, true, false);
2486 		path_power_down_sync(codec, mix_path);
2487 	}
2488 }
2489 
2490 /* re-initialize the output paths; only called from loopback_mixing_put() */
update_output_paths(struct hda_codec * codec,int num_outs,const int * paths)2491 static void update_output_paths(struct hda_codec *codec, int num_outs,
2492 				const int *paths)
2493 {
2494 	struct hda_gen_spec *spec = codec->spec;
2495 	struct nid_path *path;
2496 	int i;
2497 
2498 	for (i = 0; i < num_outs; i++) {
2499 		path = snd_hda_get_path_from_idx(codec, paths[i]);
2500 		if (path)
2501 			snd_hda_activate_path(codec, path, path->active,
2502 					      spec->aamix_mode);
2503 	}
2504 }
2505 
loopback_mixing_put(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)2506 static int loopback_mixing_put(struct snd_kcontrol *kcontrol,
2507 			       struct snd_ctl_elem_value *ucontrol)
2508 {
2509 	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2510 	struct hda_gen_spec *spec = codec->spec;
2511 	const struct auto_pin_cfg *cfg = &spec->autocfg;
2512 	unsigned int val = ucontrol->value.enumerated.item[0];
2513 
2514 	if (val == spec->aamix_mode)
2515 		return 0;
2516 	spec->aamix_mode = val;
2517 	if (has_aamix_out_paths(spec)) {
2518 		update_aamix_paths(codec, val, spec->out_paths[0],
2519 				   spec->aamix_out_paths[0],
2520 				   cfg->line_out_type);
2521 		update_aamix_paths(codec, val, spec->hp_paths[0],
2522 				   spec->aamix_out_paths[1],
2523 				   AUTO_PIN_HP_OUT);
2524 		update_aamix_paths(codec, val, spec->speaker_paths[0],
2525 				   spec->aamix_out_paths[2],
2526 				   AUTO_PIN_SPEAKER_OUT);
2527 	} else {
2528 		update_output_paths(codec, cfg->line_outs, spec->out_paths);
2529 		if (cfg->line_out_type != AUTO_PIN_HP_OUT)
2530 			update_output_paths(codec, cfg->hp_outs, spec->hp_paths);
2531 		if (cfg->line_out_type != AUTO_PIN_SPEAKER_OUT)
2532 			update_output_paths(codec, cfg->speaker_outs,
2533 					    spec->speaker_paths);
2534 	}
2535 	return 1;
2536 }
2537 
2538 static const struct snd_kcontrol_new loopback_mixing_enum = {
2539 	.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2540 	.name = "Loopback Mixing",
2541 	.info = loopback_mixing_info,
2542 	.get = loopback_mixing_get,
2543 	.put = loopback_mixing_put,
2544 };
2545 
create_loopback_mixing_ctl(struct hda_codec * codec)2546 static int create_loopback_mixing_ctl(struct hda_codec *codec)
2547 {
2548 	struct hda_gen_spec *spec = codec->spec;
2549 
2550 	if (!spec->mixer_nid)
2551 		return 0;
2552 	if (!snd_hda_gen_add_kctl(spec, NULL, &loopback_mixing_enum))
2553 		return -ENOMEM;
2554 	spec->have_aamix_ctl = 1;
2555 	return 0;
2556 }
2557 
2558 /*
2559  * shared headphone/mic handling
2560  */
2561 
2562 static void call_update_outputs(struct hda_codec *codec);
2563 
2564 /* for shared I/O, change the pin-control accordingly */
update_hp_mic(struct hda_codec * codec,int adc_mux,bool force)2565 static void update_hp_mic(struct hda_codec *codec, int adc_mux, bool force)
2566 {
2567 	struct hda_gen_spec *spec = codec->spec;
2568 	bool as_mic;
2569 	unsigned int val;
2570 	hda_nid_t pin;
2571 
2572 	pin = spec->hp_mic_pin;
2573 	as_mic = spec->cur_mux[adc_mux] == spec->hp_mic_mux_idx;
2574 
2575 	if (!force) {
2576 		val = snd_hda_codec_get_pin_target(codec, pin);
2577 		if (as_mic) {
2578 			if (val & PIN_IN)
2579 				return;
2580 		} else {
2581 			if (val & PIN_OUT)
2582 				return;
2583 		}
2584 	}
2585 
2586 	val = snd_hda_get_default_vref(codec, pin);
2587 	/* if the HP pin doesn't support VREF and the codec driver gives an
2588 	 * alternative pin, set up the VREF on that pin instead
2589 	 */
2590 	if (val == AC_PINCTL_VREF_HIZ && spec->shared_mic_vref_pin) {
2591 		const hda_nid_t vref_pin = spec->shared_mic_vref_pin;
2592 		unsigned int vref_val = snd_hda_get_default_vref(codec, vref_pin);
2593 		if (vref_val != AC_PINCTL_VREF_HIZ)
2594 			snd_hda_set_pin_ctl_cache(codec, vref_pin,
2595 						  PIN_IN | (as_mic ? vref_val : 0));
2596 	}
2597 
2598 	if (!spec->hp_mic_jack_modes) {
2599 		if (as_mic)
2600 			val |= PIN_IN;
2601 		else
2602 			val = PIN_HP;
2603 		set_pin_target(codec, pin, val, true);
2604 		call_hp_automute(codec, NULL);
2605 	}
2606 }
2607 
2608 /* create a shared input with the headphone out */
create_hp_mic(struct hda_codec * codec)2609 static int create_hp_mic(struct hda_codec *codec)
2610 {
2611 	struct hda_gen_spec *spec = codec->spec;
2612 	struct auto_pin_cfg *cfg = &spec->autocfg;
2613 	unsigned int defcfg;
2614 	hda_nid_t nid;
2615 
2616 	if (!spec->hp_mic) {
2617 		if (spec->suppress_hp_mic_detect)
2618 			return 0;
2619 		/* automatic detection: only if no input or a single internal
2620 		 * input pin is found, try to detect the shared hp/mic
2621 		 */
2622 		if (cfg->num_inputs > 1)
2623 			return 0;
2624 		else if (cfg->num_inputs == 1) {
2625 			defcfg = snd_hda_codec_get_pincfg(codec, cfg->inputs[0].pin);
2626 			if (snd_hda_get_input_pin_attr(defcfg) != INPUT_PIN_ATTR_INT)
2627 				return 0;
2628 		}
2629 	}
2630 
2631 	spec->hp_mic = 0; /* clear once */
2632 	if (cfg->num_inputs >= AUTO_CFG_MAX_INS)
2633 		return 0;
2634 
2635 	nid = 0;
2636 	if (cfg->line_out_type == AUTO_PIN_HP_OUT && cfg->line_outs > 0)
2637 		nid = cfg->line_out_pins[0];
2638 	else if (cfg->hp_outs > 0)
2639 		nid = cfg->hp_pins[0];
2640 	if (!nid)
2641 		return 0;
2642 
2643 	if (!(snd_hda_query_pin_caps(codec, nid) & AC_PINCAP_IN))
2644 		return 0; /* no input */
2645 
2646 	cfg->inputs[cfg->num_inputs].pin = nid;
2647 	cfg->inputs[cfg->num_inputs].type = AUTO_PIN_MIC;
2648 	cfg->inputs[cfg->num_inputs].is_headphone_mic = 1;
2649 	cfg->num_inputs++;
2650 	spec->hp_mic = 1;
2651 	spec->hp_mic_pin = nid;
2652 	/* we can't handle auto-mic together with HP-mic */
2653 	spec->suppress_auto_mic = 1;
2654 	codec_dbg(codec, "Enable shared I/O jack on NID 0x%x\n", nid);
2655 	return 0;
2656 }
2657 
2658 /*
2659  * output jack mode
2660  */
2661 
2662 static int create_hp_mic_jack_mode(struct hda_codec *codec, hda_nid_t pin);
2663 
2664 static const char * const out_jack_texts[] = {
2665 	"Line Out", "Headphone Out",
2666 };
2667 
out_jack_mode_info(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_info * uinfo)2668 static int out_jack_mode_info(struct snd_kcontrol *kcontrol,
2669 			      struct snd_ctl_elem_info *uinfo)
2670 {
2671 	return snd_hda_enum_helper_info(kcontrol, uinfo, 2, out_jack_texts);
2672 }
2673 
out_jack_mode_get(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)2674 static int out_jack_mode_get(struct snd_kcontrol *kcontrol,
2675 			     struct snd_ctl_elem_value *ucontrol)
2676 {
2677 	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2678 	hda_nid_t nid = kcontrol->private_value;
2679 	if (snd_hda_codec_get_pin_target(codec, nid) == PIN_HP)
2680 		ucontrol->value.enumerated.item[0] = 1;
2681 	else
2682 		ucontrol->value.enumerated.item[0] = 0;
2683 	return 0;
2684 }
2685 
out_jack_mode_put(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)2686 static int out_jack_mode_put(struct snd_kcontrol *kcontrol,
2687 			     struct snd_ctl_elem_value *ucontrol)
2688 {
2689 	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2690 	hda_nid_t nid = kcontrol->private_value;
2691 	unsigned int val;
2692 
2693 	val = ucontrol->value.enumerated.item[0] ? PIN_HP : PIN_OUT;
2694 	if (snd_hda_codec_get_pin_target(codec, nid) == val)
2695 		return 0;
2696 	snd_hda_set_pin_ctl_cache(codec, nid, val);
2697 	return 1;
2698 }
2699 
2700 static const struct snd_kcontrol_new out_jack_mode_enum = {
2701 	.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2702 	.info = out_jack_mode_info,
2703 	.get = out_jack_mode_get,
2704 	.put = out_jack_mode_put,
2705 };
2706 
find_kctl_name(struct hda_codec * codec,const char * name,int idx)2707 static bool find_kctl_name(struct hda_codec *codec, const char *name, int idx)
2708 {
2709 	struct hda_gen_spec *spec = codec->spec;
2710 	const struct snd_kcontrol_new *kctl;
2711 	int i;
2712 
2713 	snd_array_for_each(&spec->kctls, i, kctl) {
2714 		if (!strcmp(kctl->name, name) && kctl->index == idx)
2715 			return true;
2716 	}
2717 	return false;
2718 }
2719 
get_jack_mode_name(struct hda_codec * codec,hda_nid_t pin,char * name,size_t name_len)2720 static void get_jack_mode_name(struct hda_codec *codec, hda_nid_t pin,
2721 			       char *name, size_t name_len)
2722 {
2723 	struct hda_gen_spec *spec = codec->spec;
2724 	int idx = 0;
2725 
2726 	snd_hda_get_pin_label(codec, pin, &spec->autocfg, name, name_len, &idx);
2727 	strlcat(name, " Jack Mode", name_len);
2728 
2729 	for (; find_kctl_name(codec, name, idx); idx++)
2730 		;
2731 }
2732 
get_out_jack_num_items(struct hda_codec * codec,hda_nid_t pin)2733 static int get_out_jack_num_items(struct hda_codec *codec, hda_nid_t pin)
2734 {
2735 	struct hda_gen_spec *spec = codec->spec;
2736 	if (spec->add_jack_modes) {
2737 		unsigned int pincap = snd_hda_query_pin_caps(codec, pin);
2738 		if ((pincap & AC_PINCAP_OUT) && (pincap & AC_PINCAP_HP_DRV))
2739 			return 2;
2740 	}
2741 	return 1;
2742 }
2743 
create_out_jack_modes(struct hda_codec * codec,int num_pins,hda_nid_t * pins)2744 static int create_out_jack_modes(struct hda_codec *codec, int num_pins,
2745 				 hda_nid_t *pins)
2746 {
2747 	struct hda_gen_spec *spec = codec->spec;
2748 	int i;
2749 
2750 	for (i = 0; i < num_pins; i++) {
2751 		hda_nid_t pin = pins[i];
2752 		if (pin == spec->hp_mic_pin)
2753 			continue;
2754 		if (get_out_jack_num_items(codec, pin) > 1) {
2755 			struct snd_kcontrol_new *knew;
2756 			char name[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];
2757 			get_jack_mode_name(codec, pin, name, sizeof(name));
2758 			knew = snd_hda_gen_add_kctl(spec, name,
2759 						    &out_jack_mode_enum);
2760 			if (!knew)
2761 				return -ENOMEM;
2762 			knew->private_value = pin;
2763 		}
2764 	}
2765 
2766 	return 0;
2767 }
2768 
2769 /*
2770  * input jack mode
2771  */
2772 
2773 /* from AC_PINCTL_VREF_HIZ to AC_PINCTL_VREF_100 */
2774 #define NUM_VREFS	6
2775 
2776 static const char * const vref_texts[NUM_VREFS] = {
2777 	"Line In", "Mic 50pc Bias", "Mic 0V Bias",
2778 	"", "Mic 80pc Bias", "Mic 100pc Bias"
2779 };
2780 
get_vref_caps(struct hda_codec * codec,hda_nid_t pin)2781 static unsigned int get_vref_caps(struct hda_codec *codec, hda_nid_t pin)
2782 {
2783 	unsigned int pincap;
2784 
2785 	pincap = snd_hda_query_pin_caps(codec, pin);
2786 	pincap = (pincap & AC_PINCAP_VREF) >> AC_PINCAP_VREF_SHIFT;
2787 	/* filter out unusual vrefs */
2788 	pincap &= ~(AC_PINCAP_VREF_GRD | AC_PINCAP_VREF_100);
2789 	return pincap;
2790 }
2791 
2792 /* convert from the enum item index to the vref ctl index (0=HIZ, 1=50%...) */
get_vref_idx(unsigned int vref_caps,unsigned int item_idx)2793 static int get_vref_idx(unsigned int vref_caps, unsigned int item_idx)
2794 {
2795 	unsigned int i, n = 0;
2796 
2797 	for (i = 0; i < NUM_VREFS; i++) {
2798 		if (vref_caps & (1 << i)) {
2799 			if (n == item_idx)
2800 				return i;
2801 			n++;
2802 		}
2803 	}
2804 	return 0;
2805 }
2806 
2807 /* convert back from the vref ctl index to the enum item index */
cvt_from_vref_idx(unsigned int vref_caps,unsigned int idx)2808 static int cvt_from_vref_idx(unsigned int vref_caps, unsigned int idx)
2809 {
2810 	unsigned int i, n = 0;
2811 
2812 	for (i = 0; i < NUM_VREFS; i++) {
2813 		if (i == idx)
2814 			return n;
2815 		if (vref_caps & (1 << i))
2816 			n++;
2817 	}
2818 	return 0;
2819 }
2820 
in_jack_mode_info(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_info * uinfo)2821 static int in_jack_mode_info(struct snd_kcontrol *kcontrol,
2822 			     struct snd_ctl_elem_info *uinfo)
2823 {
2824 	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2825 	hda_nid_t nid = kcontrol->private_value;
2826 	unsigned int vref_caps = get_vref_caps(codec, nid);
2827 
2828 	snd_hda_enum_helper_info(kcontrol, uinfo, hweight32(vref_caps),
2829 				 vref_texts);
2830 	/* set the right text */
2831 	strcpy(uinfo->value.enumerated.name,
2832 	       vref_texts[get_vref_idx(vref_caps, uinfo->value.enumerated.item)]);
2833 	return 0;
2834 }
2835 
in_jack_mode_get(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)2836 static int in_jack_mode_get(struct snd_kcontrol *kcontrol,
2837 			    struct snd_ctl_elem_value *ucontrol)
2838 {
2839 	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2840 	hda_nid_t nid = kcontrol->private_value;
2841 	unsigned int vref_caps = get_vref_caps(codec, nid);
2842 	unsigned int idx;
2843 
2844 	idx = snd_hda_codec_get_pin_target(codec, nid) & AC_PINCTL_VREFEN;
2845 	ucontrol->value.enumerated.item[0] = cvt_from_vref_idx(vref_caps, idx);
2846 	return 0;
2847 }
2848 
in_jack_mode_put(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)2849 static int in_jack_mode_put(struct snd_kcontrol *kcontrol,
2850 			    struct snd_ctl_elem_value *ucontrol)
2851 {
2852 	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2853 	hda_nid_t nid = kcontrol->private_value;
2854 	unsigned int vref_caps = get_vref_caps(codec, nid);
2855 	unsigned int val, idx;
2856 
2857 	val = snd_hda_codec_get_pin_target(codec, nid);
2858 	idx = cvt_from_vref_idx(vref_caps, val & AC_PINCTL_VREFEN);
2859 	if (idx == ucontrol->value.enumerated.item[0])
2860 		return 0;
2861 
2862 	val &= ~AC_PINCTL_VREFEN;
2863 	val |= get_vref_idx(vref_caps, ucontrol->value.enumerated.item[0]);
2864 	snd_hda_set_pin_ctl_cache(codec, nid, val);
2865 	return 1;
2866 }
2867 
2868 static const struct snd_kcontrol_new in_jack_mode_enum = {
2869 	.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2870 	.info = in_jack_mode_info,
2871 	.get = in_jack_mode_get,
2872 	.put = in_jack_mode_put,
2873 };
2874 
get_in_jack_num_items(struct hda_codec * codec,hda_nid_t pin)2875 static int get_in_jack_num_items(struct hda_codec *codec, hda_nid_t pin)
2876 {
2877 	struct hda_gen_spec *spec = codec->spec;
2878 	int nitems = 0;
2879 	if (spec->add_jack_modes)
2880 		nitems = hweight32(get_vref_caps(codec, pin));
2881 	return nitems ? nitems : 1;
2882 }
2883 
create_in_jack_mode(struct hda_codec * codec,hda_nid_t pin)2884 static int create_in_jack_mode(struct hda_codec *codec, hda_nid_t pin)
2885 {
2886 	struct hda_gen_spec *spec = codec->spec;
2887 	struct snd_kcontrol_new *knew;
2888 	char name[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];
2889 	unsigned int defcfg;
2890 
2891 	if (pin == spec->hp_mic_pin)
2892 		return 0; /* already done in create_out_jack_mode() */
2893 
2894 	/* no jack mode for fixed pins */
2895 	defcfg = snd_hda_codec_get_pincfg(codec, pin);
2896 	if (snd_hda_get_input_pin_attr(defcfg) == INPUT_PIN_ATTR_INT)
2897 		return 0;
2898 
2899 	/* no multiple vref caps? */
2900 	if (get_in_jack_num_items(codec, pin) <= 1)
2901 		return 0;
2902 
2903 	get_jack_mode_name(codec, pin, name, sizeof(name));
2904 	knew = snd_hda_gen_add_kctl(spec, name, &in_jack_mode_enum);
2905 	if (!knew)
2906 		return -ENOMEM;
2907 	knew->private_value = pin;
2908 	return 0;
2909 }
2910 
2911 /*
2912  * HP/mic shared jack mode
2913  */
hp_mic_jack_mode_info(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_info * uinfo)2914 static int hp_mic_jack_mode_info(struct snd_kcontrol *kcontrol,
2915 				 struct snd_ctl_elem_info *uinfo)
2916 {
2917 	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2918 	hda_nid_t nid = kcontrol->private_value;
2919 	int out_jacks = get_out_jack_num_items(codec, nid);
2920 	int in_jacks = get_in_jack_num_items(codec, nid);
2921 	const char *text = NULL;
2922 	int idx;
2923 
2924 	uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
2925 	uinfo->count = 1;
2926 	uinfo->value.enumerated.items = out_jacks + in_jacks;
2927 	if (uinfo->value.enumerated.item >= uinfo->value.enumerated.items)
2928 		uinfo->value.enumerated.item = uinfo->value.enumerated.items - 1;
2929 	idx = uinfo->value.enumerated.item;
2930 	if (idx < out_jacks) {
2931 		if (out_jacks > 1)
2932 			text = out_jack_texts[idx];
2933 		else
2934 			text = "Headphone Out";
2935 	} else {
2936 		idx -= out_jacks;
2937 		if (in_jacks > 1) {
2938 			unsigned int vref_caps = get_vref_caps(codec, nid);
2939 			text = vref_texts[get_vref_idx(vref_caps, idx)];
2940 		} else
2941 			text = "Mic In";
2942 	}
2943 
2944 	strcpy(uinfo->value.enumerated.name, text);
2945 	return 0;
2946 }
2947 
get_cur_hp_mic_jack_mode(struct hda_codec * codec,hda_nid_t nid)2948 static int get_cur_hp_mic_jack_mode(struct hda_codec *codec, hda_nid_t nid)
2949 {
2950 	int out_jacks = get_out_jack_num_items(codec, nid);
2951 	int in_jacks = get_in_jack_num_items(codec, nid);
2952 	unsigned int val = snd_hda_codec_get_pin_target(codec, nid);
2953 	int idx = 0;
2954 
2955 	if (val & PIN_OUT) {
2956 		if (out_jacks > 1 && val == PIN_HP)
2957 			idx = 1;
2958 	} else if (val & PIN_IN) {
2959 		idx = out_jacks;
2960 		if (in_jacks > 1) {
2961 			unsigned int vref_caps = get_vref_caps(codec, nid);
2962 			val &= AC_PINCTL_VREFEN;
2963 			idx += cvt_from_vref_idx(vref_caps, val);
2964 		}
2965 	}
2966 	return idx;
2967 }
2968 
hp_mic_jack_mode_get(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)2969 static int hp_mic_jack_mode_get(struct snd_kcontrol *kcontrol,
2970 				struct snd_ctl_elem_value *ucontrol)
2971 {
2972 	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2973 	hda_nid_t nid = kcontrol->private_value;
2974 	ucontrol->value.enumerated.item[0] =
2975 		get_cur_hp_mic_jack_mode(codec, nid);
2976 	return 0;
2977 }
2978 
hp_mic_jack_mode_put(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)2979 static int hp_mic_jack_mode_put(struct snd_kcontrol *kcontrol,
2980 				struct snd_ctl_elem_value *ucontrol)
2981 {
2982 	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2983 	hda_nid_t nid = kcontrol->private_value;
2984 	int out_jacks = get_out_jack_num_items(codec, nid);
2985 	int in_jacks = get_in_jack_num_items(codec, nid);
2986 	unsigned int val, oldval, idx;
2987 
2988 	oldval = get_cur_hp_mic_jack_mode(codec, nid);
2989 	idx = ucontrol->value.enumerated.item[0];
2990 	if (oldval == idx)
2991 		return 0;
2992 
2993 	if (idx < out_jacks) {
2994 		if (out_jacks > 1)
2995 			val = idx ? PIN_HP : PIN_OUT;
2996 		else
2997 			val = PIN_HP;
2998 	} else {
2999 		idx -= out_jacks;
3000 		if (in_jacks > 1) {
3001 			unsigned int vref_caps = get_vref_caps(codec, nid);
3002 			val = snd_hda_codec_get_pin_target(codec, nid);
3003 			val &= ~(AC_PINCTL_VREFEN | PIN_HP);
3004 			val |= get_vref_idx(vref_caps, idx) | PIN_IN;
3005 		} else
3006 			val = snd_hda_get_default_vref(codec, nid) | PIN_IN;
3007 	}
3008 	snd_hda_set_pin_ctl_cache(codec, nid, val);
3009 	call_hp_automute(codec, NULL);
3010 
3011 	return 1;
3012 }
3013 
3014 static const struct snd_kcontrol_new hp_mic_jack_mode_enum = {
3015 	.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3016 	.info = hp_mic_jack_mode_info,
3017 	.get = hp_mic_jack_mode_get,
3018 	.put = hp_mic_jack_mode_put,
3019 };
3020 
create_hp_mic_jack_mode(struct hda_codec * codec,hda_nid_t pin)3021 static int create_hp_mic_jack_mode(struct hda_codec *codec, hda_nid_t pin)
3022 {
3023 	struct hda_gen_spec *spec = codec->spec;
3024 	struct snd_kcontrol_new *knew;
3025 
3026 	knew = snd_hda_gen_add_kctl(spec, "Headphone Mic Jack Mode",
3027 				    &hp_mic_jack_mode_enum);
3028 	if (!knew)
3029 		return -ENOMEM;
3030 	knew->private_value = pin;
3031 	spec->hp_mic_jack_modes = 1;
3032 	return 0;
3033 }
3034 
3035 /*
3036  * Parse input paths
3037  */
3038 
3039 /* add the powersave loopback-list entry */
add_loopback_list(struct hda_gen_spec * spec,hda_nid_t mix,int idx)3040 static int add_loopback_list(struct hda_gen_spec *spec, hda_nid_t mix, int idx)
3041 {
3042 	struct hda_amp_list *list;
3043 
3044 	list = snd_array_new(&spec->loopback_list);
3045 	if (!list)
3046 		return -ENOMEM;
3047 	list->nid = mix;
3048 	list->dir = HDA_INPUT;
3049 	list->idx = idx;
3050 	spec->loopback.amplist = spec->loopback_list.list;
3051 	return 0;
3052 }
3053 
3054 /* return true if either a volume or a mute amp is found for the given
3055  * aamix path; the amp has to be either in the mixer node or its direct leaf
3056  */
look_for_mix_leaf_ctls(struct hda_codec * codec,hda_nid_t mix_nid,hda_nid_t pin,unsigned int * mix_val,unsigned int * mute_val)3057 static bool look_for_mix_leaf_ctls(struct hda_codec *codec, hda_nid_t mix_nid,
3058 				   hda_nid_t pin, unsigned int *mix_val,
3059 				   unsigned int *mute_val)
3060 {
3061 	int idx, num_conns;
3062 	const hda_nid_t *list;
3063 	hda_nid_t nid;
3064 
3065 	idx = snd_hda_get_conn_index(codec, mix_nid, pin, true);
3066 	if (idx < 0)
3067 		return false;
3068 
3069 	*mix_val = *mute_val = 0;
3070 	if (nid_has_volume(codec, mix_nid, HDA_INPUT))
3071 		*mix_val = HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT);
3072 	if (nid_has_mute(codec, mix_nid, HDA_INPUT))
3073 		*mute_val = HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT);
3074 	if (*mix_val && *mute_val)
3075 		return true;
3076 
3077 	/* check leaf node */
3078 	num_conns = snd_hda_get_conn_list(codec, mix_nid, &list);
3079 	if (num_conns < idx)
3080 		return false;
3081 	nid = list[idx];
3082 	if (!*mix_val && nid_has_volume(codec, nid, HDA_OUTPUT) &&
3083 	    !is_ctl_associated(codec, nid, HDA_OUTPUT, 0, NID_PATH_VOL_CTL))
3084 		*mix_val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
3085 	if (!*mute_val && nid_has_mute(codec, nid, HDA_OUTPUT) &&
3086 	    !is_ctl_associated(codec, nid, HDA_OUTPUT, 0, NID_PATH_MUTE_CTL))
3087 		*mute_val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
3088 
3089 	return *mix_val || *mute_val;
3090 }
3091 
3092 /* create input playback/capture controls for the given pin */
new_analog_input(struct hda_codec * codec,int input_idx,hda_nid_t pin,const char * ctlname,int ctlidx,hda_nid_t mix_nid)3093 static int new_analog_input(struct hda_codec *codec, int input_idx,
3094 			    hda_nid_t pin, const char *ctlname, int ctlidx,
3095 			    hda_nid_t mix_nid)
3096 {
3097 	struct hda_gen_spec *spec = codec->spec;
3098 	struct nid_path *path;
3099 	unsigned int mix_val, mute_val;
3100 	int err, idx;
3101 
3102 	if (!look_for_mix_leaf_ctls(codec, mix_nid, pin, &mix_val, &mute_val))
3103 		return 0;
3104 
3105 	path = snd_hda_add_new_path(codec, pin, mix_nid, 0);
3106 	if (!path)
3107 		return -EINVAL;
3108 	print_nid_path(codec, "loopback", path);
3109 	spec->loopback_paths[input_idx] = snd_hda_get_path_idx(codec, path);
3110 
3111 	idx = path->idx[path->depth - 1];
3112 	if (mix_val) {
3113 		err = __add_pb_vol_ctrl(spec, HDA_CTL_WIDGET_VOL, ctlname, ctlidx, mix_val);
3114 		if (err < 0)
3115 			return err;
3116 		path->ctls[NID_PATH_VOL_CTL] = mix_val;
3117 	}
3118 
3119 	if (mute_val) {
3120 		err = __add_pb_sw_ctrl(spec, HDA_CTL_WIDGET_MUTE, ctlname, ctlidx, mute_val);
3121 		if (err < 0)
3122 			return err;
3123 		path->ctls[NID_PATH_MUTE_CTL] = mute_val;
3124 	}
3125 
3126 	path->active = true;
3127 	path->stream_enabled = true; /* no DAC/ADC involved */
3128 	err = add_loopback_list(spec, mix_nid, idx);
3129 	if (err < 0)
3130 		return err;
3131 
3132 	if (spec->mixer_nid != spec->mixer_merge_nid &&
3133 	    !spec->loopback_merge_path) {
3134 		path = snd_hda_add_new_path(codec, spec->mixer_nid,
3135 					    spec->mixer_merge_nid, 0);
3136 		if (path) {
3137 			print_nid_path(codec, "loopback-merge", path);
3138 			path->active = true;
3139 			path->pin_fixed = true; /* static route */
3140 			path->stream_enabled = true; /* no DAC/ADC involved */
3141 			spec->loopback_merge_path =
3142 				snd_hda_get_path_idx(codec, path);
3143 		}
3144 	}
3145 
3146 	return 0;
3147 }
3148 
is_input_pin(struct hda_codec * codec,hda_nid_t nid)3149 static int is_input_pin(struct hda_codec *codec, hda_nid_t nid)
3150 {
3151 	unsigned int pincap = snd_hda_query_pin_caps(codec, nid);
3152 	return (pincap & AC_PINCAP_IN) != 0;
3153 }
3154 
3155 /* Parse the codec tree and retrieve ADCs */
fill_adc_nids(struct hda_codec * codec)3156 static int fill_adc_nids(struct hda_codec *codec)
3157 {
3158 	struct hda_gen_spec *spec = codec->spec;
3159 	hda_nid_t nid;
3160 	hda_nid_t *adc_nids = spec->adc_nids;
3161 	int max_nums = ARRAY_SIZE(spec->adc_nids);
3162 	int nums = 0;
3163 
3164 	for_each_hda_codec_node(nid, codec) {
3165 		unsigned int caps = get_wcaps(codec, nid);
3166 		int type = get_wcaps_type(caps);
3167 
3168 		if (type != AC_WID_AUD_IN || (caps & AC_WCAP_DIGITAL))
3169 			continue;
3170 		adc_nids[nums] = nid;
3171 		if (++nums >= max_nums)
3172 			break;
3173 	}
3174 	spec->num_adc_nids = nums;
3175 
3176 	/* copy the detected ADCs to all_adcs[] */
3177 	spec->num_all_adcs = nums;
3178 	memcpy(spec->all_adcs, spec->adc_nids, nums * sizeof(hda_nid_t));
3179 
3180 	return nums;
3181 }
3182 
3183 /* filter out invalid adc_nids that don't give all active input pins;
3184  * if needed, check whether dynamic ADC-switching is available
3185  */
check_dyn_adc_switch(struct hda_codec * codec)3186 static int check_dyn_adc_switch(struct hda_codec *codec)
3187 {
3188 	struct hda_gen_spec *spec = codec->spec;
3189 	struct hda_input_mux *imux = &spec->input_mux;
3190 	unsigned int ok_bits;
3191 	int i, n, nums;
3192 
3193 	nums = 0;
3194 	ok_bits = 0;
3195 	for (n = 0; n < spec->num_adc_nids; n++) {
3196 		for (i = 0; i < imux->num_items; i++) {
3197 			if (!spec->input_paths[i][n])
3198 				break;
3199 		}
3200 		if (i >= imux->num_items) {
3201 			ok_bits |= (1 << n);
3202 			nums++;
3203 		}
3204 	}
3205 
3206 	if (!ok_bits) {
3207 		/* check whether ADC-switch is possible */
3208 		for (i = 0; i < imux->num_items; i++) {
3209 			for (n = 0; n < spec->num_adc_nids; n++) {
3210 				if (spec->input_paths[i][n]) {
3211 					spec->dyn_adc_idx[i] = n;
3212 					break;
3213 				}
3214 			}
3215 		}
3216 
3217 		codec_dbg(codec, "enabling ADC switching\n");
3218 		spec->dyn_adc_switch = 1;
3219 	} else if (nums != spec->num_adc_nids) {
3220 		/* shrink the invalid adcs and input paths */
3221 		nums = 0;
3222 		for (n = 0; n < spec->num_adc_nids; n++) {
3223 			if (!(ok_bits & (1 << n)))
3224 				continue;
3225 			if (n != nums) {
3226 				spec->adc_nids[nums] = spec->adc_nids[n];
3227 				for (i = 0; i < imux->num_items; i++) {
3228 					invalidate_nid_path(codec,
3229 						spec->input_paths[i][nums]);
3230 					spec->input_paths[i][nums] =
3231 						spec->input_paths[i][n];
3232 					spec->input_paths[i][n] = 0;
3233 				}
3234 			}
3235 			nums++;
3236 		}
3237 		spec->num_adc_nids = nums;
3238 	}
3239 
3240 	if (imux->num_items == 1 ||
3241 	    (imux->num_items == 2 && spec->hp_mic)) {
3242 		codec_dbg(codec, "reducing to a single ADC\n");
3243 		spec->num_adc_nids = 1; /* reduce to a single ADC */
3244 	}
3245 
3246 	/* single index for individual volumes ctls */
3247 	if (!spec->dyn_adc_switch && spec->multi_cap_vol)
3248 		spec->num_adc_nids = 1;
3249 
3250 	return 0;
3251 }
3252 
3253 /* parse capture source paths from the given pin and create imux items */
parse_capture_source(struct hda_codec * codec,hda_nid_t pin,int cfg_idx,int num_adcs,const char * label,int anchor)3254 static int parse_capture_source(struct hda_codec *codec, hda_nid_t pin,
3255 				int cfg_idx, int num_adcs,
3256 				const char *label, int anchor)
3257 {
3258 	struct hda_gen_spec *spec = codec->spec;
3259 	struct hda_input_mux *imux = &spec->input_mux;
3260 	int imux_idx = imux->num_items;
3261 	bool imux_added = false;
3262 	int c;
3263 
3264 	for (c = 0; c < num_adcs; c++) {
3265 		struct nid_path *path;
3266 		hda_nid_t adc = spec->adc_nids[c];
3267 
3268 		if (!is_reachable_path(codec, pin, adc))
3269 			continue;
3270 		path = snd_hda_add_new_path(codec, pin, adc, anchor);
3271 		if (!path)
3272 			continue;
3273 		print_nid_path(codec, "input", path);
3274 		spec->input_paths[imux_idx][c] =
3275 			snd_hda_get_path_idx(codec, path);
3276 
3277 		if (!imux_added) {
3278 			if (spec->hp_mic_pin == pin)
3279 				spec->hp_mic_mux_idx = imux->num_items;
3280 			spec->imux_pins[imux->num_items] = pin;
3281 			snd_hda_add_imux_item(codec, imux, label, cfg_idx, NULL);
3282 			imux_added = true;
3283 			if (spec->dyn_adc_switch)
3284 				spec->dyn_adc_idx[imux_idx] = c;
3285 		}
3286 	}
3287 
3288 	return 0;
3289 }
3290 
3291 /*
3292  * create playback/capture controls for input pins
3293  */
3294 
3295 /* fill the label for each input at first */
fill_input_pin_labels(struct hda_codec * codec)3296 static int fill_input_pin_labels(struct hda_codec *codec)
3297 {
3298 	struct hda_gen_spec *spec = codec->spec;
3299 	const struct auto_pin_cfg *cfg = &spec->autocfg;
3300 	int i;
3301 
3302 	for (i = 0; i < cfg->num_inputs; i++) {
3303 		hda_nid_t pin = cfg->inputs[i].pin;
3304 		const char *label;
3305 		int j, idx;
3306 
3307 		if (!is_input_pin(codec, pin))
3308 			continue;
3309 
3310 		label = hda_get_autocfg_input_label(codec, cfg, i);
3311 		idx = 0;
3312 		for (j = i - 1; j >= 0; j--) {
3313 			if (spec->input_labels[j] &&
3314 			    !strcmp(spec->input_labels[j], label)) {
3315 				idx = spec->input_label_idxs[j] + 1;
3316 				break;
3317 			}
3318 		}
3319 
3320 		spec->input_labels[i] = label;
3321 		spec->input_label_idxs[i] = idx;
3322 	}
3323 
3324 	return 0;
3325 }
3326 
3327 #define CFG_IDX_MIX	99	/* a dummy cfg->input idx for stereo mix */
3328 
create_input_ctls(struct hda_codec * codec)3329 static int create_input_ctls(struct hda_codec *codec)
3330 {
3331 	struct hda_gen_spec *spec = codec->spec;
3332 	const struct auto_pin_cfg *cfg = &spec->autocfg;
3333 	hda_nid_t mixer = spec->mixer_nid;
3334 	int num_adcs;
3335 	int i, err;
3336 	unsigned int val;
3337 
3338 	num_adcs = fill_adc_nids(codec);
3339 	if (num_adcs < 0)
3340 		return 0;
3341 
3342 	err = fill_input_pin_labels(codec);
3343 	if (err < 0)
3344 		return err;
3345 
3346 	for (i = 0; i < cfg->num_inputs; i++) {
3347 		hda_nid_t pin;
3348 
3349 		pin = cfg->inputs[i].pin;
3350 		if (!is_input_pin(codec, pin))
3351 			continue;
3352 
3353 		val = PIN_IN;
3354 		if (cfg->inputs[i].type == AUTO_PIN_MIC)
3355 			val |= snd_hda_get_default_vref(codec, pin);
3356 		if (pin != spec->hp_mic_pin &&
3357 		    !snd_hda_codec_get_pin_target(codec, pin))
3358 			set_pin_target(codec, pin, val, false);
3359 
3360 		if (mixer) {
3361 			if (is_reachable_path(codec, pin, mixer)) {
3362 				err = new_analog_input(codec, i, pin,
3363 						       spec->input_labels[i],
3364 						       spec->input_label_idxs[i],
3365 						       mixer);
3366 				if (err < 0)
3367 					return err;
3368 			}
3369 		}
3370 
3371 		err = parse_capture_source(codec, pin, i, num_adcs,
3372 					   spec->input_labels[i], -mixer);
3373 		if (err < 0)
3374 			return err;
3375 
3376 		if (spec->add_jack_modes) {
3377 			err = create_in_jack_mode(codec, pin);
3378 			if (err < 0)
3379 				return err;
3380 		}
3381 	}
3382 
3383 	/* add stereo mix when explicitly enabled via hint */
3384 	if (mixer && spec->add_stereo_mix_input == HDA_HINT_STEREO_MIX_ENABLE) {
3385 		err = parse_capture_source(codec, mixer, CFG_IDX_MIX, num_adcs,
3386 					   "Stereo Mix", 0);
3387 		if (err < 0)
3388 			return err;
3389 		else
3390 			spec->suppress_auto_mic = 1;
3391 	}
3392 
3393 	return 0;
3394 }
3395 
3396 
3397 /*
3398  * input source mux
3399  */
3400 
3401 /* get the input path specified by the given adc and imux indices */
get_input_path(struct hda_codec * codec,int adc_idx,int imux_idx)3402 static struct nid_path *get_input_path(struct hda_codec *codec, int adc_idx, int imux_idx)
3403 {
3404 	struct hda_gen_spec *spec = codec->spec;
3405 	if (imux_idx < 0 || imux_idx >= HDA_MAX_NUM_INPUTS) {
3406 		snd_BUG();
3407 		return NULL;
3408 	}
3409 	if (spec->dyn_adc_switch)
3410 		adc_idx = spec->dyn_adc_idx[imux_idx];
3411 	if (adc_idx < 0 || adc_idx >= AUTO_CFG_MAX_INS) {
3412 		snd_BUG();
3413 		return NULL;
3414 	}
3415 	return snd_hda_get_path_from_idx(codec, spec->input_paths[imux_idx][adc_idx]);
3416 }
3417 
3418 static int mux_select(struct hda_codec *codec, unsigned int adc_idx,
3419 		      unsigned int idx);
3420 
mux_enum_info(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_info * uinfo)3421 static int mux_enum_info(struct snd_kcontrol *kcontrol,
3422 			 struct snd_ctl_elem_info *uinfo)
3423 {
3424 	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3425 	struct hda_gen_spec *spec = codec->spec;
3426 	return snd_hda_input_mux_info(&spec->input_mux, uinfo);
3427 }
3428 
mux_enum_get(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)3429 static int mux_enum_get(struct snd_kcontrol *kcontrol,
3430 			struct snd_ctl_elem_value *ucontrol)
3431 {
3432 	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3433 	struct hda_gen_spec *spec = codec->spec;
3434 	/* the ctls are created at once with multiple counts */
3435 	unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
3436 
3437 	ucontrol->value.enumerated.item[0] = spec->cur_mux[adc_idx];
3438 	return 0;
3439 }
3440 
mux_enum_put(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)3441 static int mux_enum_put(struct snd_kcontrol *kcontrol,
3442 			    struct snd_ctl_elem_value *ucontrol)
3443 {
3444 	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3445 	unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
3446 	return mux_select(codec, adc_idx,
3447 			  ucontrol->value.enumerated.item[0]);
3448 }
3449 
3450 static const struct snd_kcontrol_new cap_src_temp = {
3451 	.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3452 	.name = "Input Source",
3453 	.info = mux_enum_info,
3454 	.get = mux_enum_get,
3455 	.put = mux_enum_put,
3456 };
3457 
3458 /*
3459  * capture volume and capture switch ctls
3460  */
3461 
3462 typedef int (*put_call_t)(struct snd_kcontrol *kcontrol,
3463 			  struct snd_ctl_elem_value *ucontrol);
3464 
3465 /* call the given amp update function for all amps in the imux list at once */
cap_put_caller(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol,put_call_t func,int type)3466 static int cap_put_caller(struct snd_kcontrol *kcontrol,
3467 			  struct snd_ctl_elem_value *ucontrol,
3468 			  put_call_t func, int type)
3469 {
3470 	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3471 	struct hda_gen_spec *spec = codec->spec;
3472 	const struct hda_input_mux *imux;
3473 	struct nid_path *path;
3474 	int i, adc_idx, ret, err = 0;
3475 
3476 	imux = &spec->input_mux;
3477 	adc_idx = kcontrol->id.index;
3478 	mutex_lock(&codec->control_mutex);
3479 	for (i = 0; i < imux->num_items; i++) {
3480 		path = get_input_path(codec, adc_idx, i);
3481 		if (!path || !path->ctls[type])
3482 			continue;
3483 		kcontrol->private_value = path->ctls[type];
3484 		ret = func(kcontrol, ucontrol);
3485 		if (ret < 0) {
3486 			err = ret;
3487 			break;
3488 		}
3489 		if (ret > 0)
3490 			err = 1;
3491 	}
3492 	mutex_unlock(&codec->control_mutex);
3493 	if (err >= 0 && spec->cap_sync_hook)
3494 		spec->cap_sync_hook(codec, kcontrol, ucontrol);
3495 	return err;
3496 }
3497 
3498 /* capture volume ctl callbacks */
3499 #define cap_vol_info		snd_hda_mixer_amp_volume_info
3500 #define cap_vol_get		snd_hda_mixer_amp_volume_get
3501 #define cap_vol_tlv		snd_hda_mixer_amp_tlv
3502 
cap_vol_put(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)3503 static int cap_vol_put(struct snd_kcontrol *kcontrol,
3504 		       struct snd_ctl_elem_value *ucontrol)
3505 {
3506 	return cap_put_caller(kcontrol, ucontrol,
3507 			      snd_hda_mixer_amp_volume_put,
3508 			      NID_PATH_VOL_CTL);
3509 }
3510 
3511 static const struct snd_kcontrol_new cap_vol_temp = {
3512 	.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3513 	.name = "Capture Volume",
3514 	.access = (SNDRV_CTL_ELEM_ACCESS_READWRITE |
3515 		   SNDRV_CTL_ELEM_ACCESS_TLV_READ |
3516 		   SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK),
3517 	.info = cap_vol_info,
3518 	.get = cap_vol_get,
3519 	.put = cap_vol_put,
3520 	.tlv = { .c = cap_vol_tlv },
3521 };
3522 
3523 /* capture switch ctl callbacks */
3524 #define cap_sw_info		snd_ctl_boolean_stereo_info
3525 #define cap_sw_get		snd_hda_mixer_amp_switch_get
3526 
cap_sw_put(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)3527 static int cap_sw_put(struct snd_kcontrol *kcontrol,
3528 		      struct snd_ctl_elem_value *ucontrol)
3529 {
3530 	return cap_put_caller(kcontrol, ucontrol,
3531 			      snd_hda_mixer_amp_switch_put,
3532 			      NID_PATH_MUTE_CTL);
3533 }
3534 
3535 static const struct snd_kcontrol_new cap_sw_temp = {
3536 	.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3537 	.name = "Capture Switch",
3538 	.access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
3539 	.info = cap_sw_info,
3540 	.get = cap_sw_get,
3541 	.put = cap_sw_put,
3542 };
3543 
parse_capvol_in_path(struct hda_codec * codec,struct nid_path * path)3544 static int parse_capvol_in_path(struct hda_codec *codec, struct nid_path *path)
3545 {
3546 	hda_nid_t nid;
3547 	int i, depth;
3548 
3549 	path->ctls[NID_PATH_VOL_CTL] = path->ctls[NID_PATH_MUTE_CTL] = 0;
3550 	for (depth = 0; depth < 3; depth++) {
3551 		if (depth >= path->depth)
3552 			return -EINVAL;
3553 		i = path->depth - depth - 1;
3554 		nid = path->path[i];
3555 		if (!path->ctls[NID_PATH_VOL_CTL]) {
3556 			if (nid_has_volume(codec, nid, HDA_OUTPUT))
3557 				path->ctls[NID_PATH_VOL_CTL] =
3558 					HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
3559 			else if (nid_has_volume(codec, nid, HDA_INPUT)) {
3560 				int idx = path->idx[i];
3561 				if (!depth && codec->single_adc_amp)
3562 					idx = 0;
3563 				path->ctls[NID_PATH_VOL_CTL] =
3564 					HDA_COMPOSE_AMP_VAL(nid, 3, idx, HDA_INPUT);
3565 			}
3566 		}
3567 		if (!path->ctls[NID_PATH_MUTE_CTL]) {
3568 			if (nid_has_mute(codec, nid, HDA_OUTPUT))
3569 				path->ctls[NID_PATH_MUTE_CTL] =
3570 					HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
3571 			else if (nid_has_mute(codec, nid, HDA_INPUT)) {
3572 				int idx = path->idx[i];
3573 				if (!depth && codec->single_adc_amp)
3574 					idx = 0;
3575 				path->ctls[NID_PATH_MUTE_CTL] =
3576 					HDA_COMPOSE_AMP_VAL(nid, 3, idx, HDA_INPUT);
3577 			}
3578 		}
3579 	}
3580 	return 0;
3581 }
3582 
is_inv_dmic_pin(struct hda_codec * codec,hda_nid_t nid)3583 static bool is_inv_dmic_pin(struct hda_codec *codec, hda_nid_t nid)
3584 {
3585 	struct hda_gen_spec *spec = codec->spec;
3586 	struct auto_pin_cfg *cfg = &spec->autocfg;
3587 	unsigned int val;
3588 	int i;
3589 
3590 	if (!spec->inv_dmic_split)
3591 		return false;
3592 	for (i = 0; i < cfg->num_inputs; i++) {
3593 		if (cfg->inputs[i].pin != nid)
3594 			continue;
3595 		if (cfg->inputs[i].type != AUTO_PIN_MIC)
3596 			return false;
3597 		val = snd_hda_codec_get_pincfg(codec, nid);
3598 		return snd_hda_get_input_pin_attr(val) == INPUT_PIN_ATTR_INT;
3599 	}
3600 	return false;
3601 }
3602 
3603 /* capture switch put callback for a single control with hook call */
cap_single_sw_put(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)3604 static int cap_single_sw_put(struct snd_kcontrol *kcontrol,
3605 			     struct snd_ctl_elem_value *ucontrol)
3606 {
3607 	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3608 	struct hda_gen_spec *spec = codec->spec;
3609 	int ret;
3610 
3611 	ret = snd_hda_mixer_amp_switch_put(kcontrol, ucontrol);
3612 	if (ret < 0)
3613 		return ret;
3614 
3615 	if (spec->cap_sync_hook)
3616 		spec->cap_sync_hook(codec, kcontrol, ucontrol);
3617 
3618 	return ret;
3619 }
3620 
add_single_cap_ctl(struct hda_codec * codec,const char * label,int idx,bool is_switch,unsigned int ctl,bool inv_dmic)3621 static int add_single_cap_ctl(struct hda_codec *codec, const char *label,
3622 			      int idx, bool is_switch, unsigned int ctl,
3623 			      bool inv_dmic)
3624 {
3625 	struct hda_gen_spec *spec = codec->spec;
3626 	char tmpname[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];
3627 	int type = is_switch ? HDA_CTL_WIDGET_MUTE : HDA_CTL_WIDGET_VOL;
3628 	const char *sfx = is_switch ? "Switch" : "Volume";
3629 	unsigned int chs = inv_dmic ? 1 : 3;
3630 	struct snd_kcontrol_new *knew;
3631 
3632 	if (!ctl)
3633 		return 0;
3634 
3635 	if (label)
3636 		snprintf(tmpname, sizeof(tmpname),
3637 			 "%s Capture %s", label, sfx);
3638 	else
3639 		snprintf(tmpname, sizeof(tmpname),
3640 			 "Capture %s", sfx);
3641 	knew = add_control(spec, type, tmpname, idx,
3642 			   amp_val_replace_channels(ctl, chs));
3643 	if (!knew)
3644 		return -ENOMEM;
3645 	if (is_switch) {
3646 		knew->put = cap_single_sw_put;
3647 		if (spec->mic_mute_led)
3648 			knew->access |= SNDRV_CTL_ELEM_ACCESS_MIC_LED;
3649 	}
3650 	if (!inv_dmic)
3651 		return 0;
3652 
3653 	/* Make independent right kcontrol */
3654 	if (label)
3655 		snprintf(tmpname, sizeof(tmpname),
3656 			 "Inverted %s Capture %s", label, sfx);
3657 	else
3658 		snprintf(tmpname, sizeof(tmpname),
3659 			 "Inverted Capture %s", sfx);
3660 	knew = add_control(spec, type, tmpname, idx,
3661 			   amp_val_replace_channels(ctl, 2));
3662 	if (!knew)
3663 		return -ENOMEM;
3664 	if (is_switch) {
3665 		knew->put = cap_single_sw_put;
3666 		if (spec->mic_mute_led)
3667 			knew->access |= SNDRV_CTL_ELEM_ACCESS_MIC_LED;
3668 	}
3669 	return 0;
3670 }
3671 
3672 /* create single (and simple) capture volume and switch controls */
create_single_cap_vol_ctl(struct hda_codec * codec,int idx,unsigned int vol_ctl,unsigned int sw_ctl,bool inv_dmic)3673 static int create_single_cap_vol_ctl(struct hda_codec *codec, int idx,
3674 				     unsigned int vol_ctl, unsigned int sw_ctl,
3675 				     bool inv_dmic)
3676 {
3677 	int err;
3678 	err = add_single_cap_ctl(codec, NULL, idx, false, vol_ctl, inv_dmic);
3679 	if (err < 0)
3680 		return err;
3681 	err = add_single_cap_ctl(codec, NULL, idx, true, sw_ctl, inv_dmic);
3682 	if (err < 0)
3683 		return err;
3684 	return 0;
3685 }
3686 
3687 /* create bound capture volume and switch controls */
create_bind_cap_vol_ctl(struct hda_codec * codec,int idx,unsigned int vol_ctl,unsigned int sw_ctl)3688 static int create_bind_cap_vol_ctl(struct hda_codec *codec, int idx,
3689 				   unsigned int vol_ctl, unsigned int sw_ctl)
3690 {
3691 	struct hda_gen_spec *spec = codec->spec;
3692 	struct snd_kcontrol_new *knew;
3693 
3694 	if (vol_ctl) {
3695 		knew = snd_hda_gen_add_kctl(spec, NULL, &cap_vol_temp);
3696 		if (!knew)
3697 			return -ENOMEM;
3698 		knew->index = idx;
3699 		knew->private_value = vol_ctl;
3700 		knew->subdevice = HDA_SUBDEV_AMP_FLAG;
3701 	}
3702 	if (sw_ctl) {
3703 		knew = snd_hda_gen_add_kctl(spec, NULL, &cap_sw_temp);
3704 		if (!knew)
3705 			return -ENOMEM;
3706 		knew->index = idx;
3707 		knew->private_value = sw_ctl;
3708 		knew->subdevice = HDA_SUBDEV_AMP_FLAG;
3709 		if (spec->mic_mute_led)
3710 			knew->access |= SNDRV_CTL_ELEM_ACCESS_MIC_LED;
3711 	}
3712 	return 0;
3713 }
3714 
3715 /* return the vol ctl when used first in the imux list */
get_first_cap_ctl(struct hda_codec * codec,int idx,int type)3716 static unsigned int get_first_cap_ctl(struct hda_codec *codec, int idx, int type)
3717 {
3718 	struct nid_path *path;
3719 	unsigned int ctl;
3720 	int i;
3721 
3722 	path = get_input_path(codec, 0, idx);
3723 	if (!path)
3724 		return 0;
3725 	ctl = path->ctls[type];
3726 	if (!ctl)
3727 		return 0;
3728 	for (i = 0; i < idx - 1; i++) {
3729 		path = get_input_path(codec, 0, i);
3730 		if (path && path->ctls[type] == ctl)
3731 			return 0;
3732 	}
3733 	return ctl;
3734 }
3735 
3736 /* create individual capture volume and switch controls per input */
create_multi_cap_vol_ctl(struct hda_codec * codec)3737 static int create_multi_cap_vol_ctl(struct hda_codec *codec)
3738 {
3739 	struct hda_gen_spec *spec = codec->spec;
3740 	struct hda_input_mux *imux = &spec->input_mux;
3741 	int i, err, type;
3742 
3743 	for (i = 0; i < imux->num_items; i++) {
3744 		bool inv_dmic;
3745 		int idx;
3746 
3747 		idx = imux->items[i].index;
3748 		if (idx >= spec->autocfg.num_inputs)
3749 			continue;
3750 		inv_dmic = is_inv_dmic_pin(codec, spec->imux_pins[i]);
3751 
3752 		for (type = 0; type < 2; type++) {
3753 			err = add_single_cap_ctl(codec,
3754 						 spec->input_labels[idx],
3755 						 spec->input_label_idxs[idx],
3756 						 type,
3757 						 get_first_cap_ctl(codec, i, type),
3758 						 inv_dmic);
3759 			if (err < 0)
3760 				return err;
3761 		}
3762 	}
3763 	return 0;
3764 }
3765 
create_capture_mixers(struct hda_codec * codec)3766 static int create_capture_mixers(struct hda_codec *codec)
3767 {
3768 	struct hda_gen_spec *spec = codec->spec;
3769 	struct hda_input_mux *imux = &spec->input_mux;
3770 	int i, n, nums, err;
3771 
3772 	if (spec->dyn_adc_switch)
3773 		nums = 1;
3774 	else
3775 		nums = spec->num_adc_nids;
3776 
3777 	if (!spec->auto_mic && imux->num_items > 1) {
3778 		struct snd_kcontrol_new *knew;
3779 		const char *name;
3780 		name = nums > 1 ? "Input Source" : "Capture Source";
3781 		knew = snd_hda_gen_add_kctl(spec, name, &cap_src_temp);
3782 		if (!knew)
3783 			return -ENOMEM;
3784 		knew->count = nums;
3785 	}
3786 
3787 	for (n = 0; n < nums; n++) {
3788 		bool multi = false;
3789 		bool multi_cap_vol = spec->multi_cap_vol;
3790 		bool inv_dmic = false;
3791 		int vol, sw;
3792 
3793 		vol = sw = 0;
3794 		for (i = 0; i < imux->num_items; i++) {
3795 			struct nid_path *path;
3796 			path = get_input_path(codec, n, i);
3797 			if (!path)
3798 				continue;
3799 			parse_capvol_in_path(codec, path);
3800 			if (!vol)
3801 				vol = path->ctls[NID_PATH_VOL_CTL];
3802 			else if (vol != path->ctls[NID_PATH_VOL_CTL]) {
3803 				multi = true;
3804 				if (!same_amp_caps(codec, vol,
3805 				    path->ctls[NID_PATH_VOL_CTL], HDA_INPUT))
3806 					multi_cap_vol = true;
3807 			}
3808 			if (!sw)
3809 				sw = path->ctls[NID_PATH_MUTE_CTL];
3810 			else if (sw != path->ctls[NID_PATH_MUTE_CTL]) {
3811 				multi = true;
3812 				if (!same_amp_caps(codec, sw,
3813 				    path->ctls[NID_PATH_MUTE_CTL], HDA_INPUT))
3814 					multi_cap_vol = true;
3815 			}
3816 			if (is_inv_dmic_pin(codec, spec->imux_pins[i]))
3817 				inv_dmic = true;
3818 		}
3819 
3820 		if (!multi)
3821 			err = create_single_cap_vol_ctl(codec, n, vol, sw,
3822 							inv_dmic);
3823 		else if (!multi_cap_vol && !inv_dmic)
3824 			err = create_bind_cap_vol_ctl(codec, n, vol, sw);
3825 		else
3826 			err = create_multi_cap_vol_ctl(codec);
3827 		if (err < 0)
3828 			return err;
3829 	}
3830 
3831 	return 0;
3832 }
3833 
3834 /*
3835  * add mic boosts if needed
3836  */
3837 
3838 /* check whether the given amp is feasible as a boost volume */
check_boost_vol(struct hda_codec * codec,hda_nid_t nid,int dir,int idx)3839 static bool check_boost_vol(struct hda_codec *codec, hda_nid_t nid,
3840 			    int dir, int idx)
3841 {
3842 	unsigned int step;
3843 
3844 	if (!nid_has_volume(codec, nid, dir) ||
3845 	    is_ctl_associated(codec, nid, dir, idx, NID_PATH_VOL_CTL) ||
3846 	    is_ctl_associated(codec, nid, dir, idx, NID_PATH_BOOST_CTL))
3847 		return false;
3848 
3849 	step = (query_amp_caps(codec, nid, dir) & AC_AMPCAP_STEP_SIZE)
3850 		>> AC_AMPCAP_STEP_SIZE_SHIFT;
3851 	if (step < 0x20)
3852 		return false;
3853 	return true;
3854 }
3855 
3856 /* look for a boost amp in a widget close to the pin */
look_for_boost_amp(struct hda_codec * codec,struct nid_path * path)3857 static unsigned int look_for_boost_amp(struct hda_codec *codec,
3858 				       struct nid_path *path)
3859 {
3860 	unsigned int val = 0;
3861 	hda_nid_t nid;
3862 	int depth;
3863 
3864 	for (depth = 0; depth < 3; depth++) {
3865 		if (depth >= path->depth - 1)
3866 			break;
3867 		nid = path->path[depth];
3868 		if (depth && check_boost_vol(codec, nid, HDA_OUTPUT, 0)) {
3869 			val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
3870 			break;
3871 		} else if (check_boost_vol(codec, nid, HDA_INPUT,
3872 					   path->idx[depth])) {
3873 			val = HDA_COMPOSE_AMP_VAL(nid, 3, path->idx[depth],
3874 						  HDA_INPUT);
3875 			break;
3876 		}
3877 	}
3878 
3879 	return val;
3880 }
3881 
parse_mic_boost(struct hda_codec * codec)3882 static int parse_mic_boost(struct hda_codec *codec)
3883 {
3884 	struct hda_gen_spec *spec = codec->spec;
3885 	struct auto_pin_cfg *cfg = &spec->autocfg;
3886 	struct hda_input_mux *imux = &spec->input_mux;
3887 	int i;
3888 
3889 	if (!spec->num_adc_nids)
3890 		return 0;
3891 
3892 	for (i = 0; i < imux->num_items; i++) {
3893 		struct nid_path *path;
3894 		unsigned int val;
3895 		int idx;
3896 		char boost_label[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];
3897 
3898 		idx = imux->items[i].index;
3899 		if (idx >= imux->num_items)
3900 			continue;
3901 
3902 		/* check only line-in and mic pins */
3903 		if (cfg->inputs[idx].type > AUTO_PIN_LINE_IN)
3904 			continue;
3905 
3906 		path = get_input_path(codec, 0, i);
3907 		if (!path)
3908 			continue;
3909 
3910 		val = look_for_boost_amp(codec, path);
3911 		if (!val)
3912 			continue;
3913 
3914 		/* create a boost control */
3915 		snprintf(boost_label, sizeof(boost_label),
3916 			 "%s Boost Volume", spec->input_labels[idx]);
3917 		if (!add_control(spec, HDA_CTL_WIDGET_VOL, boost_label,
3918 				 spec->input_label_idxs[idx], val))
3919 			return -ENOMEM;
3920 
3921 		path->ctls[NID_PATH_BOOST_CTL] = val;
3922 	}
3923 	return 0;
3924 }
3925 
3926 #ifdef CONFIG_SND_HDA_GENERIC_LEDS
3927 /*
3928  * vmaster mute LED hook helpers
3929  */
3930 
create_mute_led_cdev(struct hda_codec * codec,int (* callback)(struct led_classdev *,enum led_brightness),bool micmute)3931 static int create_mute_led_cdev(struct hda_codec *codec,
3932 				int (*callback)(struct led_classdev *,
3933 						enum led_brightness),
3934 				bool micmute)
3935 {
3936 	struct hda_gen_spec *spec = codec->spec;
3937 	struct led_classdev *cdev;
3938 	int idx = micmute ? LED_AUDIO_MICMUTE : LED_AUDIO_MUTE;
3939 	int err;
3940 
3941 	cdev = devm_kzalloc(&codec->core.dev, sizeof(*cdev), GFP_KERNEL);
3942 	if (!cdev)
3943 		return -ENOMEM;
3944 
3945 	cdev->name = micmute ? "hda::micmute" : "hda::mute";
3946 	cdev->max_brightness = 1;
3947 	cdev->default_trigger = micmute ? "audio-micmute" : "audio-mute";
3948 	cdev->brightness_set_blocking = callback;
3949 	cdev->flags = LED_CORE_SUSPENDRESUME;
3950 
3951 	err = led_classdev_register(&codec->core.dev, cdev);
3952 	if (err < 0)
3953 		return err;
3954 	spec->led_cdevs[idx] = cdev;
3955 	return 0;
3956 }
3957 
3958 /**
3959  * snd_hda_gen_add_mute_led_cdev - Create a LED classdev and enable as vmaster mute LED
3960  * @codec: the HDA codec
3961  * @callback: the callback for LED classdev brightness_set_blocking
3962  */
snd_hda_gen_add_mute_led_cdev(struct hda_codec * codec,int (* callback)(struct led_classdev *,enum led_brightness))3963 int snd_hda_gen_add_mute_led_cdev(struct hda_codec *codec,
3964 				  int (*callback)(struct led_classdev *,
3965 						  enum led_brightness))
3966 {
3967 	struct hda_gen_spec *spec = codec->spec;
3968 	int err;
3969 
3970 	if (callback) {
3971 		err = create_mute_led_cdev(codec, callback, false);
3972 		if (err) {
3973 			codec_warn(codec, "failed to create a mute LED cdev\n");
3974 			return err;
3975 		}
3976 	}
3977 
3978 	if (spec->vmaster_mute.hook)
3979 		codec_err(codec, "vmaster hook already present before cdev!\n");
3980 
3981 	spec->vmaster_mute_led = 1;
3982 	return 0;
3983 }
3984 EXPORT_SYMBOL_GPL(snd_hda_gen_add_mute_led_cdev);
3985 
3986 /**
3987  * snd_hda_gen_add_micmute_led_cdev - Create a LED classdev and enable as mic-mute LED
3988  * @codec: the HDA codec
3989  * @callback: the callback for LED classdev brightness_set_blocking
3990  *
3991  * Called from the codec drivers for offering the mic mute LED controls.
3992  * This creates a LED classdev and sets up the cap_sync_hook that is called at
3993  * each time when the capture mixer switch changes.
3994  *
3995  * When NULL is passed to @callback, no classdev is created but only the
3996  * LED-trigger is set up.
3997  *
3998  * Returns 0 or a negative error.
3999  */
snd_hda_gen_add_micmute_led_cdev(struct hda_codec * codec,int (* callback)(struct led_classdev *,enum led_brightness))4000 int snd_hda_gen_add_micmute_led_cdev(struct hda_codec *codec,
4001 				     int (*callback)(struct led_classdev *,
4002 						     enum led_brightness))
4003 {
4004 	struct hda_gen_spec *spec = codec->spec;
4005 	int err;
4006 
4007 	if (callback) {
4008 		err = create_mute_led_cdev(codec, callback, true);
4009 		if (err) {
4010 			codec_warn(codec, "failed to create a mic-mute LED cdev\n");
4011 			return err;
4012 		}
4013 	}
4014 
4015 	spec->mic_mute_led = 1;
4016 	return 0;
4017 }
4018 EXPORT_SYMBOL_GPL(snd_hda_gen_add_micmute_led_cdev);
4019 #endif /* CONFIG_SND_HDA_GENERIC_LEDS */
4020 
4021 /*
4022  * parse digital I/Os and set up NIDs in BIOS auto-parse mode
4023  */
parse_digital(struct hda_codec * codec)4024 static void parse_digital(struct hda_codec *codec)
4025 {
4026 	struct hda_gen_spec *spec = codec->spec;
4027 	struct nid_path *path;
4028 	int i, nums;
4029 	hda_nid_t dig_nid, pin;
4030 
4031 	/* support multiple SPDIFs; the secondary is set up as a follower */
4032 	nums = 0;
4033 	for (i = 0; i < spec->autocfg.dig_outs; i++) {
4034 		pin = spec->autocfg.dig_out_pins[i];
4035 		dig_nid = look_for_dac(codec, pin, true);
4036 		if (!dig_nid)
4037 			continue;
4038 		path = snd_hda_add_new_path(codec, dig_nid, pin, 0);
4039 		if (!path)
4040 			continue;
4041 		print_nid_path(codec, "digout", path);
4042 		path->active = true;
4043 		path->pin_fixed = true; /* no jack detection */
4044 		spec->digout_paths[i] = snd_hda_get_path_idx(codec, path);
4045 		set_pin_target(codec, pin, PIN_OUT, false);
4046 		if (!nums) {
4047 			spec->multiout.dig_out_nid = dig_nid;
4048 			spec->dig_out_type = spec->autocfg.dig_out_type[0];
4049 		} else {
4050 			spec->multiout.follower_dig_outs = spec->follower_dig_outs;
4051 			if (nums >= ARRAY_SIZE(spec->follower_dig_outs) - 1)
4052 				break;
4053 			spec->follower_dig_outs[nums - 1] = dig_nid;
4054 		}
4055 		nums++;
4056 	}
4057 
4058 	if (spec->autocfg.dig_in_pin) {
4059 		pin = spec->autocfg.dig_in_pin;
4060 		for_each_hda_codec_node(dig_nid, codec) {
4061 			unsigned int wcaps = get_wcaps(codec, dig_nid);
4062 			if (get_wcaps_type(wcaps) != AC_WID_AUD_IN)
4063 				continue;
4064 			if (!(wcaps & AC_WCAP_DIGITAL))
4065 				continue;
4066 			path = snd_hda_add_new_path(codec, pin, dig_nid, 0);
4067 			if (path) {
4068 				print_nid_path(codec, "digin", path);
4069 				path->active = true;
4070 				path->pin_fixed = true; /* no jack */
4071 				spec->dig_in_nid = dig_nid;
4072 				spec->digin_path = snd_hda_get_path_idx(codec, path);
4073 				set_pin_target(codec, pin, PIN_IN, false);
4074 				break;
4075 			}
4076 		}
4077 	}
4078 }
4079 
4080 
4081 /*
4082  * input MUX handling
4083  */
4084 
4085 static bool dyn_adc_pcm_resetup(struct hda_codec *codec, int cur);
4086 
4087 /* select the given imux item; either unmute exclusively or select the route */
mux_select(struct hda_codec * codec,unsigned int adc_idx,unsigned int idx)4088 static int mux_select(struct hda_codec *codec, unsigned int adc_idx,
4089 		      unsigned int idx)
4090 {
4091 	struct hda_gen_spec *spec = codec->spec;
4092 	const struct hda_input_mux *imux;
4093 	struct nid_path *old_path, *path;
4094 
4095 	imux = &spec->input_mux;
4096 	if (!imux->num_items)
4097 		return 0;
4098 
4099 	if (idx >= imux->num_items)
4100 		idx = imux->num_items - 1;
4101 	if (spec->cur_mux[adc_idx] == idx)
4102 		return 0;
4103 
4104 	old_path = get_input_path(codec, adc_idx, spec->cur_mux[adc_idx]);
4105 	if (!old_path)
4106 		return 0;
4107 	if (old_path->active)
4108 		snd_hda_activate_path(codec, old_path, false, false);
4109 
4110 	spec->cur_mux[adc_idx] = idx;
4111 
4112 	if (spec->hp_mic)
4113 		update_hp_mic(codec, adc_idx, false);
4114 
4115 	if (spec->dyn_adc_switch)
4116 		dyn_adc_pcm_resetup(codec, idx);
4117 
4118 	path = get_input_path(codec, adc_idx, idx);
4119 	if (!path)
4120 		return 0;
4121 	if (path->active)
4122 		return 0;
4123 	snd_hda_activate_path(codec, path, true, false);
4124 	if (spec->cap_sync_hook)
4125 		spec->cap_sync_hook(codec, NULL, NULL);
4126 	path_power_down_sync(codec, old_path);
4127 	return 1;
4128 }
4129 
4130 /* power up/down widgets in the all paths that match with the given NID
4131  * as terminals (either start- or endpoint)
4132  *
4133  * returns the last changed NID, or zero if unchanged.
4134  */
set_path_power(struct hda_codec * codec,hda_nid_t nid,int pin_state,int stream_state)4135 static hda_nid_t set_path_power(struct hda_codec *codec, hda_nid_t nid,
4136 				int pin_state, int stream_state)
4137 {
4138 	struct hda_gen_spec *spec = codec->spec;
4139 	hda_nid_t last, changed = 0;
4140 	struct nid_path *path;
4141 	int n;
4142 
4143 	snd_array_for_each(&spec->paths, n, path) {
4144 		if (!path->depth)
4145 			continue;
4146 		if (path->path[0] == nid ||
4147 		    path->path[path->depth - 1] == nid) {
4148 			bool pin_old = path->pin_enabled;
4149 			bool stream_old = path->stream_enabled;
4150 
4151 			if (pin_state >= 0)
4152 				path->pin_enabled = pin_state;
4153 			if (stream_state >= 0)
4154 				path->stream_enabled = stream_state;
4155 			if ((!path->pin_fixed && path->pin_enabled != pin_old)
4156 			    || path->stream_enabled != stream_old) {
4157 				last = path_power_update(codec, path, true);
4158 				if (last)
4159 					changed = last;
4160 			}
4161 		}
4162 	}
4163 	return changed;
4164 }
4165 
4166 /* check the jack status for power control */
detect_pin_state(struct hda_codec * codec,hda_nid_t pin)4167 static bool detect_pin_state(struct hda_codec *codec, hda_nid_t pin)
4168 {
4169 	if (!is_jack_detectable(codec, pin))
4170 		return true;
4171 	return snd_hda_jack_detect_state(codec, pin) != HDA_JACK_NOT_PRESENT;
4172 }
4173 
4174 /* power up/down the paths of the given pin according to the jack state;
4175  * power = 0/1 : only power up/down if it matches with the jack state,
4176  *       < 0   : force power up/down to follow the jack sate
4177  *
4178  * returns the last changed NID, or zero if unchanged.
4179  */
set_pin_power_jack(struct hda_codec * codec,hda_nid_t pin,int power)4180 static hda_nid_t set_pin_power_jack(struct hda_codec *codec, hda_nid_t pin,
4181 				    int power)
4182 {
4183 	bool on;
4184 
4185 	if (!codec->power_save_node)
4186 		return 0;
4187 
4188 	on = detect_pin_state(codec, pin);
4189 
4190 	if (power >= 0 && on != power)
4191 		return 0;
4192 	return set_path_power(codec, pin, on, -1);
4193 }
4194 
pin_power_callback(struct hda_codec * codec,struct hda_jack_callback * jack,bool on)4195 static void pin_power_callback(struct hda_codec *codec,
4196 			       struct hda_jack_callback *jack,
4197 			       bool on)
4198 {
4199 	if (jack && jack->nid)
4200 		sync_power_state_change(codec,
4201 					set_pin_power_jack(codec, jack->nid, on));
4202 }
4203 
4204 /* callback only doing power up -- called at first */
pin_power_up_callback(struct hda_codec * codec,struct hda_jack_callback * jack)4205 static void pin_power_up_callback(struct hda_codec *codec,
4206 				  struct hda_jack_callback *jack)
4207 {
4208 	pin_power_callback(codec, jack, true);
4209 }
4210 
4211 /* callback only doing power down -- called at last */
pin_power_down_callback(struct hda_codec * codec,struct hda_jack_callback * jack)4212 static void pin_power_down_callback(struct hda_codec *codec,
4213 				    struct hda_jack_callback *jack)
4214 {
4215 	pin_power_callback(codec, jack, false);
4216 }
4217 
4218 /* set up the power up/down callbacks */
add_pin_power_ctls(struct hda_codec * codec,int num_pins,const hda_nid_t * pins,bool on)4219 static void add_pin_power_ctls(struct hda_codec *codec, int num_pins,
4220 			       const hda_nid_t *pins, bool on)
4221 {
4222 	int i;
4223 	hda_jack_callback_fn cb =
4224 		on ? pin_power_up_callback : pin_power_down_callback;
4225 
4226 	for (i = 0; i < num_pins && pins[i]; i++) {
4227 		if (is_jack_detectable(codec, pins[i]))
4228 			snd_hda_jack_detect_enable_callback(codec, pins[i], cb);
4229 		else
4230 			set_path_power(codec, pins[i], true, -1);
4231 	}
4232 }
4233 
4234 /* enabled power callback to each available I/O pin with jack detections;
4235  * the digital I/O pins are excluded because of the unreliable detectsion
4236  */
add_all_pin_power_ctls(struct hda_codec * codec,bool on)4237 static void add_all_pin_power_ctls(struct hda_codec *codec, bool on)
4238 {
4239 	struct hda_gen_spec *spec = codec->spec;
4240 	struct auto_pin_cfg *cfg = &spec->autocfg;
4241 	int i;
4242 
4243 	if (!codec->power_save_node)
4244 		return;
4245 	add_pin_power_ctls(codec, cfg->line_outs, cfg->line_out_pins, on);
4246 	if (cfg->line_out_type != AUTO_PIN_HP_OUT)
4247 		add_pin_power_ctls(codec, cfg->hp_outs, cfg->hp_pins, on);
4248 	if (cfg->line_out_type != AUTO_PIN_SPEAKER_OUT)
4249 		add_pin_power_ctls(codec, cfg->speaker_outs, cfg->speaker_pins, on);
4250 	for (i = 0; i < cfg->num_inputs; i++)
4251 		add_pin_power_ctls(codec, 1, &cfg->inputs[i].pin, on);
4252 }
4253 
4254 /* sync path power up/down with the jack states of given pins */
sync_pin_power_ctls(struct hda_codec * codec,int num_pins,const hda_nid_t * pins)4255 static void sync_pin_power_ctls(struct hda_codec *codec, int num_pins,
4256 				const hda_nid_t *pins)
4257 {
4258 	int i;
4259 
4260 	for (i = 0; i < num_pins && pins[i]; i++)
4261 		if (is_jack_detectable(codec, pins[i]))
4262 			set_pin_power_jack(codec, pins[i], -1);
4263 }
4264 
4265 /* sync path power up/down with pins; called at init and resume */
sync_all_pin_power_ctls(struct hda_codec * codec)4266 static void sync_all_pin_power_ctls(struct hda_codec *codec)
4267 {
4268 	struct hda_gen_spec *spec = codec->spec;
4269 	struct auto_pin_cfg *cfg = &spec->autocfg;
4270 	int i;
4271 
4272 	if (!codec->power_save_node)
4273 		return;
4274 	sync_pin_power_ctls(codec, cfg->line_outs, cfg->line_out_pins);
4275 	if (cfg->line_out_type != AUTO_PIN_HP_OUT)
4276 		sync_pin_power_ctls(codec, cfg->hp_outs, cfg->hp_pins);
4277 	if (cfg->line_out_type != AUTO_PIN_SPEAKER_OUT)
4278 		sync_pin_power_ctls(codec, cfg->speaker_outs, cfg->speaker_pins);
4279 	for (i = 0; i < cfg->num_inputs; i++)
4280 		sync_pin_power_ctls(codec, 1, &cfg->inputs[i].pin);
4281 }
4282 
4283 /* add fake paths if not present yet */
add_fake_paths(struct hda_codec * codec,hda_nid_t nid,int num_pins,const hda_nid_t * pins)4284 static int add_fake_paths(struct hda_codec *codec, hda_nid_t nid,
4285 			   int num_pins, const hda_nid_t *pins)
4286 {
4287 	struct hda_gen_spec *spec = codec->spec;
4288 	struct nid_path *path;
4289 	int i;
4290 
4291 	for (i = 0; i < num_pins; i++) {
4292 		if (!pins[i])
4293 			break;
4294 		if (get_nid_path(codec, nid, pins[i], 0))
4295 			continue;
4296 		path = snd_array_new(&spec->paths);
4297 		if (!path)
4298 			return -ENOMEM;
4299 		memset(path, 0, sizeof(*path));
4300 		path->depth = 2;
4301 		path->path[0] = nid;
4302 		path->path[1] = pins[i];
4303 		path->active = true;
4304 	}
4305 	return 0;
4306 }
4307 
4308 /* create fake paths to all outputs from beep */
add_fake_beep_paths(struct hda_codec * codec)4309 static int add_fake_beep_paths(struct hda_codec *codec)
4310 {
4311 	struct hda_gen_spec *spec = codec->spec;
4312 	struct auto_pin_cfg *cfg = &spec->autocfg;
4313 	hda_nid_t nid = spec->beep_nid;
4314 	int err;
4315 
4316 	if (!codec->power_save_node || !nid)
4317 		return 0;
4318 	err = add_fake_paths(codec, nid, cfg->line_outs, cfg->line_out_pins);
4319 	if (err < 0)
4320 		return err;
4321 	if (cfg->line_out_type != AUTO_PIN_HP_OUT) {
4322 		err = add_fake_paths(codec, nid, cfg->hp_outs, cfg->hp_pins);
4323 		if (err < 0)
4324 			return err;
4325 	}
4326 	if (cfg->line_out_type != AUTO_PIN_SPEAKER_OUT) {
4327 		err = add_fake_paths(codec, nid, cfg->speaker_outs,
4328 				     cfg->speaker_pins);
4329 		if (err < 0)
4330 			return err;
4331 	}
4332 	return 0;
4333 }
4334 
4335 /* power up/down beep widget and its output paths */
beep_power_hook(struct hda_beep * beep,bool on)4336 static void beep_power_hook(struct hda_beep *beep, bool on)
4337 {
4338 	set_path_power(beep->codec, beep->nid, -1, on);
4339 }
4340 
4341 /**
4342  * snd_hda_gen_fix_pin_power - Fix the power of the given pin widget to D0
4343  * @codec: the HDA codec
4344  * @pin: NID of pin to fix
4345  */
snd_hda_gen_fix_pin_power(struct hda_codec * codec,hda_nid_t pin)4346 int snd_hda_gen_fix_pin_power(struct hda_codec *codec, hda_nid_t pin)
4347 {
4348 	struct hda_gen_spec *spec = codec->spec;
4349 	struct nid_path *path;
4350 
4351 	path = snd_array_new(&spec->paths);
4352 	if (!path)
4353 		return -ENOMEM;
4354 	memset(path, 0, sizeof(*path));
4355 	path->depth = 1;
4356 	path->path[0] = pin;
4357 	path->active = true;
4358 	path->pin_fixed = true;
4359 	path->stream_enabled = true;
4360 	return 0;
4361 }
4362 EXPORT_SYMBOL_GPL(snd_hda_gen_fix_pin_power);
4363 
4364 /*
4365  * Jack detections for HP auto-mute and mic-switch
4366  */
4367 
4368 /* check each pin in the given array; returns true if any of them is plugged */
detect_jacks(struct hda_codec * codec,int num_pins,const hda_nid_t * pins)4369 static bool detect_jacks(struct hda_codec *codec, int num_pins, const hda_nid_t *pins)
4370 {
4371 	int i;
4372 	bool present = false;
4373 
4374 	for (i = 0; i < num_pins; i++) {
4375 		hda_nid_t nid = pins[i];
4376 		if (!nid)
4377 			break;
4378 		/* don't detect pins retasked as inputs */
4379 		if (snd_hda_codec_get_pin_target(codec, nid) & AC_PINCTL_IN_EN)
4380 			continue;
4381 		if (snd_hda_jack_detect_state(codec, nid) == HDA_JACK_PRESENT)
4382 			present = true;
4383 	}
4384 	return present;
4385 }
4386 
4387 /* standard HP/line-out auto-mute helper */
do_automute(struct hda_codec * codec,int num_pins,const hda_nid_t * pins,int * paths,bool mute)4388 static void do_automute(struct hda_codec *codec, int num_pins, const hda_nid_t *pins,
4389 			int *paths, bool mute)
4390 {
4391 	struct hda_gen_spec *spec = codec->spec;
4392 	int i;
4393 
4394 	for (i = 0; i < num_pins; i++) {
4395 		hda_nid_t nid = pins[i];
4396 		unsigned int val, oldval;
4397 		if (!nid)
4398 			break;
4399 
4400 		oldval = snd_hda_codec_get_pin_target(codec, nid);
4401 		if (oldval & PIN_IN)
4402 			continue; /* no mute for inputs */
4403 
4404 		if (spec->auto_mute_via_amp) {
4405 			struct nid_path *path;
4406 			hda_nid_t mute_nid;
4407 
4408 			path = snd_hda_get_path_from_idx(codec, paths[i]);
4409 			if (!path)
4410 				continue;
4411 			mute_nid = get_amp_nid_(path->ctls[NID_PATH_MUTE_CTL]);
4412 			if (!mute_nid)
4413 				continue;
4414 			if (mute)
4415 				spec->mute_bits |= (1ULL << mute_nid);
4416 			else
4417 				spec->mute_bits &= ~(1ULL << mute_nid);
4418 			continue;
4419 		} else {
4420 			/* don't reset VREF value in case it's controlling
4421 			 * the amp (see alc861_fixup_asus_amp_vref_0f())
4422 			 */
4423 			if (spec->keep_vref_in_automute)
4424 				val = oldval & ~PIN_HP;
4425 			else
4426 				val = 0;
4427 			if (!mute)
4428 				val |= oldval;
4429 			/* here we call update_pin_ctl() so that the pinctl is
4430 			 * changed without changing the pinctl target value;
4431 			 * the original target value will be still referred at
4432 			 * the init / resume again
4433 			 */
4434 			update_pin_ctl(codec, nid, val);
4435 		}
4436 
4437 		set_pin_eapd(codec, nid, !mute);
4438 		if (codec->power_save_node) {
4439 			bool on = !mute;
4440 			if (on)
4441 				on = detect_pin_state(codec, nid);
4442 			set_path_power(codec, nid, on, -1);
4443 		}
4444 	}
4445 }
4446 
4447 /**
4448  * snd_hda_gen_update_outputs - Toggle outputs muting
4449  * @codec: the HDA codec
4450  *
4451  * Update the mute status of all outputs based on the current jack states.
4452  */
snd_hda_gen_update_outputs(struct hda_codec * codec)4453 void snd_hda_gen_update_outputs(struct hda_codec *codec)
4454 {
4455 	struct hda_gen_spec *spec = codec->spec;
4456 	int *paths;
4457 	int on;
4458 
4459 	/* Control HP pins/amps depending on master_mute state;
4460 	 * in general, HP pins/amps control should be enabled in all cases,
4461 	 * but currently set only for master_mute, just to be safe
4462 	 */
4463 	if (spec->autocfg.line_out_type == AUTO_PIN_HP_OUT)
4464 		paths = spec->out_paths;
4465 	else
4466 		paths = spec->hp_paths;
4467 	do_automute(codec, ARRAY_SIZE(spec->autocfg.hp_pins),
4468 		    spec->autocfg.hp_pins, paths, spec->master_mute);
4469 
4470 	if (!spec->automute_speaker)
4471 		on = 0;
4472 	else
4473 		on = spec->hp_jack_present | spec->line_jack_present;
4474 	on |= spec->master_mute;
4475 	spec->speaker_muted = on;
4476 	if (spec->autocfg.line_out_type == AUTO_PIN_SPEAKER_OUT)
4477 		paths = spec->out_paths;
4478 	else
4479 		paths = spec->speaker_paths;
4480 	do_automute(codec, ARRAY_SIZE(spec->autocfg.speaker_pins),
4481 		    spec->autocfg.speaker_pins, paths, on);
4482 
4483 	/* toggle line-out mutes if needed, too */
4484 	/* if LO is a copy of either HP or Speaker, don't need to handle it */
4485 	if (spec->autocfg.line_out_pins[0] == spec->autocfg.hp_pins[0] ||
4486 	    spec->autocfg.line_out_pins[0] == spec->autocfg.speaker_pins[0])
4487 		return;
4488 	if (!spec->automute_lo)
4489 		on = 0;
4490 	else
4491 		on = spec->hp_jack_present;
4492 	on |= spec->master_mute;
4493 	spec->line_out_muted = on;
4494 	paths = spec->out_paths;
4495 	do_automute(codec, ARRAY_SIZE(spec->autocfg.line_out_pins),
4496 		    spec->autocfg.line_out_pins, paths, on);
4497 }
4498 EXPORT_SYMBOL_GPL(snd_hda_gen_update_outputs);
4499 
call_update_outputs(struct hda_codec * codec)4500 static void call_update_outputs(struct hda_codec *codec)
4501 {
4502 	struct hda_gen_spec *spec = codec->spec;
4503 	if (spec->automute_hook)
4504 		spec->automute_hook(codec);
4505 	else
4506 		snd_hda_gen_update_outputs(codec);
4507 
4508 	/* sync the whole vmaster followers to reflect the new auto-mute status */
4509 	if (spec->auto_mute_via_amp && !codec->bus->shutdown)
4510 		snd_ctl_sync_vmaster(spec->vmaster_mute.sw_kctl, false);
4511 }
4512 
4513 /**
4514  * snd_hda_gen_hp_automute - standard HP-automute helper
4515  * @codec: the HDA codec
4516  * @jack: jack object, NULL for the whole
4517  */
snd_hda_gen_hp_automute(struct hda_codec * codec,struct hda_jack_callback * jack)4518 void snd_hda_gen_hp_automute(struct hda_codec *codec,
4519 			     struct hda_jack_callback *jack)
4520 {
4521 	struct hda_gen_spec *spec = codec->spec;
4522 	hda_nid_t *pins = spec->autocfg.hp_pins;
4523 	int num_pins = ARRAY_SIZE(spec->autocfg.hp_pins);
4524 
4525 	/* No detection for the first HP jack during indep-HP mode */
4526 	if (spec->indep_hp_enabled) {
4527 		pins++;
4528 		num_pins--;
4529 	}
4530 
4531 	spec->hp_jack_present = detect_jacks(codec, num_pins, pins);
4532 	if (!spec->detect_hp || (!spec->automute_speaker && !spec->automute_lo))
4533 		return;
4534 	call_update_outputs(codec);
4535 }
4536 EXPORT_SYMBOL_GPL(snd_hda_gen_hp_automute);
4537 
4538 /**
4539  * snd_hda_gen_line_automute - standard line-out-automute helper
4540  * @codec: the HDA codec
4541  * @jack: jack object, NULL for the whole
4542  */
snd_hda_gen_line_automute(struct hda_codec * codec,struct hda_jack_callback * jack)4543 void snd_hda_gen_line_automute(struct hda_codec *codec,
4544 			       struct hda_jack_callback *jack)
4545 {
4546 	struct hda_gen_spec *spec = codec->spec;
4547 
4548 	if (spec->autocfg.line_out_type == AUTO_PIN_SPEAKER_OUT)
4549 		return;
4550 	/* check LO jack only when it's different from HP */
4551 	if (spec->autocfg.line_out_pins[0] == spec->autocfg.hp_pins[0])
4552 		return;
4553 
4554 	spec->line_jack_present =
4555 		detect_jacks(codec, ARRAY_SIZE(spec->autocfg.line_out_pins),
4556 			     spec->autocfg.line_out_pins);
4557 	if (!spec->automute_speaker || !spec->detect_lo)
4558 		return;
4559 	call_update_outputs(codec);
4560 }
4561 EXPORT_SYMBOL_GPL(snd_hda_gen_line_automute);
4562 
4563 /**
4564  * snd_hda_gen_mic_autoswitch - standard mic auto-switch helper
4565  * @codec: the HDA codec
4566  * @jack: jack object, NULL for the whole
4567  */
snd_hda_gen_mic_autoswitch(struct hda_codec * codec,struct hda_jack_callback * jack)4568 void snd_hda_gen_mic_autoswitch(struct hda_codec *codec,
4569 				struct hda_jack_callback *jack)
4570 {
4571 	struct hda_gen_spec *spec = codec->spec;
4572 	int i;
4573 
4574 	if (!spec->auto_mic)
4575 		return;
4576 
4577 	for (i = spec->am_num_entries - 1; i > 0; i--) {
4578 		hda_nid_t pin = spec->am_entry[i].pin;
4579 		/* don't detect pins retasked as outputs */
4580 		if (snd_hda_codec_get_pin_target(codec, pin) & AC_PINCTL_OUT_EN)
4581 			continue;
4582 		if (snd_hda_jack_detect_state(codec, pin) == HDA_JACK_PRESENT) {
4583 			mux_select(codec, 0, spec->am_entry[i].idx);
4584 			return;
4585 		}
4586 	}
4587 	mux_select(codec, 0, spec->am_entry[0].idx);
4588 }
4589 EXPORT_SYMBOL_GPL(snd_hda_gen_mic_autoswitch);
4590 
4591 /* call appropriate hooks */
call_hp_automute(struct hda_codec * codec,struct hda_jack_callback * jack)4592 static void call_hp_automute(struct hda_codec *codec,
4593 			     struct hda_jack_callback *jack)
4594 {
4595 	struct hda_gen_spec *spec = codec->spec;
4596 	if (spec->hp_automute_hook)
4597 		spec->hp_automute_hook(codec, jack);
4598 	else
4599 		snd_hda_gen_hp_automute(codec, jack);
4600 }
4601 
call_line_automute(struct hda_codec * codec,struct hda_jack_callback * jack)4602 static void call_line_automute(struct hda_codec *codec,
4603 			       struct hda_jack_callback *jack)
4604 {
4605 	struct hda_gen_spec *spec = codec->spec;
4606 	if (spec->line_automute_hook)
4607 		spec->line_automute_hook(codec, jack);
4608 	else
4609 		snd_hda_gen_line_automute(codec, jack);
4610 }
4611 
call_mic_autoswitch(struct hda_codec * codec,struct hda_jack_callback * jack)4612 static void call_mic_autoswitch(struct hda_codec *codec,
4613 				struct hda_jack_callback *jack)
4614 {
4615 	struct hda_gen_spec *spec = codec->spec;
4616 	if (spec->mic_autoswitch_hook)
4617 		spec->mic_autoswitch_hook(codec, jack);
4618 	else
4619 		snd_hda_gen_mic_autoswitch(codec, jack);
4620 }
4621 
4622 /* update jack retasking */
update_automute_all(struct hda_codec * codec)4623 static void update_automute_all(struct hda_codec *codec)
4624 {
4625 	call_hp_automute(codec, NULL);
4626 	call_line_automute(codec, NULL);
4627 	call_mic_autoswitch(codec, NULL);
4628 }
4629 
4630 /*
4631  * Auto-Mute mode mixer enum support
4632  */
automute_mode_info(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_info * uinfo)4633 static int automute_mode_info(struct snd_kcontrol *kcontrol,
4634 			      struct snd_ctl_elem_info *uinfo)
4635 {
4636 	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
4637 	struct hda_gen_spec *spec = codec->spec;
4638 	static const char * const texts3[] = {
4639 		"Disabled", "Speaker Only", "Line Out+Speaker"
4640 	};
4641 
4642 	if (spec->automute_speaker_possible && spec->automute_lo_possible)
4643 		return snd_hda_enum_helper_info(kcontrol, uinfo, 3, texts3);
4644 	return snd_hda_enum_bool_helper_info(kcontrol, uinfo);
4645 }
4646 
automute_mode_get(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)4647 static int automute_mode_get(struct snd_kcontrol *kcontrol,
4648 			     struct snd_ctl_elem_value *ucontrol)
4649 {
4650 	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
4651 	struct hda_gen_spec *spec = codec->spec;
4652 	unsigned int val = 0;
4653 	if (spec->automute_speaker)
4654 		val++;
4655 	if (spec->automute_lo)
4656 		val++;
4657 
4658 	ucontrol->value.enumerated.item[0] = val;
4659 	return 0;
4660 }
4661 
automute_mode_put(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)4662 static int automute_mode_put(struct snd_kcontrol *kcontrol,
4663 			     struct snd_ctl_elem_value *ucontrol)
4664 {
4665 	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
4666 	struct hda_gen_spec *spec = codec->spec;
4667 
4668 	switch (ucontrol->value.enumerated.item[0]) {
4669 	case 0:
4670 		if (!spec->automute_speaker && !spec->automute_lo)
4671 			return 0;
4672 		spec->automute_speaker = 0;
4673 		spec->automute_lo = 0;
4674 		break;
4675 	case 1:
4676 		if (spec->automute_speaker_possible) {
4677 			if (!spec->automute_lo && spec->automute_speaker)
4678 				return 0;
4679 			spec->automute_speaker = 1;
4680 			spec->automute_lo = 0;
4681 		} else if (spec->automute_lo_possible) {
4682 			if (spec->automute_lo)
4683 				return 0;
4684 			spec->automute_lo = 1;
4685 		} else
4686 			return -EINVAL;
4687 		break;
4688 	case 2:
4689 		if (!spec->automute_lo_possible || !spec->automute_speaker_possible)
4690 			return -EINVAL;
4691 		if (spec->automute_speaker && spec->automute_lo)
4692 			return 0;
4693 		spec->automute_speaker = 1;
4694 		spec->automute_lo = 1;
4695 		break;
4696 	default:
4697 		return -EINVAL;
4698 	}
4699 	call_update_outputs(codec);
4700 	return 1;
4701 }
4702 
4703 static const struct snd_kcontrol_new automute_mode_enum = {
4704 	.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
4705 	.name = "Auto-Mute Mode",
4706 	.info = automute_mode_info,
4707 	.get = automute_mode_get,
4708 	.put = automute_mode_put,
4709 };
4710 
add_automute_mode_enum(struct hda_codec * codec)4711 static int add_automute_mode_enum(struct hda_codec *codec)
4712 {
4713 	struct hda_gen_spec *spec = codec->spec;
4714 
4715 	if (!snd_hda_gen_add_kctl(spec, NULL, &automute_mode_enum))
4716 		return -ENOMEM;
4717 	return 0;
4718 }
4719 
4720 /*
4721  * Check the availability of HP/line-out auto-mute;
4722  * Set up appropriately if really supported
4723  */
check_auto_mute_availability(struct hda_codec * codec)4724 static int check_auto_mute_availability(struct hda_codec *codec)
4725 {
4726 	struct hda_gen_spec *spec = codec->spec;
4727 	struct auto_pin_cfg *cfg = &spec->autocfg;
4728 	int present = 0;
4729 	int i, err;
4730 
4731 	if (spec->suppress_auto_mute)
4732 		return 0;
4733 
4734 	if (cfg->hp_pins[0])
4735 		present++;
4736 	if (cfg->line_out_pins[0])
4737 		present++;
4738 	if (cfg->speaker_pins[0])
4739 		present++;
4740 	if (present < 2) /* need two different output types */
4741 		return 0;
4742 
4743 	if (!cfg->speaker_pins[0] &&
4744 	    cfg->line_out_type == AUTO_PIN_SPEAKER_OUT) {
4745 		memcpy(cfg->speaker_pins, cfg->line_out_pins,
4746 		       sizeof(cfg->speaker_pins));
4747 		cfg->speaker_outs = cfg->line_outs;
4748 	}
4749 
4750 	if (!cfg->hp_pins[0] &&
4751 	    cfg->line_out_type == AUTO_PIN_HP_OUT) {
4752 		memcpy(cfg->hp_pins, cfg->line_out_pins,
4753 		       sizeof(cfg->hp_pins));
4754 		cfg->hp_outs = cfg->line_outs;
4755 	}
4756 
4757 	for (i = 0; i < cfg->hp_outs; i++) {
4758 		hda_nid_t nid = cfg->hp_pins[i];
4759 		if (!is_jack_detectable(codec, nid))
4760 			continue;
4761 		codec_dbg(codec, "Enable HP auto-muting on NID 0x%x\n", nid);
4762 		snd_hda_jack_detect_enable_callback(codec, nid,
4763 						    call_hp_automute);
4764 		spec->detect_hp = 1;
4765 	}
4766 
4767 	if (cfg->line_out_type == AUTO_PIN_LINE_OUT && cfg->line_outs) {
4768 		if (cfg->speaker_outs)
4769 			for (i = 0; i < cfg->line_outs; i++) {
4770 				hda_nid_t nid = cfg->line_out_pins[i];
4771 				if (!is_jack_detectable(codec, nid))
4772 					continue;
4773 				codec_dbg(codec, "Enable Line-Out auto-muting on NID 0x%x\n", nid);
4774 				snd_hda_jack_detect_enable_callback(codec, nid,
4775 								    call_line_automute);
4776 				spec->detect_lo = 1;
4777 			}
4778 		spec->automute_lo_possible = spec->detect_hp;
4779 	}
4780 
4781 	spec->automute_speaker_possible = cfg->speaker_outs &&
4782 		(spec->detect_hp || spec->detect_lo);
4783 
4784 	spec->automute_lo = spec->automute_lo_possible;
4785 	spec->automute_speaker = spec->automute_speaker_possible;
4786 
4787 	if (spec->automute_speaker_possible || spec->automute_lo_possible) {
4788 		/* create a control for automute mode */
4789 		err = add_automute_mode_enum(codec);
4790 		if (err < 0)
4791 			return err;
4792 	}
4793 	return 0;
4794 }
4795 
4796 /* check whether all auto-mic pins are valid; setup indices if OK */
auto_mic_check_imux(struct hda_codec * codec)4797 static bool auto_mic_check_imux(struct hda_codec *codec)
4798 {
4799 	struct hda_gen_spec *spec = codec->spec;
4800 	const struct hda_input_mux *imux;
4801 	int i;
4802 
4803 	imux = &spec->input_mux;
4804 	for (i = 0; i < spec->am_num_entries; i++) {
4805 		spec->am_entry[i].idx =
4806 			find_idx_in_nid_list(spec->am_entry[i].pin,
4807 					     spec->imux_pins, imux->num_items);
4808 		if (spec->am_entry[i].idx < 0)
4809 			return false; /* no corresponding imux */
4810 	}
4811 
4812 	/* we don't need the jack detection for the first pin */
4813 	for (i = 1; i < spec->am_num_entries; i++)
4814 		snd_hda_jack_detect_enable_callback(codec,
4815 						    spec->am_entry[i].pin,
4816 						    call_mic_autoswitch);
4817 	return true;
4818 }
4819 
compare_attr(const void * ap,const void * bp)4820 static int compare_attr(const void *ap, const void *bp)
4821 {
4822 	const struct automic_entry *a = ap;
4823 	const struct automic_entry *b = bp;
4824 	return (int)(a->attr - b->attr);
4825 }
4826 
4827 /*
4828  * Check the availability of auto-mic switch;
4829  * Set up if really supported
4830  */
check_auto_mic_availability(struct hda_codec * codec)4831 static int check_auto_mic_availability(struct hda_codec *codec)
4832 {
4833 	struct hda_gen_spec *spec = codec->spec;
4834 	struct auto_pin_cfg *cfg = &spec->autocfg;
4835 	unsigned int types;
4836 	int i, num_pins;
4837 
4838 	if (spec->suppress_auto_mic)
4839 		return 0;
4840 
4841 	types = 0;
4842 	num_pins = 0;
4843 	for (i = 0; i < cfg->num_inputs; i++) {
4844 		hda_nid_t nid = cfg->inputs[i].pin;
4845 		unsigned int attr;
4846 		attr = snd_hda_codec_get_pincfg(codec, nid);
4847 		attr = snd_hda_get_input_pin_attr(attr);
4848 		if (types & (1 << attr))
4849 			return 0; /* already occupied */
4850 		switch (attr) {
4851 		case INPUT_PIN_ATTR_INT:
4852 			if (cfg->inputs[i].type != AUTO_PIN_MIC)
4853 				return 0; /* invalid type */
4854 			break;
4855 		case INPUT_PIN_ATTR_UNUSED:
4856 			return 0; /* invalid entry */
4857 		default:
4858 			if (cfg->inputs[i].type > AUTO_PIN_LINE_IN)
4859 				return 0; /* invalid type */
4860 			if (!spec->line_in_auto_switch &&
4861 			    cfg->inputs[i].type != AUTO_PIN_MIC)
4862 				return 0; /* only mic is allowed */
4863 			if (!is_jack_detectable(codec, nid))
4864 				return 0; /* no unsol support */
4865 			break;
4866 		}
4867 		if (num_pins >= MAX_AUTO_MIC_PINS)
4868 			return 0;
4869 		types |= (1 << attr);
4870 		spec->am_entry[num_pins].pin = nid;
4871 		spec->am_entry[num_pins].attr = attr;
4872 		num_pins++;
4873 	}
4874 
4875 	if (num_pins < 2)
4876 		return 0;
4877 
4878 	spec->am_num_entries = num_pins;
4879 	/* sort the am_entry in the order of attr so that the pin with a
4880 	 * higher attr will be selected when the jack is plugged.
4881 	 */
4882 	sort(spec->am_entry, num_pins, sizeof(spec->am_entry[0]),
4883 	     compare_attr, NULL);
4884 
4885 	if (!auto_mic_check_imux(codec))
4886 		return 0;
4887 
4888 	spec->auto_mic = 1;
4889 	spec->num_adc_nids = 1;
4890 	spec->cur_mux[0] = spec->am_entry[0].idx;
4891 	codec_dbg(codec, "Enable auto-mic switch on NID 0x%x/0x%x/0x%x\n",
4892 		    spec->am_entry[0].pin,
4893 		    spec->am_entry[1].pin,
4894 		    spec->am_entry[2].pin);
4895 
4896 	return 0;
4897 }
4898 
4899 /**
4900  * snd_hda_gen_path_power_filter - power_filter hook to make inactive widgets
4901  * into power down
4902  * @codec: the HDA codec
4903  * @nid: NID to evalute
4904  * @power_state: target power state
4905  */
snd_hda_gen_path_power_filter(struct hda_codec * codec,hda_nid_t nid,unsigned int power_state)4906 unsigned int snd_hda_gen_path_power_filter(struct hda_codec *codec,
4907 						  hda_nid_t nid,
4908 						  unsigned int power_state)
4909 {
4910 	struct hda_gen_spec *spec = codec->spec;
4911 
4912 	if (!spec->power_down_unused && !codec->power_save_node)
4913 		return power_state;
4914 	if (power_state != AC_PWRST_D0 || nid == codec->core.afg)
4915 		return power_state;
4916 	if (get_wcaps_type(get_wcaps(codec, nid)) >= AC_WID_POWER)
4917 		return power_state;
4918 	if (is_active_nid_for_any(codec, nid))
4919 		return power_state;
4920 	return AC_PWRST_D3;
4921 }
4922 EXPORT_SYMBOL_GPL(snd_hda_gen_path_power_filter);
4923 
4924 /* mute all aamix inputs initially; parse up to the first leaves */
mute_all_mixer_nid(struct hda_codec * codec,hda_nid_t mix)4925 static void mute_all_mixer_nid(struct hda_codec *codec, hda_nid_t mix)
4926 {
4927 	int i, nums;
4928 	const hda_nid_t *conn;
4929 	bool has_amp;
4930 
4931 	nums = snd_hda_get_conn_list(codec, mix, &conn);
4932 	has_amp = nid_has_mute(codec, mix, HDA_INPUT);
4933 	for (i = 0; i < nums; i++) {
4934 		if (has_amp)
4935 			update_amp(codec, mix, HDA_INPUT, i,
4936 				   0xff, HDA_AMP_MUTE);
4937 		else if (nid_has_volume(codec, conn[i], HDA_OUTPUT))
4938 			update_amp(codec, conn[i], HDA_OUTPUT, 0,
4939 				   0xff, HDA_AMP_MUTE);
4940 	}
4941 }
4942 
4943 /**
4944  * snd_hda_gen_stream_pm - Stream power management callback
4945  * @codec: the HDA codec
4946  * @nid: audio widget
4947  * @on: power on/off flag
4948  *
4949  * Set this in patch_ops.stream_pm.  Only valid with power_save_node flag.
4950  */
snd_hda_gen_stream_pm(struct hda_codec * codec,hda_nid_t nid,bool on)4951 void snd_hda_gen_stream_pm(struct hda_codec *codec, hda_nid_t nid, bool on)
4952 {
4953 	if (codec->power_save_node)
4954 		set_path_power(codec, nid, -1, on);
4955 }
4956 EXPORT_SYMBOL_GPL(snd_hda_gen_stream_pm);
4957 
4958 /* forcibly mute the speaker output without caching; return true if updated */
force_mute_output_path(struct hda_codec * codec,hda_nid_t nid)4959 static bool force_mute_output_path(struct hda_codec *codec, hda_nid_t nid)
4960 {
4961 	if (!nid)
4962 		return false;
4963 	if (!nid_has_mute(codec, nid, HDA_OUTPUT))
4964 		return false; /* no mute, skip */
4965 	if (snd_hda_codec_amp_read(codec, nid, 0, HDA_OUTPUT, 0) &
4966 	    snd_hda_codec_amp_read(codec, nid, 1, HDA_OUTPUT, 0) &
4967 	    HDA_AMP_MUTE)
4968 		return false; /* both channels already muted, skip */
4969 
4970 	/* direct amp update without caching */
4971 	snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE,
4972 			    AC_AMP_SET_OUTPUT | AC_AMP_SET_LEFT |
4973 			    AC_AMP_SET_RIGHT | HDA_AMP_MUTE);
4974 	return true;
4975 }
4976 
4977 /**
4978  * snd_hda_gen_shutup_speakers - Forcibly mute the speaker outputs
4979  * @codec: the HDA codec
4980  *
4981  * Forcibly mute the speaker outputs, to be called at suspend or shutdown.
4982  *
4983  * The mute state done by this function isn't cached, hence the original state
4984  * will be restored at resume.
4985  *
4986  * Return true if the mute state has been changed.
4987  */
snd_hda_gen_shutup_speakers(struct hda_codec * codec)4988 bool snd_hda_gen_shutup_speakers(struct hda_codec *codec)
4989 {
4990 	struct hda_gen_spec *spec = codec->spec;
4991 	const int *paths;
4992 	const struct nid_path *path;
4993 	int i, p, num_paths;
4994 	bool updated = false;
4995 
4996 	/* if already powered off, do nothing */
4997 	if (!snd_hdac_is_power_on(&codec->core))
4998 		return false;
4999 
5000 	if (spec->autocfg.line_out_type == AUTO_PIN_SPEAKER_OUT) {
5001 		paths = spec->out_paths;
5002 		num_paths = spec->autocfg.line_outs;
5003 	} else {
5004 		paths = spec->speaker_paths;
5005 		num_paths = spec->autocfg.speaker_outs;
5006 	}
5007 
5008 	for (i = 0; i < num_paths; i++) {
5009 		path = snd_hda_get_path_from_idx(codec, paths[i]);
5010 		if (!path)
5011 			continue;
5012 		for (p = 0; p < path->depth; p++)
5013 			if (force_mute_output_path(codec, path->path[p]))
5014 				updated = true;
5015 	}
5016 
5017 	return updated;
5018 }
5019 EXPORT_SYMBOL_GPL(snd_hda_gen_shutup_speakers);
5020 
5021 /**
5022  * snd_hda_gen_parse_auto_config - Parse the given BIOS configuration and
5023  * set up the hda_gen_spec
5024  * @codec: the HDA codec
5025  * @cfg: Parsed pin configuration
5026  *
5027  * return 1 if successful, 0 if the proper config is not found,
5028  * or a negative error code
5029  */
snd_hda_gen_parse_auto_config(struct hda_codec * codec,struct auto_pin_cfg * cfg)5030 int snd_hda_gen_parse_auto_config(struct hda_codec *codec,
5031 				  struct auto_pin_cfg *cfg)
5032 {
5033 	struct hda_gen_spec *spec = codec->spec;
5034 	int err;
5035 
5036 	parse_user_hints(codec);
5037 
5038 	if (spec->vmaster_mute_led || spec->mic_mute_led)
5039 		snd_ctl_led_request();
5040 
5041 	if (spec->mixer_nid && !spec->mixer_merge_nid)
5042 		spec->mixer_merge_nid = spec->mixer_nid;
5043 
5044 	if (cfg != &spec->autocfg) {
5045 		spec->autocfg = *cfg;
5046 		cfg = &spec->autocfg;
5047 	}
5048 
5049 	if (!spec->main_out_badness)
5050 		spec->main_out_badness = &hda_main_out_badness;
5051 	if (!spec->extra_out_badness)
5052 		spec->extra_out_badness = &hda_extra_out_badness;
5053 
5054 	fill_all_dac_nids(codec);
5055 
5056 	if (!cfg->line_outs) {
5057 		if (cfg->dig_outs || cfg->dig_in_pin) {
5058 			spec->multiout.max_channels = 2;
5059 			spec->no_analog = 1;
5060 			goto dig_only;
5061 		}
5062 		if (!cfg->num_inputs && !cfg->dig_in_pin)
5063 			return 0; /* can't find valid BIOS pin config */
5064 	}
5065 
5066 	if (!spec->no_primary_hp &&
5067 	    cfg->line_out_type == AUTO_PIN_SPEAKER_OUT &&
5068 	    cfg->line_outs <= cfg->hp_outs) {
5069 		/* use HP as primary out */
5070 		cfg->speaker_outs = cfg->line_outs;
5071 		memcpy(cfg->speaker_pins, cfg->line_out_pins,
5072 		       sizeof(cfg->speaker_pins));
5073 		cfg->line_outs = cfg->hp_outs;
5074 		memcpy(cfg->line_out_pins, cfg->hp_pins, sizeof(cfg->hp_pins));
5075 		cfg->hp_outs = 0;
5076 		memset(cfg->hp_pins, 0, sizeof(cfg->hp_pins));
5077 		cfg->line_out_type = AUTO_PIN_HP_OUT;
5078 	}
5079 
5080 	err = parse_output_paths(codec);
5081 	if (err < 0)
5082 		return err;
5083 	err = create_multi_channel_mode(codec);
5084 	if (err < 0)
5085 		return err;
5086 	err = create_multi_out_ctls(codec, cfg);
5087 	if (err < 0)
5088 		return err;
5089 	err = create_hp_out_ctls(codec);
5090 	if (err < 0)
5091 		return err;
5092 	err = create_speaker_out_ctls(codec);
5093 	if (err < 0)
5094 		return err;
5095 	err = create_indep_hp_ctls(codec);
5096 	if (err < 0)
5097 		return err;
5098 	err = create_loopback_mixing_ctl(codec);
5099 	if (err < 0)
5100 		return err;
5101 	err = create_hp_mic(codec);
5102 	if (err < 0)
5103 		return err;
5104 	err = create_input_ctls(codec);
5105 	if (err < 0)
5106 		return err;
5107 
5108 	/* add power-down pin callbacks at first */
5109 	add_all_pin_power_ctls(codec, false);
5110 
5111 	spec->const_channel_count = spec->ext_channel_count;
5112 	/* check the multiple speaker and headphone pins */
5113 	if (cfg->line_out_type != AUTO_PIN_SPEAKER_OUT)
5114 		spec->const_channel_count = max(spec->const_channel_count,
5115 						cfg->speaker_outs * 2);
5116 	if (cfg->line_out_type != AUTO_PIN_HP_OUT)
5117 		spec->const_channel_count = max(spec->const_channel_count,
5118 						cfg->hp_outs * 2);
5119 	spec->multiout.max_channels = max(spec->ext_channel_count,
5120 					  spec->const_channel_count);
5121 
5122 	err = check_auto_mute_availability(codec);
5123 	if (err < 0)
5124 		return err;
5125 
5126 	err = check_dyn_adc_switch(codec);
5127 	if (err < 0)
5128 		return err;
5129 
5130 	err = check_auto_mic_availability(codec);
5131 	if (err < 0)
5132 		return err;
5133 
5134 	/* add stereo mix if available and not enabled yet */
5135 	if (!spec->auto_mic && spec->mixer_nid &&
5136 	    spec->add_stereo_mix_input == HDA_HINT_STEREO_MIX_AUTO &&
5137 	    spec->input_mux.num_items > 1) {
5138 		err = parse_capture_source(codec, spec->mixer_nid,
5139 					   CFG_IDX_MIX, spec->num_all_adcs,
5140 					   "Stereo Mix", 0);
5141 		if (err < 0)
5142 			return err;
5143 	}
5144 
5145 
5146 	err = create_capture_mixers(codec);
5147 	if (err < 0)
5148 		return err;
5149 
5150 	err = parse_mic_boost(codec);
5151 	if (err < 0)
5152 		return err;
5153 
5154 	/* create "Headphone Mic Jack Mode" if no input selection is
5155 	 * available (or user specifies add_jack_modes hint)
5156 	 */
5157 	if (spec->hp_mic_pin &&
5158 	    (spec->auto_mic || spec->input_mux.num_items == 1 ||
5159 	     spec->add_jack_modes)) {
5160 		err = create_hp_mic_jack_mode(codec, spec->hp_mic_pin);
5161 		if (err < 0)
5162 			return err;
5163 	}
5164 
5165 	if (spec->add_jack_modes) {
5166 		if (cfg->line_out_type != AUTO_PIN_SPEAKER_OUT) {
5167 			err = create_out_jack_modes(codec, cfg->line_outs,
5168 						    cfg->line_out_pins);
5169 			if (err < 0)
5170 				return err;
5171 		}
5172 		if (cfg->line_out_type != AUTO_PIN_HP_OUT) {
5173 			err = create_out_jack_modes(codec, cfg->hp_outs,
5174 						    cfg->hp_pins);
5175 			if (err < 0)
5176 				return err;
5177 		}
5178 	}
5179 
5180 	/* add power-up pin callbacks at last */
5181 	add_all_pin_power_ctls(codec, true);
5182 
5183 	/* mute all aamix input initially */
5184 	if (spec->mixer_nid)
5185 		mute_all_mixer_nid(codec, spec->mixer_nid);
5186 
5187  dig_only:
5188 	parse_digital(codec);
5189 
5190 	if (spec->power_down_unused || codec->power_save_node) {
5191 		if (!codec->power_filter)
5192 			codec->power_filter = snd_hda_gen_path_power_filter;
5193 		if (!codec->patch_ops.stream_pm)
5194 			codec->patch_ops.stream_pm = snd_hda_gen_stream_pm;
5195 	}
5196 
5197 	if (!spec->no_analog && spec->beep_nid) {
5198 		err = snd_hda_attach_beep_device(codec, spec->beep_nid);
5199 		if (err < 0)
5200 			return err;
5201 		if (codec->beep && codec->power_save_node) {
5202 			err = add_fake_beep_paths(codec);
5203 			if (err < 0)
5204 				return err;
5205 			codec->beep->power_hook = beep_power_hook;
5206 		}
5207 	}
5208 
5209 	return 1;
5210 }
5211 EXPORT_SYMBOL_GPL(snd_hda_gen_parse_auto_config);
5212 
5213 
5214 /*
5215  * Build control elements
5216  */
5217 
5218 /* follower controls for virtual master */
5219 static const char * const follower_pfxs[] = {
5220 	"Front", "Surround", "Center", "LFE", "Side",
5221 	"Headphone", "Speaker", "Mono", "Line Out",
5222 	"CLFE", "Bass Speaker", "PCM",
5223 	"Speaker Front", "Speaker Surround", "Speaker CLFE", "Speaker Side",
5224 	"Headphone Front", "Headphone Surround", "Headphone CLFE",
5225 	"Headphone Side", "Headphone+LO", "Speaker+LO",
5226 	NULL,
5227 };
5228 
5229 /**
5230  * snd_hda_gen_build_controls - Build controls from the parsed results
5231  * @codec: the HDA codec
5232  *
5233  * Pass this to build_controls patch_ops.
5234  */
snd_hda_gen_build_controls(struct hda_codec * codec)5235 int snd_hda_gen_build_controls(struct hda_codec *codec)
5236 {
5237 	struct hda_gen_spec *spec = codec->spec;
5238 	int err;
5239 
5240 	if (spec->kctls.used) {
5241 		err = snd_hda_add_new_ctls(codec, spec->kctls.list);
5242 		if (err < 0)
5243 			return err;
5244 	}
5245 
5246 	if (spec->multiout.dig_out_nid) {
5247 		err = snd_hda_create_dig_out_ctls(codec,
5248 						  spec->multiout.dig_out_nid,
5249 						  spec->multiout.dig_out_nid,
5250 						  spec->pcm_rec[1]->pcm_type);
5251 		if (err < 0)
5252 			return err;
5253 		if (!spec->no_analog) {
5254 			err = snd_hda_create_spdif_share_sw(codec,
5255 							    &spec->multiout);
5256 			if (err < 0)
5257 				return err;
5258 			spec->multiout.share_spdif = 1;
5259 		}
5260 	}
5261 	if (spec->dig_in_nid) {
5262 		err = snd_hda_create_spdif_in_ctls(codec, spec->dig_in_nid);
5263 		if (err < 0)
5264 			return err;
5265 	}
5266 
5267 	/* if we have no master control, let's create it */
5268 	if (!spec->no_analog && !spec->suppress_vmaster &&
5269 	    !snd_hda_find_mixer_ctl(codec, "Master Playback Volume")) {
5270 		err = snd_hda_add_vmaster(codec, "Master Playback Volume",
5271 					  spec->vmaster_tlv, follower_pfxs,
5272 					  "Playback Volume", 0);
5273 		if (err < 0)
5274 			return err;
5275 	}
5276 	if (!spec->no_analog && !spec->suppress_vmaster &&
5277 	    !snd_hda_find_mixer_ctl(codec, "Master Playback Switch")) {
5278 		err = __snd_hda_add_vmaster(codec, "Master Playback Switch",
5279 					    NULL, follower_pfxs,
5280 					    "Playback Switch", true,
5281 					    spec->vmaster_mute_led ?
5282 						SNDRV_CTL_ELEM_ACCESS_SPK_LED : 0,
5283 					    &spec->vmaster_mute.sw_kctl);
5284 		if (err < 0)
5285 			return err;
5286 		if (spec->vmaster_mute.hook) {
5287 			snd_hda_add_vmaster_hook(codec, &spec->vmaster_mute);
5288 			snd_hda_sync_vmaster_hook(&spec->vmaster_mute);
5289 		}
5290 	}
5291 
5292 	free_kctls(spec); /* no longer needed */
5293 
5294 	err = snd_hda_jack_add_kctls(codec, &spec->autocfg);
5295 	if (err < 0)
5296 		return err;
5297 
5298 	return 0;
5299 }
5300 EXPORT_SYMBOL_GPL(snd_hda_gen_build_controls);
5301 
5302 
5303 /*
5304  * PCM definitions
5305  */
5306 
call_pcm_playback_hook(struct hda_pcm_stream * hinfo,struct hda_codec * codec,struct snd_pcm_substream * substream,int action)5307 static void call_pcm_playback_hook(struct hda_pcm_stream *hinfo,
5308 				   struct hda_codec *codec,
5309 				   struct snd_pcm_substream *substream,
5310 				   int action)
5311 {
5312 	struct hda_gen_spec *spec = codec->spec;
5313 	if (spec->pcm_playback_hook)
5314 		spec->pcm_playback_hook(hinfo, codec, substream, action);
5315 }
5316 
call_pcm_capture_hook(struct hda_pcm_stream * hinfo,struct hda_codec * codec,struct snd_pcm_substream * substream,int action)5317 static void call_pcm_capture_hook(struct hda_pcm_stream *hinfo,
5318 				  struct hda_codec *codec,
5319 				  struct snd_pcm_substream *substream,
5320 				  int action)
5321 {
5322 	struct hda_gen_spec *spec = codec->spec;
5323 	if (spec->pcm_capture_hook)
5324 		spec->pcm_capture_hook(hinfo, codec, substream, action);
5325 }
5326 
5327 /*
5328  * Analog playback callbacks
5329  */
playback_pcm_open(struct hda_pcm_stream * hinfo,struct hda_codec * codec,struct snd_pcm_substream * substream)5330 static int playback_pcm_open(struct hda_pcm_stream *hinfo,
5331 			     struct hda_codec *codec,
5332 			     struct snd_pcm_substream *substream)
5333 {
5334 	struct hda_gen_spec *spec = codec->spec;
5335 	int err;
5336 
5337 	mutex_lock(&spec->pcm_mutex);
5338 	err = snd_hda_multi_out_analog_open(codec,
5339 					    &spec->multiout, substream,
5340 					     hinfo);
5341 	if (!err) {
5342 		spec->active_streams |= 1 << STREAM_MULTI_OUT;
5343 		call_pcm_playback_hook(hinfo, codec, substream,
5344 				       HDA_GEN_PCM_ACT_OPEN);
5345 	}
5346 	mutex_unlock(&spec->pcm_mutex);
5347 	return err;
5348 }
5349 
playback_pcm_prepare(struct hda_pcm_stream * hinfo,struct hda_codec * codec,unsigned int stream_tag,unsigned int format,struct snd_pcm_substream * substream)5350 static int playback_pcm_prepare(struct hda_pcm_stream *hinfo,
5351 				struct hda_codec *codec,
5352 				unsigned int stream_tag,
5353 				unsigned int format,
5354 				struct snd_pcm_substream *substream)
5355 {
5356 	struct hda_gen_spec *spec = codec->spec;
5357 	int err;
5358 
5359 	err = snd_hda_multi_out_analog_prepare(codec, &spec->multiout,
5360 					       stream_tag, format, substream);
5361 	if (!err)
5362 		call_pcm_playback_hook(hinfo, codec, substream,
5363 				       HDA_GEN_PCM_ACT_PREPARE);
5364 	return err;
5365 }
5366 
playback_pcm_cleanup(struct hda_pcm_stream * hinfo,struct hda_codec * codec,struct snd_pcm_substream * substream)5367 static int playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
5368 				struct hda_codec *codec,
5369 				struct snd_pcm_substream *substream)
5370 {
5371 	struct hda_gen_spec *spec = codec->spec;
5372 	int err;
5373 
5374 	err = snd_hda_multi_out_analog_cleanup(codec, &spec->multiout);
5375 	if (!err)
5376 		call_pcm_playback_hook(hinfo, codec, substream,
5377 				       HDA_GEN_PCM_ACT_CLEANUP);
5378 	return err;
5379 }
5380 
playback_pcm_close(struct hda_pcm_stream * hinfo,struct hda_codec * codec,struct snd_pcm_substream * substream)5381 static int playback_pcm_close(struct hda_pcm_stream *hinfo,
5382 			      struct hda_codec *codec,
5383 			      struct snd_pcm_substream *substream)
5384 {
5385 	struct hda_gen_spec *spec = codec->spec;
5386 	mutex_lock(&spec->pcm_mutex);
5387 	spec->active_streams &= ~(1 << STREAM_MULTI_OUT);
5388 	call_pcm_playback_hook(hinfo, codec, substream,
5389 			       HDA_GEN_PCM_ACT_CLOSE);
5390 	mutex_unlock(&spec->pcm_mutex);
5391 	return 0;
5392 }
5393 
capture_pcm_open(struct hda_pcm_stream * hinfo,struct hda_codec * codec,struct snd_pcm_substream * substream)5394 static int capture_pcm_open(struct hda_pcm_stream *hinfo,
5395 			    struct hda_codec *codec,
5396 			    struct snd_pcm_substream *substream)
5397 {
5398 	call_pcm_capture_hook(hinfo, codec, substream, HDA_GEN_PCM_ACT_OPEN);
5399 	return 0;
5400 }
5401 
capture_pcm_prepare(struct hda_pcm_stream * hinfo,struct hda_codec * codec,unsigned int stream_tag,unsigned int format,struct snd_pcm_substream * substream)5402 static int capture_pcm_prepare(struct hda_pcm_stream *hinfo,
5403 			       struct hda_codec *codec,
5404 			       unsigned int stream_tag,
5405 			       unsigned int format,
5406 			       struct snd_pcm_substream *substream)
5407 {
5408 	snd_hda_codec_setup_stream(codec, hinfo->nid, stream_tag, 0, format);
5409 	call_pcm_capture_hook(hinfo, codec, substream,
5410 			      HDA_GEN_PCM_ACT_PREPARE);
5411 	return 0;
5412 }
5413 
capture_pcm_cleanup(struct hda_pcm_stream * hinfo,struct hda_codec * codec,struct snd_pcm_substream * substream)5414 static int capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
5415 			       struct hda_codec *codec,
5416 			       struct snd_pcm_substream *substream)
5417 {
5418 	snd_hda_codec_cleanup_stream(codec, hinfo->nid);
5419 	call_pcm_capture_hook(hinfo, codec, substream,
5420 			      HDA_GEN_PCM_ACT_CLEANUP);
5421 	return 0;
5422 }
5423 
capture_pcm_close(struct hda_pcm_stream * hinfo,struct hda_codec * codec,struct snd_pcm_substream * substream)5424 static int capture_pcm_close(struct hda_pcm_stream *hinfo,
5425 			     struct hda_codec *codec,
5426 			     struct snd_pcm_substream *substream)
5427 {
5428 	call_pcm_capture_hook(hinfo, codec, substream, HDA_GEN_PCM_ACT_CLOSE);
5429 	return 0;
5430 }
5431 
alt_playback_pcm_open(struct hda_pcm_stream * hinfo,struct hda_codec * codec,struct snd_pcm_substream * substream)5432 static int alt_playback_pcm_open(struct hda_pcm_stream *hinfo,
5433 				 struct hda_codec *codec,
5434 				 struct snd_pcm_substream *substream)
5435 {
5436 	struct hda_gen_spec *spec = codec->spec;
5437 	int err = 0;
5438 
5439 	mutex_lock(&spec->pcm_mutex);
5440 	if (spec->indep_hp && !spec->indep_hp_enabled)
5441 		err = -EBUSY;
5442 	else
5443 		spec->active_streams |= 1 << STREAM_INDEP_HP;
5444 	call_pcm_playback_hook(hinfo, codec, substream,
5445 			       HDA_GEN_PCM_ACT_OPEN);
5446 	mutex_unlock(&spec->pcm_mutex);
5447 	return err;
5448 }
5449 
alt_playback_pcm_close(struct hda_pcm_stream * hinfo,struct hda_codec * codec,struct snd_pcm_substream * substream)5450 static int alt_playback_pcm_close(struct hda_pcm_stream *hinfo,
5451 				  struct hda_codec *codec,
5452 				  struct snd_pcm_substream *substream)
5453 {
5454 	struct hda_gen_spec *spec = codec->spec;
5455 	mutex_lock(&spec->pcm_mutex);
5456 	spec->active_streams &= ~(1 << STREAM_INDEP_HP);
5457 	call_pcm_playback_hook(hinfo, codec, substream,
5458 			       HDA_GEN_PCM_ACT_CLOSE);
5459 	mutex_unlock(&spec->pcm_mutex);
5460 	return 0;
5461 }
5462 
alt_playback_pcm_prepare(struct hda_pcm_stream * hinfo,struct hda_codec * codec,unsigned int stream_tag,unsigned int format,struct snd_pcm_substream * substream)5463 static int alt_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
5464 				    struct hda_codec *codec,
5465 				    unsigned int stream_tag,
5466 				    unsigned int format,
5467 				    struct snd_pcm_substream *substream)
5468 {
5469 	snd_hda_codec_setup_stream(codec, hinfo->nid, stream_tag, 0, format);
5470 	call_pcm_playback_hook(hinfo, codec, substream,
5471 			       HDA_GEN_PCM_ACT_PREPARE);
5472 	return 0;
5473 }
5474 
alt_playback_pcm_cleanup(struct hda_pcm_stream * hinfo,struct hda_codec * codec,struct snd_pcm_substream * substream)5475 static int alt_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
5476 				    struct hda_codec *codec,
5477 				    struct snd_pcm_substream *substream)
5478 {
5479 	snd_hda_codec_cleanup_stream(codec, hinfo->nid);
5480 	call_pcm_playback_hook(hinfo, codec, substream,
5481 			       HDA_GEN_PCM_ACT_CLEANUP);
5482 	return 0;
5483 }
5484 
5485 /*
5486  * Digital out
5487  */
dig_playback_pcm_open(struct hda_pcm_stream * hinfo,struct hda_codec * codec,struct snd_pcm_substream * substream)5488 static int dig_playback_pcm_open(struct hda_pcm_stream *hinfo,
5489 				 struct hda_codec *codec,
5490 				 struct snd_pcm_substream *substream)
5491 {
5492 	struct hda_gen_spec *spec = codec->spec;
5493 	return snd_hda_multi_out_dig_open(codec, &spec->multiout);
5494 }
5495 
dig_playback_pcm_prepare(struct hda_pcm_stream * hinfo,struct hda_codec * codec,unsigned int stream_tag,unsigned int format,struct snd_pcm_substream * substream)5496 static int dig_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
5497 				    struct hda_codec *codec,
5498 				    unsigned int stream_tag,
5499 				    unsigned int format,
5500 				    struct snd_pcm_substream *substream)
5501 {
5502 	struct hda_gen_spec *spec = codec->spec;
5503 	return snd_hda_multi_out_dig_prepare(codec, &spec->multiout,
5504 					     stream_tag, format, substream);
5505 }
5506 
dig_playback_pcm_cleanup(struct hda_pcm_stream * hinfo,struct hda_codec * codec,struct snd_pcm_substream * substream)5507 static int dig_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
5508 				    struct hda_codec *codec,
5509 				    struct snd_pcm_substream *substream)
5510 {
5511 	struct hda_gen_spec *spec = codec->spec;
5512 	return snd_hda_multi_out_dig_cleanup(codec, &spec->multiout);
5513 }
5514 
dig_playback_pcm_close(struct hda_pcm_stream * hinfo,struct hda_codec * codec,struct snd_pcm_substream * substream)5515 static int dig_playback_pcm_close(struct hda_pcm_stream *hinfo,
5516 				  struct hda_codec *codec,
5517 				  struct snd_pcm_substream *substream)
5518 {
5519 	struct hda_gen_spec *spec = codec->spec;
5520 	return snd_hda_multi_out_dig_close(codec, &spec->multiout);
5521 }
5522 
5523 /*
5524  * Analog capture
5525  */
5526 #define alt_capture_pcm_open	capture_pcm_open
5527 #define alt_capture_pcm_close	capture_pcm_close
5528 
alt_capture_pcm_prepare(struct hda_pcm_stream * hinfo,struct hda_codec * codec,unsigned int stream_tag,unsigned int format,struct snd_pcm_substream * substream)5529 static int alt_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
5530 				   struct hda_codec *codec,
5531 				   unsigned int stream_tag,
5532 				   unsigned int format,
5533 				   struct snd_pcm_substream *substream)
5534 {
5535 	struct hda_gen_spec *spec = codec->spec;
5536 
5537 	snd_hda_codec_setup_stream(codec, spec->adc_nids[substream->number + 1],
5538 				   stream_tag, 0, format);
5539 	call_pcm_capture_hook(hinfo, codec, substream,
5540 			      HDA_GEN_PCM_ACT_PREPARE);
5541 	return 0;
5542 }
5543 
alt_capture_pcm_cleanup(struct hda_pcm_stream * hinfo,struct hda_codec * codec,struct snd_pcm_substream * substream)5544 static int alt_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
5545 				   struct hda_codec *codec,
5546 				   struct snd_pcm_substream *substream)
5547 {
5548 	struct hda_gen_spec *spec = codec->spec;
5549 
5550 	snd_hda_codec_cleanup_stream(codec,
5551 				     spec->adc_nids[substream->number + 1]);
5552 	call_pcm_capture_hook(hinfo, codec, substream,
5553 			      HDA_GEN_PCM_ACT_CLEANUP);
5554 	return 0;
5555 }
5556 
5557 /*
5558  */
5559 static const struct hda_pcm_stream pcm_analog_playback = {
5560 	.substreams = 1,
5561 	.channels_min = 2,
5562 	.channels_max = 8,
5563 	/* NID is set in build_pcms */
5564 	.ops = {
5565 		.open = playback_pcm_open,
5566 		.close = playback_pcm_close,
5567 		.prepare = playback_pcm_prepare,
5568 		.cleanup = playback_pcm_cleanup
5569 	},
5570 };
5571 
5572 static const struct hda_pcm_stream pcm_analog_capture = {
5573 	.substreams = 1,
5574 	.channels_min = 2,
5575 	.channels_max = 2,
5576 	/* NID is set in build_pcms */
5577 	.ops = {
5578 		.open = capture_pcm_open,
5579 		.close = capture_pcm_close,
5580 		.prepare = capture_pcm_prepare,
5581 		.cleanup = capture_pcm_cleanup
5582 	},
5583 };
5584 
5585 static const struct hda_pcm_stream pcm_analog_alt_playback = {
5586 	.substreams = 1,
5587 	.channels_min = 2,
5588 	.channels_max = 2,
5589 	/* NID is set in build_pcms */
5590 	.ops = {
5591 		.open = alt_playback_pcm_open,
5592 		.close = alt_playback_pcm_close,
5593 		.prepare = alt_playback_pcm_prepare,
5594 		.cleanup = alt_playback_pcm_cleanup
5595 	},
5596 };
5597 
5598 static const struct hda_pcm_stream pcm_analog_alt_capture = {
5599 	.substreams = 2, /* can be overridden */
5600 	.channels_min = 2,
5601 	.channels_max = 2,
5602 	/* NID is set in build_pcms */
5603 	.ops = {
5604 		.open = alt_capture_pcm_open,
5605 		.close = alt_capture_pcm_close,
5606 		.prepare = alt_capture_pcm_prepare,
5607 		.cleanup = alt_capture_pcm_cleanup
5608 	},
5609 };
5610 
5611 static const struct hda_pcm_stream pcm_digital_playback = {
5612 	.substreams = 1,
5613 	.channels_min = 2,
5614 	.channels_max = 2,
5615 	/* NID is set in build_pcms */
5616 	.ops = {
5617 		.open = dig_playback_pcm_open,
5618 		.close = dig_playback_pcm_close,
5619 		.prepare = dig_playback_pcm_prepare,
5620 		.cleanup = dig_playback_pcm_cleanup
5621 	},
5622 };
5623 
5624 static const struct hda_pcm_stream pcm_digital_capture = {
5625 	.substreams = 1,
5626 	.channels_min = 2,
5627 	.channels_max = 2,
5628 	/* NID is set in build_pcms */
5629 };
5630 
5631 /* Used by build_pcms to flag that a PCM has no playback stream */
5632 static const struct hda_pcm_stream pcm_null_stream = {
5633 	.substreams = 0,
5634 	.channels_min = 0,
5635 	.channels_max = 0,
5636 };
5637 
5638 /*
5639  * dynamic changing ADC PCM streams
5640  */
dyn_adc_pcm_resetup(struct hda_codec * codec,int cur)5641 static bool dyn_adc_pcm_resetup(struct hda_codec *codec, int cur)
5642 {
5643 	struct hda_gen_spec *spec = codec->spec;
5644 	hda_nid_t new_adc = spec->adc_nids[spec->dyn_adc_idx[cur]];
5645 
5646 	if (spec->cur_adc && spec->cur_adc != new_adc) {
5647 		/* stream is running, let's swap the current ADC */
5648 		__snd_hda_codec_cleanup_stream(codec, spec->cur_adc, 1);
5649 		spec->cur_adc = new_adc;
5650 		snd_hda_codec_setup_stream(codec, new_adc,
5651 					   spec->cur_adc_stream_tag, 0,
5652 					   spec->cur_adc_format);
5653 		return true;
5654 	}
5655 	return false;
5656 }
5657 
5658 /* analog capture with dynamic dual-adc changes */
dyn_adc_capture_pcm_prepare(struct hda_pcm_stream * hinfo,struct hda_codec * codec,unsigned int stream_tag,unsigned int format,struct snd_pcm_substream * substream)5659 static int dyn_adc_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
5660 				       struct hda_codec *codec,
5661 				       unsigned int stream_tag,
5662 				       unsigned int format,
5663 				       struct snd_pcm_substream *substream)
5664 {
5665 	struct hda_gen_spec *spec = codec->spec;
5666 	spec->cur_adc = spec->adc_nids[spec->dyn_adc_idx[spec->cur_mux[0]]];
5667 	spec->cur_adc_stream_tag = stream_tag;
5668 	spec->cur_adc_format = format;
5669 	snd_hda_codec_setup_stream(codec, spec->cur_adc, stream_tag, 0, format);
5670 	call_pcm_capture_hook(hinfo, codec, substream, HDA_GEN_PCM_ACT_PREPARE);
5671 	return 0;
5672 }
5673 
dyn_adc_capture_pcm_cleanup(struct hda_pcm_stream * hinfo,struct hda_codec * codec,struct snd_pcm_substream * substream)5674 static int dyn_adc_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
5675 				       struct hda_codec *codec,
5676 				       struct snd_pcm_substream *substream)
5677 {
5678 	struct hda_gen_spec *spec = codec->spec;
5679 	snd_hda_codec_cleanup_stream(codec, spec->cur_adc);
5680 	spec->cur_adc = 0;
5681 	call_pcm_capture_hook(hinfo, codec, substream, HDA_GEN_PCM_ACT_CLEANUP);
5682 	return 0;
5683 }
5684 
5685 static const struct hda_pcm_stream dyn_adc_pcm_analog_capture = {
5686 	.substreams = 1,
5687 	.channels_min = 2,
5688 	.channels_max = 2,
5689 	.nid = 0, /* fill later */
5690 	.ops = {
5691 		.prepare = dyn_adc_capture_pcm_prepare,
5692 		.cleanup = dyn_adc_capture_pcm_cleanup
5693 	},
5694 };
5695 
fill_pcm_stream_name(char * str,size_t len,const char * sfx,const char * chip_name)5696 static void fill_pcm_stream_name(char *str, size_t len, const char *sfx,
5697 				 const char *chip_name)
5698 {
5699 	char *p;
5700 
5701 	if (*str)
5702 		return;
5703 	strscpy(str, chip_name, len);
5704 
5705 	/* drop non-alnum chars after a space */
5706 	for (p = strchr(str, ' '); p; p = strchr(p + 1, ' ')) {
5707 		if (!isalnum(p[1])) {
5708 			*p = 0;
5709 			break;
5710 		}
5711 	}
5712 	strlcat(str, sfx, len);
5713 }
5714 
5715 /* copy PCM stream info from @default_str, and override non-NULL entries
5716  * from @spec_str and @nid
5717  */
setup_pcm_stream(struct hda_pcm_stream * str,const struct hda_pcm_stream * default_str,const struct hda_pcm_stream * spec_str,hda_nid_t nid)5718 static void setup_pcm_stream(struct hda_pcm_stream *str,
5719 			     const struct hda_pcm_stream *default_str,
5720 			     const struct hda_pcm_stream *spec_str,
5721 			     hda_nid_t nid)
5722 {
5723 	*str = *default_str;
5724 	if (nid)
5725 		str->nid = nid;
5726 	if (spec_str) {
5727 		if (spec_str->substreams)
5728 			str->substreams = spec_str->substreams;
5729 		if (spec_str->channels_min)
5730 			str->channels_min = spec_str->channels_min;
5731 		if (spec_str->channels_max)
5732 			str->channels_max = spec_str->channels_max;
5733 		if (spec_str->rates)
5734 			str->rates = spec_str->rates;
5735 		if (spec_str->formats)
5736 			str->formats = spec_str->formats;
5737 		if (spec_str->maxbps)
5738 			str->maxbps = spec_str->maxbps;
5739 	}
5740 }
5741 
5742 /**
5743  * snd_hda_gen_build_pcms - build PCM streams based on the parsed results
5744  * @codec: the HDA codec
5745  *
5746  * Pass this to build_pcms patch_ops.
5747  */
snd_hda_gen_build_pcms(struct hda_codec * codec)5748 int snd_hda_gen_build_pcms(struct hda_codec *codec)
5749 {
5750 	struct hda_gen_spec *spec = codec->spec;
5751 	struct hda_pcm *info;
5752 	bool have_multi_adcs;
5753 
5754 	if (spec->no_analog)
5755 		goto skip_analog;
5756 
5757 	fill_pcm_stream_name(spec->stream_name_analog,
5758 			     sizeof(spec->stream_name_analog),
5759 			     " Analog", codec->core.chip_name);
5760 	info = snd_hda_codec_pcm_new(codec, "%s", spec->stream_name_analog);
5761 	if (!info)
5762 		return -ENOMEM;
5763 	spec->pcm_rec[0] = info;
5764 
5765 	if (spec->multiout.num_dacs > 0) {
5766 		setup_pcm_stream(&info->stream[SNDRV_PCM_STREAM_PLAYBACK],
5767 				 &pcm_analog_playback,
5768 				 spec->stream_analog_playback,
5769 				 spec->multiout.dac_nids[0]);
5770 		info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max =
5771 			spec->multiout.max_channels;
5772 		if (spec->autocfg.line_out_type == AUTO_PIN_SPEAKER_OUT &&
5773 		    spec->autocfg.line_outs == 2)
5774 			info->stream[SNDRV_PCM_STREAM_PLAYBACK].chmap =
5775 				snd_pcm_2_1_chmaps;
5776 	}
5777 	if (spec->num_adc_nids) {
5778 		setup_pcm_stream(&info->stream[SNDRV_PCM_STREAM_CAPTURE],
5779 				 (spec->dyn_adc_switch ?
5780 				  &dyn_adc_pcm_analog_capture : &pcm_analog_capture),
5781 				 spec->stream_analog_capture,
5782 				 spec->adc_nids[0]);
5783 	}
5784 
5785  skip_analog:
5786 	/* SPDIF for stream index #1 */
5787 	if (spec->multiout.dig_out_nid || spec->dig_in_nid) {
5788 		fill_pcm_stream_name(spec->stream_name_digital,
5789 				     sizeof(spec->stream_name_digital),
5790 				     " Digital", codec->core.chip_name);
5791 		info = snd_hda_codec_pcm_new(codec, "%s",
5792 					     spec->stream_name_digital);
5793 		if (!info)
5794 			return -ENOMEM;
5795 		codec->follower_dig_outs = spec->multiout.follower_dig_outs;
5796 		spec->pcm_rec[1] = info;
5797 		if (spec->dig_out_type)
5798 			info->pcm_type = spec->dig_out_type;
5799 		else
5800 			info->pcm_type = HDA_PCM_TYPE_SPDIF;
5801 		if (spec->multiout.dig_out_nid)
5802 			setup_pcm_stream(&info->stream[SNDRV_PCM_STREAM_PLAYBACK],
5803 					 &pcm_digital_playback,
5804 					 spec->stream_digital_playback,
5805 					 spec->multiout.dig_out_nid);
5806 		if (spec->dig_in_nid)
5807 			setup_pcm_stream(&info->stream[SNDRV_PCM_STREAM_CAPTURE],
5808 					 &pcm_digital_capture,
5809 					 spec->stream_digital_capture,
5810 					 spec->dig_in_nid);
5811 	}
5812 
5813 	if (spec->no_analog)
5814 		return 0;
5815 
5816 	/* If the use of more than one ADC is requested for the current
5817 	 * model, configure a second analog capture-only PCM.
5818 	 */
5819 	have_multi_adcs = (spec->num_adc_nids > 1) &&
5820 		!spec->dyn_adc_switch && !spec->auto_mic;
5821 	/* Additional Analaog capture for index #2 */
5822 	if (spec->alt_dac_nid || have_multi_adcs) {
5823 		fill_pcm_stream_name(spec->stream_name_alt_analog,
5824 				     sizeof(spec->stream_name_alt_analog),
5825 			     " Alt Analog", codec->core.chip_name);
5826 		info = snd_hda_codec_pcm_new(codec, "%s",
5827 					     spec->stream_name_alt_analog);
5828 		if (!info)
5829 			return -ENOMEM;
5830 		spec->pcm_rec[2] = info;
5831 		if (spec->alt_dac_nid)
5832 			setup_pcm_stream(&info->stream[SNDRV_PCM_STREAM_PLAYBACK],
5833 					 &pcm_analog_alt_playback,
5834 					 spec->stream_analog_alt_playback,
5835 					 spec->alt_dac_nid);
5836 		else
5837 			setup_pcm_stream(&info->stream[SNDRV_PCM_STREAM_PLAYBACK],
5838 					 &pcm_null_stream, NULL, 0);
5839 		if (have_multi_adcs) {
5840 			setup_pcm_stream(&info->stream[SNDRV_PCM_STREAM_CAPTURE],
5841 					 &pcm_analog_alt_capture,
5842 					 spec->stream_analog_alt_capture,
5843 					 spec->adc_nids[1]);
5844 			info->stream[SNDRV_PCM_STREAM_CAPTURE].substreams =
5845 				spec->num_adc_nids - 1;
5846 		} else {
5847 			setup_pcm_stream(&info->stream[SNDRV_PCM_STREAM_CAPTURE],
5848 					 &pcm_null_stream, NULL, 0);
5849 		}
5850 	}
5851 
5852 	return 0;
5853 }
5854 EXPORT_SYMBOL_GPL(snd_hda_gen_build_pcms);
5855 
5856 
5857 /*
5858  * Standard auto-parser initializations
5859  */
5860 
5861 /* configure the given path as a proper output */
set_output_and_unmute(struct hda_codec * codec,int path_idx)5862 static void set_output_and_unmute(struct hda_codec *codec, int path_idx)
5863 {
5864 	struct nid_path *path;
5865 	hda_nid_t pin;
5866 
5867 	path = snd_hda_get_path_from_idx(codec, path_idx);
5868 	if (!path || !path->depth)
5869 		return;
5870 	pin = path->path[path->depth - 1];
5871 	restore_pin_ctl(codec, pin);
5872 	snd_hda_activate_path(codec, path, path->active,
5873 			      aamix_default(codec->spec));
5874 	set_pin_eapd(codec, pin, path->active);
5875 }
5876 
5877 /* initialize primary output paths */
init_multi_out(struct hda_codec * codec)5878 static void init_multi_out(struct hda_codec *codec)
5879 {
5880 	struct hda_gen_spec *spec = codec->spec;
5881 	int i;
5882 
5883 	for (i = 0; i < spec->autocfg.line_outs; i++)
5884 		set_output_and_unmute(codec, spec->out_paths[i]);
5885 }
5886 
5887 
__init_extra_out(struct hda_codec * codec,int num_outs,int * paths)5888 static void __init_extra_out(struct hda_codec *codec, int num_outs, int *paths)
5889 {
5890 	int i;
5891 
5892 	for (i = 0; i < num_outs; i++)
5893 		set_output_and_unmute(codec, paths[i]);
5894 }
5895 
5896 /* initialize hp and speaker paths */
init_extra_out(struct hda_codec * codec)5897 static void init_extra_out(struct hda_codec *codec)
5898 {
5899 	struct hda_gen_spec *spec = codec->spec;
5900 
5901 	if (spec->autocfg.line_out_type != AUTO_PIN_HP_OUT)
5902 		__init_extra_out(codec, spec->autocfg.hp_outs, spec->hp_paths);
5903 	if (spec->autocfg.line_out_type != AUTO_PIN_SPEAKER_OUT)
5904 		__init_extra_out(codec, spec->autocfg.speaker_outs,
5905 				 spec->speaker_paths);
5906 }
5907 
5908 /* initialize multi-io paths */
init_multi_io(struct hda_codec * codec)5909 static void init_multi_io(struct hda_codec *codec)
5910 {
5911 	struct hda_gen_spec *spec = codec->spec;
5912 	int i;
5913 
5914 	for (i = 0; i < spec->multi_ios; i++) {
5915 		hda_nid_t pin = spec->multi_io[i].pin;
5916 		struct nid_path *path;
5917 		path = get_multiio_path(codec, i);
5918 		if (!path)
5919 			continue;
5920 		if (!spec->multi_io[i].ctl_in)
5921 			spec->multi_io[i].ctl_in =
5922 				snd_hda_codec_get_pin_target(codec, pin);
5923 		snd_hda_activate_path(codec, path, path->active,
5924 				      aamix_default(spec));
5925 	}
5926 }
5927 
init_aamix_paths(struct hda_codec * codec)5928 static void init_aamix_paths(struct hda_codec *codec)
5929 {
5930 	struct hda_gen_spec *spec = codec->spec;
5931 
5932 	if (!spec->have_aamix_ctl)
5933 		return;
5934 	if (!has_aamix_out_paths(spec))
5935 		return;
5936 	update_aamix_paths(codec, spec->aamix_mode, spec->out_paths[0],
5937 			   spec->aamix_out_paths[0],
5938 			   spec->autocfg.line_out_type);
5939 	update_aamix_paths(codec, spec->aamix_mode, spec->hp_paths[0],
5940 			   spec->aamix_out_paths[1],
5941 			   AUTO_PIN_HP_OUT);
5942 	update_aamix_paths(codec, spec->aamix_mode, spec->speaker_paths[0],
5943 			   spec->aamix_out_paths[2],
5944 			   AUTO_PIN_SPEAKER_OUT);
5945 }
5946 
5947 /* set up input pins and loopback paths */
init_analog_input(struct hda_codec * codec)5948 static void init_analog_input(struct hda_codec *codec)
5949 {
5950 	struct hda_gen_spec *spec = codec->spec;
5951 	struct auto_pin_cfg *cfg = &spec->autocfg;
5952 	int i;
5953 
5954 	for (i = 0; i < cfg->num_inputs; i++) {
5955 		hda_nid_t nid = cfg->inputs[i].pin;
5956 		if (is_input_pin(codec, nid))
5957 			restore_pin_ctl(codec, nid);
5958 
5959 		/* init loopback inputs */
5960 		if (spec->mixer_nid) {
5961 			resume_path_from_idx(codec, spec->loopback_paths[i]);
5962 			resume_path_from_idx(codec, spec->loopback_merge_path);
5963 		}
5964 	}
5965 }
5966 
5967 /* initialize ADC paths */
init_input_src(struct hda_codec * codec)5968 static void init_input_src(struct hda_codec *codec)
5969 {
5970 	struct hda_gen_spec *spec = codec->spec;
5971 	struct hda_input_mux *imux = &spec->input_mux;
5972 	struct nid_path *path;
5973 	int i, c, nums;
5974 
5975 	if (spec->dyn_adc_switch)
5976 		nums = 1;
5977 	else
5978 		nums = spec->num_adc_nids;
5979 
5980 	for (c = 0; c < nums; c++) {
5981 		for (i = 0; i < imux->num_items; i++) {
5982 			path = get_input_path(codec, c, i);
5983 			if (path) {
5984 				bool active = path->active;
5985 				if (i == spec->cur_mux[c])
5986 					active = true;
5987 				snd_hda_activate_path(codec, path, active, false);
5988 			}
5989 		}
5990 		if (spec->hp_mic)
5991 			update_hp_mic(codec, c, true);
5992 	}
5993 
5994 	if (spec->cap_sync_hook)
5995 		spec->cap_sync_hook(codec, NULL, NULL);
5996 }
5997 
5998 /* set right pin controls for digital I/O */
init_digital(struct hda_codec * codec)5999 static void init_digital(struct hda_codec *codec)
6000 {
6001 	struct hda_gen_spec *spec = codec->spec;
6002 	int i;
6003 	hda_nid_t pin;
6004 
6005 	for (i = 0; i < spec->autocfg.dig_outs; i++)
6006 		set_output_and_unmute(codec, spec->digout_paths[i]);
6007 	pin = spec->autocfg.dig_in_pin;
6008 	if (pin) {
6009 		restore_pin_ctl(codec, pin);
6010 		resume_path_from_idx(codec, spec->digin_path);
6011 	}
6012 }
6013 
6014 /* clear unsol-event tags on unused pins; Conexant codecs seem to leave
6015  * invalid unsol tags by some reason
6016  */
clear_unsol_on_unused_pins(struct hda_codec * codec)6017 static void clear_unsol_on_unused_pins(struct hda_codec *codec)
6018 {
6019 	const struct hda_pincfg *pin;
6020 	int i;
6021 
6022 	snd_array_for_each(&codec->init_pins, i, pin) {
6023 		hda_nid_t nid = pin->nid;
6024 		if (is_jack_detectable(codec, nid) &&
6025 		    !snd_hda_jack_tbl_get(codec, nid))
6026 			snd_hda_codec_write_cache(codec, nid, 0,
6027 					AC_VERB_SET_UNSOLICITED_ENABLE, 0);
6028 	}
6029 }
6030 
6031 /**
6032  * snd_hda_gen_init - initialize the generic spec
6033  * @codec: the HDA codec
6034  *
6035  * This can be put as patch_ops init function.
6036  */
snd_hda_gen_init(struct hda_codec * codec)6037 int snd_hda_gen_init(struct hda_codec *codec)
6038 {
6039 	struct hda_gen_spec *spec = codec->spec;
6040 
6041 	if (spec->init_hook)
6042 		spec->init_hook(codec);
6043 
6044 	if (!spec->skip_verbs)
6045 		snd_hda_apply_verbs(codec);
6046 
6047 	init_multi_out(codec);
6048 	init_extra_out(codec);
6049 	init_multi_io(codec);
6050 	init_aamix_paths(codec);
6051 	init_analog_input(codec);
6052 	init_input_src(codec);
6053 	init_digital(codec);
6054 
6055 	clear_unsol_on_unused_pins(codec);
6056 
6057 	sync_all_pin_power_ctls(codec);
6058 
6059 	/* call init functions of standard auto-mute helpers */
6060 	update_automute_all(codec);
6061 
6062 	snd_hda_regmap_sync(codec);
6063 
6064 	if (spec->vmaster_mute.sw_kctl && spec->vmaster_mute.hook)
6065 		snd_hda_sync_vmaster_hook(&spec->vmaster_mute);
6066 
6067 	hda_call_check_power_status(codec, 0x01);
6068 	return 0;
6069 }
6070 EXPORT_SYMBOL_GPL(snd_hda_gen_init);
6071 
6072 /**
6073  * snd_hda_gen_free - free the generic spec
6074  * @codec: the HDA codec
6075  *
6076  * This can be put as patch_ops free function.
6077  */
snd_hda_gen_free(struct hda_codec * codec)6078 void snd_hda_gen_free(struct hda_codec *codec)
6079 {
6080 	snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_FREE);
6081 	snd_hda_gen_spec_free(codec->spec);
6082 	kfree(codec->spec);
6083 	codec->spec = NULL;
6084 }
6085 EXPORT_SYMBOL_GPL(snd_hda_gen_free);
6086 
6087 /**
6088  * snd_hda_gen_check_power_status - check the loopback power save state
6089  * @codec: the HDA codec
6090  * @nid: NID to inspect
6091  *
6092  * This can be put as patch_ops check_power_status function.
6093  */
snd_hda_gen_check_power_status(struct hda_codec * codec,hda_nid_t nid)6094 int snd_hda_gen_check_power_status(struct hda_codec *codec, hda_nid_t nid)
6095 {
6096 	struct hda_gen_spec *spec = codec->spec;
6097 	return snd_hda_check_amp_list_power(codec, &spec->loopback, nid);
6098 }
6099 EXPORT_SYMBOL_GPL(snd_hda_gen_check_power_status);
6100 
6101 
6102 /*
6103  * the generic codec support
6104  */
6105 
6106 static const struct hda_codec_ops generic_patch_ops = {
6107 	.build_controls = snd_hda_gen_build_controls,
6108 	.build_pcms = snd_hda_gen_build_pcms,
6109 	.init = snd_hda_gen_init,
6110 	.free = snd_hda_gen_free,
6111 	.unsol_event = snd_hda_jack_unsol_event,
6112 	.check_power_status = snd_hda_gen_check_power_status,
6113 };
6114 
6115 /*
6116  * snd_hda_parse_generic_codec - Generic codec parser
6117  * @codec: the HDA codec
6118  */
snd_hda_parse_generic_codec(struct hda_codec * codec)6119 static int snd_hda_parse_generic_codec(struct hda_codec *codec)
6120 {
6121 	struct hda_gen_spec *spec;
6122 	int err;
6123 
6124 	spec = kzalloc(sizeof(*spec), GFP_KERNEL);
6125 	if (!spec)
6126 		return -ENOMEM;
6127 	snd_hda_gen_spec_init(spec);
6128 	codec->spec = spec;
6129 
6130 	err = snd_hda_parse_pin_defcfg(codec, &spec->autocfg, NULL, 0);
6131 	if (err < 0)
6132 		goto error;
6133 
6134 	err = snd_hda_gen_parse_auto_config(codec, &spec->autocfg);
6135 	if (err < 0)
6136 		goto error;
6137 
6138 	codec->patch_ops = generic_patch_ops;
6139 	return 0;
6140 
6141 error:
6142 	snd_hda_gen_free(codec);
6143 	return err;
6144 }
6145 
6146 static const struct hda_device_id snd_hda_id_generic[] = {
6147 	HDA_CODEC_ENTRY(HDA_CODEC_ID_GENERIC, "Generic", snd_hda_parse_generic_codec),
6148 	{} /* terminator */
6149 };
6150 MODULE_DEVICE_TABLE(hdaudio, snd_hda_id_generic);
6151 
6152 static struct hda_codec_driver generic_driver = {
6153 	.id = snd_hda_id_generic,
6154 };
6155 
6156 module_hda_codec_driver(generic_driver);
6157 
6158 MODULE_LICENSE("GPL");
6159 MODULE_DESCRIPTION("Generic HD-audio codec parser");
6160