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->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->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->brightness = ledtrig_audio_get(idx);
3950 cdev->flags = LED_CORE_SUSPENDRESUME;
3951
3952 err = led_classdev_register(&codec->core.dev, cdev);
3953 if (err < 0)
3954 return err;
3955 spec->led_cdevs[idx] = cdev;
3956 return 0;
3957 }
3958
3959 /**
3960 * snd_hda_gen_add_mute_led_cdev - Create a LED classdev and enable as vmaster mute LED
3961 * @codec: the HDA codec
3962 * @callback: the callback for LED classdev brightness_set_blocking
3963 */
snd_hda_gen_add_mute_led_cdev(struct hda_codec * codec,int (* callback)(struct led_classdev *,enum led_brightness))3964 int snd_hda_gen_add_mute_led_cdev(struct hda_codec *codec,
3965 int (*callback)(struct led_classdev *,
3966 enum led_brightness))
3967 {
3968 struct hda_gen_spec *spec = codec->spec;
3969 int err;
3970
3971 if (callback) {
3972 err = create_mute_led_cdev(codec, callback, false);
3973 if (err) {
3974 codec_warn(codec, "failed to create a mute LED cdev\n");
3975 return err;
3976 }
3977 }
3978
3979 if (spec->vmaster_mute.hook)
3980 codec_err(codec, "vmaster hook already present before cdev!\n");
3981
3982 spec->vmaster_mute_led = 1;
3983 return 0;
3984 }
3985 EXPORT_SYMBOL_GPL(snd_hda_gen_add_mute_led_cdev);
3986
3987 /**
3988 * snd_hda_gen_add_micmute_led_cdev - Create a LED classdev and enable as mic-mute LED
3989 * @codec: the HDA codec
3990 * @callback: the callback for LED classdev brightness_set_blocking
3991 *
3992 * Called from the codec drivers for offering the mic mute LED controls.
3993 * This creates a LED classdev and sets up the cap_sync_hook that is called at
3994 * each time when the capture mixer switch changes.
3995 *
3996 * When NULL is passed to @callback, no classdev is created but only the
3997 * LED-trigger is set up.
3998 *
3999 * Returns 0 or a negative error.
4000 */
snd_hda_gen_add_micmute_led_cdev(struct hda_codec * codec,int (* callback)(struct led_classdev *,enum led_brightness))4001 int snd_hda_gen_add_micmute_led_cdev(struct hda_codec *codec,
4002 int (*callback)(struct led_classdev *,
4003 enum led_brightness))
4004 {
4005 struct hda_gen_spec *spec = codec->spec;
4006 int err;
4007
4008 if (callback) {
4009 err = create_mute_led_cdev(codec, callback, true);
4010 if (err) {
4011 codec_warn(codec, "failed to create a mic-mute LED cdev\n");
4012 return err;
4013 }
4014 }
4015
4016 spec->mic_mute_led = 1;
4017 return 0;
4018 }
4019 EXPORT_SYMBOL_GPL(snd_hda_gen_add_micmute_led_cdev);
4020 #endif /* CONFIG_SND_HDA_GENERIC_LEDS */
4021
4022 /*
4023 * parse digital I/Os and set up NIDs in BIOS auto-parse mode
4024 */
parse_digital(struct hda_codec * codec)4025 static void parse_digital(struct hda_codec *codec)
4026 {
4027 struct hda_gen_spec *spec = codec->spec;
4028 struct nid_path *path;
4029 int i, nums;
4030 hda_nid_t dig_nid, pin;
4031
4032 /* support multiple SPDIFs; the secondary is set up as a follower */
4033 nums = 0;
4034 for (i = 0; i < spec->autocfg.dig_outs; i++) {
4035 pin = spec->autocfg.dig_out_pins[i];
4036 dig_nid = look_for_dac(codec, pin, true);
4037 if (!dig_nid)
4038 continue;
4039 path = snd_hda_add_new_path(codec, dig_nid, pin, 0);
4040 if (!path)
4041 continue;
4042 print_nid_path(codec, "digout", path);
4043 path->active = true;
4044 path->pin_fixed = true; /* no jack detection */
4045 spec->digout_paths[i] = snd_hda_get_path_idx(codec, path);
4046 set_pin_target(codec, pin, PIN_OUT, false);
4047 if (!nums) {
4048 spec->multiout.dig_out_nid = dig_nid;
4049 spec->dig_out_type = spec->autocfg.dig_out_type[0];
4050 } else {
4051 spec->multiout.follower_dig_outs = spec->follower_dig_outs;
4052 if (nums >= ARRAY_SIZE(spec->follower_dig_outs) - 1)
4053 break;
4054 spec->follower_dig_outs[nums - 1] = dig_nid;
4055 }
4056 nums++;
4057 }
4058
4059 if (spec->autocfg.dig_in_pin) {
4060 pin = spec->autocfg.dig_in_pin;
4061 for_each_hda_codec_node(dig_nid, codec) {
4062 unsigned int wcaps = get_wcaps(codec, dig_nid);
4063 if (get_wcaps_type(wcaps) != AC_WID_AUD_IN)
4064 continue;
4065 if (!(wcaps & AC_WCAP_DIGITAL))
4066 continue;
4067 path = snd_hda_add_new_path(codec, pin, dig_nid, 0);
4068 if (path) {
4069 print_nid_path(codec, "digin", path);
4070 path->active = true;
4071 path->pin_fixed = true; /* no jack */
4072 spec->dig_in_nid = dig_nid;
4073 spec->digin_path = snd_hda_get_path_idx(codec, path);
4074 set_pin_target(codec, pin, PIN_IN, false);
4075 break;
4076 }
4077 }
4078 }
4079 }
4080
4081
4082 /*
4083 * input MUX handling
4084 */
4085
4086 static bool dyn_adc_pcm_resetup(struct hda_codec *codec, int cur);
4087
4088 /* 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)4089 static int mux_select(struct hda_codec *codec, unsigned int adc_idx,
4090 unsigned int idx)
4091 {
4092 struct hda_gen_spec *spec = codec->spec;
4093 const struct hda_input_mux *imux;
4094 struct nid_path *old_path, *path;
4095
4096 imux = &spec->input_mux;
4097 if (!imux->num_items)
4098 return 0;
4099
4100 if (idx >= imux->num_items)
4101 idx = imux->num_items - 1;
4102 if (spec->cur_mux[adc_idx] == idx)
4103 return 0;
4104
4105 old_path = get_input_path(codec, adc_idx, spec->cur_mux[adc_idx]);
4106 if (!old_path)
4107 return 0;
4108 if (old_path->active)
4109 snd_hda_activate_path(codec, old_path, false, false);
4110
4111 spec->cur_mux[adc_idx] = idx;
4112
4113 if (spec->hp_mic)
4114 update_hp_mic(codec, adc_idx, false);
4115
4116 if (spec->dyn_adc_switch)
4117 dyn_adc_pcm_resetup(codec, idx);
4118
4119 path = get_input_path(codec, adc_idx, idx);
4120 if (!path)
4121 return 0;
4122 if (path->active)
4123 return 0;
4124 snd_hda_activate_path(codec, path, true, false);
4125 if (spec->cap_sync_hook)
4126 spec->cap_sync_hook(codec, NULL, NULL);
4127 path_power_down_sync(codec, old_path);
4128 return 1;
4129 }
4130
4131 /* power up/down widgets in the all paths that match with the given NID
4132 * as terminals (either start- or endpoint)
4133 *
4134 * returns the last changed NID, or zero if unchanged.
4135 */
set_path_power(struct hda_codec * codec,hda_nid_t nid,int pin_state,int stream_state)4136 static hda_nid_t set_path_power(struct hda_codec *codec, hda_nid_t nid,
4137 int pin_state, int stream_state)
4138 {
4139 struct hda_gen_spec *spec = codec->spec;
4140 hda_nid_t last, changed = 0;
4141 struct nid_path *path;
4142 int n;
4143
4144 snd_array_for_each(&spec->paths, n, path) {
4145 if (!path->depth)
4146 continue;
4147 if (path->path[0] == nid ||
4148 path->path[path->depth - 1] == nid) {
4149 bool pin_old = path->pin_enabled;
4150 bool stream_old = path->stream_enabled;
4151
4152 if (pin_state >= 0)
4153 path->pin_enabled = pin_state;
4154 if (stream_state >= 0)
4155 path->stream_enabled = stream_state;
4156 if ((!path->pin_fixed && path->pin_enabled != pin_old)
4157 || path->stream_enabled != stream_old) {
4158 last = path_power_update(codec, path, true);
4159 if (last)
4160 changed = last;
4161 }
4162 }
4163 }
4164 return changed;
4165 }
4166
4167 /* check the jack status for power control */
detect_pin_state(struct hda_codec * codec,hda_nid_t pin)4168 static bool detect_pin_state(struct hda_codec *codec, hda_nid_t pin)
4169 {
4170 if (!is_jack_detectable(codec, pin))
4171 return true;
4172 return snd_hda_jack_detect_state(codec, pin) != HDA_JACK_NOT_PRESENT;
4173 }
4174
4175 /* power up/down the paths of the given pin according to the jack state;
4176 * power = 0/1 : only power up/down if it matches with the jack state,
4177 * < 0 : force power up/down to follow the jack sate
4178 *
4179 * returns the last changed NID, or zero if unchanged.
4180 */
set_pin_power_jack(struct hda_codec * codec,hda_nid_t pin,int power)4181 static hda_nid_t set_pin_power_jack(struct hda_codec *codec, hda_nid_t pin,
4182 int power)
4183 {
4184 bool on;
4185
4186 if (!codec->power_save_node)
4187 return 0;
4188
4189 on = detect_pin_state(codec, pin);
4190
4191 if (power >= 0 && on != power)
4192 return 0;
4193 return set_path_power(codec, pin, on, -1);
4194 }
4195
pin_power_callback(struct hda_codec * codec,struct hda_jack_callback * jack,bool on)4196 static void pin_power_callback(struct hda_codec *codec,
4197 struct hda_jack_callback *jack,
4198 bool on)
4199 {
4200 if (jack && jack->nid)
4201 sync_power_state_change(codec,
4202 set_pin_power_jack(codec, jack->nid, on));
4203 }
4204
4205 /* callback only doing power up -- called at first */
pin_power_up_callback(struct hda_codec * codec,struct hda_jack_callback * jack)4206 static void pin_power_up_callback(struct hda_codec *codec,
4207 struct hda_jack_callback *jack)
4208 {
4209 pin_power_callback(codec, jack, true);
4210 }
4211
4212 /* callback only doing power down -- called at last */
pin_power_down_callback(struct hda_codec * codec,struct hda_jack_callback * jack)4213 static void pin_power_down_callback(struct hda_codec *codec,
4214 struct hda_jack_callback *jack)
4215 {
4216 pin_power_callback(codec, jack, false);
4217 }
4218
4219 /* 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)4220 static void add_pin_power_ctls(struct hda_codec *codec, int num_pins,
4221 const hda_nid_t *pins, bool on)
4222 {
4223 int i;
4224 hda_jack_callback_fn cb =
4225 on ? pin_power_up_callback : pin_power_down_callback;
4226
4227 for (i = 0; i < num_pins && pins[i]; i++) {
4228 if (is_jack_detectable(codec, pins[i]))
4229 snd_hda_jack_detect_enable_callback(codec, pins[i], cb);
4230 else
4231 set_path_power(codec, pins[i], true, -1);
4232 }
4233 }
4234
4235 /* enabled power callback to each available I/O pin with jack detections;
4236 * the digital I/O pins are excluded because of the unreliable detectsion
4237 */
add_all_pin_power_ctls(struct hda_codec * codec,bool on)4238 static void add_all_pin_power_ctls(struct hda_codec *codec, bool on)
4239 {
4240 struct hda_gen_spec *spec = codec->spec;
4241 struct auto_pin_cfg *cfg = &spec->autocfg;
4242 int i;
4243
4244 if (!codec->power_save_node)
4245 return;
4246 add_pin_power_ctls(codec, cfg->line_outs, cfg->line_out_pins, on);
4247 if (cfg->line_out_type != AUTO_PIN_HP_OUT)
4248 add_pin_power_ctls(codec, cfg->hp_outs, cfg->hp_pins, on);
4249 if (cfg->line_out_type != AUTO_PIN_SPEAKER_OUT)
4250 add_pin_power_ctls(codec, cfg->speaker_outs, cfg->speaker_pins, on);
4251 for (i = 0; i < cfg->num_inputs; i++)
4252 add_pin_power_ctls(codec, 1, &cfg->inputs[i].pin, on);
4253 }
4254
4255 /* 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)4256 static void sync_pin_power_ctls(struct hda_codec *codec, int num_pins,
4257 const hda_nid_t *pins)
4258 {
4259 int i;
4260
4261 for (i = 0; i < num_pins && pins[i]; i++)
4262 if (is_jack_detectable(codec, pins[i]))
4263 set_pin_power_jack(codec, pins[i], -1);
4264 }
4265
4266 /* sync path power up/down with pins; called at init and resume */
sync_all_pin_power_ctls(struct hda_codec * codec)4267 static void sync_all_pin_power_ctls(struct hda_codec *codec)
4268 {
4269 struct hda_gen_spec *spec = codec->spec;
4270 struct auto_pin_cfg *cfg = &spec->autocfg;
4271 int i;
4272
4273 if (!codec->power_save_node)
4274 return;
4275 sync_pin_power_ctls(codec, cfg->line_outs, cfg->line_out_pins);
4276 if (cfg->line_out_type != AUTO_PIN_HP_OUT)
4277 sync_pin_power_ctls(codec, cfg->hp_outs, cfg->hp_pins);
4278 if (cfg->line_out_type != AUTO_PIN_SPEAKER_OUT)
4279 sync_pin_power_ctls(codec, cfg->speaker_outs, cfg->speaker_pins);
4280 for (i = 0; i < cfg->num_inputs; i++)
4281 sync_pin_power_ctls(codec, 1, &cfg->inputs[i].pin);
4282 }
4283
4284 /* 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)4285 static int add_fake_paths(struct hda_codec *codec, hda_nid_t nid,
4286 int num_pins, const hda_nid_t *pins)
4287 {
4288 struct hda_gen_spec *spec = codec->spec;
4289 struct nid_path *path;
4290 int i;
4291
4292 for (i = 0; i < num_pins; i++) {
4293 if (!pins[i])
4294 break;
4295 if (get_nid_path(codec, nid, pins[i], 0))
4296 continue;
4297 path = snd_array_new(&spec->paths);
4298 if (!path)
4299 return -ENOMEM;
4300 memset(path, 0, sizeof(*path));
4301 path->depth = 2;
4302 path->path[0] = nid;
4303 path->path[1] = pins[i];
4304 path->active = true;
4305 }
4306 return 0;
4307 }
4308
4309 /* create fake paths to all outputs from beep */
add_fake_beep_paths(struct hda_codec * codec)4310 static int add_fake_beep_paths(struct hda_codec *codec)
4311 {
4312 struct hda_gen_spec *spec = codec->spec;
4313 struct auto_pin_cfg *cfg = &spec->autocfg;
4314 hda_nid_t nid = spec->beep_nid;
4315 int err;
4316
4317 if (!codec->power_save_node || !nid)
4318 return 0;
4319 err = add_fake_paths(codec, nid, cfg->line_outs, cfg->line_out_pins);
4320 if (err < 0)
4321 return err;
4322 if (cfg->line_out_type != AUTO_PIN_HP_OUT) {
4323 err = add_fake_paths(codec, nid, cfg->hp_outs, cfg->hp_pins);
4324 if (err < 0)
4325 return err;
4326 }
4327 if (cfg->line_out_type != AUTO_PIN_SPEAKER_OUT) {
4328 err = add_fake_paths(codec, nid, cfg->speaker_outs,
4329 cfg->speaker_pins);
4330 if (err < 0)
4331 return err;
4332 }
4333 return 0;
4334 }
4335
4336 /* power up/down beep widget and its output paths */
beep_power_hook(struct hda_beep * beep,bool on)4337 static void beep_power_hook(struct hda_beep *beep, bool on)
4338 {
4339 set_path_power(beep->codec, beep->nid, -1, on);
4340 }
4341
4342 /**
4343 * snd_hda_gen_fix_pin_power - Fix the power of the given pin widget to D0
4344 * @codec: the HDA codec
4345 * @pin: NID of pin to fix
4346 */
snd_hda_gen_fix_pin_power(struct hda_codec * codec,hda_nid_t pin)4347 int snd_hda_gen_fix_pin_power(struct hda_codec *codec, hda_nid_t pin)
4348 {
4349 struct hda_gen_spec *spec = codec->spec;
4350 struct nid_path *path;
4351
4352 path = snd_array_new(&spec->paths);
4353 if (!path)
4354 return -ENOMEM;
4355 memset(path, 0, sizeof(*path));
4356 path->depth = 1;
4357 path->path[0] = pin;
4358 path->active = true;
4359 path->pin_fixed = true;
4360 path->stream_enabled = true;
4361 return 0;
4362 }
4363 EXPORT_SYMBOL_GPL(snd_hda_gen_fix_pin_power);
4364
4365 /*
4366 * Jack detections for HP auto-mute and mic-switch
4367 */
4368
4369 /* 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)4370 static bool detect_jacks(struct hda_codec *codec, int num_pins, const hda_nid_t *pins)
4371 {
4372 int i;
4373 bool present = false;
4374
4375 for (i = 0; i < num_pins; i++) {
4376 hda_nid_t nid = pins[i];
4377 if (!nid)
4378 break;
4379 /* don't detect pins retasked as inputs */
4380 if (snd_hda_codec_get_pin_target(codec, nid) & AC_PINCTL_IN_EN)
4381 continue;
4382 if (snd_hda_jack_detect_state(codec, nid) == HDA_JACK_PRESENT)
4383 present = true;
4384 }
4385 return present;
4386 }
4387
4388 /* 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)4389 static void do_automute(struct hda_codec *codec, int num_pins, const hda_nid_t *pins,
4390 int *paths, bool mute)
4391 {
4392 struct hda_gen_spec *spec = codec->spec;
4393 int i;
4394
4395 for (i = 0; i < num_pins; i++) {
4396 hda_nid_t nid = pins[i];
4397 unsigned int val, oldval;
4398 if (!nid)
4399 break;
4400
4401 oldval = snd_hda_codec_get_pin_target(codec, nid);
4402 if (oldval & PIN_IN)
4403 continue; /* no mute for inputs */
4404
4405 if (spec->auto_mute_via_amp) {
4406 struct nid_path *path;
4407 hda_nid_t mute_nid;
4408
4409 path = snd_hda_get_path_from_idx(codec, paths[i]);
4410 if (!path)
4411 continue;
4412 mute_nid = get_amp_nid_(path->ctls[NID_PATH_MUTE_CTL]);
4413 if (!mute_nid)
4414 continue;
4415 if (mute)
4416 spec->mute_bits |= (1ULL << mute_nid);
4417 else
4418 spec->mute_bits &= ~(1ULL << mute_nid);
4419 continue;
4420 } else {
4421 /* don't reset VREF value in case it's controlling
4422 * the amp (see alc861_fixup_asus_amp_vref_0f())
4423 */
4424 if (spec->keep_vref_in_automute)
4425 val = oldval & ~PIN_HP;
4426 else
4427 val = 0;
4428 if (!mute)
4429 val |= oldval;
4430 /* here we call update_pin_ctl() so that the pinctl is
4431 * changed without changing the pinctl target value;
4432 * the original target value will be still referred at
4433 * the init / resume again
4434 */
4435 update_pin_ctl(codec, nid, val);
4436 }
4437
4438 set_pin_eapd(codec, nid, !mute);
4439 if (codec->power_save_node) {
4440 bool on = !mute;
4441 if (on)
4442 on = detect_pin_state(codec, nid);
4443 set_path_power(codec, nid, on, -1);
4444 }
4445 }
4446 }
4447
4448 /**
4449 * snd_hda_gen_update_outputs - Toggle outputs muting
4450 * @codec: the HDA codec
4451 *
4452 * Update the mute status of all outputs based on the current jack states.
4453 */
snd_hda_gen_update_outputs(struct hda_codec * codec)4454 void snd_hda_gen_update_outputs(struct hda_codec *codec)
4455 {
4456 struct hda_gen_spec *spec = codec->spec;
4457 int *paths;
4458 int on;
4459
4460 /* Control HP pins/amps depending on master_mute state;
4461 * in general, HP pins/amps control should be enabled in all cases,
4462 * but currently set only for master_mute, just to be safe
4463 */
4464 if (spec->autocfg.line_out_type == AUTO_PIN_HP_OUT)
4465 paths = spec->out_paths;
4466 else
4467 paths = spec->hp_paths;
4468 do_automute(codec, ARRAY_SIZE(spec->autocfg.hp_pins),
4469 spec->autocfg.hp_pins, paths, spec->master_mute);
4470
4471 if (!spec->automute_speaker)
4472 on = 0;
4473 else
4474 on = spec->hp_jack_present | spec->line_jack_present;
4475 on |= spec->master_mute;
4476 spec->speaker_muted = on;
4477 if (spec->autocfg.line_out_type == AUTO_PIN_SPEAKER_OUT)
4478 paths = spec->out_paths;
4479 else
4480 paths = spec->speaker_paths;
4481 do_automute(codec, ARRAY_SIZE(spec->autocfg.speaker_pins),
4482 spec->autocfg.speaker_pins, paths, on);
4483
4484 /* toggle line-out mutes if needed, too */
4485 /* if LO is a copy of either HP or Speaker, don't need to handle it */
4486 if (spec->autocfg.line_out_pins[0] == spec->autocfg.hp_pins[0] ||
4487 spec->autocfg.line_out_pins[0] == spec->autocfg.speaker_pins[0])
4488 return;
4489 if (!spec->automute_lo)
4490 on = 0;
4491 else
4492 on = spec->hp_jack_present;
4493 on |= spec->master_mute;
4494 spec->line_out_muted = on;
4495 paths = spec->out_paths;
4496 do_automute(codec, ARRAY_SIZE(spec->autocfg.line_out_pins),
4497 spec->autocfg.line_out_pins, paths, on);
4498 }
4499 EXPORT_SYMBOL_GPL(snd_hda_gen_update_outputs);
4500
call_update_outputs(struct hda_codec * codec)4501 static void call_update_outputs(struct hda_codec *codec)
4502 {
4503 struct hda_gen_spec *spec = codec->spec;
4504 if (spec->automute_hook)
4505 spec->automute_hook(codec);
4506 else
4507 snd_hda_gen_update_outputs(codec);
4508
4509 /* sync the whole vmaster followers to reflect the new auto-mute status */
4510 if (spec->auto_mute_via_amp && !codec->bus->shutdown)
4511 snd_ctl_sync_vmaster(spec->vmaster_mute.sw_kctl, false);
4512 }
4513
4514 /**
4515 * snd_hda_gen_hp_automute - standard HP-automute helper
4516 * @codec: the HDA codec
4517 * @jack: jack object, NULL for the whole
4518 */
snd_hda_gen_hp_automute(struct hda_codec * codec,struct hda_jack_callback * jack)4519 void snd_hda_gen_hp_automute(struct hda_codec *codec,
4520 struct hda_jack_callback *jack)
4521 {
4522 struct hda_gen_spec *spec = codec->spec;
4523 hda_nid_t *pins = spec->autocfg.hp_pins;
4524 int num_pins = ARRAY_SIZE(spec->autocfg.hp_pins);
4525
4526 /* No detection for the first HP jack during indep-HP mode */
4527 if (spec->indep_hp_enabled) {
4528 pins++;
4529 num_pins--;
4530 }
4531
4532 spec->hp_jack_present = detect_jacks(codec, num_pins, pins);
4533 if (!spec->detect_hp || (!spec->automute_speaker && !spec->automute_lo))
4534 return;
4535 call_update_outputs(codec);
4536 }
4537 EXPORT_SYMBOL_GPL(snd_hda_gen_hp_automute);
4538
4539 /**
4540 * snd_hda_gen_line_automute - standard line-out-automute helper
4541 * @codec: the HDA codec
4542 * @jack: jack object, NULL for the whole
4543 */
snd_hda_gen_line_automute(struct hda_codec * codec,struct hda_jack_callback * jack)4544 void snd_hda_gen_line_automute(struct hda_codec *codec,
4545 struct hda_jack_callback *jack)
4546 {
4547 struct hda_gen_spec *spec = codec->spec;
4548
4549 if (spec->autocfg.line_out_type == AUTO_PIN_SPEAKER_OUT)
4550 return;
4551 /* check LO jack only when it's different from HP */
4552 if (spec->autocfg.line_out_pins[0] == spec->autocfg.hp_pins[0])
4553 return;
4554
4555 spec->line_jack_present =
4556 detect_jacks(codec, ARRAY_SIZE(spec->autocfg.line_out_pins),
4557 spec->autocfg.line_out_pins);
4558 if (!spec->automute_speaker || !spec->detect_lo)
4559 return;
4560 call_update_outputs(codec);
4561 }
4562 EXPORT_SYMBOL_GPL(snd_hda_gen_line_automute);
4563
4564 /**
4565 * snd_hda_gen_mic_autoswitch - standard mic auto-switch helper
4566 * @codec: the HDA codec
4567 * @jack: jack object, NULL for the whole
4568 */
snd_hda_gen_mic_autoswitch(struct hda_codec * codec,struct hda_jack_callback * jack)4569 void snd_hda_gen_mic_autoswitch(struct hda_codec *codec,
4570 struct hda_jack_callback *jack)
4571 {
4572 struct hda_gen_spec *spec = codec->spec;
4573 int i;
4574
4575 if (!spec->auto_mic)
4576 return;
4577
4578 for (i = spec->am_num_entries - 1; i > 0; i--) {
4579 hda_nid_t pin = spec->am_entry[i].pin;
4580 /* don't detect pins retasked as outputs */
4581 if (snd_hda_codec_get_pin_target(codec, pin) & AC_PINCTL_OUT_EN)
4582 continue;
4583 if (snd_hda_jack_detect_state(codec, pin) == HDA_JACK_PRESENT) {
4584 mux_select(codec, 0, spec->am_entry[i].idx);
4585 return;
4586 }
4587 }
4588 mux_select(codec, 0, spec->am_entry[0].idx);
4589 }
4590 EXPORT_SYMBOL_GPL(snd_hda_gen_mic_autoswitch);
4591
4592 /* call appropriate hooks */
call_hp_automute(struct hda_codec * codec,struct hda_jack_callback * jack)4593 static void call_hp_automute(struct hda_codec *codec,
4594 struct hda_jack_callback *jack)
4595 {
4596 struct hda_gen_spec *spec = codec->spec;
4597 if (spec->hp_automute_hook)
4598 spec->hp_automute_hook(codec, jack);
4599 else
4600 snd_hda_gen_hp_automute(codec, jack);
4601 }
4602
call_line_automute(struct hda_codec * codec,struct hda_jack_callback * jack)4603 static void call_line_automute(struct hda_codec *codec,
4604 struct hda_jack_callback *jack)
4605 {
4606 struct hda_gen_spec *spec = codec->spec;
4607 if (spec->line_automute_hook)
4608 spec->line_automute_hook(codec, jack);
4609 else
4610 snd_hda_gen_line_automute(codec, jack);
4611 }
4612
call_mic_autoswitch(struct hda_codec * codec,struct hda_jack_callback * jack)4613 static void call_mic_autoswitch(struct hda_codec *codec,
4614 struct hda_jack_callback *jack)
4615 {
4616 struct hda_gen_spec *spec = codec->spec;
4617 if (spec->mic_autoswitch_hook)
4618 spec->mic_autoswitch_hook(codec, jack);
4619 else
4620 snd_hda_gen_mic_autoswitch(codec, jack);
4621 }
4622
4623 /* update jack retasking */
update_automute_all(struct hda_codec * codec)4624 static void update_automute_all(struct hda_codec *codec)
4625 {
4626 call_hp_automute(codec, NULL);
4627 call_line_automute(codec, NULL);
4628 call_mic_autoswitch(codec, NULL);
4629 }
4630
4631 /*
4632 * Auto-Mute mode mixer enum support
4633 */
automute_mode_info(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_info * uinfo)4634 static int automute_mode_info(struct snd_kcontrol *kcontrol,
4635 struct snd_ctl_elem_info *uinfo)
4636 {
4637 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
4638 struct hda_gen_spec *spec = codec->spec;
4639 static const char * const texts3[] = {
4640 "Disabled", "Speaker Only", "Line Out+Speaker"
4641 };
4642
4643 if (spec->automute_speaker_possible && spec->automute_lo_possible)
4644 return snd_hda_enum_helper_info(kcontrol, uinfo, 3, texts3);
4645 return snd_hda_enum_bool_helper_info(kcontrol, uinfo);
4646 }
4647
automute_mode_get(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)4648 static int automute_mode_get(struct snd_kcontrol *kcontrol,
4649 struct snd_ctl_elem_value *ucontrol)
4650 {
4651 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
4652 struct hda_gen_spec *spec = codec->spec;
4653 unsigned int val = 0;
4654 if (spec->automute_speaker)
4655 val++;
4656 if (spec->automute_lo)
4657 val++;
4658
4659 ucontrol->value.enumerated.item[0] = val;
4660 return 0;
4661 }
4662
automute_mode_put(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)4663 static int automute_mode_put(struct snd_kcontrol *kcontrol,
4664 struct snd_ctl_elem_value *ucontrol)
4665 {
4666 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
4667 struct hda_gen_spec *spec = codec->spec;
4668
4669 switch (ucontrol->value.enumerated.item[0]) {
4670 case 0:
4671 if (!spec->automute_speaker && !spec->automute_lo)
4672 return 0;
4673 spec->automute_speaker = 0;
4674 spec->automute_lo = 0;
4675 break;
4676 case 1:
4677 if (spec->automute_speaker_possible) {
4678 if (!spec->automute_lo && spec->automute_speaker)
4679 return 0;
4680 spec->automute_speaker = 1;
4681 spec->automute_lo = 0;
4682 } else if (spec->automute_lo_possible) {
4683 if (spec->automute_lo)
4684 return 0;
4685 spec->automute_lo = 1;
4686 } else
4687 return -EINVAL;
4688 break;
4689 case 2:
4690 if (!spec->automute_lo_possible || !spec->automute_speaker_possible)
4691 return -EINVAL;
4692 if (spec->automute_speaker && spec->automute_lo)
4693 return 0;
4694 spec->automute_speaker = 1;
4695 spec->automute_lo = 1;
4696 break;
4697 default:
4698 return -EINVAL;
4699 }
4700 call_update_outputs(codec);
4701 return 1;
4702 }
4703
4704 static const struct snd_kcontrol_new automute_mode_enum = {
4705 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
4706 .name = "Auto-Mute Mode",
4707 .info = automute_mode_info,
4708 .get = automute_mode_get,
4709 .put = automute_mode_put,
4710 };
4711
add_automute_mode_enum(struct hda_codec * codec)4712 static int add_automute_mode_enum(struct hda_codec *codec)
4713 {
4714 struct hda_gen_spec *spec = codec->spec;
4715
4716 if (!snd_hda_gen_add_kctl(spec, NULL, &automute_mode_enum))
4717 return -ENOMEM;
4718 return 0;
4719 }
4720
4721 /*
4722 * Check the availability of HP/line-out auto-mute;
4723 * Set up appropriately if really supported
4724 */
check_auto_mute_availability(struct hda_codec * codec)4725 static int check_auto_mute_availability(struct hda_codec *codec)
4726 {
4727 struct hda_gen_spec *spec = codec->spec;
4728 struct auto_pin_cfg *cfg = &spec->autocfg;
4729 int present = 0;
4730 int i, err;
4731
4732 if (spec->suppress_auto_mute)
4733 return 0;
4734
4735 if (cfg->hp_pins[0])
4736 present++;
4737 if (cfg->line_out_pins[0])
4738 present++;
4739 if (cfg->speaker_pins[0])
4740 present++;
4741 if (present < 2) /* need two different output types */
4742 return 0;
4743
4744 if (!cfg->speaker_pins[0] &&
4745 cfg->line_out_type == AUTO_PIN_SPEAKER_OUT) {
4746 memcpy(cfg->speaker_pins, cfg->line_out_pins,
4747 sizeof(cfg->speaker_pins));
4748 cfg->speaker_outs = cfg->line_outs;
4749 }
4750
4751 if (!cfg->hp_pins[0] &&
4752 cfg->line_out_type == AUTO_PIN_HP_OUT) {
4753 memcpy(cfg->hp_pins, cfg->line_out_pins,
4754 sizeof(cfg->hp_pins));
4755 cfg->hp_outs = cfg->line_outs;
4756 }
4757
4758 for (i = 0; i < cfg->hp_outs; i++) {
4759 hda_nid_t nid = cfg->hp_pins[i];
4760 if (!is_jack_detectable(codec, nid))
4761 continue;
4762 codec_dbg(codec, "Enable HP auto-muting on NID 0x%x\n", nid);
4763 snd_hda_jack_detect_enable_callback(codec, nid,
4764 call_hp_automute);
4765 spec->detect_hp = 1;
4766 }
4767
4768 if (cfg->line_out_type == AUTO_PIN_LINE_OUT && cfg->line_outs) {
4769 if (cfg->speaker_outs)
4770 for (i = 0; i < cfg->line_outs; i++) {
4771 hda_nid_t nid = cfg->line_out_pins[i];
4772 if (!is_jack_detectable(codec, nid))
4773 continue;
4774 codec_dbg(codec, "Enable Line-Out auto-muting on NID 0x%x\n", nid);
4775 snd_hda_jack_detect_enable_callback(codec, nid,
4776 call_line_automute);
4777 spec->detect_lo = 1;
4778 }
4779 spec->automute_lo_possible = spec->detect_hp;
4780 }
4781
4782 spec->automute_speaker_possible = cfg->speaker_outs &&
4783 (spec->detect_hp || spec->detect_lo);
4784
4785 spec->automute_lo = spec->automute_lo_possible;
4786 spec->automute_speaker = spec->automute_speaker_possible;
4787
4788 if (spec->automute_speaker_possible || spec->automute_lo_possible) {
4789 /* create a control for automute mode */
4790 err = add_automute_mode_enum(codec);
4791 if (err < 0)
4792 return err;
4793 }
4794 return 0;
4795 }
4796
4797 /* check whether all auto-mic pins are valid; setup indices if OK */
auto_mic_check_imux(struct hda_codec * codec)4798 static bool auto_mic_check_imux(struct hda_codec *codec)
4799 {
4800 struct hda_gen_spec *spec = codec->spec;
4801 const struct hda_input_mux *imux;
4802 int i;
4803
4804 imux = &spec->input_mux;
4805 for (i = 0; i < spec->am_num_entries; i++) {
4806 spec->am_entry[i].idx =
4807 find_idx_in_nid_list(spec->am_entry[i].pin,
4808 spec->imux_pins, imux->num_items);
4809 if (spec->am_entry[i].idx < 0)
4810 return false; /* no corresponding imux */
4811 }
4812
4813 /* we don't need the jack detection for the first pin */
4814 for (i = 1; i < spec->am_num_entries; i++)
4815 snd_hda_jack_detect_enable_callback(codec,
4816 spec->am_entry[i].pin,
4817 call_mic_autoswitch);
4818 return true;
4819 }
4820
compare_attr(const void * ap,const void * bp)4821 static int compare_attr(const void *ap, const void *bp)
4822 {
4823 const struct automic_entry *a = ap;
4824 const struct automic_entry *b = bp;
4825 return (int)(a->attr - b->attr);
4826 }
4827
4828 /*
4829 * Check the availability of auto-mic switch;
4830 * Set up if really supported
4831 */
check_auto_mic_availability(struct hda_codec * codec)4832 static int check_auto_mic_availability(struct hda_codec *codec)
4833 {
4834 struct hda_gen_spec *spec = codec->spec;
4835 struct auto_pin_cfg *cfg = &spec->autocfg;
4836 unsigned int types;
4837 int i, num_pins;
4838
4839 if (spec->suppress_auto_mic)
4840 return 0;
4841
4842 types = 0;
4843 num_pins = 0;
4844 for (i = 0; i < cfg->num_inputs; i++) {
4845 hda_nid_t nid = cfg->inputs[i].pin;
4846 unsigned int attr;
4847 attr = snd_hda_codec_get_pincfg(codec, nid);
4848 attr = snd_hda_get_input_pin_attr(attr);
4849 if (types & (1 << attr))
4850 return 0; /* already occupied */
4851 switch (attr) {
4852 case INPUT_PIN_ATTR_INT:
4853 if (cfg->inputs[i].type != AUTO_PIN_MIC)
4854 return 0; /* invalid type */
4855 break;
4856 case INPUT_PIN_ATTR_UNUSED:
4857 return 0; /* invalid entry */
4858 default:
4859 if (cfg->inputs[i].type > AUTO_PIN_LINE_IN)
4860 return 0; /* invalid type */
4861 if (!spec->line_in_auto_switch &&
4862 cfg->inputs[i].type != AUTO_PIN_MIC)
4863 return 0; /* only mic is allowed */
4864 if (!is_jack_detectable(codec, nid))
4865 return 0; /* no unsol support */
4866 break;
4867 }
4868 if (num_pins >= MAX_AUTO_MIC_PINS)
4869 return 0;
4870 types |= (1 << attr);
4871 spec->am_entry[num_pins].pin = nid;
4872 spec->am_entry[num_pins].attr = attr;
4873 num_pins++;
4874 }
4875
4876 if (num_pins < 2)
4877 return 0;
4878
4879 spec->am_num_entries = num_pins;
4880 /* sort the am_entry in the order of attr so that the pin with a
4881 * higher attr will be selected when the jack is plugged.
4882 */
4883 sort(spec->am_entry, num_pins, sizeof(spec->am_entry[0]),
4884 compare_attr, NULL);
4885
4886 if (!auto_mic_check_imux(codec))
4887 return 0;
4888
4889 spec->auto_mic = 1;
4890 spec->num_adc_nids = 1;
4891 spec->cur_mux[0] = spec->am_entry[0].idx;
4892 codec_dbg(codec, "Enable auto-mic switch on NID 0x%x/0x%x/0x%x\n",
4893 spec->am_entry[0].pin,
4894 spec->am_entry[1].pin,
4895 spec->am_entry[2].pin);
4896
4897 return 0;
4898 }
4899
4900 /**
4901 * snd_hda_gen_path_power_filter - power_filter hook to make inactive widgets
4902 * into power down
4903 * @codec: the HDA codec
4904 * @nid: NID to evalute
4905 * @power_state: target power state
4906 */
snd_hda_gen_path_power_filter(struct hda_codec * codec,hda_nid_t nid,unsigned int power_state)4907 unsigned int snd_hda_gen_path_power_filter(struct hda_codec *codec,
4908 hda_nid_t nid,
4909 unsigned int power_state)
4910 {
4911 struct hda_gen_spec *spec = codec->spec;
4912
4913 if (!spec->power_down_unused && !codec->power_save_node)
4914 return power_state;
4915 if (power_state != AC_PWRST_D0 || nid == codec->core.afg)
4916 return power_state;
4917 if (get_wcaps_type(get_wcaps(codec, nid)) >= AC_WID_POWER)
4918 return power_state;
4919 if (is_active_nid_for_any(codec, nid))
4920 return power_state;
4921 return AC_PWRST_D3;
4922 }
4923 EXPORT_SYMBOL_GPL(snd_hda_gen_path_power_filter);
4924
4925 /* mute all aamix inputs initially; parse up to the first leaves */
mute_all_mixer_nid(struct hda_codec * codec,hda_nid_t mix)4926 static void mute_all_mixer_nid(struct hda_codec *codec, hda_nid_t mix)
4927 {
4928 int i, nums;
4929 const hda_nid_t *conn;
4930 bool has_amp;
4931
4932 nums = snd_hda_get_conn_list(codec, mix, &conn);
4933 has_amp = nid_has_mute(codec, mix, HDA_INPUT);
4934 for (i = 0; i < nums; i++) {
4935 if (has_amp)
4936 update_amp(codec, mix, HDA_INPUT, i,
4937 0xff, HDA_AMP_MUTE);
4938 else if (nid_has_volume(codec, conn[i], HDA_OUTPUT))
4939 update_amp(codec, conn[i], HDA_OUTPUT, 0,
4940 0xff, HDA_AMP_MUTE);
4941 }
4942 }
4943
4944 /**
4945 * snd_hda_gen_stream_pm - Stream power management callback
4946 * @codec: the HDA codec
4947 * @nid: audio widget
4948 * @on: power on/off flag
4949 *
4950 * Set this in patch_ops.stream_pm. Only valid with power_save_node flag.
4951 */
snd_hda_gen_stream_pm(struct hda_codec * codec,hda_nid_t nid,bool on)4952 void snd_hda_gen_stream_pm(struct hda_codec *codec, hda_nid_t nid, bool on)
4953 {
4954 if (codec->power_save_node)
4955 set_path_power(codec, nid, -1, on);
4956 }
4957 EXPORT_SYMBOL_GPL(snd_hda_gen_stream_pm);
4958
4959 /* forcibly mute the speaker output without caching; return true if updated */
force_mute_output_path(struct hda_codec * codec,hda_nid_t nid)4960 static bool force_mute_output_path(struct hda_codec *codec, hda_nid_t nid)
4961 {
4962 if (!nid)
4963 return false;
4964 if (!nid_has_mute(codec, nid, HDA_OUTPUT))
4965 return false; /* no mute, skip */
4966 if (snd_hda_codec_amp_read(codec, nid, 0, HDA_OUTPUT, 0) &
4967 snd_hda_codec_amp_read(codec, nid, 1, HDA_OUTPUT, 0) &
4968 HDA_AMP_MUTE)
4969 return false; /* both channels already muted, skip */
4970
4971 /* direct amp update without caching */
4972 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE,
4973 AC_AMP_SET_OUTPUT | AC_AMP_SET_LEFT |
4974 AC_AMP_SET_RIGHT | HDA_AMP_MUTE);
4975 return true;
4976 }
4977
4978 /**
4979 * snd_hda_gen_shutup_speakers - Forcibly mute the speaker outputs
4980 * @codec: the HDA codec
4981 *
4982 * Forcibly mute the speaker outputs, to be called at suspend or shutdown.
4983 *
4984 * The mute state done by this function isn't cached, hence the original state
4985 * will be restored at resume.
4986 *
4987 * Return true if the mute state has been changed.
4988 */
snd_hda_gen_shutup_speakers(struct hda_codec * codec)4989 bool snd_hda_gen_shutup_speakers(struct hda_codec *codec)
4990 {
4991 struct hda_gen_spec *spec = codec->spec;
4992 const int *paths;
4993 const struct nid_path *path;
4994 int i, p, num_paths;
4995 bool updated = false;
4996
4997 /* if already powered off, do nothing */
4998 if (!snd_hdac_is_power_on(&codec->core))
4999 return false;
5000
5001 if (spec->autocfg.line_out_type == AUTO_PIN_SPEAKER_OUT) {
5002 paths = spec->out_paths;
5003 num_paths = spec->autocfg.line_outs;
5004 } else {
5005 paths = spec->speaker_paths;
5006 num_paths = spec->autocfg.speaker_outs;
5007 }
5008
5009 for (i = 0; i < num_paths; i++) {
5010 path = snd_hda_get_path_from_idx(codec, paths[i]);
5011 if (!path)
5012 continue;
5013 for (p = 0; p < path->depth; p++)
5014 if (force_mute_output_path(codec, path->path[p]))
5015 updated = true;
5016 }
5017
5018 return updated;
5019 }
5020 EXPORT_SYMBOL_GPL(snd_hda_gen_shutup_speakers);
5021
5022 /**
5023 * snd_hda_gen_parse_auto_config - Parse the given BIOS configuration and
5024 * set up the hda_gen_spec
5025 * @codec: the HDA codec
5026 * @cfg: Parsed pin configuration
5027 *
5028 * return 1 if successful, 0 if the proper config is not found,
5029 * or a negative error code
5030 */
snd_hda_gen_parse_auto_config(struct hda_codec * codec,struct auto_pin_cfg * cfg)5031 int snd_hda_gen_parse_auto_config(struct hda_codec *codec,
5032 struct auto_pin_cfg *cfg)
5033 {
5034 struct hda_gen_spec *spec = codec->spec;
5035 int err;
5036
5037 parse_user_hints(codec);
5038
5039 if (spec->vmaster_mute_led || spec->mic_mute_led)
5040 snd_ctl_led_request();
5041
5042 if (spec->mixer_nid && !spec->mixer_merge_nid)
5043 spec->mixer_merge_nid = spec->mixer_nid;
5044
5045 if (cfg != &spec->autocfg) {
5046 spec->autocfg = *cfg;
5047 cfg = &spec->autocfg;
5048 }
5049
5050 if (!spec->main_out_badness)
5051 spec->main_out_badness = &hda_main_out_badness;
5052 if (!spec->extra_out_badness)
5053 spec->extra_out_badness = &hda_extra_out_badness;
5054
5055 fill_all_dac_nids(codec);
5056
5057 if (!cfg->line_outs) {
5058 if (cfg->dig_outs || cfg->dig_in_pin) {
5059 spec->multiout.max_channels = 2;
5060 spec->no_analog = 1;
5061 goto dig_only;
5062 }
5063 if (!cfg->num_inputs && !cfg->dig_in_pin)
5064 return 0; /* can't find valid BIOS pin config */
5065 }
5066
5067 if (!spec->no_primary_hp &&
5068 cfg->line_out_type == AUTO_PIN_SPEAKER_OUT &&
5069 cfg->line_outs <= cfg->hp_outs) {
5070 /* use HP as primary out */
5071 cfg->speaker_outs = cfg->line_outs;
5072 memcpy(cfg->speaker_pins, cfg->line_out_pins,
5073 sizeof(cfg->speaker_pins));
5074 cfg->line_outs = cfg->hp_outs;
5075 memcpy(cfg->line_out_pins, cfg->hp_pins, sizeof(cfg->hp_pins));
5076 cfg->hp_outs = 0;
5077 memset(cfg->hp_pins, 0, sizeof(cfg->hp_pins));
5078 cfg->line_out_type = AUTO_PIN_HP_OUT;
5079 }
5080
5081 err = parse_output_paths(codec);
5082 if (err < 0)
5083 return err;
5084 err = create_multi_channel_mode(codec);
5085 if (err < 0)
5086 return err;
5087 err = create_multi_out_ctls(codec, cfg);
5088 if (err < 0)
5089 return err;
5090 err = create_hp_out_ctls(codec);
5091 if (err < 0)
5092 return err;
5093 err = create_speaker_out_ctls(codec);
5094 if (err < 0)
5095 return err;
5096 err = create_indep_hp_ctls(codec);
5097 if (err < 0)
5098 return err;
5099 err = create_loopback_mixing_ctl(codec);
5100 if (err < 0)
5101 return err;
5102 err = create_hp_mic(codec);
5103 if (err < 0)
5104 return err;
5105 err = create_input_ctls(codec);
5106 if (err < 0)
5107 return err;
5108
5109 /* add power-down pin callbacks at first */
5110 add_all_pin_power_ctls(codec, false);
5111
5112 spec->const_channel_count = spec->ext_channel_count;
5113 /* check the multiple speaker and headphone pins */
5114 if (cfg->line_out_type != AUTO_PIN_SPEAKER_OUT)
5115 spec->const_channel_count = max(spec->const_channel_count,
5116 cfg->speaker_outs * 2);
5117 if (cfg->line_out_type != AUTO_PIN_HP_OUT)
5118 spec->const_channel_count = max(spec->const_channel_count,
5119 cfg->hp_outs * 2);
5120 spec->multiout.max_channels = max(spec->ext_channel_count,
5121 spec->const_channel_count);
5122
5123 err = check_auto_mute_availability(codec);
5124 if (err < 0)
5125 return err;
5126
5127 err = check_dyn_adc_switch(codec);
5128 if (err < 0)
5129 return err;
5130
5131 err = check_auto_mic_availability(codec);
5132 if (err < 0)
5133 return err;
5134
5135 /* add stereo mix if available and not enabled yet */
5136 if (!spec->auto_mic && spec->mixer_nid &&
5137 spec->add_stereo_mix_input == HDA_HINT_STEREO_MIX_AUTO &&
5138 spec->input_mux.num_items > 1) {
5139 err = parse_capture_source(codec, spec->mixer_nid,
5140 CFG_IDX_MIX, spec->num_all_adcs,
5141 "Stereo Mix", 0);
5142 if (err < 0)
5143 return err;
5144 }
5145
5146
5147 err = create_capture_mixers(codec);
5148 if (err < 0)
5149 return err;
5150
5151 err = parse_mic_boost(codec);
5152 if (err < 0)
5153 return err;
5154
5155 /* create "Headphone Mic Jack Mode" if no input selection is
5156 * available (or user specifies add_jack_modes hint)
5157 */
5158 if (spec->hp_mic_pin &&
5159 (spec->auto_mic || spec->input_mux.num_items == 1 ||
5160 spec->add_jack_modes)) {
5161 err = create_hp_mic_jack_mode(codec, spec->hp_mic_pin);
5162 if (err < 0)
5163 return err;
5164 }
5165
5166 if (spec->add_jack_modes) {
5167 if (cfg->line_out_type != AUTO_PIN_SPEAKER_OUT) {
5168 err = create_out_jack_modes(codec, cfg->line_outs,
5169 cfg->line_out_pins);
5170 if (err < 0)
5171 return err;
5172 }
5173 if (cfg->line_out_type != AUTO_PIN_HP_OUT) {
5174 err = create_out_jack_modes(codec, cfg->hp_outs,
5175 cfg->hp_pins);
5176 if (err < 0)
5177 return err;
5178 }
5179 }
5180
5181 /* add power-up pin callbacks at last */
5182 add_all_pin_power_ctls(codec, true);
5183
5184 /* mute all aamix input initially */
5185 if (spec->mixer_nid)
5186 mute_all_mixer_nid(codec, spec->mixer_nid);
5187
5188 dig_only:
5189 parse_digital(codec);
5190
5191 if (spec->power_down_unused || codec->power_save_node) {
5192 if (!codec->power_filter)
5193 codec->power_filter = snd_hda_gen_path_power_filter;
5194 if (!codec->patch_ops.stream_pm)
5195 codec->patch_ops.stream_pm = snd_hda_gen_stream_pm;
5196 }
5197
5198 if (!spec->no_analog && spec->beep_nid) {
5199 err = snd_hda_attach_beep_device(codec, spec->beep_nid);
5200 if (err < 0)
5201 return err;
5202 if (codec->beep && codec->power_save_node) {
5203 err = add_fake_beep_paths(codec);
5204 if (err < 0)
5205 return err;
5206 codec->beep->power_hook = beep_power_hook;
5207 }
5208 }
5209
5210 return 1;
5211 }
5212 EXPORT_SYMBOL_GPL(snd_hda_gen_parse_auto_config);
5213
5214
5215 /*
5216 * Build control elements
5217 */
5218
5219 /* follower controls for virtual master */
5220 static const char * const follower_pfxs[] = {
5221 "Front", "Surround", "Center", "LFE", "Side",
5222 "Headphone", "Speaker", "Mono", "Line Out",
5223 "CLFE", "Bass Speaker", "PCM",
5224 "Speaker Front", "Speaker Surround", "Speaker CLFE", "Speaker Side",
5225 "Headphone Front", "Headphone Surround", "Headphone CLFE",
5226 "Headphone Side", "Headphone+LO", "Speaker+LO",
5227 NULL,
5228 };
5229
5230 /**
5231 * snd_hda_gen_build_controls - Build controls from the parsed results
5232 * @codec: the HDA codec
5233 *
5234 * Pass this to build_controls patch_ops.
5235 */
snd_hda_gen_build_controls(struct hda_codec * codec)5236 int snd_hda_gen_build_controls(struct hda_codec *codec)
5237 {
5238 struct hda_gen_spec *spec = codec->spec;
5239 int err;
5240
5241 if (spec->kctls.used) {
5242 err = snd_hda_add_new_ctls(codec, spec->kctls.list);
5243 if (err < 0)
5244 return err;
5245 }
5246
5247 if (spec->multiout.dig_out_nid) {
5248 err = snd_hda_create_dig_out_ctls(codec,
5249 spec->multiout.dig_out_nid,
5250 spec->multiout.dig_out_nid,
5251 spec->pcm_rec[1]->pcm_type);
5252 if (err < 0)
5253 return err;
5254 if (!spec->no_analog) {
5255 err = snd_hda_create_spdif_share_sw(codec,
5256 &spec->multiout);
5257 if (err < 0)
5258 return err;
5259 spec->multiout.share_spdif = 1;
5260 }
5261 }
5262 if (spec->dig_in_nid) {
5263 err = snd_hda_create_spdif_in_ctls(codec, spec->dig_in_nid);
5264 if (err < 0)
5265 return err;
5266 }
5267
5268 /* if we have no master control, let's create it */
5269 if (!spec->no_analog && !spec->suppress_vmaster &&
5270 !snd_hda_find_mixer_ctl(codec, "Master Playback Volume")) {
5271 err = snd_hda_add_vmaster(codec, "Master Playback Volume",
5272 spec->vmaster_tlv, follower_pfxs,
5273 "Playback Volume", 0);
5274 if (err < 0)
5275 return err;
5276 }
5277 if (!spec->no_analog && !spec->suppress_vmaster &&
5278 !snd_hda_find_mixer_ctl(codec, "Master Playback Switch")) {
5279 err = __snd_hda_add_vmaster(codec, "Master Playback Switch",
5280 NULL, follower_pfxs,
5281 "Playback Switch", true,
5282 spec->vmaster_mute_led ?
5283 SNDRV_CTL_ELEM_ACCESS_SPK_LED : 0,
5284 &spec->vmaster_mute.sw_kctl);
5285 if (err < 0)
5286 return err;
5287 if (spec->vmaster_mute.hook) {
5288 snd_hda_add_vmaster_hook(codec, &spec->vmaster_mute);
5289 snd_hda_sync_vmaster_hook(&spec->vmaster_mute);
5290 }
5291 }
5292
5293 free_kctls(spec); /* no longer needed */
5294
5295 err = snd_hda_jack_add_kctls(codec, &spec->autocfg);
5296 if (err < 0)
5297 return err;
5298
5299 return 0;
5300 }
5301 EXPORT_SYMBOL_GPL(snd_hda_gen_build_controls);
5302
5303
5304 /*
5305 * PCM definitions
5306 */
5307
call_pcm_playback_hook(struct hda_pcm_stream * hinfo,struct hda_codec * codec,struct snd_pcm_substream * substream,int action)5308 static void call_pcm_playback_hook(struct hda_pcm_stream *hinfo,
5309 struct hda_codec *codec,
5310 struct snd_pcm_substream *substream,
5311 int action)
5312 {
5313 struct hda_gen_spec *spec = codec->spec;
5314 if (spec->pcm_playback_hook)
5315 spec->pcm_playback_hook(hinfo, codec, substream, action);
5316 }
5317
call_pcm_capture_hook(struct hda_pcm_stream * hinfo,struct hda_codec * codec,struct snd_pcm_substream * substream,int action)5318 static void call_pcm_capture_hook(struct hda_pcm_stream *hinfo,
5319 struct hda_codec *codec,
5320 struct snd_pcm_substream *substream,
5321 int action)
5322 {
5323 struct hda_gen_spec *spec = codec->spec;
5324 if (spec->pcm_capture_hook)
5325 spec->pcm_capture_hook(hinfo, codec, substream, action);
5326 }
5327
5328 /*
5329 * Analog playback callbacks
5330 */
playback_pcm_open(struct hda_pcm_stream * hinfo,struct hda_codec * codec,struct snd_pcm_substream * substream)5331 static int playback_pcm_open(struct hda_pcm_stream *hinfo,
5332 struct hda_codec *codec,
5333 struct snd_pcm_substream *substream)
5334 {
5335 struct hda_gen_spec *spec = codec->spec;
5336 int err;
5337
5338 mutex_lock(&spec->pcm_mutex);
5339 err = snd_hda_multi_out_analog_open(codec,
5340 &spec->multiout, substream,
5341 hinfo);
5342 if (!err) {
5343 spec->active_streams |= 1 << STREAM_MULTI_OUT;
5344 call_pcm_playback_hook(hinfo, codec, substream,
5345 HDA_GEN_PCM_ACT_OPEN);
5346 }
5347 mutex_unlock(&spec->pcm_mutex);
5348 return err;
5349 }
5350
playback_pcm_prepare(struct hda_pcm_stream * hinfo,struct hda_codec * codec,unsigned int stream_tag,unsigned int format,struct snd_pcm_substream * substream)5351 static int playback_pcm_prepare(struct hda_pcm_stream *hinfo,
5352 struct hda_codec *codec,
5353 unsigned int stream_tag,
5354 unsigned int format,
5355 struct snd_pcm_substream *substream)
5356 {
5357 struct hda_gen_spec *spec = codec->spec;
5358 int err;
5359
5360 err = snd_hda_multi_out_analog_prepare(codec, &spec->multiout,
5361 stream_tag, format, substream);
5362 if (!err)
5363 call_pcm_playback_hook(hinfo, codec, substream,
5364 HDA_GEN_PCM_ACT_PREPARE);
5365 return err;
5366 }
5367
playback_pcm_cleanup(struct hda_pcm_stream * hinfo,struct hda_codec * codec,struct snd_pcm_substream * substream)5368 static int playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
5369 struct hda_codec *codec,
5370 struct snd_pcm_substream *substream)
5371 {
5372 struct hda_gen_spec *spec = codec->spec;
5373 int err;
5374
5375 err = snd_hda_multi_out_analog_cleanup(codec, &spec->multiout);
5376 if (!err)
5377 call_pcm_playback_hook(hinfo, codec, substream,
5378 HDA_GEN_PCM_ACT_CLEANUP);
5379 return err;
5380 }
5381
playback_pcm_close(struct hda_pcm_stream * hinfo,struct hda_codec * codec,struct snd_pcm_substream * substream)5382 static int playback_pcm_close(struct hda_pcm_stream *hinfo,
5383 struct hda_codec *codec,
5384 struct snd_pcm_substream *substream)
5385 {
5386 struct hda_gen_spec *spec = codec->spec;
5387 mutex_lock(&spec->pcm_mutex);
5388 spec->active_streams &= ~(1 << STREAM_MULTI_OUT);
5389 call_pcm_playback_hook(hinfo, codec, substream,
5390 HDA_GEN_PCM_ACT_CLOSE);
5391 mutex_unlock(&spec->pcm_mutex);
5392 return 0;
5393 }
5394
capture_pcm_open(struct hda_pcm_stream * hinfo,struct hda_codec * codec,struct snd_pcm_substream * substream)5395 static int capture_pcm_open(struct hda_pcm_stream *hinfo,
5396 struct hda_codec *codec,
5397 struct snd_pcm_substream *substream)
5398 {
5399 call_pcm_capture_hook(hinfo, codec, substream, HDA_GEN_PCM_ACT_OPEN);
5400 return 0;
5401 }
5402
capture_pcm_prepare(struct hda_pcm_stream * hinfo,struct hda_codec * codec,unsigned int stream_tag,unsigned int format,struct snd_pcm_substream * substream)5403 static int capture_pcm_prepare(struct hda_pcm_stream *hinfo,
5404 struct hda_codec *codec,
5405 unsigned int stream_tag,
5406 unsigned int format,
5407 struct snd_pcm_substream *substream)
5408 {
5409 snd_hda_codec_setup_stream(codec, hinfo->nid, stream_tag, 0, format);
5410 call_pcm_capture_hook(hinfo, codec, substream,
5411 HDA_GEN_PCM_ACT_PREPARE);
5412 return 0;
5413 }
5414
capture_pcm_cleanup(struct hda_pcm_stream * hinfo,struct hda_codec * codec,struct snd_pcm_substream * substream)5415 static int capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
5416 struct hda_codec *codec,
5417 struct snd_pcm_substream *substream)
5418 {
5419 snd_hda_codec_cleanup_stream(codec, hinfo->nid);
5420 call_pcm_capture_hook(hinfo, codec, substream,
5421 HDA_GEN_PCM_ACT_CLEANUP);
5422 return 0;
5423 }
5424
capture_pcm_close(struct hda_pcm_stream * hinfo,struct hda_codec * codec,struct snd_pcm_substream * substream)5425 static int capture_pcm_close(struct hda_pcm_stream *hinfo,
5426 struct hda_codec *codec,
5427 struct snd_pcm_substream *substream)
5428 {
5429 call_pcm_capture_hook(hinfo, codec, substream, HDA_GEN_PCM_ACT_CLOSE);
5430 return 0;
5431 }
5432
alt_playback_pcm_open(struct hda_pcm_stream * hinfo,struct hda_codec * codec,struct snd_pcm_substream * substream)5433 static int alt_playback_pcm_open(struct hda_pcm_stream *hinfo,
5434 struct hda_codec *codec,
5435 struct snd_pcm_substream *substream)
5436 {
5437 struct hda_gen_spec *spec = codec->spec;
5438 int err = 0;
5439
5440 mutex_lock(&spec->pcm_mutex);
5441 if (spec->indep_hp && !spec->indep_hp_enabled)
5442 err = -EBUSY;
5443 else
5444 spec->active_streams |= 1 << STREAM_INDEP_HP;
5445 call_pcm_playback_hook(hinfo, codec, substream,
5446 HDA_GEN_PCM_ACT_OPEN);
5447 mutex_unlock(&spec->pcm_mutex);
5448 return err;
5449 }
5450
alt_playback_pcm_close(struct hda_pcm_stream * hinfo,struct hda_codec * codec,struct snd_pcm_substream * substream)5451 static int alt_playback_pcm_close(struct hda_pcm_stream *hinfo,
5452 struct hda_codec *codec,
5453 struct snd_pcm_substream *substream)
5454 {
5455 struct hda_gen_spec *spec = codec->spec;
5456 mutex_lock(&spec->pcm_mutex);
5457 spec->active_streams &= ~(1 << STREAM_INDEP_HP);
5458 call_pcm_playback_hook(hinfo, codec, substream,
5459 HDA_GEN_PCM_ACT_CLOSE);
5460 mutex_unlock(&spec->pcm_mutex);
5461 return 0;
5462 }
5463
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)5464 static int alt_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
5465 struct hda_codec *codec,
5466 unsigned int stream_tag,
5467 unsigned int format,
5468 struct snd_pcm_substream *substream)
5469 {
5470 snd_hda_codec_setup_stream(codec, hinfo->nid, stream_tag, 0, format);
5471 call_pcm_playback_hook(hinfo, codec, substream,
5472 HDA_GEN_PCM_ACT_PREPARE);
5473 return 0;
5474 }
5475
alt_playback_pcm_cleanup(struct hda_pcm_stream * hinfo,struct hda_codec * codec,struct snd_pcm_substream * substream)5476 static int alt_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
5477 struct hda_codec *codec,
5478 struct snd_pcm_substream *substream)
5479 {
5480 snd_hda_codec_cleanup_stream(codec, hinfo->nid);
5481 call_pcm_playback_hook(hinfo, codec, substream,
5482 HDA_GEN_PCM_ACT_CLEANUP);
5483 return 0;
5484 }
5485
5486 /*
5487 * Digital out
5488 */
dig_playback_pcm_open(struct hda_pcm_stream * hinfo,struct hda_codec * codec,struct snd_pcm_substream * substream)5489 static int dig_playback_pcm_open(struct hda_pcm_stream *hinfo,
5490 struct hda_codec *codec,
5491 struct snd_pcm_substream *substream)
5492 {
5493 struct hda_gen_spec *spec = codec->spec;
5494 return snd_hda_multi_out_dig_open(codec, &spec->multiout);
5495 }
5496
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)5497 static int dig_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
5498 struct hda_codec *codec,
5499 unsigned int stream_tag,
5500 unsigned int format,
5501 struct snd_pcm_substream *substream)
5502 {
5503 struct hda_gen_spec *spec = codec->spec;
5504 return snd_hda_multi_out_dig_prepare(codec, &spec->multiout,
5505 stream_tag, format, substream);
5506 }
5507
dig_playback_pcm_cleanup(struct hda_pcm_stream * hinfo,struct hda_codec * codec,struct snd_pcm_substream * substream)5508 static int dig_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
5509 struct hda_codec *codec,
5510 struct snd_pcm_substream *substream)
5511 {
5512 struct hda_gen_spec *spec = codec->spec;
5513 return snd_hda_multi_out_dig_cleanup(codec, &spec->multiout);
5514 }
5515
dig_playback_pcm_close(struct hda_pcm_stream * hinfo,struct hda_codec * codec,struct snd_pcm_substream * substream)5516 static int dig_playback_pcm_close(struct hda_pcm_stream *hinfo,
5517 struct hda_codec *codec,
5518 struct snd_pcm_substream *substream)
5519 {
5520 struct hda_gen_spec *spec = codec->spec;
5521 return snd_hda_multi_out_dig_close(codec, &spec->multiout);
5522 }
5523
5524 /*
5525 * Analog capture
5526 */
5527 #define alt_capture_pcm_open capture_pcm_open
5528 #define alt_capture_pcm_close capture_pcm_close
5529
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)5530 static int alt_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
5531 struct hda_codec *codec,
5532 unsigned int stream_tag,
5533 unsigned int format,
5534 struct snd_pcm_substream *substream)
5535 {
5536 struct hda_gen_spec *spec = codec->spec;
5537
5538 snd_hda_codec_setup_stream(codec, spec->adc_nids[substream->number + 1],
5539 stream_tag, 0, format);
5540 call_pcm_capture_hook(hinfo, codec, substream,
5541 HDA_GEN_PCM_ACT_PREPARE);
5542 return 0;
5543 }
5544
alt_capture_pcm_cleanup(struct hda_pcm_stream * hinfo,struct hda_codec * codec,struct snd_pcm_substream * substream)5545 static int alt_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
5546 struct hda_codec *codec,
5547 struct snd_pcm_substream *substream)
5548 {
5549 struct hda_gen_spec *spec = codec->spec;
5550
5551 snd_hda_codec_cleanup_stream(codec,
5552 spec->adc_nids[substream->number + 1]);
5553 call_pcm_capture_hook(hinfo, codec, substream,
5554 HDA_GEN_PCM_ACT_CLEANUP);
5555 return 0;
5556 }
5557
5558 /*
5559 */
5560 static const struct hda_pcm_stream pcm_analog_playback = {
5561 .substreams = 1,
5562 .channels_min = 2,
5563 .channels_max = 8,
5564 /* NID is set in build_pcms */
5565 .ops = {
5566 .open = playback_pcm_open,
5567 .close = playback_pcm_close,
5568 .prepare = playback_pcm_prepare,
5569 .cleanup = playback_pcm_cleanup
5570 },
5571 };
5572
5573 static const struct hda_pcm_stream pcm_analog_capture = {
5574 .substreams = 1,
5575 .channels_min = 2,
5576 .channels_max = 2,
5577 /* NID is set in build_pcms */
5578 .ops = {
5579 .open = capture_pcm_open,
5580 .close = capture_pcm_close,
5581 .prepare = capture_pcm_prepare,
5582 .cleanup = capture_pcm_cleanup
5583 },
5584 };
5585
5586 static const struct hda_pcm_stream pcm_analog_alt_playback = {
5587 .substreams = 1,
5588 .channels_min = 2,
5589 .channels_max = 2,
5590 /* NID is set in build_pcms */
5591 .ops = {
5592 .open = alt_playback_pcm_open,
5593 .close = alt_playback_pcm_close,
5594 .prepare = alt_playback_pcm_prepare,
5595 .cleanup = alt_playback_pcm_cleanup
5596 },
5597 };
5598
5599 static const struct hda_pcm_stream pcm_analog_alt_capture = {
5600 .substreams = 2, /* can be overridden */
5601 .channels_min = 2,
5602 .channels_max = 2,
5603 /* NID is set in build_pcms */
5604 .ops = {
5605 .open = alt_capture_pcm_open,
5606 .close = alt_capture_pcm_close,
5607 .prepare = alt_capture_pcm_prepare,
5608 .cleanup = alt_capture_pcm_cleanup
5609 },
5610 };
5611
5612 static const struct hda_pcm_stream pcm_digital_playback = {
5613 .substreams = 1,
5614 .channels_min = 2,
5615 .channels_max = 2,
5616 /* NID is set in build_pcms */
5617 .ops = {
5618 .open = dig_playback_pcm_open,
5619 .close = dig_playback_pcm_close,
5620 .prepare = dig_playback_pcm_prepare,
5621 .cleanup = dig_playback_pcm_cleanup
5622 },
5623 };
5624
5625 static const struct hda_pcm_stream pcm_digital_capture = {
5626 .substreams = 1,
5627 .channels_min = 2,
5628 .channels_max = 2,
5629 /* NID is set in build_pcms */
5630 };
5631
5632 /* Used by build_pcms to flag that a PCM has no playback stream */
5633 static const struct hda_pcm_stream pcm_null_stream = {
5634 .substreams = 0,
5635 .channels_min = 0,
5636 .channels_max = 0,
5637 };
5638
5639 /*
5640 * dynamic changing ADC PCM streams
5641 */
dyn_adc_pcm_resetup(struct hda_codec * codec,int cur)5642 static bool dyn_adc_pcm_resetup(struct hda_codec *codec, int cur)
5643 {
5644 struct hda_gen_spec *spec = codec->spec;
5645 hda_nid_t new_adc = spec->adc_nids[spec->dyn_adc_idx[cur]];
5646
5647 if (spec->cur_adc && spec->cur_adc != new_adc) {
5648 /* stream is running, let's swap the current ADC */
5649 __snd_hda_codec_cleanup_stream(codec, spec->cur_adc, 1);
5650 spec->cur_adc = new_adc;
5651 snd_hda_codec_setup_stream(codec, new_adc,
5652 spec->cur_adc_stream_tag, 0,
5653 spec->cur_adc_format);
5654 return true;
5655 }
5656 return false;
5657 }
5658
5659 /* 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)5660 static int dyn_adc_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
5661 struct hda_codec *codec,
5662 unsigned int stream_tag,
5663 unsigned int format,
5664 struct snd_pcm_substream *substream)
5665 {
5666 struct hda_gen_spec *spec = codec->spec;
5667 spec->cur_adc = spec->adc_nids[spec->dyn_adc_idx[spec->cur_mux[0]]];
5668 spec->cur_adc_stream_tag = stream_tag;
5669 spec->cur_adc_format = format;
5670 snd_hda_codec_setup_stream(codec, spec->cur_adc, stream_tag, 0, format);
5671 call_pcm_capture_hook(hinfo, codec, substream, HDA_GEN_PCM_ACT_PREPARE);
5672 return 0;
5673 }
5674
dyn_adc_capture_pcm_cleanup(struct hda_pcm_stream * hinfo,struct hda_codec * codec,struct snd_pcm_substream * substream)5675 static int dyn_adc_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
5676 struct hda_codec *codec,
5677 struct snd_pcm_substream *substream)
5678 {
5679 struct hda_gen_spec *spec = codec->spec;
5680 snd_hda_codec_cleanup_stream(codec, spec->cur_adc);
5681 spec->cur_adc = 0;
5682 call_pcm_capture_hook(hinfo, codec, substream, HDA_GEN_PCM_ACT_CLEANUP);
5683 return 0;
5684 }
5685
5686 static const struct hda_pcm_stream dyn_adc_pcm_analog_capture = {
5687 .substreams = 1,
5688 .channels_min = 2,
5689 .channels_max = 2,
5690 .nid = 0, /* fill later */
5691 .ops = {
5692 .prepare = dyn_adc_capture_pcm_prepare,
5693 .cleanup = dyn_adc_capture_pcm_cleanup
5694 },
5695 };
5696
fill_pcm_stream_name(char * str,size_t len,const char * sfx,const char * chip_name)5697 static void fill_pcm_stream_name(char *str, size_t len, const char *sfx,
5698 const char *chip_name)
5699 {
5700 char *p;
5701
5702 if (*str)
5703 return;
5704 strscpy(str, chip_name, len);
5705
5706 /* drop non-alnum chars after a space */
5707 for (p = strchr(str, ' '); p; p = strchr(p + 1, ' ')) {
5708 if (!isalnum(p[1])) {
5709 *p = 0;
5710 break;
5711 }
5712 }
5713 strlcat(str, sfx, len);
5714 }
5715
5716 /* copy PCM stream info from @default_str, and override non-NULL entries
5717 * from @spec_str and @nid
5718 */
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)5719 static void setup_pcm_stream(struct hda_pcm_stream *str,
5720 const struct hda_pcm_stream *default_str,
5721 const struct hda_pcm_stream *spec_str,
5722 hda_nid_t nid)
5723 {
5724 *str = *default_str;
5725 if (nid)
5726 str->nid = nid;
5727 if (spec_str) {
5728 if (spec_str->substreams)
5729 str->substreams = spec_str->substreams;
5730 if (spec_str->channels_min)
5731 str->channels_min = spec_str->channels_min;
5732 if (spec_str->channels_max)
5733 str->channels_max = spec_str->channels_max;
5734 if (spec_str->rates)
5735 str->rates = spec_str->rates;
5736 if (spec_str->formats)
5737 str->formats = spec_str->formats;
5738 if (spec_str->maxbps)
5739 str->maxbps = spec_str->maxbps;
5740 }
5741 }
5742
5743 /**
5744 * snd_hda_gen_build_pcms - build PCM streams based on the parsed results
5745 * @codec: the HDA codec
5746 *
5747 * Pass this to build_pcms patch_ops.
5748 */
snd_hda_gen_build_pcms(struct hda_codec * codec)5749 int snd_hda_gen_build_pcms(struct hda_codec *codec)
5750 {
5751 struct hda_gen_spec *spec = codec->spec;
5752 struct hda_pcm *info;
5753 bool have_multi_adcs;
5754
5755 if (spec->no_analog)
5756 goto skip_analog;
5757
5758 fill_pcm_stream_name(spec->stream_name_analog,
5759 sizeof(spec->stream_name_analog),
5760 " Analog", codec->core.chip_name);
5761 info = snd_hda_codec_pcm_new(codec, "%s", spec->stream_name_analog);
5762 if (!info)
5763 return -ENOMEM;
5764 spec->pcm_rec[0] = info;
5765
5766 if (spec->multiout.num_dacs > 0) {
5767 setup_pcm_stream(&info->stream[SNDRV_PCM_STREAM_PLAYBACK],
5768 &pcm_analog_playback,
5769 spec->stream_analog_playback,
5770 spec->multiout.dac_nids[0]);
5771 info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max =
5772 spec->multiout.max_channels;
5773 if (spec->autocfg.line_out_type == AUTO_PIN_SPEAKER_OUT &&
5774 spec->autocfg.line_outs == 2)
5775 info->stream[SNDRV_PCM_STREAM_PLAYBACK].chmap =
5776 snd_pcm_2_1_chmaps;
5777 }
5778 if (spec->num_adc_nids) {
5779 setup_pcm_stream(&info->stream[SNDRV_PCM_STREAM_CAPTURE],
5780 (spec->dyn_adc_switch ?
5781 &dyn_adc_pcm_analog_capture : &pcm_analog_capture),
5782 spec->stream_analog_capture,
5783 spec->adc_nids[0]);
5784 }
5785
5786 skip_analog:
5787 /* SPDIF for stream index #1 */
5788 if (spec->multiout.dig_out_nid || spec->dig_in_nid) {
5789 fill_pcm_stream_name(spec->stream_name_digital,
5790 sizeof(spec->stream_name_digital),
5791 " Digital", codec->core.chip_name);
5792 info = snd_hda_codec_pcm_new(codec, "%s",
5793 spec->stream_name_digital);
5794 if (!info)
5795 return -ENOMEM;
5796 codec->follower_dig_outs = spec->multiout.follower_dig_outs;
5797 spec->pcm_rec[1] = info;
5798 if (spec->dig_out_type)
5799 info->pcm_type = spec->dig_out_type;
5800 else
5801 info->pcm_type = HDA_PCM_TYPE_SPDIF;
5802 if (spec->multiout.dig_out_nid)
5803 setup_pcm_stream(&info->stream[SNDRV_PCM_STREAM_PLAYBACK],
5804 &pcm_digital_playback,
5805 spec->stream_digital_playback,
5806 spec->multiout.dig_out_nid);
5807 if (spec->dig_in_nid)
5808 setup_pcm_stream(&info->stream[SNDRV_PCM_STREAM_CAPTURE],
5809 &pcm_digital_capture,
5810 spec->stream_digital_capture,
5811 spec->dig_in_nid);
5812 }
5813
5814 if (spec->no_analog)
5815 return 0;
5816
5817 /* If the use of more than one ADC is requested for the current
5818 * model, configure a second analog capture-only PCM.
5819 */
5820 have_multi_adcs = (spec->num_adc_nids > 1) &&
5821 !spec->dyn_adc_switch && !spec->auto_mic;
5822 /* Additional Analaog capture for index #2 */
5823 if (spec->alt_dac_nid || have_multi_adcs) {
5824 fill_pcm_stream_name(spec->stream_name_alt_analog,
5825 sizeof(spec->stream_name_alt_analog),
5826 " Alt Analog", codec->core.chip_name);
5827 info = snd_hda_codec_pcm_new(codec, "%s",
5828 spec->stream_name_alt_analog);
5829 if (!info)
5830 return -ENOMEM;
5831 spec->pcm_rec[2] = info;
5832 if (spec->alt_dac_nid)
5833 setup_pcm_stream(&info->stream[SNDRV_PCM_STREAM_PLAYBACK],
5834 &pcm_analog_alt_playback,
5835 spec->stream_analog_alt_playback,
5836 spec->alt_dac_nid);
5837 else
5838 setup_pcm_stream(&info->stream[SNDRV_PCM_STREAM_PLAYBACK],
5839 &pcm_null_stream, NULL, 0);
5840 if (have_multi_adcs) {
5841 setup_pcm_stream(&info->stream[SNDRV_PCM_STREAM_CAPTURE],
5842 &pcm_analog_alt_capture,
5843 spec->stream_analog_alt_capture,
5844 spec->adc_nids[1]);
5845 info->stream[SNDRV_PCM_STREAM_CAPTURE].substreams =
5846 spec->num_adc_nids - 1;
5847 } else {
5848 setup_pcm_stream(&info->stream[SNDRV_PCM_STREAM_CAPTURE],
5849 &pcm_null_stream, NULL, 0);
5850 }
5851 }
5852
5853 return 0;
5854 }
5855 EXPORT_SYMBOL_GPL(snd_hda_gen_build_pcms);
5856
5857
5858 /*
5859 * Standard auto-parser initializations
5860 */
5861
5862 /* configure the given path as a proper output */
set_output_and_unmute(struct hda_codec * codec,int path_idx)5863 static void set_output_and_unmute(struct hda_codec *codec, int path_idx)
5864 {
5865 struct nid_path *path;
5866 hda_nid_t pin;
5867
5868 path = snd_hda_get_path_from_idx(codec, path_idx);
5869 if (!path || !path->depth)
5870 return;
5871 pin = path->path[path->depth - 1];
5872 restore_pin_ctl(codec, pin);
5873 snd_hda_activate_path(codec, path, path->active,
5874 aamix_default(codec->spec));
5875 set_pin_eapd(codec, pin, path->active);
5876 }
5877
5878 /* initialize primary output paths */
init_multi_out(struct hda_codec * codec)5879 static void init_multi_out(struct hda_codec *codec)
5880 {
5881 struct hda_gen_spec *spec = codec->spec;
5882 int i;
5883
5884 for (i = 0; i < spec->autocfg.line_outs; i++)
5885 set_output_and_unmute(codec, spec->out_paths[i]);
5886 }
5887
5888
__init_extra_out(struct hda_codec * codec,int num_outs,int * paths)5889 static void __init_extra_out(struct hda_codec *codec, int num_outs, int *paths)
5890 {
5891 int i;
5892
5893 for (i = 0; i < num_outs; i++)
5894 set_output_and_unmute(codec, paths[i]);
5895 }
5896
5897 /* initialize hp and speaker paths */
init_extra_out(struct hda_codec * codec)5898 static void init_extra_out(struct hda_codec *codec)
5899 {
5900 struct hda_gen_spec *spec = codec->spec;
5901
5902 if (spec->autocfg.line_out_type != AUTO_PIN_HP_OUT)
5903 __init_extra_out(codec, spec->autocfg.hp_outs, spec->hp_paths);
5904 if (spec->autocfg.line_out_type != AUTO_PIN_SPEAKER_OUT)
5905 __init_extra_out(codec, spec->autocfg.speaker_outs,
5906 spec->speaker_paths);
5907 }
5908
5909 /* initialize multi-io paths */
init_multi_io(struct hda_codec * codec)5910 static void init_multi_io(struct hda_codec *codec)
5911 {
5912 struct hda_gen_spec *spec = codec->spec;
5913 int i;
5914
5915 for (i = 0; i < spec->multi_ios; i++) {
5916 hda_nid_t pin = spec->multi_io[i].pin;
5917 struct nid_path *path;
5918 path = get_multiio_path(codec, i);
5919 if (!path)
5920 continue;
5921 if (!spec->multi_io[i].ctl_in)
5922 spec->multi_io[i].ctl_in =
5923 snd_hda_codec_get_pin_target(codec, pin);
5924 snd_hda_activate_path(codec, path, path->active,
5925 aamix_default(spec));
5926 }
5927 }
5928
init_aamix_paths(struct hda_codec * codec)5929 static void init_aamix_paths(struct hda_codec *codec)
5930 {
5931 struct hda_gen_spec *spec = codec->spec;
5932
5933 if (!spec->have_aamix_ctl)
5934 return;
5935 if (!has_aamix_out_paths(spec))
5936 return;
5937 update_aamix_paths(codec, spec->aamix_mode, spec->out_paths[0],
5938 spec->aamix_out_paths[0],
5939 spec->autocfg.line_out_type);
5940 update_aamix_paths(codec, spec->aamix_mode, spec->hp_paths[0],
5941 spec->aamix_out_paths[1],
5942 AUTO_PIN_HP_OUT);
5943 update_aamix_paths(codec, spec->aamix_mode, spec->speaker_paths[0],
5944 spec->aamix_out_paths[2],
5945 AUTO_PIN_SPEAKER_OUT);
5946 }
5947
5948 /* set up input pins and loopback paths */
init_analog_input(struct hda_codec * codec)5949 static void init_analog_input(struct hda_codec *codec)
5950 {
5951 struct hda_gen_spec *spec = codec->spec;
5952 struct auto_pin_cfg *cfg = &spec->autocfg;
5953 int i;
5954
5955 for (i = 0; i < cfg->num_inputs; i++) {
5956 hda_nid_t nid = cfg->inputs[i].pin;
5957 if (is_input_pin(codec, nid))
5958 restore_pin_ctl(codec, nid);
5959
5960 /* init loopback inputs */
5961 if (spec->mixer_nid) {
5962 resume_path_from_idx(codec, spec->loopback_paths[i]);
5963 resume_path_from_idx(codec, spec->loopback_merge_path);
5964 }
5965 }
5966 }
5967
5968 /* initialize ADC paths */
init_input_src(struct hda_codec * codec)5969 static void init_input_src(struct hda_codec *codec)
5970 {
5971 struct hda_gen_spec *spec = codec->spec;
5972 struct hda_input_mux *imux = &spec->input_mux;
5973 struct nid_path *path;
5974 int i, c, nums;
5975
5976 if (spec->dyn_adc_switch)
5977 nums = 1;
5978 else
5979 nums = spec->num_adc_nids;
5980
5981 for (c = 0; c < nums; c++) {
5982 for (i = 0; i < imux->num_items; i++) {
5983 path = get_input_path(codec, c, i);
5984 if (path) {
5985 bool active = path->active;
5986 if (i == spec->cur_mux[c])
5987 active = true;
5988 snd_hda_activate_path(codec, path, active, false);
5989 }
5990 }
5991 if (spec->hp_mic)
5992 update_hp_mic(codec, c, true);
5993 }
5994
5995 if (spec->cap_sync_hook)
5996 spec->cap_sync_hook(codec, NULL, NULL);
5997 }
5998
5999 /* set right pin controls for digital I/O */
init_digital(struct hda_codec * codec)6000 static void init_digital(struct hda_codec *codec)
6001 {
6002 struct hda_gen_spec *spec = codec->spec;
6003 int i;
6004 hda_nid_t pin;
6005
6006 for (i = 0; i < spec->autocfg.dig_outs; i++)
6007 set_output_and_unmute(codec, spec->digout_paths[i]);
6008 pin = spec->autocfg.dig_in_pin;
6009 if (pin) {
6010 restore_pin_ctl(codec, pin);
6011 resume_path_from_idx(codec, spec->digin_path);
6012 }
6013 }
6014
6015 /* clear unsol-event tags on unused pins; Conexant codecs seem to leave
6016 * invalid unsol tags by some reason
6017 */
clear_unsol_on_unused_pins(struct hda_codec * codec)6018 static void clear_unsol_on_unused_pins(struct hda_codec *codec)
6019 {
6020 const struct hda_pincfg *pin;
6021 int i;
6022
6023 snd_array_for_each(&codec->init_pins, i, pin) {
6024 hda_nid_t nid = pin->nid;
6025 if (is_jack_detectable(codec, nid) &&
6026 !snd_hda_jack_tbl_get(codec, nid))
6027 snd_hda_codec_write_cache(codec, nid, 0,
6028 AC_VERB_SET_UNSOLICITED_ENABLE, 0);
6029 }
6030 }
6031
6032 /**
6033 * snd_hda_gen_init - initialize the generic spec
6034 * @codec: the HDA codec
6035 *
6036 * This can be put as patch_ops init function.
6037 */
snd_hda_gen_init(struct hda_codec * codec)6038 int snd_hda_gen_init(struct hda_codec *codec)
6039 {
6040 struct hda_gen_spec *spec = codec->spec;
6041
6042 if (spec->init_hook)
6043 spec->init_hook(codec);
6044
6045 if (!spec->skip_verbs)
6046 snd_hda_apply_verbs(codec);
6047
6048 init_multi_out(codec);
6049 init_extra_out(codec);
6050 init_multi_io(codec);
6051 init_aamix_paths(codec);
6052 init_analog_input(codec);
6053 init_input_src(codec);
6054 init_digital(codec);
6055
6056 clear_unsol_on_unused_pins(codec);
6057
6058 sync_all_pin_power_ctls(codec);
6059
6060 /* call init functions of standard auto-mute helpers */
6061 update_automute_all(codec);
6062
6063 snd_hda_regmap_sync(codec);
6064
6065 if (spec->vmaster_mute.sw_kctl && spec->vmaster_mute.hook)
6066 snd_hda_sync_vmaster_hook(&spec->vmaster_mute);
6067
6068 hda_call_check_power_status(codec, 0x01);
6069 return 0;
6070 }
6071 EXPORT_SYMBOL_GPL(snd_hda_gen_init);
6072
6073 /**
6074 * snd_hda_gen_free - free the generic spec
6075 * @codec: the HDA codec
6076 *
6077 * This can be put as patch_ops free function.
6078 */
snd_hda_gen_free(struct hda_codec * codec)6079 void snd_hda_gen_free(struct hda_codec *codec)
6080 {
6081 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_FREE);
6082 snd_hda_gen_spec_free(codec->spec);
6083 kfree(codec->spec);
6084 codec->spec = NULL;
6085 }
6086 EXPORT_SYMBOL_GPL(snd_hda_gen_free);
6087
6088 #ifdef CONFIG_PM
6089 /**
6090 * snd_hda_gen_check_power_status - check the loopback power save state
6091 * @codec: the HDA codec
6092 * @nid: NID to inspect
6093 *
6094 * This can be put as patch_ops check_power_status function.
6095 */
snd_hda_gen_check_power_status(struct hda_codec * codec,hda_nid_t nid)6096 int snd_hda_gen_check_power_status(struct hda_codec *codec, hda_nid_t nid)
6097 {
6098 struct hda_gen_spec *spec = codec->spec;
6099 return snd_hda_check_amp_list_power(codec, &spec->loopback, nid);
6100 }
6101 EXPORT_SYMBOL_GPL(snd_hda_gen_check_power_status);
6102 #endif
6103
6104
6105 /*
6106 * the generic codec support
6107 */
6108
6109 static const struct hda_codec_ops generic_patch_ops = {
6110 .build_controls = snd_hda_gen_build_controls,
6111 .build_pcms = snd_hda_gen_build_pcms,
6112 .init = snd_hda_gen_init,
6113 .free = snd_hda_gen_free,
6114 .unsol_event = snd_hda_jack_unsol_event,
6115 #ifdef CONFIG_PM
6116 .check_power_status = snd_hda_gen_check_power_status,
6117 #endif
6118 };
6119
6120 /*
6121 * snd_hda_parse_generic_codec - Generic codec parser
6122 * @codec: the HDA codec
6123 */
snd_hda_parse_generic_codec(struct hda_codec * codec)6124 static int snd_hda_parse_generic_codec(struct hda_codec *codec)
6125 {
6126 struct hda_gen_spec *spec;
6127 int err;
6128
6129 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
6130 if (!spec)
6131 return -ENOMEM;
6132 snd_hda_gen_spec_init(spec);
6133 codec->spec = spec;
6134
6135 err = snd_hda_parse_pin_defcfg(codec, &spec->autocfg, NULL, 0);
6136 if (err < 0)
6137 goto error;
6138
6139 err = snd_hda_gen_parse_auto_config(codec, &spec->autocfg);
6140 if (err < 0)
6141 goto error;
6142
6143 codec->patch_ops = generic_patch_ops;
6144 return 0;
6145
6146 error:
6147 snd_hda_gen_free(codec);
6148 return err;
6149 }
6150
6151 static const struct hda_device_id snd_hda_id_generic[] = {
6152 HDA_CODEC_ENTRY(HDA_CODEC_ID_GENERIC, "Generic", snd_hda_parse_generic_codec),
6153 {} /* terminator */
6154 };
6155 MODULE_DEVICE_TABLE(hdaudio, snd_hda_id_generic);
6156
6157 static struct hda_codec_driver generic_driver = {
6158 .id = snd_hda_id_generic,
6159 };
6160
6161 module_hda_codec_driver(generic_driver);
6162
6163 MODULE_LICENSE("GPL");
6164 MODULE_DESCRIPTION("Generic HD-audio codec parser");
6165