?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge git://git.kernel.org/pub/scm/linux/kernel/git/davem/net
[linux-2.6/libata-dev.git] / sound / pci / hda / hda_generic.c
blob43c2ea5395618f9ca1c166c9125b006839714f6d
1 /*
2 * Universal Interface for Intel High Definition Audio Codec
3 *
4 * Generic widget tree parser
5 *
6 * Copyright (c) 2004 Takashi Iwai <tiwai@suse.de>
7 *
8 * This driver is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 2 of the License, or
11 * (at your option) any later version.
12 *
13 * This driver is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
17 *
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, write to the Free Software
20 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
21 */
22
23 #include <linux/init.h>
24 #include <linux/slab.h>
25 #include <linux/export.h>
26 #include <linux/sort.h>
27 #include <linux/delay.h>
28 #include <linux/ctype.h>
29 #include <linux/string.h>
30 #include <linux/bitops.h>
31 #include <sound/core.h>
32 #include <sound/jack.h>
33 #include "hda_codec.h"
34 #include "hda_local.h"
35 #include "hda_auto_parser.h"
36 #include "hda_jack.h"
37 #include "hda_generic.h"
38
39
40 /* initialize hda_gen_spec struct */
41 int snd_hda_gen_spec_init(struct hda_gen_spec *spec)
42 {
43 snd_array_init(&spec->kctls, sizeof(struct snd_kcontrol_new), 32);
44 snd_array_init(&spec->paths, sizeof(struct nid_path), 8);
45 snd_array_init(&spec->loopback_list, sizeof(struct hda_amp_list), 8);
46 mutex_init(&spec->pcm_mutex);
47 return 0;
48 }
49 EXPORT_SYMBOL_HDA(snd_hda_gen_spec_init);
50
51 struct snd_kcontrol_new *
52 snd_hda_gen_add_kctl(struct hda_gen_spec *spec, const char *name,
53 const struct snd_kcontrol_new *temp)
54 {
55 struct snd_kcontrol_new *knew = snd_array_new(&spec->kctls);
56 if (!knew)
57 return NULL;
58 *knew = *temp;
59 if (name)
60 knew->name = kstrdup(name, GFP_KERNEL);
61 else if (knew->name)
62 knew->name = kstrdup(knew->name, GFP_KERNEL);
63 if (!knew->name)
64 return NULL;
65 return knew;
66 }
67 EXPORT_SYMBOL_HDA(snd_hda_gen_add_kctl);
68
69 static void free_kctls(struct hda_gen_spec *spec)
70 {
71 if (spec->kctls.list) {
72 struct snd_kcontrol_new *kctl = spec->kctls.list;
73 int i;
74 for (i = 0; i < spec->kctls.used; i++)
75 kfree(kctl[i].name);
76 }
77 snd_array_free(&spec->kctls);
78 }
79
80 void snd_hda_gen_spec_free(struct hda_gen_spec *spec)
81 {
82 if (!spec)
83 return;
84 free_kctls(spec);
85 snd_array_free(&spec->paths);
86 snd_array_free(&spec->loopback_list);
87 }
88 EXPORT_SYMBOL_HDA(snd_hda_gen_spec_free);
89
90 /*
91 * store user hints
92 */
93 static void parse_user_hints(struct hda_codec *codec)
94 {
95 struct hda_gen_spec *spec = codec->spec;
96 int val;
97
98 val = snd_hda_get_bool_hint(codec, "jack_detect");
99 if (val >= 0)
100 codec->no_jack_detect = !val;
101 val = snd_hda_get_bool_hint(codec, "inv_jack_detect");
102 if (val >= 0)
103 codec->inv_jack_detect = !!val;
104 val = snd_hda_get_bool_hint(codec, "trigger_sense");
105 if (val >= 0)
106 codec->no_trigger_sense = !val;
107 val = snd_hda_get_bool_hint(codec, "inv_eapd");
108 if (val >= 0)
109 codec->inv_eapd = !!val;
110 val = snd_hda_get_bool_hint(codec, "pcm_format_first");
111 if (val >= 0)
112 codec->pcm_format_first = !!val;
113 val = snd_hda_get_bool_hint(codec, "sticky_stream");
114 if (val >= 0)
115 codec->no_sticky_stream = !val;
116 val = snd_hda_get_bool_hint(codec, "spdif_status_reset");
117 if (val >= 0)
118 codec->spdif_status_reset = !!val;
119 val = snd_hda_get_bool_hint(codec, "pin_amp_workaround");
120 if (val >= 0)
121 codec->pin_amp_workaround = !!val;
122 val = snd_hda_get_bool_hint(codec, "single_adc_amp");
123 if (val >= 0)
124 codec->single_adc_amp = !!val;
125
126 val = snd_hda_get_bool_hint(codec, "auto_mute");
127 if (val >= 0)
128 spec->suppress_auto_mute = !val;
129 val = snd_hda_get_bool_hint(codec, "auto_mic");
130 if (val >= 0)
131 spec->suppress_auto_mic = !val;
132 val = snd_hda_get_bool_hint(codec, "line_in_auto_switch");
133 if (val >= 0)
134 spec->line_in_auto_switch = !!val;
135 val = snd_hda_get_bool_hint(codec, "need_dac_fix");
136 if (val >= 0)
137 spec->need_dac_fix = !!val;
138 val = snd_hda_get_bool_hint(codec, "primary_hp");
139 if (val >= 0)
140 spec->no_primary_hp = !val;
141 val = snd_hda_get_bool_hint(codec, "multi_cap_vol");
142 if (val >= 0)
143 spec->multi_cap_vol = !!val;
144 val = snd_hda_get_bool_hint(codec, "inv_dmic_split");
145 if (val >= 0)
146 spec->inv_dmic_split = !!val;
147 val = snd_hda_get_bool_hint(codec, "indep_hp");
148 if (val >= 0)
149 spec->indep_hp = !!val;
150 val = snd_hda_get_bool_hint(codec, "add_stereo_mix_input");
151 if (val >= 0)
152 spec->add_stereo_mix_input = !!val;
153 val = snd_hda_get_bool_hint(codec, "add_out_jack_modes");
154 if (val >= 0)
155 spec->add_out_jack_modes = !!val;
156 val = snd_hda_get_bool_hint(codec, "add_in_jack_modes");
157 if (val >= 0)
158 spec->add_in_jack_modes = !!val;
159 val = snd_hda_get_bool_hint(codec, "power_down_unused");
160 if (val >= 0)
161 spec->power_down_unused = !!val;
162
163 if (!snd_hda_get_int_hint(codec, "mixer_nid", &val))
164 spec->mixer_nid = val;
165 }
166
167 /*
168 * pin control value accesses
169 */
170
171 #define update_pin_ctl(codec, pin, val) \
172 snd_hda_codec_update_cache(codec, pin, 0, \
173 AC_VERB_SET_PIN_WIDGET_CONTROL, val)
174
175 /* restore the pinctl based on the cached value */
176 static inline void restore_pin_ctl(struct hda_codec *codec, hda_nid_t pin)
177 {
178 update_pin_ctl(codec, pin, snd_hda_codec_get_pin_target(codec, pin));
179 }
180
181 /* set the pinctl target value and write it if requested */
182 static void set_pin_target(struct hda_codec *codec, hda_nid_t pin,
183 unsigned int val, bool do_write)
184 {
185 if (!pin)
186 return;
187 val = snd_hda_correct_pin_ctl(codec, pin, val);
188 snd_hda_codec_set_pin_target(codec, pin, val);
189 if (do_write)
190 update_pin_ctl(codec, pin, val);
191 }
192
193 /* set pinctl target values for all given pins */
194 static void set_pin_targets(struct hda_codec *codec, int num_pins,
195 hda_nid_t *pins, unsigned int val)
196 {
197 int i;
198 for (i = 0; i < num_pins; i++)
199 set_pin_target(codec, pins[i], val, false);
200 }
201
202 /*
203 * parsing paths
204 */
205
206 /* return the position of NID in the list, or -1 if not found */
207 static int find_idx_in_nid_list(hda_nid_t nid, const hda_nid_t *list, int nums)
208 {
209 int i;
210 for (i = 0; i < nums; i++)
211 if (list[i] == nid)
212 return i;
213 return -1;
214 }
215
216 /* return true if the given NID is contained in the path */
217 static bool is_nid_contained(struct nid_path *path, hda_nid_t nid)
218 {
219 return find_idx_in_nid_list(nid, path->path, path->depth) >= 0;
220 }
221
222 static struct nid_path *get_nid_path(struct hda_codec *codec,
223 hda_nid_t from_nid, hda_nid_t to_nid,
224 int anchor_nid)
225 {
226 struct hda_gen_spec *spec = codec->spec;
227 int i;
228
229 for (i = 0; i < spec->paths.used; i++) {
230 struct nid_path *path = snd_array_elem(&spec->paths, i);
231 if (path->depth <= 0)
232 continue;
233 if ((!from_nid || path->path[0] == from_nid) &&
234 (!to_nid || path->path[path->depth - 1] == to_nid)) {
235 if (!anchor_nid ||
236 (anchor_nid > 0 && is_nid_contained(path, anchor_nid)) ||
237 (anchor_nid < 0 && !is_nid_contained(path, anchor_nid)))
238 return path;
239 }
240 }
241 return NULL;
242 }
243
244 /* get the path between the given NIDs;
245 * passing 0 to either @pin or @dac behaves as a wildcard
246 */
247 struct nid_path *snd_hda_get_nid_path(struct hda_codec *codec,
248 hda_nid_t from_nid, hda_nid_t to_nid)
249 {
250 return get_nid_path(codec, from_nid, to_nid, 0);
251 }
252 EXPORT_SYMBOL_HDA(snd_hda_get_nid_path);
253
254 /* get the index number corresponding to the path instance;
255 * the index starts from 1, for easier checking the invalid value
256 */
257 int snd_hda_get_path_idx(struct hda_codec *codec, struct nid_path *path)
258 {
259 struct hda_gen_spec *spec = codec->spec;
260 struct nid_path *array = spec->paths.list;
261 ssize_t idx;
262
263 if (!spec->paths.used)
264 return 0;
265 idx = path - array;
266 if (idx < 0 || idx >= spec->paths.used)
267 return 0;
268 return idx + 1;
269 }
270 EXPORT_SYMBOL_HDA(snd_hda_get_path_idx);
271
272 /* get the path instance corresponding to the given index number */
273 struct nid_path *snd_hda_get_path_from_idx(struct hda_codec *codec, int idx)
274 {
275 struct hda_gen_spec *spec = codec->spec;
276
277 if (idx <= 0 || idx > spec->paths.used)
278 return NULL;
279 return snd_array_elem(&spec->paths, idx - 1);
280 }
281 EXPORT_SYMBOL_HDA(snd_hda_get_path_from_idx);
282
283 /* check whether the given DAC is already found in any existing paths */
284 static bool is_dac_already_used(struct hda_codec *codec, hda_nid_t nid)
285 {
286 struct hda_gen_spec *spec = codec->spec;
287 int i;
288
289 for (i = 0; i < spec->paths.used; i++) {
290 struct nid_path *path = snd_array_elem(&spec->paths, i);
291 if (path->path[0] == nid)
292 return true;
293 }
294 return false;
295 }
296
297 /* check whether the given two widgets can be connected */
298 static bool is_reachable_path(struct hda_codec *codec,
299 hda_nid_t from_nid, hda_nid_t to_nid)
300 {
301 if (!from_nid || !to_nid)
302 return false;
303 return snd_hda_get_conn_index(codec, to_nid, from_nid, true) >= 0;
304 }
305
306 /* nid, dir and idx */
307 #define AMP_VAL_COMPARE_MASK (0xffff | (1U << 18) | (0x0f << 19))
308
309 /* check whether the given ctl is already assigned in any path elements */
310 static bool is_ctl_used(struct hda_codec *codec, unsigned int val, int type)
311 {
312 struct hda_gen_spec *spec = codec->spec;
313 int i;
314
315 val &= AMP_VAL_COMPARE_MASK;
316 for (i = 0; i < spec->paths.used; i++) {
317 struct nid_path *path = snd_array_elem(&spec->paths, i);
318 if ((path->ctls[type] & AMP_VAL_COMPARE_MASK) == val)
319 return true;
320 }
321 return false;
322 }
323
324 /* check whether a control with the given (nid, dir, idx) was assigned */
325 static bool is_ctl_associated(struct hda_codec *codec, hda_nid_t nid,
326 int dir, int idx, int type)
327 {
328 unsigned int val = HDA_COMPOSE_AMP_VAL(nid, 3, idx, dir);
329 return is_ctl_used(codec, val, type);
330 }
331
332 static void print_nid_path(const char *pfx, struct nid_path *path)
333 {
334 char buf[40];
335 int i;
336
337
338 buf[0] = 0;
339 for (i = 0; i < path->depth; i++) {
340 char tmp[4];
341 sprintf(tmp, ":%02x", path->path[i]);
342 strlcat(buf, tmp, sizeof(buf));
343 }
344 snd_printdd("%s path: depth=%d %s\n", pfx, path->depth, buf);
345 }
346
347 /* called recursively */
348 static bool __parse_nid_path(struct hda_codec *codec,
349 hda_nid_t from_nid, hda_nid_t to_nid,
350 int anchor_nid, struct nid_path *path,
351 int depth)
352 {
353 const hda_nid_t *conn;
354 int i, nums;
355
356 if (to_nid == anchor_nid)
357 anchor_nid = 0; /* anchor passed */
358 else if (to_nid == (hda_nid_t)(-anchor_nid))
359 return false; /* hit the exclusive nid */
360
361 nums = snd_hda_get_conn_list(codec, to_nid, &conn);
362 for (i = 0; i < nums; i++) {
363 if (conn[i] != from_nid) {
364 /* special case: when from_nid is 0,
365 * try to find an empty DAC
366 */
367 if (from_nid ||
368 get_wcaps_type(get_wcaps(codec, conn[i])) != AC_WID_AUD_OUT ||
369 is_dac_already_used(codec, conn[i]))
370 continue;
371 }
372 /* anchor is not requested or already passed? */
373 if (anchor_nid <= 0)
374 goto found;
375 }
376 if (depth >= MAX_NID_PATH_DEPTH)
377 return false;
378 for (i = 0; i < nums; i++) {
379 unsigned int type;
380 type = get_wcaps_type(get_wcaps(codec, conn[i]));
381 if (type == AC_WID_AUD_OUT || type == AC_WID_AUD_IN ||
382 type == AC_WID_PIN)
383 continue;
384 if (__parse_nid_path(codec, from_nid, conn[i],
385 anchor_nid, path, depth + 1))
386 goto found;
387 }
388 return false;
389
390 found:
391 path->path[path->depth] = conn[i];
392 path->idx[path->depth + 1] = i;
393 if (nums > 1 && get_wcaps_type(get_wcaps(codec, to_nid)) != AC_WID_AUD_MIX)
394 path->multi[path->depth + 1] = 1;
395 path->depth++;
396 return true;
397 }
398
399 /* parse the widget path from the given nid to the target nid;
400 * when @from_nid is 0, try to find an empty DAC;
401 * when @anchor_nid is set to a positive value, only paths through the widget
402 * with the given value are evaluated.
403 * when @anchor_nid is set to a negative value, paths through the widget
404 * with the negative of given value are excluded, only other paths are chosen.
405 * when @anchor_nid is zero, no special handling about path selection.
406 */
407 bool snd_hda_parse_nid_path(struct hda_codec *codec, hda_nid_t from_nid,
408 hda_nid_t to_nid, int anchor_nid,
409 struct nid_path *path)
410 {
411 if (__parse_nid_path(codec, from_nid, to_nid, anchor_nid, path, 1)) {
412 path->path[path->depth] = to_nid;
413 path->depth++;
414 return true;
415 }
416 return false;
417 }
418 EXPORT_SYMBOL_HDA(snd_hda_parse_nid_path);
419
420 /*
421 * parse the path between the given NIDs and add to the path list.
422 * if no valid path is found, return NULL
423 */
424 struct nid_path *
425 snd_hda_add_new_path(struct hda_codec *codec, hda_nid_t from_nid,
426 hda_nid_t to_nid, int anchor_nid)
427 {
428 struct hda_gen_spec *spec = codec->spec;
429 struct nid_path *path;
430
431 if (from_nid && to_nid && !is_reachable_path(codec, from_nid, to_nid))
432 return NULL;
433
434 /* check whether the path has been already added */
435 path = get_nid_path(codec, from_nid, to_nid, anchor_nid);
436 if (path)
437 return path;
438
439 path = snd_array_new(&spec->paths);
440 if (!path)
441 return NULL;
442 memset(path, 0, sizeof(*path));
443 if (snd_hda_parse_nid_path(codec, from_nid, to_nid, anchor_nid, path))
444 return path;
445 /* push back */
446 spec->paths.used--;
447 return NULL;
448 }
449 EXPORT_SYMBOL_HDA(snd_hda_add_new_path);
450
451 /* clear the given path as invalid so that it won't be picked up later */
452 static void invalidate_nid_path(struct hda_codec *codec, int idx)
453 {
454 struct nid_path *path = snd_hda_get_path_from_idx(codec, idx);
455 if (!path)
456 return;
457 memset(path, 0, sizeof(*path));
458 }
459
460 /* look for an empty DAC slot */
461 static hda_nid_t look_for_dac(struct hda_codec *codec, hda_nid_t pin,
462 bool is_digital)
463 {
464 struct hda_gen_spec *spec = codec->spec;
465 bool cap_digital;
466 int i;
467
468 for (i = 0; i < spec->num_all_dacs; i++) {
469 hda_nid_t nid = spec->all_dacs[i];
470 if (!nid || is_dac_already_used(codec, nid))
471 continue;
472 cap_digital = !!(get_wcaps(codec, nid) & AC_WCAP_DIGITAL);
473 if (is_digital != cap_digital)
474 continue;
475 if (is_reachable_path(codec, nid, pin))
476 return nid;
477 }
478 return 0;
479 }
480
481 /* replace the channels in the composed amp value with the given number */
482 static unsigned int amp_val_replace_channels(unsigned int val, unsigned int chs)
483 {
484 val &= ~(0x3U << 16);
485 val |= chs << 16;
486 return val;
487 }
488
489 /* check whether the widget has the given amp capability for the direction */
490 static bool check_amp_caps(struct hda_codec *codec, hda_nid_t nid,
491 int dir, unsigned int bits)
492 {
493 if (!nid)
494 return false;
495 if (get_wcaps(codec, nid) & (1 << (dir + 1)))
496 if (query_amp_caps(codec, nid, dir) & bits)
497 return true;
498 return false;
499 }
500
501 static bool same_amp_caps(struct hda_codec *codec, hda_nid_t nid1,
502 hda_nid_t nid2, int dir)
503 {
504 if (!(get_wcaps(codec, nid1) & (1 << (dir + 1))))
505 return !(get_wcaps(codec, nid2) & (1 << (dir + 1)));
506 return (query_amp_caps(codec, nid1, dir) ==
507 query_amp_caps(codec, nid2, dir));
508 }
509
510 #define nid_has_mute(codec, nid, dir) \
511 check_amp_caps(codec, nid, dir, AC_AMPCAP_MUTE)
512 #define nid_has_volume(codec, nid, dir) \
513 check_amp_caps(codec, nid, dir, AC_AMPCAP_NUM_STEPS)
514
515 /* look for a widget suitable for assigning a mute switch in the path */
516 static hda_nid_t look_for_out_mute_nid(struct hda_codec *codec,
517 struct nid_path *path)
518 {
519 int i;
520
521 for (i = path->depth - 1; i >= 0; i--) {
522 if (nid_has_mute(codec, path->path[i], HDA_OUTPUT))
523 return path->path[i];
524 if (i != path->depth - 1 && i != 0 &&
525 nid_has_mute(codec, path->path[i], HDA_INPUT))
526 return path->path[i];
527 }
528 return 0;
529 }
530
531 /* look for a widget suitable for assigning a volume ctl in the path */
532 static hda_nid_t look_for_out_vol_nid(struct hda_codec *codec,
533 struct nid_path *path)
534 {
535 int i;
536
537 for (i = path->depth - 1; i >= 0; i--) {
538 if (nid_has_volume(codec, path->path[i], HDA_OUTPUT))
539 return path->path[i];
540 }
541 return 0;
542 }
543
544 /*
545 * path activation / deactivation
546 */
547
548 /* can have the amp-in capability? */
549 static bool has_amp_in(struct hda_codec *codec, struct nid_path *path, int idx)
550 {
551 hda_nid_t nid = path->path[idx];
552 unsigned int caps = get_wcaps(codec, nid);
553 unsigned int type = get_wcaps_type(caps);
554
555 if (!(caps & AC_WCAP_IN_AMP))
556 return false;
557 if (type == AC_WID_PIN && idx > 0) /* only for input pins */
558 return false;
559 return true;
560 }
561
562 /* can have the amp-out capability? */
563 static bool has_amp_out(struct hda_codec *codec, struct nid_path *path, int idx)
564 {
565 hda_nid_t nid = path->path[idx];
566 unsigned int caps = get_wcaps(codec, nid);
567 unsigned int type = get_wcaps_type(caps);
568
569 if (!(caps & AC_WCAP_OUT_AMP))
570 return false;
571 if (type == AC_WID_PIN && !idx) /* only for output pins */
572 return false;
573 return true;
574 }
575
576 /* check whether the given (nid,dir,idx) is active */
577 static bool is_active_nid(struct hda_codec *codec, hda_nid_t nid,
578 unsigned int dir, unsigned int idx)
579 {
580 struct hda_gen_spec *spec = codec->spec;
581 int i, n;
582
583 for (n = 0; n < spec->paths.used; n++) {
584 struct nid_path *path = snd_array_elem(&spec->paths, n);
585 if (!path->active)
586 continue;
587 for (i = 0; i < path->depth; i++) {
588 if (path->path[i] == nid) {
589 if (dir == HDA_OUTPUT || path->idx[i] == idx)
590 return true;
591 break;
592 }
593 }
594 }
595 return false;
596 }
597
598 /* get the default amp value for the target state */
599 static int get_amp_val_to_activate(struct hda_codec *codec, hda_nid_t nid,
600 int dir, unsigned int caps, bool enable)
601 {
602 unsigned int val = 0;
603
604 if (caps & AC_AMPCAP_NUM_STEPS) {
605 /* set to 0dB */
606 if (enable)
607 val = (caps & AC_AMPCAP_OFFSET) >> AC_AMPCAP_OFFSET_SHIFT;
608 }
609 if (caps & AC_AMPCAP_MUTE) {
610 if (!enable)
611 val |= HDA_AMP_MUTE;
612 }
613 return val;
614 }
615
616 /* initialize the amp value (only at the first time) */
617 static void init_amp(struct hda_codec *codec, hda_nid_t nid, int dir, int idx)
618 {
619 unsigned int caps = query_amp_caps(codec, nid, dir);
620 int val = get_amp_val_to_activate(codec, nid, dir, caps, false);
621 snd_hda_codec_amp_init_stereo(codec, nid, dir, idx, 0xff, val);
622 }
623
624 /* calculate amp value mask we can modify;
625 * if the given amp is controlled by mixers, don't touch it
626 */
627 static unsigned int get_amp_mask_to_modify(struct hda_codec *codec,
628 hda_nid_t nid, int dir, int idx,
629 unsigned int caps)
630 {
631 unsigned int mask = 0xff;
632
633 if (caps & AC_AMPCAP_MUTE) {
634 if (is_ctl_associated(codec, nid, dir, idx, NID_PATH_MUTE_CTL))
635 mask &= ~0x80;
636 }
637 if (caps & AC_AMPCAP_NUM_STEPS) {
638 if (is_ctl_associated(codec, nid, dir, idx, NID_PATH_VOL_CTL) ||
639 is_ctl_associated(codec, nid, dir, idx, NID_PATH_BOOST_CTL))
640 mask &= ~0x7f;
641 }
642 return mask;
643 }
644
645 static void activate_amp(struct hda_codec *codec, hda_nid_t nid, int dir,
646 int idx, int idx_to_check, bool enable)
647 {
648 unsigned int caps;
649 unsigned int mask, val;
650
651 if (!enable && is_active_nid(codec, nid, dir, idx_to_check))
652 return;
653
654 caps = query_amp_caps(codec, nid, dir);
655 val = get_amp_val_to_activate(codec, nid, dir, caps, enable);
656 mask = get_amp_mask_to_modify(codec, nid, dir, idx_to_check, caps);
657 if (!mask)
658 return;
659
660 val &= mask;
661 snd_hda_codec_amp_stereo(codec, nid, dir, idx, mask, val);
662 }
663
664 static void activate_amp_out(struct hda_codec *codec, struct nid_path *path,
665 int i, bool enable)
666 {
667 hda_nid_t nid = path->path[i];
668 init_amp(codec, nid, HDA_OUTPUT, 0);
669 activate_amp(codec, nid, HDA_OUTPUT, 0, 0, enable);
670 }
671
672 static void activate_amp_in(struct hda_codec *codec, struct nid_path *path,
673 int i, bool enable, bool add_aamix)
674 {
675 struct hda_gen_spec *spec = codec->spec;
676 const hda_nid_t *conn;
677 int n, nums, idx;
678 int type;
679 hda_nid_t nid = path->path[i];
680
681 nums = snd_hda_get_conn_list(codec, nid, &conn);
682 type = get_wcaps_type(get_wcaps(codec, nid));
683 if (type == AC_WID_PIN ||
684 (type == AC_WID_AUD_IN && codec->single_adc_amp)) {
685 nums = 1;
686 idx = 0;
687 } else
688 idx = path->idx[i];
689
690 for (n = 0; n < nums; n++)
691 init_amp(codec, nid, HDA_INPUT, n);
692
693 /* here is a little bit tricky in comparison with activate_amp_out();
694 * when aa-mixer is available, we need to enable the path as well
695 */
696 for (n = 0; n < nums; n++) {
697 if (n != idx && (!add_aamix || conn[n] != spec->mixer_merge_nid))
698 continue;
699 activate_amp(codec, nid, HDA_INPUT, n, idx, enable);
700 }
701 }
702
703 /* activate or deactivate the given path
704 * if @add_aamix is set, enable the input from aa-mix NID as well (if any)
705 */
706 void snd_hda_activate_path(struct hda_codec *codec, struct nid_path *path,
707 bool enable, bool add_aamix)
708 {
709 struct hda_gen_spec *spec = codec->spec;
710 int i;
711
712 if (!enable)
713 path->active = false;
714
715 for (i = path->depth - 1; i >= 0; i--) {
716 hda_nid_t nid = path->path[i];
717 if (enable && spec->power_down_unused) {
718 /* make sure the widget is powered up */
719 if (!snd_hda_check_power_state(codec, nid, AC_PWRST_D0))
720 snd_hda_codec_write(codec, nid, 0,
721 AC_VERB_SET_POWER_STATE,
722 AC_PWRST_D0);
723 }
724 if (enable && path->multi[i])
725 snd_hda_codec_write_cache(codec, nid, 0,
726 AC_VERB_SET_CONNECT_SEL,
727 path->idx[i]);
728 if (has_amp_in(codec, path, i))
729 activate_amp_in(codec, path, i, enable, add_aamix);
730 if (has_amp_out(codec, path, i))
731 activate_amp_out(codec, path, i, enable);
732 }
733
734 if (enable)
735 path->active = true;
736 }
737 EXPORT_SYMBOL_HDA(snd_hda_activate_path);
738
739 /* if the given path is inactive, put widgets into D3 (only if suitable) */
740 static void path_power_down_sync(struct hda_codec *codec, struct nid_path *path)
741 {
742 struct hda_gen_spec *spec = codec->spec;
743 bool changed;
744 int i;
745
746 if (!spec->power_down_unused || path->active)
747 return;
748
749 for (i = 0; i < path->depth; i++) {
750 hda_nid_t nid = path->path[i];
751 if (!snd_hda_check_power_state(codec, nid, AC_PWRST_D3)) {
752 snd_hda_codec_write(codec, nid, 0,
753 AC_VERB_SET_POWER_STATE,
754 AC_PWRST_D3);
755 changed = true;
756 }
757 }
758
759 if (changed) {
760 msleep(10);
761 snd_hda_codec_read(codec, path->path[0], 0,
762 AC_VERB_GET_POWER_STATE, 0);
763 }
764 }
765
766 /* turn on/off EAPD on the given pin */
767 static void set_pin_eapd(struct hda_codec *codec, hda_nid_t pin, bool enable)
768 {
769 struct hda_gen_spec *spec = codec->spec;
770 if (spec->own_eapd_ctl ||
771 !(snd_hda_query_pin_caps(codec, pin) & AC_PINCAP_EAPD))
772 return;
773 if (codec->inv_eapd)
774 enable = !enable;
775 snd_hda_codec_update_cache(codec, pin, 0,
776 AC_VERB_SET_EAPD_BTLENABLE,
777 enable ? 0x02 : 0x00);
778 }
779
780 /* re-initialize the path specified by the given path index */
781 static void resume_path_from_idx(struct hda_codec *codec, int path_idx)
782 {
783 struct nid_path *path = snd_hda_get_path_from_idx(codec, path_idx);
784 if (path)
785 snd_hda_activate_path(codec, path, path->active, false);
786 }
787
788
789 /*
790 * Helper functions for creating mixer ctl elements
791 */
792
793 enum {
794 HDA_CTL_WIDGET_VOL,
795 HDA_CTL_WIDGET_MUTE,
796 HDA_CTL_BIND_MUTE,
797 };
798 static const struct snd_kcontrol_new control_templates[] = {
799 HDA_CODEC_VOLUME(NULL, 0, 0, 0),
800 HDA_CODEC_MUTE(NULL, 0, 0, 0),
801 HDA_BIND_MUTE(NULL, 0, 0, 0),
802 };
803
804 /* add dynamic controls from template */
805 static struct snd_kcontrol_new *
806 add_control(struct hda_gen_spec *spec, int type, const char *name,
807 int cidx, unsigned long val)
808 {
809 struct snd_kcontrol_new *knew;
810
811 knew = snd_hda_gen_add_kctl(spec, name, &control_templates[type]);
812 if (!knew)
813 return NULL;
814 knew->index = cidx;
815 if (get_amp_nid_(val))
816 knew->subdevice = HDA_SUBDEV_AMP_FLAG;
817 knew->private_value = val;
818 return knew;
819 }
820
821 static int add_control_with_pfx(struct hda_gen_spec *spec, int type,
822 const char *pfx, const char *dir,
823 const char *sfx, int cidx, unsigned long val)
824 {
825 char name[32];
826 snprintf(name, sizeof(name), "%s %s %s", pfx, dir, sfx);
827 if (!add_control(spec, type, name, cidx, val))
828 return -ENOMEM;
829 return 0;
830 }
831
832 #define add_pb_vol_ctrl(spec, type, pfx, val) \
833 add_control_with_pfx(spec, type, pfx, "Playback", "Volume", 0, val)
834 #define add_pb_sw_ctrl(spec, type, pfx, val) \
835 add_control_with_pfx(spec, type, pfx, "Playback", "Switch", 0, val)
836 #define __add_pb_vol_ctrl(spec, type, pfx, cidx, val) \
837 add_control_with_pfx(spec, type, pfx, "Playback", "Volume", cidx, val)
838 #define __add_pb_sw_ctrl(spec, type, pfx, cidx, val) \
839 add_control_with_pfx(spec, type, pfx, "Playback", "Switch", cidx, val)
840
841 static int add_vol_ctl(struct hda_codec *codec, const char *pfx, int cidx,
842 unsigned int chs, struct nid_path *path)
843 {
844 unsigned int val;
845 if (!path)
846 return 0;
847 val = path->ctls[NID_PATH_VOL_CTL];
848 if (!val)
849 return 0;
850 val = amp_val_replace_channels(val, chs);
851 return __add_pb_vol_ctrl(codec->spec, HDA_CTL_WIDGET_VOL, pfx, cidx, val);
852 }
853
854 /* return the channel bits suitable for the given path->ctls[] */
855 static int get_default_ch_nums(struct hda_codec *codec, struct nid_path *path,
856 int type)
857 {
858 int chs = 1; /* mono (left only) */
859 if (path) {
860 hda_nid_t nid = get_amp_nid_(path->ctls[type]);
861 if (nid && (get_wcaps(codec, nid) & AC_WCAP_STEREO))
862 chs = 3; /* stereo */
863 }
864 return chs;
865 }
866
867 static int add_stereo_vol(struct hda_codec *codec, const char *pfx, int cidx,
868 struct nid_path *path)
869 {
870 int chs = get_default_ch_nums(codec, path, NID_PATH_VOL_CTL);
871 return add_vol_ctl(codec, pfx, cidx, chs, path);
872 }
873
874 /* create a mute-switch for the given mixer widget;
875 * if it has multiple sources (e.g. DAC and loopback), create a bind-mute
876 */
877 static int add_sw_ctl(struct hda_codec *codec, const char *pfx, int cidx,
878 unsigned int chs, struct nid_path *path)
879 {
880 unsigned int val;
881 int type = HDA_CTL_WIDGET_MUTE;
882
883 if (!path)
884 return 0;
885 val = path->ctls[NID_PATH_MUTE_CTL];
886 if (!val)
887 return 0;
888 val = amp_val_replace_channels(val, chs);
889 if (get_amp_direction_(val) == HDA_INPUT) {
890 hda_nid_t nid = get_amp_nid_(val);
891 int nums = snd_hda_get_num_conns(codec, nid);
892 if (nums > 1) {
893 type = HDA_CTL_BIND_MUTE;
894 val |= nums << 19;
895 }
896 }
897 return __add_pb_sw_ctrl(codec->spec, type, pfx, cidx, val);
898 }
899
900 static int add_stereo_sw(struct hda_codec *codec, const char *pfx,
901 int cidx, struct nid_path *path)
902 {
903 int chs = get_default_ch_nums(codec, path, NID_PATH_MUTE_CTL);
904 return add_sw_ctl(codec, pfx, cidx, chs, path);
905 }
906
907 /* any ctl assigned to the path with the given index? */
908 static bool path_has_mixer(struct hda_codec *codec, int path_idx, int ctl_type)
909 {
910 struct nid_path *path = snd_hda_get_path_from_idx(codec, path_idx);
911 return path && path->ctls[ctl_type];
912 }
913
914 static const char * const channel_name[4] = {
915 "Front", "Surround", "CLFE", "Side"
916 };
917
918 /* give some appropriate ctl name prefix for the given line out channel */
919 static const char *get_line_out_pfx(struct hda_codec *codec, int ch,
920 int *index, int ctl_type)
921 {
922 struct hda_gen_spec *spec = codec->spec;
923 struct auto_pin_cfg *cfg = &spec->autocfg;
924
925 *index = 0;
926 if (cfg->line_outs == 1 && !spec->multi_ios &&
927 !cfg->hp_outs && !cfg->speaker_outs)
928 return spec->vmaster_mute.hook ? "PCM" : "Master";
929
930 /* if there is really a single DAC used in the whole output paths,
931 * use it master (or "PCM" if a vmaster hook is present)
932 */
933 if (spec->multiout.num_dacs == 1 && !spec->mixer_nid &&
934 !spec->multiout.hp_out_nid[0] && !spec->multiout.extra_out_nid[0])
935 return spec->vmaster_mute.hook ? "PCM" : "Master";
936
937 /* multi-io channels */
938 if (ch >= cfg->line_outs)
939 return channel_name[ch];
940
941 switch (cfg->line_out_type) {
942 case AUTO_PIN_SPEAKER_OUT:
943 /* if the primary channel vol/mute is shared with HP volume,
944 * don't name it as Speaker
945 */
946 if (!ch && cfg->hp_outs &&
947 !path_has_mixer(codec, spec->hp_paths[0], ctl_type))
948 break;
949 if (cfg->line_outs == 1)
950 return "Speaker";
951 if (cfg->line_outs == 2)
952 return ch ? "Bass Speaker" : "Speaker";
953 break;
954 case AUTO_PIN_HP_OUT:
955 /* if the primary channel vol/mute is shared with spk volume,
956 * don't name it as Headphone
957 */
958 if (!ch && cfg->speaker_outs &&
959 !path_has_mixer(codec, spec->speaker_paths[0], ctl_type))
960 break;
961 /* for multi-io case, only the primary out */
962 if (ch && spec->multi_ios)
963 break;
964 *index = ch;
965 return "Headphone";
966 }
967
968 /* for a single channel output, we don't have to name the channel */
969 if (cfg->line_outs == 1 && !spec->multi_ios)
970 return "PCM";
971
972 if (ch >= ARRAY_SIZE(channel_name)) {
973 snd_BUG();
974 return "PCM";
975 }
976
977 return channel_name[ch];
978 }
979
980 /*
981 * Parse output paths
982 */
983
984 /* badness definition */
985 enum {
986 /* No primary DAC is found for the main output */
987 BAD_NO_PRIMARY_DAC = 0x10000,
988 /* No DAC is found for the extra output */
989 BAD_NO_DAC = 0x4000,
990 /* No possible multi-ios */
991 BAD_MULTI_IO = 0x120,
992 /* No individual DAC for extra output */
993 BAD_NO_EXTRA_DAC = 0x102,
994 /* No individual DAC for extra surrounds */
995 BAD_NO_EXTRA_SURR_DAC = 0x101,
996 /* Primary DAC shared with main surrounds */
997 BAD_SHARED_SURROUND = 0x100,
998 /* No independent HP possible */
999 BAD_NO_INDEP_HP = 0x40,
1000 /* Primary DAC shared with main CLFE */
1001 BAD_SHARED_CLFE = 0x10,
1002 /* Primary DAC shared with extra surrounds */
1003 BAD_SHARED_EXTRA_SURROUND = 0x10,
1004 /* Volume widget is shared */
1005 BAD_SHARED_VOL = 0x10,
1006 };
1007
1008 /* look for widgets in the given path which are appropriate for
1009 * volume and mute controls, and assign the values to ctls[].
1010 *
1011 * When no appropriate widget is found in the path, the badness value
1012 * is incremented depending on the situation. The function returns the
1013 * total badness for both volume and mute controls.
1014 */
1015 static int assign_out_path_ctls(struct hda_codec *codec, struct nid_path *path)
1016 {
1017 hda_nid_t nid;
1018 unsigned int val;
1019 int badness = 0;
1020
1021 if (!path)
1022 return BAD_SHARED_VOL * 2;
1023
1024 if (path->ctls[NID_PATH_VOL_CTL] ||
1025 path->ctls[NID_PATH_MUTE_CTL])
1026 return 0; /* already evaluated */
1027
1028 nid = look_for_out_vol_nid(codec, path);
1029 if (nid) {
1030 val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
1031 if (is_ctl_used(codec, val, NID_PATH_VOL_CTL))
1032 badness += BAD_SHARED_VOL;
1033 else
1034 path->ctls[NID_PATH_VOL_CTL] = val;
1035 } else
1036 badness += BAD_SHARED_VOL;
1037 nid = look_for_out_mute_nid(codec, path);
1038 if (nid) {
1039 unsigned int wid_type = get_wcaps_type(get_wcaps(codec, nid));
1040 if (wid_type == AC_WID_PIN || wid_type == AC_WID_AUD_OUT ||
1041 nid_has_mute(codec, nid, HDA_OUTPUT))
1042 val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
1043 else
1044 val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT);
1045 if (is_ctl_used(codec, val, NID_PATH_MUTE_CTL))
1046 badness += BAD_SHARED_VOL;
1047 else
1048 path->ctls[NID_PATH_MUTE_CTL] = val;
1049 } else
1050 badness += BAD_SHARED_VOL;
1051 return badness;
1052 }
1053
1054 struct badness_table {
1055 int no_primary_dac; /* no primary DAC */
1056 int no_dac; /* no secondary DACs */
1057 int shared_primary; /* primary DAC is shared with main output */
1058 int shared_surr; /* secondary DAC shared with main or primary */
1059 int shared_clfe; /* third DAC shared with main or primary */
1060 int shared_surr_main; /* secondary DAC sahred with main/DAC0 */
1061 };
1062
1063 static struct badness_table main_out_badness = {
1064 .no_primary_dac = BAD_NO_PRIMARY_DAC,
1065 .no_dac = BAD_NO_DAC,
1066 .shared_primary = BAD_NO_PRIMARY_DAC,
1067 .shared_surr = BAD_SHARED_SURROUND,
1068 .shared_clfe = BAD_SHARED_CLFE,
1069 .shared_surr_main = BAD_SHARED_SURROUND,
1070 };
1071
1072 static struct badness_table extra_out_badness = {
1073 .no_primary_dac = BAD_NO_DAC,
1074 .no_dac = BAD_NO_DAC,
1075 .shared_primary = BAD_NO_EXTRA_DAC,
1076 .shared_surr = BAD_SHARED_EXTRA_SURROUND,
1077 .shared_clfe = BAD_SHARED_EXTRA_SURROUND,
1078 .shared_surr_main = BAD_NO_EXTRA_SURR_DAC,
1079 };
1080
1081 /* get the DAC of the primary output corresponding to the given array index */
1082 static hda_nid_t get_primary_out(struct hda_codec *codec, int idx)
1083 {
1084 struct hda_gen_spec *spec = codec->spec;
1085 struct auto_pin_cfg *cfg = &spec->autocfg;
1086
1087 if (cfg->line_outs > idx)
1088 return spec->private_dac_nids[idx];
1089 idx -= cfg->line_outs;
1090 if (spec->multi_ios > idx)
1091 return spec->multi_io[idx].dac;
1092 return 0;
1093 }
1094
1095 /* return the DAC if it's reachable, otherwise zero */
1096 static inline hda_nid_t try_dac(struct hda_codec *codec,
1097 hda_nid_t dac, hda_nid_t pin)
1098 {
1099 return is_reachable_path(codec, dac, pin) ? dac : 0;
1100 }
1101
1102 /* try to assign DACs to pins and return the resultant badness */
1103 static int try_assign_dacs(struct hda_codec *codec, int num_outs,
1104 const hda_nid_t *pins, hda_nid_t *dacs,
1105 int *path_idx,
1106 const struct badness_table *bad)
1107 {
1108 struct hda_gen_spec *spec = codec->spec;
1109 int i, j;
1110 int badness = 0;
1111 hda_nid_t dac;
1112
1113 if (!num_outs)
1114 return 0;
1115
1116 for (i = 0; i < num_outs; i++) {
1117 struct nid_path *path;
1118 hda_nid_t pin = pins[i];
1119
1120 path = snd_hda_get_path_from_idx(codec, path_idx[i]);
1121 if (path) {
1122 badness += assign_out_path_ctls(codec, path);
1123 continue;
1124 }
1125
1126 dacs[i] = look_for_dac(codec, pin, false);
1127 if (!dacs[i] && !i) {
1128 /* try to steal the DAC of surrounds for the front */
1129 for (j = 1; j < num_outs; j++) {
1130 if (is_reachable_path(codec, dacs[j], pin)) {
1131 dacs[0] = dacs[j];
1132 dacs[j] = 0;
1133 invalidate_nid_path(codec, path_idx[j]);
1134 path_idx[j] = 0;
1135 break;
1136 }
1137 }
1138 }
1139 dac = dacs[i];
1140 if (!dac) {
1141 if (num_outs > 2)
1142 dac = try_dac(codec, get_primary_out(codec, i), pin);
1143 if (!dac)
1144 dac = try_dac(codec, dacs[0], pin);
1145 if (!dac)
1146 dac = try_dac(codec, get_primary_out(codec, i), pin);
1147 if (dac) {
1148 if (!i)
1149 badness += bad->shared_primary;
1150 else if (i == 1)
1151 badness += bad->shared_surr;
1152 else
1153 badness += bad->shared_clfe;
1154 } else if (is_reachable_path(codec, spec->private_dac_nids[0], pin)) {
1155 dac = spec->private_dac_nids[0];
1156 badness += bad->shared_surr_main;
1157 } else if (!i)
1158 badness += bad->no_primary_dac;
1159 else
1160 badness += bad->no_dac;
1161 }
1162 if (!dac)
1163 continue;
1164 path = snd_hda_add_new_path(codec, dac, pin, -spec->mixer_nid);
1165 if (!path && !i && spec->mixer_nid) {
1166 /* try with aamix */
1167 path = snd_hda_add_new_path(codec, dac, pin, 0);
1168 }
1169 if (!path) {
1170 dac = dacs[i] = 0;
1171 badness += bad->no_dac;
1172 } else {
1173 /* print_nid_path("output", path); */
1174 path->active = true;
1175 path_idx[i] = snd_hda_get_path_idx(codec, path);
1176 badness += assign_out_path_ctls(codec, path);
1177 }
1178 }
1179
1180 return badness;
1181 }
1182
1183 /* return NID if the given pin has only a single connection to a certain DAC */
1184 static hda_nid_t get_dac_if_single(struct hda_codec *codec, hda_nid_t pin)
1185 {
1186 struct hda_gen_spec *spec = codec->spec;
1187 int i;
1188 hda_nid_t nid_found = 0;
1189
1190 for (i = 0; i < spec->num_all_dacs; i++) {
1191 hda_nid_t nid = spec->all_dacs[i];
1192 if (!nid || is_dac_already_used(codec, nid))
1193 continue;
1194 if (is_reachable_path(codec, nid, pin)) {
1195 if (nid_found)
1196 return 0;
1197 nid_found = nid;
1198 }
1199 }
1200 return nid_found;
1201 }
1202
1203 /* check whether the given pin can be a multi-io pin */
1204 static bool can_be_multiio_pin(struct hda_codec *codec,
1205 unsigned int location, hda_nid_t nid)
1206 {
1207 unsigned int defcfg, caps;
1208
1209 defcfg = snd_hda_codec_get_pincfg(codec, nid);
1210 if (get_defcfg_connect(defcfg) != AC_JACK_PORT_COMPLEX)
1211 return false;
1212 if (location && get_defcfg_location(defcfg) != location)
1213 return false;
1214 caps = snd_hda_query_pin_caps(codec, nid);
1215 if (!(caps & AC_PINCAP_OUT))
1216 return false;
1217 return true;
1218 }
1219
1220 /* count the number of input pins that are capable to be multi-io */
1221 static int count_multiio_pins(struct hda_codec *codec, hda_nid_t reference_pin)
1222 {
1223 struct hda_gen_spec *spec = codec->spec;
1224 struct auto_pin_cfg *cfg = &spec->autocfg;
1225 unsigned int defcfg = snd_hda_codec_get_pincfg(codec, reference_pin);
1226 unsigned int location = get_defcfg_location(defcfg);
1227 int type, i;
1228 int num_pins = 0;
1229
1230 for (type = AUTO_PIN_LINE_IN; type >= AUTO_PIN_MIC; type--) {
1231 for (i = 0; i < cfg->num_inputs; i++) {
1232 if (cfg->inputs[i].type != type)
1233 continue;
1234 if (can_be_multiio_pin(codec, location,
1235 cfg->inputs[i].pin))
1236 num_pins++;
1237 }
1238 }
1239 return num_pins;
1240 }
1241
1242 /*
1243 * multi-io helper
1244 *
1245 * When hardwired is set, try to fill ony hardwired pins, and returns
1246 * zero if any pins are filled, non-zero if nothing found.
1247 * When hardwired is off, try to fill possible input pins, and returns
1248 * the badness value.
1249 */
1250 static int fill_multi_ios(struct hda_codec *codec,
1251 hda_nid_t reference_pin,
1252 bool hardwired)
1253 {
1254 struct hda_gen_spec *spec = codec->spec;
1255 struct auto_pin_cfg *cfg = &spec->autocfg;
1256 int type, i, j, num_pins, old_pins;
1257 unsigned int defcfg = snd_hda_codec_get_pincfg(codec, reference_pin);
1258 unsigned int location = get_defcfg_location(defcfg);
1259 int badness = 0;
1260 struct nid_path *path;
1261
1262 old_pins = spec->multi_ios;
1263 if (old_pins >= 2)
1264 goto end_fill;
1265
1266 num_pins = count_multiio_pins(codec, reference_pin);
1267 if (num_pins < 2)
1268 goto end_fill;
1269
1270 for (type = AUTO_PIN_LINE_IN; type >= AUTO_PIN_MIC; type--) {
1271 for (i = 0; i < cfg->num_inputs; i++) {
1272 hda_nid_t nid = cfg->inputs[i].pin;
1273 hda_nid_t dac = 0;
1274
1275 if (cfg->inputs[i].type != type)
1276 continue;
1277 if (!can_be_multiio_pin(codec, location, nid))
1278 continue;
1279 for (j = 0; j < spec->multi_ios; j++) {
1280 if (nid == spec->multi_io[j].pin)
1281 break;
1282 }
1283 if (j < spec->multi_ios)
1284 continue;
1285
1286 if (hardwired)
1287 dac = get_dac_if_single(codec, nid);
1288 else if (!dac)
1289 dac = look_for_dac(codec, nid, false);
1290 if (!dac) {
1291 badness++;
1292 continue;
1293 }
1294 path = snd_hda_add_new_path(codec, dac, nid,
1295 -spec->mixer_nid);
1296 if (!path) {
1297 badness++;
1298 continue;
1299 }
1300 /* print_nid_path("multiio", path); */
1301 spec->multi_io[spec->multi_ios].pin = nid;
1302 spec->multi_io[spec->multi_ios].dac = dac;
1303 spec->out_paths[cfg->line_outs + spec->multi_ios] =
1304 snd_hda_get_path_idx(codec, path);
1305 spec->multi_ios++;
1306 if (spec->multi_ios >= 2)
1307 break;
1308 }
1309 }
1310 end_fill:
1311 if (badness)
1312 badness = BAD_MULTI_IO;
1313 if (old_pins == spec->multi_ios) {
1314 if (hardwired)
1315 return 1; /* nothing found */
1316 else
1317 return badness; /* no badness if nothing found */
1318 }
1319 if (!hardwired && spec->multi_ios < 2) {
1320 /* cancel newly assigned paths */
1321 spec->paths.used -= spec->multi_ios - old_pins;
1322 spec->multi_ios = old_pins;
1323 return badness;
1324 }
1325
1326 /* assign volume and mute controls */
1327 for (i = old_pins; i < spec->multi_ios; i++) {
1328 path = snd_hda_get_path_from_idx(codec, spec->out_paths[cfg->line_outs + i]);
1329 badness += assign_out_path_ctls(codec, path);
1330 }
1331
1332 return badness;
1333 }
1334
1335 /* map DACs for all pins in the list if they are single connections */
1336 static bool map_singles(struct hda_codec *codec, int outs,
1337 const hda_nid_t *pins, hda_nid_t *dacs, int *path_idx)
1338 {
1339 struct hda_gen_spec *spec = codec->spec;
1340 int i;
1341 bool found = false;
1342 for (i = 0; i < outs; i++) {
1343 struct nid_path *path;
1344 hda_nid_t dac;
1345 if (dacs[i])
1346 continue;
1347 dac = get_dac_if_single(codec, pins[i]);
1348 if (!dac)
1349 continue;
1350 path = snd_hda_add_new_path(codec, dac, pins[i],
1351 -spec->mixer_nid);
1352 if (!path && !i && spec->mixer_nid)
1353 path = snd_hda_add_new_path(codec, dac, pins[i], 0);
1354 if (path) {
1355 dacs[i] = dac;
1356 found = true;
1357 /* print_nid_path("output", path); */
1358 path->active = true;
1359 path_idx[i] = snd_hda_get_path_idx(codec, path);
1360 }
1361 }
1362 return found;
1363 }
1364
1365 /* create a new path including aamix if available, and return its index */
1366 static int check_aamix_out_path(struct hda_codec *codec, int path_idx)
1367 {
1368 struct hda_gen_spec *spec = codec->spec;
1369 struct nid_path *path;
1370 hda_nid_t dac, pin;
1371
1372 path = snd_hda_get_path_from_idx(codec, path_idx);
1373 if (!path || !path->depth ||
1374 is_nid_contained(path, spec->mixer_nid))
1375 return 0;
1376 dac = path->path[0];
1377 pin = path->path[path->depth - 1];
1378 path = snd_hda_add_new_path(codec, dac, pin, spec->mixer_nid);
1379 if (!path) {
1380 if (dac != spec->multiout.dac_nids[0])
1381 dac = spec->multiout.dac_nids[0];
1382 else if (spec->multiout.hp_out_nid[0])
1383 dac = spec->multiout.hp_out_nid[0];
1384 else if (spec->multiout.extra_out_nid[0])
1385 dac = spec->multiout.extra_out_nid[0];
1386 if (dac)
1387 path = snd_hda_add_new_path(codec, dac, pin,
1388 spec->mixer_nid);
1389 }
1390 if (!path)
1391 return 0;
1392 /* print_nid_path("output-aamix", path); */
1393 path->active = false; /* unused as default */
1394 return snd_hda_get_path_idx(codec, path);
1395 }
1396
1397 /* check whether the independent HP is available with the current config */
1398 static bool indep_hp_possible(struct hda_codec *codec)
1399 {
1400 struct hda_gen_spec *spec = codec->spec;
1401 struct auto_pin_cfg *cfg = &spec->autocfg;
1402 struct nid_path *path;
1403 int i, idx;
1404
1405 if (cfg->line_out_type == AUTO_PIN_HP_OUT)
1406 idx = spec->out_paths[0];
1407 else
1408 idx = spec->hp_paths[0];
1409 path = snd_hda_get_path_from_idx(codec, idx);
1410 if (!path)
1411 return false;
1412
1413 /* assume no path conflicts unless aamix is involved */
1414 if (!spec->mixer_nid || !is_nid_contained(path, spec->mixer_nid))
1415 return true;
1416
1417 /* check whether output paths contain aamix */
1418 for (i = 0; i < cfg->line_outs; i++) {
1419 if (spec->out_paths[i] == idx)
1420 break;
1421 path = snd_hda_get_path_from_idx(codec, spec->out_paths[i]);
1422 if (path && is_nid_contained(path, spec->mixer_nid))
1423 return false;
1424 }
1425 for (i = 0; i < cfg->speaker_outs; i++) {
1426 path = snd_hda_get_path_from_idx(codec, spec->speaker_paths[i]);
1427 if (path && is_nid_contained(path, spec->mixer_nid))
1428 return false;
1429 }
1430
1431 return true;
1432 }
1433
1434 /* fill the empty entries in the dac array for speaker/hp with the
1435 * shared dac pointed by the paths
1436 */
1437 static void refill_shared_dacs(struct hda_codec *codec, int num_outs,
1438 hda_nid_t *dacs, int *path_idx)
1439 {
1440 struct nid_path *path;
1441 int i;
1442
1443 for (i = 0; i < num_outs; i++) {
1444 if (dacs[i])
1445 continue;
1446 path = snd_hda_get_path_from_idx(codec, path_idx[i]);
1447 if (!path)
1448 continue;
1449 dacs[i] = path->path[0];
1450 }
1451 }
1452
1453 /* fill in the dac_nids table from the parsed pin configuration */
1454 static int fill_and_eval_dacs(struct hda_codec *codec,
1455 bool fill_hardwired,
1456 bool fill_mio_first)
1457 {
1458 struct hda_gen_spec *spec = codec->spec;
1459 struct auto_pin_cfg *cfg = &spec->autocfg;
1460 int i, err, badness;
1461
1462 /* set num_dacs once to full for look_for_dac() */
1463 spec->multiout.num_dacs = cfg->line_outs;
1464 spec->multiout.dac_nids = spec->private_dac_nids;
1465 memset(spec->private_dac_nids, 0, sizeof(spec->private_dac_nids));
1466 memset(spec->multiout.hp_out_nid, 0, sizeof(spec->multiout.hp_out_nid));
1467 memset(spec->multiout.extra_out_nid, 0, sizeof(spec->multiout.extra_out_nid));
1468 spec->multi_ios = 0;
1469 snd_array_free(&spec->paths);
1470
1471 /* clear path indices */
1472 memset(spec->out_paths, 0, sizeof(spec->out_paths));
1473 memset(spec->hp_paths, 0, sizeof(spec->hp_paths));
1474 memset(spec->speaker_paths, 0, sizeof(spec->speaker_paths));
1475 memset(spec->aamix_out_paths, 0, sizeof(spec->aamix_out_paths));
1476 memset(spec->digout_paths, 0, sizeof(spec->digout_paths));
1477 memset(spec->input_paths, 0, sizeof(spec->input_paths));
1478 memset(spec->loopback_paths, 0, sizeof(spec->loopback_paths));
1479 memset(&spec->digin_path, 0, sizeof(spec->digin_path));
1480
1481 badness = 0;
1482
1483 /* fill hard-wired DACs first */
1484 if (fill_hardwired) {
1485 bool mapped;
1486 do {
1487 mapped = map_singles(codec, cfg->line_outs,
1488 cfg->line_out_pins,
1489 spec->private_dac_nids,
1490 spec->out_paths);
1491 mapped |= map_singles(codec, cfg->hp_outs,
1492 cfg->hp_pins,
1493 spec->multiout.hp_out_nid,
1494 spec->hp_paths);
1495 mapped |= map_singles(codec, cfg->speaker_outs,
1496 cfg->speaker_pins,
1497 spec->multiout.extra_out_nid,
1498 spec->speaker_paths);
1499 if (fill_mio_first && cfg->line_outs == 1 &&
1500 cfg->line_out_type != AUTO_PIN_SPEAKER_OUT) {
1501 err = fill_multi_ios(codec, cfg->line_out_pins[0], true);
1502 if (!err)
1503 mapped = true;
1504 }
1505 } while (mapped);
1506 }
1507
1508 badness += try_assign_dacs(codec, cfg->line_outs, cfg->line_out_pins,
1509 spec->private_dac_nids, spec->out_paths,
1510 &main_out_badness);
1511
1512 if (fill_mio_first &&
1513 cfg->line_outs == 1 && cfg->line_out_type != AUTO_PIN_SPEAKER_OUT) {
1514 /* try to fill multi-io first */
1515 err = fill_multi_ios(codec, cfg->line_out_pins[0], false);
1516 if (err < 0)
1517 return err;
1518 /* we don't count badness at this stage yet */
1519 }
1520
1521 if (cfg->line_out_type != AUTO_PIN_HP_OUT) {
1522 err = try_assign_dacs(codec, cfg->hp_outs, cfg->hp_pins,
1523 spec->multiout.hp_out_nid,
1524 spec->hp_paths,
1525 &extra_out_badness);
1526 if (err < 0)
1527 return err;
1528 badness += err;
1529 }
1530 if (cfg->line_out_type != AUTO_PIN_SPEAKER_OUT) {
1531 err = try_assign_dacs(codec, cfg->speaker_outs,
1532 cfg->speaker_pins,
1533 spec->multiout.extra_out_nid,
1534 spec->speaker_paths,
1535 &extra_out_badness);
1536 if (err < 0)
1537 return err;
1538 badness += err;
1539 }
1540 if (cfg->line_outs == 1 && cfg->line_out_type != AUTO_PIN_SPEAKER_OUT) {
1541 err = fill_multi_ios(codec, cfg->line_out_pins[0], false);
1542 if (err < 0)
1543 return err;
1544 badness += err;
1545 }
1546
1547 if (spec->mixer_nid) {
1548 spec->aamix_out_paths[0] =
1549 check_aamix_out_path(codec, spec->out_paths[0]);
1550 if (cfg->line_out_type != AUTO_PIN_HP_OUT)
1551 spec->aamix_out_paths[1] =
1552 check_aamix_out_path(codec, spec->hp_paths[0]);
1553 if (cfg->line_out_type != AUTO_PIN_SPEAKER_OUT)
1554 spec->aamix_out_paths[2] =
1555 check_aamix_out_path(codec, spec->speaker_paths[0]);
1556 }
1557
1558 if (cfg->hp_outs && cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
1559 if (count_multiio_pins(codec, cfg->hp_pins[0]) >= 2)
1560 spec->multi_ios = 1; /* give badness */
1561
1562 /* re-count num_dacs and squash invalid entries */
1563 spec->multiout.num_dacs = 0;
1564 for (i = 0; i < cfg->line_outs; i++) {
1565 if (spec->private_dac_nids[i])
1566 spec->multiout.num_dacs++;
1567 else {
1568 memmove(spec->private_dac_nids + i,
1569 spec->private_dac_nids + i + 1,
1570 sizeof(hda_nid_t) * (cfg->line_outs - i - 1));
1571 spec->private_dac_nids[cfg->line_outs - 1] = 0;
1572 }
1573 }
1574
1575 spec->ext_channel_count = spec->min_channel_count =
1576 spec->multiout.num_dacs * 2;
1577
1578 if (spec->multi_ios == 2) {
1579 for (i = 0; i < 2; i++)
1580 spec->private_dac_nids[spec->multiout.num_dacs++] =
1581 spec->multi_io[i].dac;
1582 } else if (spec->multi_ios) {
1583 spec->multi_ios = 0;
1584 badness += BAD_MULTI_IO;
1585 }
1586
1587 if (spec->indep_hp && !indep_hp_possible(codec))
1588 badness += BAD_NO_INDEP_HP;
1589
1590 /* re-fill the shared DAC for speaker / headphone */
1591 if (cfg->line_out_type != AUTO_PIN_HP_OUT)
1592 refill_shared_dacs(codec, cfg->hp_outs,
1593 spec->multiout.hp_out_nid,
1594 spec->hp_paths);
1595 if (cfg->line_out_type != AUTO_PIN_SPEAKER_OUT)
1596 refill_shared_dacs(codec, cfg->speaker_outs,
1597 spec->multiout.extra_out_nid,
1598 spec->speaker_paths);
1599
1600 return badness;
1601 }
1602
1603 #define DEBUG_BADNESS
1604
1605 #ifdef DEBUG_BADNESS
1606 #define debug_badness snd_printdd
1607 #else
1608 #define debug_badness(...)
1609 #endif
1610
1611 #ifdef DEBUG_BADNESS
1612 static inline void print_nid_path_idx(struct hda_codec *codec,
1613 const char *pfx, int idx)
1614 {
1615 struct nid_path *path;
1616
1617 path = snd_hda_get_path_from_idx(codec, idx);
1618 if (path)
1619 print_nid_path(pfx, path);
1620 }
1621
1622 static void debug_show_configs(struct hda_codec *codec,
1623 struct auto_pin_cfg *cfg)
1624 {
1625 struct hda_gen_spec *spec = codec->spec;
1626 static const char * const lo_type[3] = { "LO", "SP", "HP" };
1627 int i;
1628
1629 debug_badness("multi_outs = %x/%x/%x/%x : %x/%x/%x/%x (type %s)\n",
1630 cfg->line_out_pins[0], cfg->line_out_pins[1],
1631 cfg->line_out_pins[2], cfg->line_out_pins[3],
1632 spec->multiout.dac_nids[0],
1633 spec->multiout.dac_nids[1],
1634 spec->multiout.dac_nids[2],
1635 spec->multiout.dac_nids[3],
1636 lo_type[cfg->line_out_type]);
1637 for (i = 0; i < cfg->line_outs; i++)
1638 print_nid_path_idx(codec, " out", spec->out_paths[i]);
1639 if (spec->multi_ios > 0)
1640 debug_badness("multi_ios(%d) = %x/%x : %x/%x\n",
1641 spec->multi_ios,
1642 spec->multi_io[0].pin, spec->multi_io[1].pin,
1643 spec->multi_io[0].dac, spec->multi_io[1].dac);
1644 for (i = 0; i < spec->multi_ios; i++)
1645 print_nid_path_idx(codec, " mio",
1646 spec->out_paths[cfg->line_outs + i]);
1647 if (cfg->hp_outs)
1648 debug_badness("hp_outs = %x/%x/%x/%x : %x/%x/%x/%x\n",
1649 cfg->hp_pins[0], cfg->hp_pins[1],
1650 cfg->hp_pins[2], cfg->hp_pins[3],
1651 spec->multiout.hp_out_nid[0],
1652 spec->multiout.hp_out_nid[1],
1653 spec->multiout.hp_out_nid[2],
1654 spec->multiout.hp_out_nid[3]);
1655 for (i = 0; i < cfg->hp_outs; i++)
1656 print_nid_path_idx(codec, " hp ", spec->hp_paths[i]);
1657 if (cfg->speaker_outs)
1658 debug_badness("spk_outs = %x/%x/%x/%x : %x/%x/%x/%x\n",
1659 cfg->speaker_pins[0], cfg->speaker_pins[1],
1660 cfg->speaker_pins[2], cfg->speaker_pins[3],
1661 spec->multiout.extra_out_nid[0],
1662 spec->multiout.extra_out_nid[1],
1663 spec->multiout.extra_out_nid[2],
1664 spec->multiout.extra_out_nid[3]);
1665 for (i = 0; i < cfg->speaker_outs; i++)
1666 print_nid_path_idx(codec, " spk", spec->speaker_paths[i]);
1667 for (i = 0; i < 3; i++)
1668 print_nid_path_idx(codec, " mix", spec->aamix_out_paths[i]);
1669 }
1670 #else
1671 #define debug_show_configs(codec, cfg) /* NOP */
1672 #endif
1673
1674 /* find all available DACs of the codec */
1675 static void fill_all_dac_nids(struct hda_codec *codec)
1676 {
1677 struct hda_gen_spec *spec = codec->spec;
1678 int i;
1679 hda_nid_t nid = codec->start_nid;
1680
1681 spec->num_all_dacs = 0;
1682 memset(spec->all_dacs, 0, sizeof(spec->all_dacs));
1683 for (i = 0; i < codec->num_nodes; i++, nid++) {
1684 if (get_wcaps_type(get_wcaps(codec, nid)) != AC_WID_AUD_OUT)
1685 continue;
1686 if (spec->num_all_dacs >= ARRAY_SIZE(spec->all_dacs)) {
1687 snd_printk(KERN_ERR "hda: Too many DACs!\n");
1688 break;
1689 }
1690 spec->all_dacs[spec->num_all_dacs++] = nid;
1691 }
1692 }
1693
1694 static int parse_output_paths(struct hda_codec *codec)
1695 {
1696 struct hda_gen_spec *spec = codec->spec;
1697 struct auto_pin_cfg *cfg = &spec->autocfg;
1698 struct auto_pin_cfg *best_cfg;
1699 unsigned int val;
1700 int best_badness = INT_MAX;
1701 int badness;
1702 bool fill_hardwired = true, fill_mio_first = true;
1703 bool best_wired = true, best_mio = true;
1704 bool hp_spk_swapped = false;
1705
1706 best_cfg = kmalloc(sizeof(*best_cfg), GFP_KERNEL);
1707 if (!best_cfg)
1708 return -ENOMEM;
1709 *best_cfg = *cfg;
1710
1711 for (;;) {
1712 badness = fill_and_eval_dacs(codec, fill_hardwired,
1713 fill_mio_first);
1714 if (badness < 0) {
1715 kfree(best_cfg);
1716 return badness;
1717 }
1718 debug_badness("==> lo_type=%d, wired=%d, mio=%d, badness=0x%x\n",
1719 cfg->line_out_type, fill_hardwired, fill_mio_first,
1720 badness);
1721 debug_show_configs(codec, cfg);
1722 if (badness < best_badness) {
1723 best_badness = badness;
1724 *best_cfg = *cfg;
1725 best_wired = fill_hardwired;
1726 best_mio = fill_mio_first;
1727 }
1728 if (!badness)
1729 break;
1730 fill_mio_first = !fill_mio_first;
1731 if (!fill_mio_first)
1732 continue;
1733 fill_hardwired = !fill_hardwired;
1734 if (!fill_hardwired)
1735 continue;
1736 if (hp_spk_swapped)
1737 break;
1738 hp_spk_swapped = true;
1739 if (cfg->speaker_outs > 0 &&
1740 cfg->line_out_type == AUTO_PIN_HP_OUT) {
1741 cfg->hp_outs = cfg->line_outs;
1742 memcpy(cfg->hp_pins, cfg->line_out_pins,
1743 sizeof(cfg->hp_pins));
1744 cfg->line_outs = cfg->speaker_outs;
1745 memcpy(cfg->line_out_pins, cfg->speaker_pins,
1746 sizeof(cfg->speaker_pins));
1747 cfg->speaker_outs = 0;
1748 memset(cfg->speaker_pins, 0, sizeof(cfg->speaker_pins));
1749 cfg->line_out_type = AUTO_PIN_SPEAKER_OUT;
1750 fill_hardwired = true;
1751 continue;
1752 }
1753 if (cfg->hp_outs > 0 &&
1754 cfg->line_out_type == AUTO_PIN_SPEAKER_OUT) {
1755 cfg->speaker_outs = cfg->line_outs;
1756 memcpy(cfg->speaker_pins, cfg->line_out_pins,
1757 sizeof(cfg->speaker_pins));
1758 cfg->line_outs = cfg->hp_outs;
1759 memcpy(cfg->line_out_pins, cfg->hp_pins,
1760 sizeof(cfg->hp_pins));
1761 cfg->hp_outs = 0;
1762 memset(cfg->hp_pins, 0, sizeof(cfg->hp_pins));
1763 cfg->line_out_type = AUTO_PIN_HP_OUT;
1764 fill_hardwired = true;
1765 continue;
1766 }
1767 break;
1768 }
1769
1770 if (badness) {
1771 debug_badness("==> restoring best_cfg\n");
1772 *cfg = *best_cfg;
1773 fill_and_eval_dacs(codec, best_wired, best_mio);
1774 }
1775 debug_badness("==> Best config: lo_type=%d, wired=%d, mio=%d\n",
1776 cfg->line_out_type, best_wired, best_mio);
1777 debug_show_configs(codec, cfg);
1778
1779 if (cfg->line_out_pins[0]) {
1780 struct nid_path *path;
1781 path = snd_hda_get_path_from_idx(codec, spec->out_paths[0]);
1782 if (path)
1783 spec->vmaster_nid = look_for_out_vol_nid(codec, path);
1784 if (spec->vmaster_nid)
1785 snd_hda_set_vmaster_tlv(codec, spec->vmaster_nid,
1786 HDA_OUTPUT, spec->vmaster_tlv);
1787 }
1788
1789 /* set initial pinctl targets */
1790 if (spec->prefer_hp_amp || cfg->line_out_type == AUTO_PIN_HP_OUT)
1791 val = PIN_HP;
1792 else
1793 val = PIN_OUT;
1794 set_pin_targets(codec, cfg->line_outs, cfg->line_out_pins, val);
1795 if (cfg->line_out_type != AUTO_PIN_HP_OUT)
1796 set_pin_targets(codec, cfg->hp_outs, cfg->hp_pins, PIN_HP);
1797 if (cfg->line_out_type != AUTO_PIN_SPEAKER_OUT) {
1798 val = spec->prefer_hp_amp ? PIN_HP : PIN_OUT;
1799 set_pin_targets(codec, cfg->speaker_outs,
1800 cfg->speaker_pins, val);
1801 }
1802
1803 /* clear indep_hp flag if not available */
1804 if (spec->indep_hp && !indep_hp_possible(codec))
1805 spec->indep_hp = 0;
1806
1807 kfree(best_cfg);
1808 return 0;
1809 }
1810
1811 /* add playback controls from the parsed DAC table */
1812 static int create_multi_out_ctls(struct hda_codec *codec,
1813 const struct auto_pin_cfg *cfg)
1814 {
1815 struct hda_gen_spec *spec = codec->spec;
1816 int i, err, noutputs;
1817
1818 noutputs = cfg->line_outs;
1819 if (spec->multi_ios > 0 && cfg->line_outs < 3)
1820 noutputs += spec->multi_ios;
1821
1822 for (i = 0; i < noutputs; i++) {
1823 const char *name;
1824 int index;
1825 struct nid_path *path;
1826
1827 path = snd_hda_get_path_from_idx(codec, spec->out_paths[i]);
1828 if (!path)
1829 continue;
1830
1831 name = get_line_out_pfx(codec, i, &index, NID_PATH_VOL_CTL);
1832 if (!name || !strcmp(name, "CLFE")) {
1833 /* Center/LFE */
1834 err = add_vol_ctl(codec, "Center", 0, 1, path);
1835 if (err < 0)
1836 return err;
1837 err = add_vol_ctl(codec, "LFE", 0, 2, path);
1838 if (err < 0)
1839 return err;
1840 } else {
1841 err = add_stereo_vol(codec, name, index, path);
1842 if (err < 0)
1843 return err;
1844 }
1845
1846 name = get_line_out_pfx(codec, i, &index, NID_PATH_MUTE_CTL);
1847 if (!name || !strcmp(name, "CLFE")) {
1848 err = add_sw_ctl(codec, "Center", 0, 1, path);
1849 if (err < 0)
1850 return err;
1851 err = add_sw_ctl(codec, "LFE", 0, 2, path);
1852 if (err < 0)
1853 return err;
1854 } else {
1855 err = add_stereo_sw(codec, name, index, path);
1856 if (err < 0)
1857 return err;
1858 }
1859 }
1860 return 0;
1861 }
1862
1863 static int create_extra_out(struct hda_codec *codec, int path_idx,
1864 const char *pfx, int cidx)
1865 {
1866 struct nid_path *path;
1867 int err;
1868
1869 path = snd_hda_get_path_from_idx(codec, path_idx);
1870 if (!path)
1871 return 0;
1872 err = add_stereo_vol(codec, pfx, cidx, path);
1873 if (err < 0)
1874 return err;
1875 err = add_stereo_sw(codec, pfx, cidx, path);
1876 if (err < 0)
1877 return err;
1878 return 0;
1879 }
1880
1881 /* add playback controls for speaker and HP outputs */
1882 static int create_extra_outs(struct hda_codec *codec, int num_pins,
1883 const int *paths, const char *pfx)
1884 {
1885 int i;
1886
1887 for (i = 0; i < num_pins; i++) {
1888 const char *name;
1889 char tmp[44];
1890 int err, idx = 0;
1891
1892 if (num_pins == 2 && i == 1 && !strcmp(pfx, "Speaker"))
1893 name = "Bass Speaker";
1894 else if (num_pins >= 3) {
1895 snprintf(tmp, sizeof(tmp), "%s %s",
1896 pfx, channel_name[i]);
1897 name = tmp;
1898 } else {
1899 name = pfx;
1900 idx = i;
1901 }
1902 err = create_extra_out(codec, paths[i], name, idx);
1903 if (err < 0)
1904 return err;
1905 }
1906 return 0;
1907 }
1908
1909 static int create_hp_out_ctls(struct hda_codec *codec)
1910 {
1911 struct hda_gen_spec *spec = codec->spec;
1912 return create_extra_outs(codec, spec->autocfg.hp_outs,
1913 spec->hp_paths,
1914 "Headphone");
1915 }
1916
1917 static int create_speaker_out_ctls(struct hda_codec *codec)
1918 {
1919 struct hda_gen_spec *spec = codec->spec;
1920 return create_extra_outs(codec, spec->autocfg.speaker_outs,
1921 spec->speaker_paths,
1922 "Speaker");
1923 }
1924
1925 /*
1926 * independent HP controls
1927 */
1928
1929 static int indep_hp_info(struct snd_kcontrol *kcontrol,
1930 struct snd_ctl_elem_info *uinfo)
1931 {
1932 return snd_hda_enum_bool_helper_info(kcontrol, uinfo);
1933 }
1934
1935 static int indep_hp_get(struct snd_kcontrol *kcontrol,
1936 struct snd_ctl_elem_value *ucontrol)
1937 {
1938 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1939 struct hda_gen_spec *spec = codec->spec;
1940 ucontrol->value.enumerated.item[0] = spec->indep_hp_enabled;
1941 return 0;
1942 }
1943
1944 static void update_aamix_paths(struct hda_codec *codec, bool do_mix,
1945 int nomix_path_idx, int mix_path_idx,
1946 int out_type);
1947
1948 static int indep_hp_put(struct snd_kcontrol *kcontrol,
1949 struct snd_ctl_elem_value *ucontrol)
1950 {
1951 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1952 struct hda_gen_spec *spec = codec->spec;
1953 unsigned int select = ucontrol->value.enumerated.item[0];
1954 int ret = 0;
1955
1956 mutex_lock(&spec->pcm_mutex);
1957 if (spec->active_streams) {
1958 ret = -EBUSY;
1959 goto unlock;
1960 }
1961
1962 if (spec->indep_hp_enabled != select) {
1963 hda_nid_t *dacp;
1964 if (spec->autocfg.line_out_type == AUTO_PIN_HP_OUT)
1965 dacp = &spec->private_dac_nids[0];
1966 else
1967 dacp = &spec->multiout.hp_out_nid[0];
1968
1969 /* update HP aamix paths in case it conflicts with indep HP */
1970 if (spec->have_aamix_ctl) {
1971 if (spec->autocfg.line_out_type == AUTO_PIN_HP_OUT)
1972 update_aamix_paths(codec, spec->aamix_mode,
1973 spec->out_paths[0],
1974 spec->aamix_out_paths[0],
1975 spec->autocfg.line_out_type);
1976 else
1977 update_aamix_paths(codec, spec->aamix_mode,
1978 spec->hp_paths[0],
1979 spec->aamix_out_paths[1],
1980 AUTO_PIN_HP_OUT);
1981 }
1982
1983 spec->indep_hp_enabled = select;
1984 if (spec->indep_hp_enabled)
1985 *dacp = 0;
1986 else
1987 *dacp = spec->alt_dac_nid;
1988
1989 /* update HP auto-mute state too */
1990 if (spec->hp_automute_hook)
1991 spec->hp_automute_hook(codec, NULL);
1992 else
1993 snd_hda_gen_hp_automute(codec, NULL);
1994
1995 ret = 1;
1996 }
1997 unlock:
1998 mutex_unlock(&spec->pcm_mutex);
1999 return ret;
2000 }
2001
2002 static const struct snd_kcontrol_new indep_hp_ctl = {
2003 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2004 .name = "Independent HP",
2005 .info = indep_hp_info,
2006 .get = indep_hp_get,
2007 .put = indep_hp_put,
2008 };
2009
2010
2011 static int create_indep_hp_ctls(struct hda_codec *codec)
2012 {
2013 struct hda_gen_spec *spec = codec->spec;
2014 hda_nid_t dac;
2015
2016 if (!spec->indep_hp)
2017 return 0;
2018 if (spec->autocfg.line_out_type == AUTO_PIN_HP_OUT)
2019 dac = spec->multiout.dac_nids[0];
2020 else
2021 dac = spec->multiout.hp_out_nid[0];
2022 if (!dac) {
2023 spec->indep_hp = 0;
2024 return 0;
2025 }
2026
2027 spec->indep_hp_enabled = false;
2028 spec->alt_dac_nid = dac;
2029 if (!snd_hda_gen_add_kctl(spec, NULL, &indep_hp_ctl))
2030 return -ENOMEM;
2031 return 0;
2032 }
2033
2034 /*
2035 * channel mode enum control
2036 */
2037
2038 static int ch_mode_info(struct snd_kcontrol *kcontrol,
2039 struct snd_ctl_elem_info *uinfo)
2040 {
2041 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2042 struct hda_gen_spec *spec = codec->spec;
2043 int chs;
2044
2045 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
2046 uinfo->count = 1;
2047 uinfo->value.enumerated.items = spec->multi_ios + 1;
2048 if (uinfo->value.enumerated.item > spec->multi_ios)
2049 uinfo->value.enumerated.item = spec->multi_ios;
2050 chs = uinfo->value.enumerated.item * 2 + spec->min_channel_count;
2051 sprintf(uinfo->value.enumerated.name, "%dch", chs);
2052 return 0;
2053 }
2054
2055 static int ch_mode_get(struct snd_kcontrol *kcontrol,
2056 struct snd_ctl_elem_value *ucontrol)
2057 {
2058 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2059 struct hda_gen_spec *spec = codec->spec;
2060 ucontrol->value.enumerated.item[0] =
2061 (spec->ext_channel_count - spec->min_channel_count) / 2;
2062 return 0;
2063 }
2064
2065 static inline struct nid_path *
2066 get_multiio_path(struct hda_codec *codec, int idx)
2067 {
2068 struct hda_gen_spec *spec = codec->spec;
2069 return snd_hda_get_path_from_idx(codec,
2070 spec->out_paths[spec->autocfg.line_outs + idx]);
2071 }
2072
2073 static void update_automute_all(struct hda_codec *codec);
2074
2075 static int set_multi_io(struct hda_codec *codec, int idx, bool output)
2076 {
2077 struct hda_gen_spec *spec = codec->spec;
2078 hda_nid_t nid = spec->multi_io[idx].pin;
2079 struct nid_path *path;
2080
2081 path = get_multiio_path(codec, idx);
2082 if (!path)
2083 return -EINVAL;
2084
2085 if (path->active == output)
2086 return 0;
2087
2088 if (output) {
2089 set_pin_target(codec, nid, PIN_OUT, true);
2090 snd_hda_activate_path(codec, path, true, true);
2091 set_pin_eapd(codec, nid, true);
2092 } else {
2093 set_pin_eapd(codec, nid, false);
2094 snd_hda_activate_path(codec, path, false, true);
2095 set_pin_target(codec, nid, spec->multi_io[idx].ctl_in, true);
2096 path_power_down_sync(codec, path);
2097 }
2098
2099 /* update jack retasking in case it modifies any of them */
2100 update_automute_all(codec);
2101
2102 return 0;
2103 }
2104
2105 static int ch_mode_put(struct snd_kcontrol *kcontrol,
2106 struct snd_ctl_elem_value *ucontrol)
2107 {
2108 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2109 struct hda_gen_spec *spec = codec->spec;
2110 int i, ch;
2111
2112 ch = ucontrol->value.enumerated.item[0];
2113 if (ch < 0 || ch > spec->multi_ios)
2114 return -EINVAL;
2115 if (ch == (spec->ext_channel_count - spec->min_channel_count) / 2)
2116 return 0;
2117 spec->ext_channel_count = ch * 2 + spec->min_channel_count;
2118 for (i = 0; i < spec->multi_ios; i++)
2119 set_multi_io(codec, i, i < ch);
2120 spec->multiout.max_channels = max(spec->ext_channel_count,
2121 spec->const_channel_count);
2122 if (spec->need_dac_fix)
2123 spec->multiout.num_dacs = spec->multiout.max_channels / 2;
2124 return 1;
2125 }
2126
2127 static const struct snd_kcontrol_new channel_mode_enum = {
2128 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2129 .name = "Channel Mode",
2130 .info = ch_mode_info,
2131 .get = ch_mode_get,
2132 .put = ch_mode_put,
2133 };
2134
2135 static int create_multi_channel_mode(struct hda_codec *codec)
2136 {
2137 struct hda_gen_spec *spec = codec->spec;
2138
2139 if (spec->multi_ios > 0) {
2140 if (!snd_hda_gen_add_kctl(spec, NULL, &channel_mode_enum))
2141 return -ENOMEM;
2142 }
2143 return 0;
2144 }
2145
2146 /*
2147 * aamix loopback enable/disable switch
2148 */
2149
2150 #define loopback_mixing_info indep_hp_info
2151
2152 static int loopback_mixing_get(struct snd_kcontrol *kcontrol,
2153 struct snd_ctl_elem_value *ucontrol)
2154 {
2155 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2156 struct hda_gen_spec *spec = codec->spec;
2157 ucontrol->value.enumerated.item[0] = spec->aamix_mode;
2158 return 0;
2159 }
2160
2161 static void update_aamix_paths(struct hda_codec *codec, bool do_mix,
2162 int nomix_path_idx, int mix_path_idx,
2163 int out_type)
2164 {
2165 struct hda_gen_spec *spec = codec->spec;
2166 struct nid_path *nomix_path, *mix_path;
2167
2168 nomix_path = snd_hda_get_path_from_idx(codec, nomix_path_idx);
2169 mix_path = snd_hda_get_path_from_idx(codec, mix_path_idx);
2170 if (!nomix_path || !mix_path)
2171 return;
2172
2173 /* if HP aamix path is driven from a different DAC and the
2174 * independent HP mode is ON, can't turn on aamix path
2175 */
2176 if (out_type == AUTO_PIN_HP_OUT && spec->indep_hp_enabled &&
2177 mix_path->path[0] != spec->alt_dac_nid)
2178 do_mix = false;
2179
2180 if (do_mix) {
2181 snd_hda_activate_path(codec, nomix_path, false, true);
2182 snd_hda_activate_path(codec, mix_path, true, true);
2183 path_power_down_sync(codec, nomix_path);
2184 } else {
2185 snd_hda_activate_path(codec, mix_path, false, true);
2186 snd_hda_activate_path(codec, nomix_path, true, true);
2187 path_power_down_sync(codec, mix_path);
2188 }
2189 }
2190
2191 static int loopback_mixing_put(struct snd_kcontrol *kcontrol,
2192 struct snd_ctl_elem_value *ucontrol)
2193 {
2194 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2195 struct hda_gen_spec *spec = codec->spec;
2196 unsigned int val = ucontrol->value.enumerated.item[0];
2197
2198 if (val == spec->aamix_mode)
2199 return 0;
2200 spec->aamix_mode = val;
2201 update_aamix_paths(codec, val, spec->out_paths[0],
2202 spec->aamix_out_paths[0],
2203 spec->autocfg.line_out_type);
2204 update_aamix_paths(codec, val, spec->hp_paths[0],
2205 spec->aamix_out_paths[1],
2206 AUTO_PIN_HP_OUT);
2207 update_aamix_paths(codec, val, spec->speaker_paths[0],
2208 spec->aamix_out_paths[2],
2209 AUTO_PIN_SPEAKER_OUT);
2210 return 1;
2211 }
2212
2213 static const struct snd_kcontrol_new loopback_mixing_enum = {
2214 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2215 .name = "Loopback Mixing",
2216 .info = loopback_mixing_info,
2217 .get = loopback_mixing_get,
2218 .put = loopback_mixing_put,
2219 };
2220
2221 static int create_loopback_mixing_ctl(struct hda_codec *codec)
2222 {
2223 struct hda_gen_spec *spec = codec->spec;
2224
2225 if (!spec->mixer_nid)
2226 return 0;
2227 if (!(spec->aamix_out_paths[0] || spec->aamix_out_paths[1] ||
2228 spec->aamix_out_paths[2]))
2229 return 0;
2230 if (!snd_hda_gen_add_kctl(spec, NULL, &loopback_mixing_enum))
2231 return -ENOMEM;
2232 spec->have_aamix_ctl = 1;
2233 return 0;
2234 }
2235
2236 /*
2237 * shared headphone/mic handling
2238 */
2239
2240 static void call_update_outputs(struct hda_codec *codec);
2241
2242 /* for shared I/O, change the pin-control accordingly */
2243 static void update_shared_mic_hp(struct hda_codec *codec, bool set_as_mic)
2244 {
2245 struct hda_gen_spec *spec = codec->spec;
2246 unsigned int val;
2247 hda_nid_t pin = spec->autocfg.inputs[1].pin;
2248 /* NOTE: this assumes that there are only two inputs, the
2249 * first is the real internal mic and the second is HP/mic jack.
2250 */
2251
2252 val = snd_hda_get_default_vref(codec, pin);
2253
2254 /* This pin does not have vref caps - let's enable vref on pin 0x18
2255 instead, as suggested by Realtek */
2256 if (val == AC_PINCTL_VREF_HIZ && spec->shared_mic_vref_pin) {
2257 const hda_nid_t vref_pin = spec->shared_mic_vref_pin;
2258 unsigned int vref_val = snd_hda_get_default_vref(codec, vref_pin);
2259 if (vref_val != AC_PINCTL_VREF_HIZ)
2260 snd_hda_set_pin_ctl_cache(codec, vref_pin,
2261 PIN_IN | (set_as_mic ? vref_val : 0));
2262 }
2263
2264 val = set_as_mic ? val | PIN_IN : PIN_HP;
2265 set_pin_target(codec, pin, val, true);
2266
2267 spec->automute_speaker = !set_as_mic;
2268 call_update_outputs(codec);
2269 }
2270
2271 /* create a shared input with the headphone out */
2272 static int create_shared_input(struct hda_codec *codec)
2273 {
2274 struct hda_gen_spec *spec = codec->spec;
2275 struct auto_pin_cfg *cfg = &spec->autocfg;
2276 unsigned int defcfg;
2277 hda_nid_t nid;
2278
2279 /* only one internal input pin? */
2280 if (cfg->num_inputs != 1)
2281 return 0;
2282 defcfg = snd_hda_codec_get_pincfg(codec, cfg->inputs[0].pin);
2283 if (snd_hda_get_input_pin_attr(defcfg) != INPUT_PIN_ATTR_INT)
2284 return 0;
2285
2286 if (cfg->hp_outs == 1 && cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
2287 nid = cfg->hp_pins[0]; /* OK, we have a single HP-out */
2288 else if (cfg->line_outs == 1 && cfg->line_out_type == AUTO_PIN_HP_OUT)
2289 nid = cfg->line_out_pins[0]; /* OK, we have a single line-out */
2290 else
2291 return 0; /* both not available */
2292
2293 if (!(snd_hda_query_pin_caps(codec, nid) & AC_PINCAP_IN))
2294 return 0; /* no input */
2295
2296 cfg->inputs[1].pin = nid;
2297 cfg->inputs[1].type = AUTO_PIN_MIC;
2298 cfg->num_inputs = 2;
2299 spec->shared_mic_hp = 1;
2300 snd_printdd("hda-codec: Enable shared I/O jack on NID 0x%x\n", nid);
2301 return 0;
2302 }
2303
2304 /*
2305 * output jack mode
2306 */
2307 static int out_jack_mode_info(struct snd_kcontrol *kcontrol,
2308 struct snd_ctl_elem_info *uinfo)
2309 {
2310 static const char * const texts[] = {
2311 "Line Out", "Headphone Out",
2312 };
2313 return snd_hda_enum_helper_info(kcontrol, uinfo, 2, texts);
2314 }
2315
2316 static int out_jack_mode_get(struct snd_kcontrol *kcontrol,
2317 struct snd_ctl_elem_value *ucontrol)
2318 {
2319 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2320 hda_nid_t nid = kcontrol->private_value;
2321 if (snd_hda_codec_get_pin_target(codec, nid) == PIN_HP)
2322 ucontrol->value.enumerated.item[0] = 1;
2323 else
2324 ucontrol->value.enumerated.item[0] = 0;
2325 return 0;
2326 }
2327
2328 static int out_jack_mode_put(struct snd_kcontrol *kcontrol,
2329 struct snd_ctl_elem_value *ucontrol)
2330 {
2331 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2332 hda_nid_t nid = kcontrol->private_value;
2333 unsigned int val;
2334
2335 val = ucontrol->value.enumerated.item[0] ? PIN_HP : PIN_OUT;
2336 if (snd_hda_codec_get_pin_target(codec, nid) == val)
2337 return 0;
2338 snd_hda_set_pin_ctl_cache(codec, nid, val);
2339 return 1;
2340 }
2341
2342 static const struct snd_kcontrol_new out_jack_mode_enum = {
2343 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2344 .info = out_jack_mode_info,
2345 .get = out_jack_mode_get,
2346 .put = out_jack_mode_put,
2347 };
2348
2349 static bool find_kctl_name(struct hda_codec *codec, const char *name, int idx)
2350 {
2351 struct hda_gen_spec *spec = codec->spec;
2352 int i;
2353
2354 for (i = 0; i < spec->kctls.used; i++) {
2355 struct snd_kcontrol_new *kctl = snd_array_elem(&spec->kctls, i);
2356 if (!strcmp(kctl->name, name) && kctl->index == idx)
2357 return true;
2358 }
2359 return false;
2360 }
2361
2362 static void get_jack_mode_name(struct hda_codec *codec, hda_nid_t pin,
2363 char *name, size_t name_len)
2364 {
2365 struct hda_gen_spec *spec = codec->spec;
2366 int idx = 0;
2367
2368 snd_hda_get_pin_label(codec, pin, &spec->autocfg, name, name_len, &idx);
2369 strlcat(name, " Jack Mode", name_len);
2370
2371 for (; find_kctl_name(codec, name, idx); idx++)
2372 ;
2373 }
2374
2375 static int create_out_jack_modes(struct hda_codec *codec, int num_pins,
2376 hda_nid_t *pins)
2377 {
2378 struct hda_gen_spec *spec = codec->spec;
2379 int i;
2380
2381 for (i = 0; i < num_pins; i++) {
2382 hda_nid_t pin = pins[i];
2383 unsigned int pincap = snd_hda_query_pin_caps(codec, pin);
2384 if ((pincap & AC_PINCAP_OUT) && (pincap & AC_PINCAP_HP_DRV)) {
2385 struct snd_kcontrol_new *knew;
2386 char name[44];
2387 get_jack_mode_name(codec, pin, name, sizeof(name));
2388 knew = snd_hda_gen_add_kctl(spec, name,
2389 &out_jack_mode_enum);
2390 if (!knew)
2391 return -ENOMEM;
2392 knew->private_value = pin;
2393 }
2394 }
2395
2396 return 0;
2397 }
2398
2399 /*
2400 * input jack mode
2401 */
2402
2403 /* from AC_PINCTL_VREF_HIZ to AC_PINCTL_VREF_100 */
2404 #define NUM_VREFS 6
2405
2406 static const char * const vref_texts[NUM_VREFS] = {
2407 "Line In", "Mic 50pc Bias", "Mic 0V Bias",
2408 "", "Mic 80pc Bias", "Mic 100pc Bias"
2409 };
2410
2411 static unsigned int get_vref_caps(struct hda_codec *codec, hda_nid_t pin)
2412 {
2413 unsigned int pincap;
2414
2415 pincap = snd_hda_query_pin_caps(codec, pin);
2416 pincap = (pincap & AC_PINCAP_VREF) >> AC_PINCAP_VREF_SHIFT;
2417 /* filter out unusual vrefs */
2418 pincap &= ~(AC_PINCAP_VREF_GRD | AC_PINCAP_VREF_100);
2419 return pincap;
2420 }
2421
2422 /* convert from the enum item index to the vref ctl index (0=HIZ, 1=50%...) */
2423 static int get_vref_idx(unsigned int vref_caps, unsigned int item_idx)
2424 {
2425 unsigned int i, n = 0;
2426
2427 for (i = 0; i < NUM_VREFS; i++) {
2428 if (vref_caps & (1 << i)) {
2429 if (n == item_idx)
2430 return i;
2431 n++;
2432 }
2433 }
2434 return 0;
2435 }
2436
2437 /* convert back from the vref ctl index to the enum item index */
2438 static int cvt_from_vref_idx(unsigned int vref_caps, unsigned int idx)
2439 {
2440 unsigned int i, n = 0;
2441
2442 for (i = 0; i < NUM_VREFS; i++) {
2443 if (i == idx)
2444 return n;
2445 if (vref_caps & (1 << i))
2446 n++;
2447 }
2448 return 0;
2449 }
2450
2451 static int in_jack_mode_info(struct snd_kcontrol *kcontrol,
2452 struct snd_ctl_elem_info *uinfo)
2453 {
2454 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2455 hda_nid_t nid = kcontrol->private_value;
2456 unsigned int vref_caps = get_vref_caps(codec, nid);
2457
2458 snd_hda_enum_helper_info(kcontrol, uinfo, hweight32(vref_caps),
2459 vref_texts);
2460 /* set the right text */
2461 strcpy(uinfo->value.enumerated.name,
2462 vref_texts[get_vref_idx(vref_caps, uinfo->value.enumerated.item)]);
2463 return 0;
2464 }
2465
2466 static int in_jack_mode_get(struct snd_kcontrol *kcontrol,
2467 struct snd_ctl_elem_value *ucontrol)
2468 {
2469 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2470 hda_nid_t nid = kcontrol->private_value;
2471 unsigned int vref_caps = get_vref_caps(codec, nid);
2472 unsigned int idx;
2473
2474 idx = snd_hda_codec_get_pin_target(codec, nid) & AC_PINCTL_VREFEN;
2475 ucontrol->value.enumerated.item[0] = cvt_from_vref_idx(vref_caps, idx);
2476 return 0;
2477 }
2478
2479 static int in_jack_mode_put(struct snd_kcontrol *kcontrol,
2480 struct snd_ctl_elem_value *ucontrol)
2481 {
2482 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2483 hda_nid_t nid = kcontrol->private_value;
2484 unsigned int vref_caps = get_vref_caps(codec, nid);
2485 unsigned int val, idx;
2486
2487 val = snd_hda_codec_get_pin_target(codec, nid);
2488 idx = cvt_from_vref_idx(vref_caps, val & AC_PINCTL_VREFEN);
2489 if (idx == ucontrol->value.enumerated.item[0])
2490 return 0;
2491
2492 val &= ~AC_PINCTL_VREFEN;
2493 val |= get_vref_idx(vref_caps, ucontrol->value.enumerated.item[0]);
2494 snd_hda_set_pin_ctl_cache(codec, nid, val);
2495 return 1;
2496 }
2497
2498 static const struct snd_kcontrol_new in_jack_mode_enum = {
2499 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2500 .info = in_jack_mode_info,
2501 .get = in_jack_mode_get,
2502 .put = in_jack_mode_put,
2503 };
2504
2505 static int create_in_jack_mode(struct hda_codec *codec, hda_nid_t pin)
2506 {
2507 struct hda_gen_spec *spec = codec->spec;
2508 unsigned int defcfg;
2509 struct snd_kcontrol_new *knew;
2510 char name[44];
2511
2512 /* no jack mode for fixed pins */
2513 defcfg = snd_hda_codec_get_pincfg(codec, pin);
2514 if (snd_hda_get_input_pin_attr(defcfg) == INPUT_PIN_ATTR_INT)
2515 return 0;
2516
2517 /* no multiple vref caps? */
2518 if (hweight32(get_vref_caps(codec, pin)) <= 1)
2519 return 0;
2520
2521 get_jack_mode_name(codec, pin, name, sizeof(name));
2522 knew = snd_hda_gen_add_kctl(spec, name, &in_jack_mode_enum);
2523 if (!knew)
2524 return -ENOMEM;
2525 knew->private_value = pin;
2526 return 0;
2527 }
2528
2529
2530 /*
2531 * Parse input paths
2532 */
2533
2534 /* add the powersave loopback-list entry */
2535 static int add_loopback_list(struct hda_gen_spec *spec, hda_nid_t mix, int idx)
2536 {
2537 struct hda_amp_list *list;
2538
2539 list = snd_array_new(&spec->loopback_list);
2540 if (!list)
2541 return -ENOMEM;
2542 list->nid = mix;
2543 list->dir = HDA_INPUT;
2544 list->idx = idx;
2545 spec->loopback.amplist = spec->loopback_list.list;
2546 return 0;
2547 }
2548
2549 /* create input playback/capture controls for the given pin */
2550 static int new_analog_input(struct hda_codec *codec, int input_idx,
2551 hda_nid_t pin, const char *ctlname, int ctlidx,
2552 hda_nid_t mix_nid)
2553 {
2554 struct hda_gen_spec *spec = codec->spec;
2555 struct nid_path *path;
2556 unsigned int val;
2557 int err, idx;
2558
2559 if (!nid_has_volume(codec, mix_nid, HDA_INPUT) &&
2560 !nid_has_mute(codec, mix_nid, HDA_INPUT))
2561 return 0; /* no need for analog loopback */
2562
2563 path = snd_hda_add_new_path(codec, pin, mix_nid, 0);
2564 if (!path)
2565 return -EINVAL;
2566 print_nid_path("loopback", path);
2567 spec->loopback_paths[input_idx] = snd_hda_get_path_idx(codec, path);
2568
2569 idx = path->idx[path->depth - 1];
2570 if (nid_has_volume(codec, mix_nid, HDA_INPUT)) {
2571 val = HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT);
2572 err = __add_pb_vol_ctrl(spec, HDA_CTL_WIDGET_VOL, ctlname, ctlidx, val);
2573 if (err < 0)
2574 return err;
2575 path->ctls[NID_PATH_VOL_CTL] = val;
2576 }
2577
2578 if (nid_has_mute(codec, mix_nid, HDA_INPUT)) {
2579 val = HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT);
2580 err = __add_pb_sw_ctrl(spec, HDA_CTL_WIDGET_MUTE, ctlname, ctlidx, val);
2581 if (err < 0)
2582 return err;
2583 path->ctls[NID_PATH_MUTE_CTL] = val;
2584 }
2585
2586 path->active = true;
2587 err = add_loopback_list(spec, mix_nid, idx);
2588 if (err < 0)
2589 return err;
2590
2591 if (spec->mixer_nid != spec->mixer_merge_nid &&
2592 !spec->loopback_merge_path) {
2593 path = snd_hda_add_new_path(codec, spec->mixer_nid,
2594 spec->mixer_merge_nid, 0);
2595 if (path) {
2596 print_nid_path("loopback-merge", path);
2597 path->active = true;
2598 spec->loopback_merge_path =
2599 snd_hda_get_path_idx(codec, path);
2600 }
2601 }
2602
2603 return 0;
2604 }
2605
2606 static int is_input_pin(struct hda_codec *codec, hda_nid_t nid)
2607 {
2608 unsigned int pincap = snd_hda_query_pin_caps(codec, nid);
2609 return (pincap & AC_PINCAP_IN) != 0;
2610 }
2611
2612 /* Parse the codec tree and retrieve ADCs */
2613 static int fill_adc_nids(struct hda_codec *codec)
2614 {
2615 struct hda_gen_spec *spec = codec->spec;
2616 hda_nid_t nid;
2617 hda_nid_t *adc_nids = spec->adc_nids;
2618 int max_nums = ARRAY_SIZE(spec->adc_nids);
2619 int i, nums = 0;
2620
2621 nid = codec->start_nid;
2622 for (i = 0; i < codec->num_nodes; i++, nid++) {
2623 unsigned int caps = get_wcaps(codec, nid);
2624 int type = get_wcaps_type(caps);
2625
2626 if (type != AC_WID_AUD_IN || (caps & AC_WCAP_DIGITAL))
2627 continue;
2628 adc_nids[nums] = nid;
2629 if (++nums >= max_nums)
2630 break;
2631 }
2632 spec->num_adc_nids = nums;
2633
2634 /* copy the detected ADCs to all_adcs[] */
2635 spec->num_all_adcs = nums;
2636 memcpy(spec->all_adcs, spec->adc_nids, nums * sizeof(hda_nid_t));
2637
2638 return nums;
2639 }
2640
2641 /* filter out invalid adc_nids that don't give all active input pins;
2642 * if needed, check whether dynamic ADC-switching is available
2643 */
2644 static int check_dyn_adc_switch(struct hda_codec *codec)
2645 {
2646 struct hda_gen_spec *spec = codec->spec;
2647 struct hda_input_mux *imux = &spec->input_mux;
2648 unsigned int ok_bits;
2649 int i, n, nums;
2650
2651 again:
2652 nums = 0;
2653 ok_bits = 0;
2654 for (n = 0; n < spec->num_adc_nids; n++) {
2655 for (i = 0; i < imux->num_items; i++) {
2656 if (!spec->input_paths[i][n])
2657 break;
2658 }
2659 if (i >= imux->num_items) {
2660 ok_bits |= (1 << n);
2661 nums++;
2662 }
2663 }
2664
2665 if (!ok_bits) {
2666 if (spec->shared_mic_hp) {
2667 spec->shared_mic_hp = 0;
2668 imux->num_items = 1;
2669 goto again;
2670 }
2671
2672 /* check whether ADC-switch is possible */
2673 for (i = 0; i < imux->num_items; i++) {
2674 for (n = 0; n < spec->num_adc_nids; n++) {
2675 if (spec->input_paths[i][n]) {
2676 spec->dyn_adc_idx[i] = n;
2677 break;
2678 }
2679 }
2680 }
2681
2682 snd_printdd("hda-codec: enabling ADC switching\n");
2683 spec->dyn_adc_switch = 1;
2684 } else if (nums != spec->num_adc_nids) {
2685 /* shrink the invalid adcs and input paths */
2686 nums = 0;
2687 for (n = 0; n < spec->num_adc_nids; n++) {
2688 if (!(ok_bits & (1 << n)))
2689 continue;
2690 if (n != nums) {
2691 spec->adc_nids[nums] = spec->adc_nids[n];
2692 for (i = 0; i < imux->num_items; i++) {
2693 invalidate_nid_path(codec,
2694 spec->input_paths[i][nums]);
2695 spec->input_paths[i][nums] =
2696 spec->input_paths[i][n];
2697 }
2698 }
2699 nums++;
2700 }
2701 spec->num_adc_nids = nums;
2702 }
2703
2704 if (imux->num_items == 1 || spec->shared_mic_hp) {
2705 snd_printdd("hda-codec: reducing to a single ADC\n");
2706 spec->num_adc_nids = 1; /* reduce to a single ADC */
2707 }
2708
2709 /* single index for individual volumes ctls */
2710 if (!spec->dyn_adc_switch && spec->multi_cap_vol)
2711 spec->num_adc_nids = 1;
2712
2713 return 0;
2714 }
2715
2716 /* parse capture source paths from the given pin and create imux items */
2717 static int parse_capture_source(struct hda_codec *codec, hda_nid_t pin,
2718 int cfg_idx, int num_adcs,
2719 const char *label, int anchor)
2720 {
2721 struct hda_gen_spec *spec = codec->spec;
2722 struct hda_input_mux *imux = &spec->input_mux;
2723 int imux_idx = imux->num_items;
2724 bool imux_added = false;
2725 int c;
2726
2727 for (c = 0; c < num_adcs; c++) {
2728 struct nid_path *path;
2729 hda_nid_t adc = spec->adc_nids[c];
2730
2731 if (!is_reachable_path(codec, pin, adc))
2732 continue;
2733 path = snd_hda_add_new_path(codec, pin, adc, anchor);
2734 if (!path)
2735 continue;
2736 print_nid_path("input", path);
2737 spec->input_paths[imux_idx][c] =
2738 snd_hda_get_path_idx(codec, path);
2739
2740 if (!imux_added) {
2741 spec->imux_pins[imux->num_items] = pin;
2742 snd_hda_add_imux_item(imux, label, cfg_idx, NULL);
2743 imux_added = true;
2744 }
2745 }
2746
2747 return 0;
2748 }
2749
2750 /*
2751 * create playback/capture controls for input pins
2752 */
2753
2754 /* fill the label for each input at first */
2755 static int fill_input_pin_labels(struct hda_codec *codec)
2756 {
2757 struct hda_gen_spec *spec = codec->spec;
2758 const struct auto_pin_cfg *cfg = &spec->autocfg;
2759 int i;
2760
2761 for (i = 0; i < cfg->num_inputs; i++) {
2762 hda_nid_t pin = cfg->inputs[i].pin;
2763 const char *label;
2764 int j, idx;
2765
2766 if (!is_input_pin(codec, pin))
2767 continue;
2768
2769 label = hda_get_autocfg_input_label(codec, cfg, i);
2770 idx = 0;
2771 for (j = i - 1; j >= 0; j--) {
2772 if (spec->input_labels[j] &&
2773 !strcmp(spec->input_labels[j], label)) {
2774 idx = spec->input_label_idxs[j] + 1;
2775 break;
2776 }
2777 }
2778
2779 spec->input_labels[i] = label;
2780 spec->input_label_idxs[i] = idx;
2781 }
2782
2783 return 0;
2784 }
2785
2786 #define CFG_IDX_MIX 99 /* a dummy cfg->input idx for stereo mix */
2787
2788 static int create_input_ctls(struct hda_codec *codec)
2789 {
2790 struct hda_gen_spec *spec = codec->spec;
2791 const struct auto_pin_cfg *cfg = &spec->autocfg;
2792 hda_nid_t mixer = spec->mixer_nid;
2793 int num_adcs;
2794 int i, err;
2795 unsigned int val;
2796
2797 num_adcs = fill_adc_nids(codec);
2798 if (num_adcs < 0)
2799 return 0;
2800
2801 err = fill_input_pin_labels(codec);
2802 if (err < 0)
2803 return err;
2804
2805 for (i = 0; i < cfg->num_inputs; i++) {
2806 hda_nid_t pin;
2807
2808 pin = cfg->inputs[i].pin;
2809 if (!is_input_pin(codec, pin))
2810 continue;
2811
2812 val = PIN_IN;
2813 if (cfg->inputs[i].type == AUTO_PIN_MIC)
2814 val |= snd_hda_get_default_vref(codec, pin);
2815 set_pin_target(codec, pin, val, false);
2816
2817 if (mixer) {
2818 if (is_reachable_path(codec, pin, mixer)) {
2819 err = new_analog_input(codec, i, pin,
2820 spec->input_labels[i],
2821 spec->input_label_idxs[i],
2822 mixer);
2823 if (err < 0)
2824 return err;
2825 }
2826 }
2827
2828 err = parse_capture_source(codec, pin, i, num_adcs,
2829 spec->input_labels[i], -mixer);
2830 if (err < 0)
2831 return err;
2832
2833 if (spec->add_in_jack_modes) {
2834 err = create_in_jack_mode(codec, pin);
2835 if (err < 0)
2836 return err;
2837 }
2838 }
2839
2840 if (mixer && spec->add_stereo_mix_input) {
2841 err = parse_capture_source(codec, mixer, CFG_IDX_MIX, num_adcs,
2842 "Stereo Mix", 0);
2843 if (err < 0)
2844 return err;
2845 }
2846
2847 return 0;
2848 }
2849
2850
2851 /*
2852 * input source mux
2853 */
2854
2855 /* get the input path specified by the given adc and imux indices */
2856 static struct nid_path *get_input_path(struct hda_codec *codec, int adc_idx, int imux_idx)
2857 {
2858 struct hda_gen_spec *spec = codec->spec;
2859 if (imux_idx < 0 || imux_idx >= HDA_MAX_NUM_INPUTS) {
2860 snd_BUG();
2861 return NULL;
2862 }
2863 if (spec->dyn_adc_switch)
2864 adc_idx = spec->dyn_adc_idx[imux_idx];
2865 if (adc_idx < 0 || adc_idx >= AUTO_CFG_MAX_INS) {
2866 snd_BUG();
2867 return NULL;
2868 }
2869 return snd_hda_get_path_from_idx(codec, spec->input_paths[imux_idx][adc_idx]);
2870 }
2871
2872 static int mux_select(struct hda_codec *codec, unsigned int adc_idx,
2873 unsigned int idx);
2874
2875 static int mux_enum_info(struct snd_kcontrol *kcontrol,
2876 struct snd_ctl_elem_info *uinfo)
2877 {
2878 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2879 struct hda_gen_spec *spec = codec->spec;
2880 return snd_hda_input_mux_info(&spec->input_mux, uinfo);
2881 }
2882
2883 static int mux_enum_get(struct snd_kcontrol *kcontrol,
2884 struct snd_ctl_elem_value *ucontrol)
2885 {
2886 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2887 struct hda_gen_spec *spec = codec->spec;
2888 /* the ctls are created at once with multiple counts */
2889 unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
2890
2891 ucontrol->value.enumerated.item[0] = spec->cur_mux[adc_idx];
2892 return 0;
2893 }
2894
2895 static int mux_enum_put(struct snd_kcontrol *kcontrol,
2896 struct snd_ctl_elem_value *ucontrol)
2897 {
2898 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2899 unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
2900 return mux_select(codec, adc_idx,
2901 ucontrol->value.enumerated.item[0]);
2902 }
2903
2904 static const struct snd_kcontrol_new cap_src_temp = {
2905 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2906 .name = "Input Source",
2907 .info = mux_enum_info,
2908 .get = mux_enum_get,
2909 .put = mux_enum_put,
2910 };
2911
2912 /*
2913 * capture volume and capture switch ctls
2914 */
2915
2916 typedef int (*put_call_t)(struct snd_kcontrol *kcontrol,
2917 struct snd_ctl_elem_value *ucontrol);
2918
2919 /* call the given amp update function for all amps in the imux list at once */
2920 static int cap_put_caller(struct snd_kcontrol *kcontrol,
2921 struct snd_ctl_elem_value *ucontrol,
2922 put_call_t func, int type)
2923 {
2924 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2925 struct hda_gen_spec *spec = codec->spec;
2926 const struct hda_input_mux *imux;
2927 struct nid_path *path;
2928 int i, adc_idx, err = 0;
2929
2930 imux = &spec->input_mux;
2931 adc_idx = kcontrol->id.index;
2932 mutex_lock(&codec->control_mutex);
2933 /* we use the cache-only update at first since multiple input paths
2934 * may shared the same amp; by updating only caches, the redundant
2935 * writes to hardware can be reduced.
2936 */
2937 codec->cached_write = 1;
2938 for (i = 0; i < imux->num_items; i++) {
2939 path = get_input_path(codec, adc_idx, i);
2940 if (!path || !path->ctls[type])
2941 continue;
2942 kcontrol->private_value = path->ctls[type];
2943 err = func(kcontrol, ucontrol);
2944 if (err < 0)
2945 goto error;
2946 }
2947 error:
2948 codec->cached_write = 0;
2949 mutex_unlock(&codec->control_mutex);
2950 snd_hda_codec_flush_cache(codec); /* flush the updates */
2951 if (err >= 0 && spec->cap_sync_hook)
2952 spec->cap_sync_hook(codec, ucontrol);
2953 return err;
2954 }
2955
2956 /* capture volume ctl callbacks */
2957 #define cap_vol_info snd_hda_mixer_amp_volume_info
2958 #define cap_vol_get snd_hda_mixer_amp_volume_get
2959 #define cap_vol_tlv snd_hda_mixer_amp_tlv
2960
2961 static int cap_vol_put(struct snd_kcontrol *kcontrol,
2962 struct snd_ctl_elem_value *ucontrol)
2963 {
2964 return cap_put_caller(kcontrol, ucontrol,
2965 snd_hda_mixer_amp_volume_put,
2966 NID_PATH_VOL_CTL);
2967 }
2968
2969 static const struct snd_kcontrol_new cap_vol_temp = {
2970 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2971 .name = "Capture Volume",
2972 .access = (SNDRV_CTL_ELEM_ACCESS_READWRITE |
2973 SNDRV_CTL_ELEM_ACCESS_TLV_READ |
2974 SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK),
2975 .info = cap_vol_info,
2976 .get = cap_vol_get,
2977 .put = cap_vol_put,
2978 .tlv = { .c = cap_vol_tlv },
2979 };
2980
2981 /* capture switch ctl callbacks */
2982 #define cap_sw_info snd_ctl_boolean_stereo_info
2983 #define cap_sw_get snd_hda_mixer_amp_switch_get
2984
2985 static int cap_sw_put(struct snd_kcontrol *kcontrol,
2986 struct snd_ctl_elem_value *ucontrol)
2987 {
2988 return cap_put_caller(kcontrol, ucontrol,
2989 snd_hda_mixer_amp_switch_put,
2990 NID_PATH_MUTE_CTL);
2991 }
2992
2993 static const struct snd_kcontrol_new cap_sw_temp = {
2994 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2995 .name = "Capture Switch",
2996 .info = cap_sw_info,
2997 .get = cap_sw_get,
2998 .put = cap_sw_put,
2999 };
3000
3001 static int parse_capvol_in_path(struct hda_codec *codec, struct nid_path *path)
3002 {
3003 hda_nid_t nid;
3004 int i, depth;
3005
3006 path->ctls[NID_PATH_VOL_CTL] = path->ctls[NID_PATH_MUTE_CTL] = 0;
3007 for (depth = 0; depth < 3; depth++) {
3008 if (depth >= path->depth)
3009 return -EINVAL;
3010 i = path->depth - depth - 1;
3011 nid = path->path[i];
3012 if (!path->ctls[NID_PATH_VOL_CTL]) {
3013 if (nid_has_volume(codec, nid, HDA_OUTPUT))
3014 path->ctls[NID_PATH_VOL_CTL] =
3015 HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
3016 else if (nid_has_volume(codec, nid, HDA_INPUT)) {
3017 int idx = path->idx[i];
3018 if (!depth && codec->single_adc_amp)
3019 idx = 0;
3020 path->ctls[NID_PATH_VOL_CTL] =
3021 HDA_COMPOSE_AMP_VAL(nid, 3, idx, HDA_INPUT);
3022 }
3023 }
3024 if (!path->ctls[NID_PATH_MUTE_CTL]) {
3025 if (nid_has_mute(codec, nid, HDA_OUTPUT))
3026 path->ctls[NID_PATH_MUTE_CTL] =
3027 HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
3028 else if (nid_has_mute(codec, nid, HDA_INPUT)) {
3029 int idx = path->idx[i];
3030 if (!depth && codec->single_adc_amp)
3031 idx = 0;
3032 path->ctls[NID_PATH_MUTE_CTL] =
3033 HDA_COMPOSE_AMP_VAL(nid, 3, idx, HDA_INPUT);
3034 }
3035 }
3036 }
3037 return 0;
3038 }
3039
3040 static bool is_inv_dmic_pin(struct hda_codec *codec, hda_nid_t nid)
3041 {
3042 struct hda_gen_spec *spec = codec->spec;
3043 struct auto_pin_cfg *cfg = &spec->autocfg;
3044 unsigned int val;
3045 int i;
3046
3047 if (!spec->inv_dmic_split)
3048 return false;
3049 for (i = 0; i < cfg->num_inputs; i++) {
3050 if (cfg->inputs[i].pin != nid)
3051 continue;
3052 if (cfg->inputs[i].type != AUTO_PIN_MIC)
3053 return false;
3054 val = snd_hda_codec_get_pincfg(codec, nid);
3055 return snd_hda_get_input_pin_attr(val) == INPUT_PIN_ATTR_INT;
3056 }
3057 return false;
3058 }
3059
3060 /* capture switch put callback for a single control with hook call */
3061 static int cap_single_sw_put(struct snd_kcontrol *kcontrol,
3062 struct snd_ctl_elem_value *ucontrol)
3063 {
3064 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3065 struct hda_gen_spec *spec = codec->spec;
3066 int ret;
3067
3068 ret = snd_hda_mixer_amp_switch_put(kcontrol, ucontrol);
3069 if (ret < 0)
3070 return ret;
3071
3072 if (spec->cap_sync_hook)
3073 spec->cap_sync_hook(codec, ucontrol);
3074
3075 return ret;
3076 }
3077
3078 static int add_single_cap_ctl(struct hda_codec *codec, const char *label,
3079 int idx, bool is_switch, unsigned int ctl,
3080 bool inv_dmic)
3081 {
3082 struct hda_gen_spec *spec = codec->spec;
3083 char tmpname[44];
3084 int type = is_switch ? HDA_CTL_WIDGET_MUTE : HDA_CTL_WIDGET_VOL;
3085 const char *sfx = is_switch ? "Switch" : "Volume";
3086 unsigned int chs = inv_dmic ? 1 : 3;
3087 struct snd_kcontrol_new *knew;
3088
3089 if (!ctl)
3090 return 0;
3091
3092 if (label)
3093 snprintf(tmpname, sizeof(tmpname),
3094 "%s Capture %s", label, sfx);
3095 else
3096 snprintf(tmpname, sizeof(tmpname),
3097 "Capture %s", sfx);
3098 knew = add_control(spec, type, tmpname, idx,
3099 amp_val_replace_channels(ctl, chs));
3100 if (!knew)
3101 return -ENOMEM;
3102 if (is_switch)
3103 knew->put = cap_single_sw_put;
3104 if (!inv_dmic)
3105 return 0;
3106
3107 /* Make independent right kcontrol */
3108 if (label)
3109 snprintf(tmpname, sizeof(tmpname),
3110 "Inverted %s Capture %s", label, sfx);
3111 else
3112 snprintf(tmpname, sizeof(tmpname),
3113 "Inverted Capture %s", sfx);
3114 knew = add_control(spec, type, tmpname, idx,
3115 amp_val_replace_channels(ctl, 2));
3116 if (!knew)
3117 return -ENOMEM;
3118 if (is_switch)
3119 knew->put = cap_single_sw_put;
3120 return 0;
3121 }
3122
3123 /* create single (and simple) capture volume and switch controls */
3124 static int create_single_cap_vol_ctl(struct hda_codec *codec, int idx,
3125 unsigned int vol_ctl, unsigned int sw_ctl,
3126 bool inv_dmic)
3127 {
3128 int err;
3129 err = add_single_cap_ctl(codec, NULL, idx, false, vol_ctl, inv_dmic);
3130 if (err < 0)
3131 return err;
3132 err = add_single_cap_ctl(codec, NULL, idx, true, sw_ctl, inv_dmic);
3133 if (err < 0)
3134 return err;
3135 return 0;
3136 }
3137
3138 /* create bound capture volume and switch controls */
3139 static int create_bind_cap_vol_ctl(struct hda_codec *codec, int idx,
3140 unsigned int vol_ctl, unsigned int sw_ctl)
3141 {
3142 struct hda_gen_spec *spec = codec->spec;
3143 struct snd_kcontrol_new *knew;
3144
3145 if (vol_ctl) {
3146 knew = snd_hda_gen_add_kctl(spec, NULL, &cap_vol_temp);
3147 if (!knew)
3148 return -ENOMEM;
3149 knew->index = idx;
3150 knew->private_value = vol_ctl;
3151 knew->subdevice = HDA_SUBDEV_AMP_FLAG;
3152 }
3153 if (sw_ctl) {
3154 knew = snd_hda_gen_add_kctl(spec, NULL, &cap_sw_temp);
3155 if (!knew)
3156 return -ENOMEM;
3157 knew->index = idx;
3158 knew->private_value = sw_ctl;
3159 knew->subdevice = HDA_SUBDEV_AMP_FLAG;
3160 }
3161 return 0;
3162 }
3163
3164 /* return the vol ctl when used first in the imux list */
3165 static unsigned int get_first_cap_ctl(struct hda_codec *codec, int idx, int type)
3166 {
3167 struct nid_path *path;
3168 unsigned int ctl;
3169 int i;
3170
3171 path = get_input_path(codec, 0, idx);
3172 if (!path)
3173 return 0;
3174 ctl = path->ctls[type];
3175 if (!ctl)
3176 return 0;
3177 for (i = 0; i < idx - 1; i++) {
3178 path = get_input_path(codec, 0, i);
3179 if (path && path->ctls[type] == ctl)
3180 return 0;
3181 }
3182 return ctl;
3183 }
3184
3185 /* create individual capture volume and switch controls per input */
3186 static int create_multi_cap_vol_ctl(struct hda_codec *codec)
3187 {
3188 struct hda_gen_spec *spec = codec->spec;
3189 struct hda_input_mux *imux = &spec->input_mux;
3190 int i, err, type;
3191
3192 for (i = 0; i < imux->num_items; i++) {
3193 bool inv_dmic;
3194 int idx;
3195
3196 idx = imux->items[i].index;
3197 if (idx >= spec->autocfg.num_inputs)
3198 continue;
3199 inv_dmic = is_inv_dmic_pin(codec, spec->imux_pins[i]);
3200
3201 for (type = 0; type < 2; type++) {
3202 err = add_single_cap_ctl(codec,
3203 spec->input_labels[idx],
3204 spec->input_label_idxs[idx],
3205 type,
3206 get_first_cap_ctl(codec, i, type),
3207 inv_dmic);
3208 if (err < 0)
3209 return err;
3210 }
3211 }
3212 return 0;
3213 }
3214
3215 static int create_capture_mixers(struct hda_codec *codec)
3216 {
3217 struct hda_gen_spec *spec = codec->spec;
3218 struct hda_input_mux *imux = &spec->input_mux;
3219 int i, n, nums, err;
3220
3221 if (spec->dyn_adc_switch)
3222 nums = 1;
3223 else
3224 nums = spec->num_adc_nids;
3225
3226 if (!spec->auto_mic && imux->num_items > 1) {
3227 struct snd_kcontrol_new *knew;
3228 const char *name;
3229 name = nums > 1 ? "Input Source" : "Capture Source";
3230 knew = snd_hda_gen_add_kctl(spec, name, &cap_src_temp);
3231 if (!knew)
3232 return -ENOMEM;
3233 knew->count = nums;
3234 }
3235
3236 for (n = 0; n < nums; n++) {
3237 bool multi = false;
3238 bool multi_cap_vol = spec->multi_cap_vol;
3239 bool inv_dmic = false;
3240 int vol, sw;
3241
3242 vol = sw = 0;
3243 for (i = 0; i < imux->num_items; i++) {
3244 struct nid_path *path;
3245 path = get_input_path(codec, n, i);
3246 if (!path)
3247 continue;
3248 parse_capvol_in_path(codec, path);
3249 if (!vol)
3250 vol = path->ctls[NID_PATH_VOL_CTL];
3251 else if (vol != path->ctls[NID_PATH_VOL_CTL]) {
3252 multi = true;
3253 if (!same_amp_caps(codec, vol,
3254 path->ctls[NID_PATH_VOL_CTL], HDA_INPUT))
3255 multi_cap_vol = true;
3256 }
3257 if (!sw)
3258 sw = path->ctls[NID_PATH_MUTE_CTL];
3259 else if (sw != path->ctls[NID_PATH_MUTE_CTL]) {
3260 multi = true;
3261 if (!same_amp_caps(codec, sw,
3262 path->ctls[NID_PATH_MUTE_CTL], HDA_INPUT))
3263 multi_cap_vol = true;
3264 }
3265 if (is_inv_dmic_pin(codec, spec->imux_pins[i]))
3266 inv_dmic = true;
3267 }
3268
3269 if (!multi)
3270 err = create_single_cap_vol_ctl(codec, n, vol, sw,
3271 inv_dmic);
3272 else if (!multi_cap_vol)
3273 err = create_bind_cap_vol_ctl(codec, n, vol, sw);
3274 else
3275 err = create_multi_cap_vol_ctl(codec);
3276 if (err < 0)
3277 return err;
3278 }
3279
3280 return 0;
3281 }
3282
3283 /*
3284 * add mic boosts if needed
3285 */
3286
3287 /* check whether the given amp is feasible as a boost volume */
3288 static bool check_boost_vol(struct hda_codec *codec, hda_nid_t nid,
3289 int dir, int idx)
3290 {
3291 unsigned int step;
3292
3293 if (!nid_has_volume(codec, nid, dir) ||
3294 is_ctl_associated(codec, nid, dir, idx, NID_PATH_VOL_CTL) ||
3295 is_ctl_associated(codec, nid, dir, idx, NID_PATH_BOOST_CTL))
3296 return false;
3297
3298 step = (query_amp_caps(codec, nid, dir) & AC_AMPCAP_STEP_SIZE)
3299 >> AC_AMPCAP_STEP_SIZE_SHIFT;
3300 if (step < 0x20)
3301 return false;
3302 return true;
3303 }
3304
3305 /* look for a boost amp in a widget close to the pin */
3306 static unsigned int look_for_boost_amp(struct hda_codec *codec,
3307 struct nid_path *path)
3308 {
3309 unsigned int val = 0;
3310 hda_nid_t nid;
3311 int depth;
3312
3313 for (depth = 0; depth < 3; depth++) {
3314 if (depth >= path->depth - 1)
3315 break;
3316 nid = path->path[depth];
3317 if (depth && check_boost_vol(codec, nid, HDA_OUTPUT, 0)) {
3318 val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
3319 break;
3320 } else if (check_boost_vol(codec, nid, HDA_INPUT,
3321 path->idx[depth])) {
3322 val = HDA_COMPOSE_AMP_VAL(nid, 3, path->idx[depth],
3323 HDA_INPUT);
3324 break;
3325 }
3326 }
3327
3328 return val;
3329 }
3330
3331 static int parse_mic_boost(struct hda_codec *codec)
3332 {
3333 struct hda_gen_spec *spec = codec->spec;
3334 struct auto_pin_cfg *cfg = &spec->autocfg;
3335 struct hda_input_mux *imux = &spec->input_mux;
3336 int i;
3337
3338 if (!spec->num_adc_nids)
3339 return 0;
3340
3341 for (i = 0; i < imux->num_items; i++) {
3342 struct nid_path *path;
3343 unsigned int val;
3344 int idx;
3345 char boost_label[44];
3346
3347 idx = imux->items[i].index;
3348 if (idx >= imux->num_items)
3349 continue;
3350
3351 /* check only line-in and mic pins */
3352 if (cfg->inputs[idx].type > AUTO_PIN_LINE_IN)
3353 continue;
3354
3355 path = get_input_path(codec, 0, i);
3356 if (!path)
3357 continue;
3358
3359 val = look_for_boost_amp(codec, path);
3360 if (!val)
3361 continue;
3362
3363 /* create a boost control */
3364 snprintf(boost_label, sizeof(boost_label),
3365 "%s Boost Volume", spec->input_labels[idx]);
3366 if (!add_control(spec, HDA_CTL_WIDGET_VOL, boost_label,
3367 spec->input_label_idxs[idx], val))
3368 return -ENOMEM;
3369
3370 path->ctls[NID_PATH_BOOST_CTL] = val;
3371 }
3372 return 0;
3373 }
3374
3375 /*
3376 * parse digital I/Os and set up NIDs in BIOS auto-parse mode
3377 */
3378 static void parse_digital(struct hda_codec *codec)
3379 {
3380 struct hda_gen_spec *spec = codec->spec;
3381 struct nid_path *path;
3382 int i, nums;
3383 hda_nid_t dig_nid, pin;
3384
3385 /* support multiple SPDIFs; the secondary is set up as a slave */
3386 nums = 0;
3387 for (i = 0; i < spec->autocfg.dig_outs; i++) {
3388 pin = spec->autocfg.dig_out_pins[i];
3389 dig_nid = look_for_dac(codec, pin, true);
3390 if (!dig_nid)
3391 continue;
3392 path = snd_hda_add_new_path(codec, dig_nid, pin, 0);
3393 if (!path)
3394 continue;
3395 print_nid_path("digout", path);
3396 path->active = true;
3397 spec->digout_paths[i] = snd_hda_get_path_idx(codec, path);
3398 set_pin_target(codec, pin, PIN_OUT, false);
3399 if (!nums) {
3400 spec->multiout.dig_out_nid = dig_nid;
3401 spec->dig_out_type = spec->autocfg.dig_out_type[0];
3402 } else {
3403 spec->multiout.slave_dig_outs = spec->slave_dig_outs;
3404 if (nums >= ARRAY_SIZE(spec->slave_dig_outs) - 1)
3405 break;
3406 spec->slave_dig_outs[nums - 1] = dig_nid;
3407 }
3408 nums++;
3409 }
3410
3411 if (spec->autocfg.dig_in_pin) {
3412 pin = spec->autocfg.dig_in_pin;
3413 dig_nid = codec->start_nid;
3414 for (i = 0; i < codec->num_nodes; i++, dig_nid++) {
3415 unsigned int wcaps = get_wcaps(codec, dig_nid);
3416 if (get_wcaps_type(wcaps) != AC_WID_AUD_IN)
3417 continue;
3418 if (!(wcaps & AC_WCAP_DIGITAL))
3419 continue;
3420 path = snd_hda_add_new_path(codec, pin, dig_nid, 0);
3421 if (path) {
3422 print_nid_path("digin", path);
3423 path->active = true;
3424 spec->dig_in_nid = dig_nid;
3425 spec->digin_path = snd_hda_get_path_idx(codec, path);
3426 set_pin_target(codec, pin, PIN_IN, false);
3427 break;
3428 }
3429 }
3430 }
3431 }
3432
3433
3434 /*
3435 * input MUX handling
3436 */
3437
3438 static bool dyn_adc_pcm_resetup(struct hda_codec *codec, int cur);
3439
3440 /* select the given imux item; either unmute exclusively or select the route */
3441 static int mux_select(struct hda_codec *codec, unsigned int adc_idx,
3442 unsigned int idx)
3443 {
3444 struct hda_gen_spec *spec = codec->spec;
3445 const struct hda_input_mux *imux;
3446 struct nid_path *old_path, *path;
3447
3448 imux = &spec->input_mux;
3449 if (!imux->num_items)
3450 return 0;
3451
3452 if (idx >= imux->num_items)
3453 idx = imux->num_items - 1;
3454 if (spec->cur_mux[adc_idx] == idx)
3455 return 0;
3456
3457 old_path = get_input_path(codec, adc_idx, spec->cur_mux[adc_idx]);
3458 if (!old_path)
3459 return 0;
3460 if (old_path->active)
3461 snd_hda_activate_path(codec, old_path, false, false);
3462
3463 spec->cur_mux[adc_idx] = idx;
3464
3465 if (spec->shared_mic_hp)
3466 update_shared_mic_hp(codec, spec->cur_mux[adc_idx]);
3467
3468 if (spec->dyn_adc_switch)
3469 dyn_adc_pcm_resetup(codec, idx);
3470
3471 path = get_input_path(codec, adc_idx, idx);
3472 if (!path)
3473 return 0;
3474 if (path->active)
3475 return 0;
3476 snd_hda_activate_path(codec, path, true, false);
3477 if (spec->cap_sync_hook)
3478 spec->cap_sync_hook(codec, NULL);
3479 path_power_down_sync(codec, old_path);
3480 return 1;
3481 }
3482
3483
3484 /*
3485 * Jack detections for HP auto-mute and mic-switch
3486 */
3487
3488 /* check each pin in the given array; returns true if any of them is plugged */
3489 static bool detect_jacks(struct hda_codec *codec, int num_pins, hda_nid_t *pins)
3490 {
3491 int i, present = 0;
3492
3493 for (i = 0; i < num_pins; i++) {
3494 hda_nid_t nid = pins[i];
3495 if (!nid)
3496 break;
3497 /* don't detect pins retasked as inputs */
3498 if (snd_hda_codec_get_pin_target(codec, nid) & AC_PINCTL_IN_EN)
3499 continue;
3500 present |= snd_hda_jack_detect(codec, nid);
3501 }
3502 return present;
3503 }
3504
3505 /* standard HP/line-out auto-mute helper */
3506 static void do_automute(struct hda_codec *codec, int num_pins, hda_nid_t *pins,
3507 bool mute)
3508 {
3509 struct hda_gen_spec *spec = codec->spec;
3510 int i;
3511
3512 for (i = 0; i < num_pins; i++) {
3513 hda_nid_t nid = pins[i];
3514 unsigned int val;
3515 if (!nid)
3516 break;
3517 /* don't reset VREF value in case it's controlling
3518 * the amp (see alc861_fixup_asus_amp_vref_0f())
3519 */
3520 if (spec->keep_vref_in_automute)
3521 val = snd_hda_codec_get_pin_target(codec, nid) & ~PIN_HP;
3522 else
3523 val = 0;
3524 if (!mute)
3525 val |= snd_hda_codec_get_pin_target(codec, nid);
3526 /* here we call update_pin_ctl() so that the pinctl is changed
3527 * without changing the pinctl target value;
3528 * the original target value will be still referred at the
3529 * init / resume again
3530 */
3531 update_pin_ctl(codec, nid, val);
3532 set_pin_eapd(codec, nid, !mute);
3533 }
3534 }
3535
3536 /* Toggle outputs muting */
3537 void snd_hda_gen_update_outputs(struct hda_codec *codec)
3538 {
3539 struct hda_gen_spec *spec = codec->spec;
3540 int on;
3541
3542 /* Control HP pins/amps depending on master_mute state;
3543 * in general, HP pins/amps control should be enabled in all cases,
3544 * but currently set only for master_mute, just to be safe
3545 */
3546 if (!spec->shared_mic_hp) /* don't change HP-pin when shared with mic */
3547 do_automute(codec, ARRAY_SIZE(spec->autocfg.hp_pins),
3548 spec->autocfg.hp_pins, spec->master_mute);
3549
3550 if (!spec->automute_speaker)
3551 on = 0;
3552 else
3553 on = spec->hp_jack_present | spec->line_jack_present;
3554 on |= spec->master_mute;
3555 spec->speaker_muted = on;
3556 do_automute(codec, ARRAY_SIZE(spec->autocfg.speaker_pins),
3557 spec->autocfg.speaker_pins, on);
3558
3559 /* toggle line-out mutes if needed, too */
3560 /* if LO is a copy of either HP or Speaker, don't need to handle it */
3561 if (spec->autocfg.line_out_pins[0] == spec->autocfg.hp_pins[0] ||
3562 spec->autocfg.line_out_pins[0] == spec->autocfg.speaker_pins[0])
3563 return;
3564 if (!spec->automute_lo)
3565 on = 0;
3566 else
3567 on = spec->hp_jack_present;
3568 on |= spec->master_mute;
3569 spec->line_out_muted = on;
3570 do_automute(codec, ARRAY_SIZE(spec->autocfg.line_out_pins),
3571 spec->autocfg.line_out_pins, on);
3572 }
3573 EXPORT_SYMBOL_HDA(snd_hda_gen_update_outputs);
3574
3575 static void call_update_outputs(struct hda_codec *codec)
3576 {
3577 struct hda_gen_spec *spec = codec->spec;
3578 if (spec->automute_hook)
3579 spec->automute_hook(codec);
3580 else
3581 snd_hda_gen_update_outputs(codec);
3582 }
3583
3584 /* standard HP-automute helper */
3585 void snd_hda_gen_hp_automute(struct hda_codec *codec, struct hda_jack_tbl *jack)
3586 {
3587 struct hda_gen_spec *spec = codec->spec;
3588 hda_nid_t *pins = spec->autocfg.hp_pins;
3589 int num_pins = ARRAY_SIZE(spec->autocfg.hp_pins);
3590
3591 /* No detection for the first HP jack during indep-HP mode */
3592 if (spec->indep_hp_enabled) {
3593 pins++;
3594 num_pins--;
3595 }
3596
3597 spec->hp_jack_present = detect_jacks(codec, num_pins, pins);
3598 if (!spec->detect_hp || (!spec->automute_speaker && !spec->automute_lo))
3599 return;
3600 call_update_outputs(codec);
3601 }
3602 EXPORT_SYMBOL_HDA(snd_hda_gen_hp_automute);
3603
3604 /* standard line-out-automute helper */
3605 void snd_hda_gen_line_automute(struct hda_codec *codec, struct hda_jack_tbl *jack)
3606 {
3607 struct hda_gen_spec *spec = codec->spec;
3608
3609 if (spec->autocfg.line_out_type == AUTO_PIN_SPEAKER_OUT)
3610 return;
3611 /* check LO jack only when it's different from HP */
3612 if (spec->autocfg.line_out_pins[0] == spec->autocfg.hp_pins[0])
3613 return;
3614
3615 spec->line_jack_present =
3616 detect_jacks(codec, ARRAY_SIZE(spec->autocfg.line_out_pins),
3617 spec->autocfg.line_out_pins);
3618 if (!spec->automute_speaker || !spec->detect_lo)
3619 return;
3620 call_update_outputs(codec);
3621 }
3622 EXPORT_SYMBOL_HDA(snd_hda_gen_line_automute);
3623
3624 /* standard mic auto-switch helper */
3625 void snd_hda_gen_mic_autoswitch(struct hda_codec *codec, struct hda_jack_tbl *jack)
3626 {
3627 struct hda_gen_spec *spec = codec->spec;
3628 int i;
3629
3630 if (!spec->auto_mic)
3631 return;
3632
3633 for (i = spec->am_num_entries - 1; i > 0; i--) {
3634 hda_nid_t pin = spec->am_entry[i].pin;
3635 /* don't detect pins retasked as outputs */
3636 if (snd_hda_codec_get_pin_target(codec, pin) & AC_PINCTL_OUT_EN)
3637 continue;
3638 if (snd_hda_jack_detect(codec, pin)) {
3639 mux_select(codec, 0, spec->am_entry[i].idx);
3640 return;
3641 }
3642 }
3643 mux_select(codec, 0, spec->am_entry[0].idx);
3644 }
3645 EXPORT_SYMBOL_HDA(snd_hda_gen_mic_autoswitch);
3646
3647 /* update jack retasking */
3648 static void update_automute_all(struct hda_codec *codec)
3649 {
3650 struct hda_gen_spec *spec = codec->spec;
3651
3652 if (spec->hp_automute_hook)
3653 spec->hp_automute_hook(codec, NULL);
3654 else
3655 snd_hda_gen_hp_automute(codec, NULL);
3656 if (spec->line_automute_hook)
3657 spec->line_automute_hook(codec, NULL);
3658 else
3659 snd_hda_gen_line_automute(codec, NULL);
3660 if (spec->mic_autoswitch_hook)
3661 spec->mic_autoswitch_hook(codec, NULL);
3662 else
3663 snd_hda_gen_mic_autoswitch(codec, NULL);
3664 }
3665
3666 /*
3667 * Auto-Mute mode mixer enum support
3668 */
3669 static int automute_mode_info(struct snd_kcontrol *kcontrol,
3670 struct snd_ctl_elem_info *uinfo)
3671 {
3672 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3673 struct hda_gen_spec *spec = codec->spec;
3674 static const char * const texts3[] = {
3675 "Disabled", "Speaker Only", "Line Out+Speaker"
3676 };
3677
3678 if (spec->automute_speaker_possible && spec->automute_lo_possible)
3679 return snd_hda_enum_helper_info(kcontrol, uinfo, 3, texts3);
3680 return snd_hda_enum_bool_helper_info(kcontrol, uinfo);
3681 }
3682
3683 static int automute_mode_get(struct snd_kcontrol *kcontrol,
3684 struct snd_ctl_elem_value *ucontrol)
3685 {
3686 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3687 struct hda_gen_spec *spec = codec->spec;
3688 unsigned int val = 0;
3689 if (spec->automute_speaker)
3690 val++;
3691 if (spec->automute_lo)
3692 val++;
3693
3694 ucontrol->value.enumerated.item[0] = val;
3695 return 0;
3696 }
3697
3698 static int automute_mode_put(struct snd_kcontrol *kcontrol,
3699 struct snd_ctl_elem_value *ucontrol)
3700 {
3701 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3702 struct hda_gen_spec *spec = codec->spec;
3703
3704 switch (ucontrol->value.enumerated.item[0]) {
3705 case 0:
3706 if (!spec->automute_speaker && !spec->automute_lo)
3707 return 0;
3708 spec->automute_speaker = 0;
3709 spec->automute_lo = 0;
3710 break;
3711 case 1:
3712 if (spec->automute_speaker_possible) {
3713 if (!spec->automute_lo && spec->automute_speaker)
3714 return 0;
3715 spec->automute_speaker = 1;
3716 spec->automute_lo = 0;
3717 } else if (spec->automute_lo_possible) {
3718 if (spec->automute_lo)
3719 return 0;
3720 spec->automute_lo = 1;
3721 } else
3722 return -EINVAL;
3723 break;
3724 case 2:
3725 if (!spec->automute_lo_possible || !spec->automute_speaker_possible)
3726 return -EINVAL;
3727 if (spec->automute_speaker && spec->automute_lo)
3728 return 0;
3729 spec->automute_speaker = 1;
3730 spec->automute_lo = 1;
3731 break;
3732 default:
3733 return -EINVAL;
3734 }
3735 call_update_outputs(codec);
3736 return 1;
3737 }
3738
3739 static const struct snd_kcontrol_new automute_mode_enum = {
3740 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3741 .name = "Auto-Mute Mode",
3742 .info = automute_mode_info,
3743 .get = automute_mode_get,
3744 .put = automute_mode_put,
3745 };
3746
3747 static int add_automute_mode_enum(struct hda_codec *codec)
3748 {
3749 struct hda_gen_spec *spec = codec->spec;
3750
3751 if (!snd_hda_gen_add_kctl(spec, NULL, &automute_mode_enum))
3752 return -ENOMEM;
3753 return 0;
3754 }
3755
3756 /*
3757 * Check the availability of HP/line-out auto-mute;
3758 * Set up appropriately if really supported
3759 */
3760 static int check_auto_mute_availability(struct hda_codec *codec)
3761 {
3762 struct hda_gen_spec *spec = codec->spec;
3763 struct auto_pin_cfg *cfg = &spec->autocfg;
3764 int present = 0;
3765 int i, err;
3766
3767 if (spec->suppress_auto_mute)
3768 return 0;
3769
3770 if (cfg->hp_pins[0])
3771 present++;
3772 if (cfg->line_out_pins[0])
3773 present++;
3774 if (cfg->speaker_pins[0])
3775 present++;
3776 if (present < 2) /* need two different output types */
3777 return 0;
3778
3779 if (!cfg->speaker_pins[0] &&
3780 cfg->line_out_type == AUTO_PIN_SPEAKER_OUT) {
3781 memcpy(cfg->speaker_pins, cfg->line_out_pins,
3782 sizeof(cfg->speaker_pins));
3783 cfg->speaker_outs = cfg->line_outs;
3784 }
3785
3786 if (!cfg->hp_pins[0] &&
3787 cfg->line_out_type == AUTO_PIN_HP_OUT) {
3788 memcpy(cfg->hp_pins, cfg->line_out_pins,
3789 sizeof(cfg->hp_pins));
3790 cfg->hp_outs = cfg->line_outs;
3791 }
3792
3793 for (i = 0; i < cfg->hp_outs; i++) {
3794 hda_nid_t nid = cfg->hp_pins[i];
3795 if (!is_jack_detectable(codec, nid))
3796 continue;
3797 snd_printdd("hda-codec: Enable HP auto-muting on NID 0x%x\n",
3798 nid);
3799 snd_hda_jack_detect_enable_callback(codec, nid, HDA_GEN_HP_EVENT,
3800 spec->hp_automute_hook ?
3801 spec->hp_automute_hook :
3802 snd_hda_gen_hp_automute);
3803 spec->detect_hp = 1;
3804 }
3805
3806 if (cfg->line_out_type == AUTO_PIN_LINE_OUT && cfg->line_outs) {
3807 if (cfg->speaker_outs)
3808 for (i = 0; i < cfg->line_outs; i++) {
3809 hda_nid_t nid = cfg->line_out_pins[i];
3810 if (!is_jack_detectable(codec, nid))
3811 continue;
3812 snd_printdd("hda-codec: Enable Line-Out auto-muting on NID 0x%x\n", nid);
3813 snd_hda_jack_detect_enable_callback(codec, nid,
3814 HDA_GEN_FRONT_EVENT,
3815 spec->line_automute_hook ?
3816 spec->line_automute_hook :
3817 snd_hda_gen_line_automute);
3818 spec->detect_lo = 1;
3819 }
3820 spec->automute_lo_possible = spec->detect_hp;
3821 }
3822
3823 spec->automute_speaker_possible = cfg->speaker_outs &&
3824 (spec->detect_hp || spec->detect_lo);
3825
3826 spec->automute_lo = spec->automute_lo_possible;
3827 spec->automute_speaker = spec->automute_speaker_possible;
3828
3829 if (spec->automute_speaker_possible || spec->automute_lo_possible) {
3830 /* create a control for automute mode */
3831 err = add_automute_mode_enum(codec);
3832 if (err < 0)
3833 return err;
3834 }
3835 return 0;
3836 }
3837
3838 /* check whether all auto-mic pins are valid; setup indices if OK */
3839 static bool auto_mic_check_imux(struct hda_codec *codec)
3840 {
3841 struct hda_gen_spec *spec = codec->spec;
3842 const struct hda_input_mux *imux;
3843 int i;
3844
3845 imux = &spec->input_mux;
3846 for (i = 0; i < spec->am_num_entries; i++) {
3847 spec->am_entry[i].idx =
3848 find_idx_in_nid_list(spec->am_entry[i].pin,
3849 spec->imux_pins, imux->num_items);
3850 if (spec->am_entry[i].idx < 0)
3851 return false; /* no corresponding imux */
3852 }
3853
3854 /* we don't need the jack detection for the first pin */
3855 for (i = 1; i < spec->am_num_entries; i++)
3856 snd_hda_jack_detect_enable_callback(codec,
3857 spec->am_entry[i].pin,
3858 HDA_GEN_MIC_EVENT,
3859 spec->mic_autoswitch_hook ?
3860 spec->mic_autoswitch_hook :
3861 snd_hda_gen_mic_autoswitch);
3862 return true;
3863 }
3864
3865 static int compare_attr(const void *ap, const void *bp)
3866 {
3867 const struct automic_entry *a = ap;
3868 const struct automic_entry *b = bp;
3869 return (int)(a->attr - b->attr);
3870 }
3871
3872 /*
3873 * Check the availability of auto-mic switch;
3874 * Set up if really supported
3875 */
3876 static int check_auto_mic_availability(struct hda_codec *codec)
3877 {
3878 struct hda_gen_spec *spec = codec->spec;
3879 struct auto_pin_cfg *cfg = &spec->autocfg;
3880 unsigned int types;
3881 int i, num_pins;
3882
3883 if (spec->suppress_auto_mic)
3884 return 0;
3885
3886 types = 0;
3887 num_pins = 0;
3888 for (i = 0; i < cfg->num_inputs; i++) {
3889 hda_nid_t nid = cfg->inputs[i].pin;
3890 unsigned int attr;
3891 attr = snd_hda_codec_get_pincfg(codec, nid);
3892 attr = snd_hda_get_input_pin_attr(attr);
3893 if (types & (1 << attr))
3894 return 0; /* already occupied */
3895 switch (attr) {
3896 case INPUT_PIN_ATTR_INT:
3897 if (cfg->inputs[i].type != AUTO_PIN_MIC)
3898 return 0; /* invalid type */
3899 break;
3900 case INPUT_PIN_ATTR_UNUSED:
3901 return 0; /* invalid entry */
3902 default:
3903 if (cfg->inputs[i].type > AUTO_PIN_LINE_IN)
3904 return 0; /* invalid type */
3905 if (!spec->line_in_auto_switch &&
3906 cfg->inputs[i].type != AUTO_PIN_MIC)
3907 return 0; /* only mic is allowed */
3908 if (!is_jack_detectable(codec, nid))
3909 return 0; /* no unsol support */
3910 break;
3911 }
3912 if (num_pins >= MAX_AUTO_MIC_PINS)
3913 return 0;
3914 types |= (1 << attr);
3915 spec->am_entry[num_pins].pin = nid;
3916 spec->am_entry[num_pins].attr = attr;
3917 num_pins++;
3918 }
3919
3920 if (num_pins < 2)
3921 return 0;
3922
3923 spec->am_num_entries = num_pins;
3924 /* sort the am_entry in the order of attr so that the pin with a
3925 * higher attr will be selected when the jack is plugged.
3926 */
3927 sort(spec->am_entry, num_pins, sizeof(spec->am_entry[0]),
3928 compare_attr, NULL);
3929
3930 if (!auto_mic_check_imux(codec))
3931 return 0;
3932
3933 spec->auto_mic = 1;
3934 spec->num_adc_nids = 1;
3935 spec->cur_mux[0] = spec->am_entry[0].idx;
3936 snd_printdd("hda-codec: Enable auto-mic switch on NID 0x%x/0x%x/0x%x\n",
3937 spec->am_entry[0].pin,
3938 spec->am_entry[1].pin,
3939 spec->am_entry[2].pin);
3940
3941 return 0;
3942 }
3943
3944 /* power_filter hook; make inactive widgets into power down */
3945 static unsigned int snd_hda_gen_path_power_filter(struct hda_codec *codec,
3946 hda_nid_t nid,
3947 unsigned int power_state)
3948 {
3949 if (power_state != AC_PWRST_D0)
3950 return power_state;
3951 if (get_wcaps_type(get_wcaps(codec, nid)) >= AC_WID_POWER)
3952 return power_state;
3953 if (is_active_nid(codec, nid, HDA_OUTPUT, 0))
3954 return power_state;
3955 return AC_PWRST_D3;
3956 }
3957
3958
3959 /*
3960 * Parse the given BIOS configuration and set up the hda_gen_spec
3961 *
3962 * return 1 if successful, 0 if the proper config is not found,
3963 * or a negative error code
3964 */
3965 int snd_hda_gen_parse_auto_config(struct hda_codec *codec,
3966 struct auto_pin_cfg *cfg)
3967 {
3968 struct hda_gen_spec *spec = codec->spec;
3969 int err;
3970
3971 parse_user_hints(codec);
3972
3973 if (spec->mixer_nid && !spec->mixer_merge_nid)
3974 spec->mixer_merge_nid = spec->mixer_nid;
3975
3976 if (cfg != &spec->autocfg) {
3977 spec->autocfg = *cfg;
3978 cfg = &spec->autocfg;
3979 }
3980
3981 fill_all_dac_nids(codec);
3982
3983 if (!cfg->line_outs) {
3984 if (cfg->dig_outs || cfg->dig_in_pin) {
3985 spec->multiout.max_channels = 2;
3986 spec->no_analog = 1;
3987 goto dig_only;
3988 }
3989 return 0; /* can't find valid BIOS pin config */
3990 }
3991
3992 if (!spec->no_primary_hp &&
3993 cfg->line_out_type == AUTO_PIN_SPEAKER_OUT &&
3994 cfg->line_outs <= cfg->hp_outs) {
3995 /* use HP as primary out */
3996 cfg->speaker_outs = cfg->line_outs;
3997 memcpy(cfg->speaker_pins, cfg->line_out_pins,
3998 sizeof(cfg->speaker_pins));
3999 cfg->line_outs = cfg->hp_outs;
4000 memcpy(cfg->line_out_pins, cfg->hp_pins, sizeof(cfg->hp_pins));
4001 cfg->hp_outs = 0;
4002 memset(cfg->hp_pins, 0, sizeof(cfg->hp_pins));
4003 cfg->line_out_type = AUTO_PIN_HP_OUT;
4004 }
4005
4006 err = parse_output_paths(codec);
4007 if (err < 0)
4008 return err;
4009 err = create_multi_channel_mode(codec);
4010 if (err < 0)
4011 return err;
4012 err = create_multi_out_ctls(codec, cfg);
4013 if (err < 0)
4014 return err;
4015 err = create_hp_out_ctls(codec);
4016 if (err < 0)
4017 return err;
4018 err = create_speaker_out_ctls(codec);
4019 if (err < 0)
4020 return err;
4021 err = create_indep_hp_ctls(codec);
4022 if (err < 0)
4023 return err;
4024 err = create_loopback_mixing_ctl(codec);
4025 if (err < 0)
4026 return err;
4027 err = create_shared_input(codec);
4028 if (err < 0)
4029 return err;
4030 err = create_input_ctls(codec);
4031 if (err < 0)
4032 return err;
4033
4034 spec->const_channel_count = spec->ext_channel_count;
4035 /* check the multiple speaker and headphone pins */
4036 if (cfg->line_out_type != AUTO_PIN_SPEAKER_OUT)
4037 spec->const_channel_count = max(spec->const_channel_count,
4038 cfg->speaker_outs * 2);
4039 if (cfg->line_out_type != AUTO_PIN_HP_OUT)
4040 spec->const_channel_count = max(spec->const_channel_count,
4041 cfg->hp_outs * 2);
4042 spec->multiout.max_channels = max(spec->ext_channel_count,
4043 spec->const_channel_count);
4044
4045 err = check_auto_mute_availability(codec);
4046 if (err < 0)
4047 return err;
4048
4049 err = check_dyn_adc_switch(codec);
4050 if (err < 0)
4051 return err;
4052
4053 if (!spec->shared_mic_hp) {
4054 err = check_auto_mic_availability(codec);
4055 if (err < 0)
4056 return err;
4057 }
4058
4059 err = create_capture_mixers(codec);
4060 if (err < 0)
4061 return err;
4062
4063 err = parse_mic_boost(codec);
4064 if (err < 0)
4065 return err;
4066
4067 if (spec->add_out_jack_modes) {
4068 if (cfg->line_out_type != AUTO_PIN_SPEAKER_OUT) {
4069 err = create_out_jack_modes(codec, cfg->line_outs,
4070 cfg->line_out_pins);
4071 if (err < 0)
4072 return err;
4073 }
4074 if (cfg->line_out_type != AUTO_PIN_HP_OUT) {
4075 err = create_out_jack_modes(codec, cfg->hp_outs,
4076 cfg->hp_pins);
4077 if (err < 0)
4078 return err;
4079 }
4080 }
4081
4082 dig_only:
4083 parse_digital(codec);
4084
4085 if (spec->power_down_unused)
4086 codec->power_filter = snd_hda_gen_path_power_filter;
4087
4088 return 1;
4089 }
4090 EXPORT_SYMBOL_HDA(snd_hda_gen_parse_auto_config);
4091
4092
4093 /*
4094 * Build control elements
4095 */
4096
4097 /* slave controls for virtual master */
4098 static const char * const slave_pfxs[] = {
4099 "Front", "Surround", "Center", "LFE", "Side",
4100 "Headphone", "Speaker", "Mono", "Line Out",
4101 "CLFE", "Bass Speaker", "PCM",
4102 "Speaker Front", "Speaker Surround", "Speaker CLFE", "Speaker Side",
4103 "Headphone Front", "Headphone Surround", "Headphone CLFE",
4104 "Headphone Side",
4105 NULL,
4106 };
4107
4108 int snd_hda_gen_build_controls(struct hda_codec *codec)
4109 {
4110 struct hda_gen_spec *spec = codec->spec;
4111 int err;
4112
4113 if (spec->kctls.used) {
4114 err = snd_hda_add_new_ctls(codec, spec->kctls.list);
4115 if (err < 0)
4116 return err;
4117 }
4118
4119 if (spec->multiout.dig_out_nid) {
4120 err = snd_hda_create_dig_out_ctls(codec,
4121 spec->multiout.dig_out_nid,
4122 spec->multiout.dig_out_nid,
4123 spec->pcm_rec[1].pcm_type);
4124 if (err < 0)
4125 return err;
4126 if (!spec->no_analog) {
4127 err = snd_hda_create_spdif_share_sw(codec,
4128 &spec->multiout);
4129 if (err < 0)
4130 return err;
4131 spec->multiout.share_spdif = 1;
4132 }
4133 }
4134 if (spec->dig_in_nid) {
4135 err = snd_hda_create_spdif_in_ctls(codec, spec->dig_in_nid);
4136 if (err < 0)
4137 return err;
4138 }
4139
4140 /* if we have no master control, let's create it */
4141 if (!spec->no_analog &&
4142 !snd_hda_find_mixer_ctl(codec, "Master Playback Volume")) {
4143 err = snd_hda_add_vmaster(codec, "Master Playback Volume",
4144 spec->vmaster_tlv, slave_pfxs,
4145 "Playback Volume");
4146 if (err < 0)
4147 return err;
4148 }
4149 if (!spec->no_analog &&
4150 !snd_hda_find_mixer_ctl(codec, "Master Playback Switch")) {
4151 err = __snd_hda_add_vmaster(codec, "Master Playback Switch",
4152 NULL, slave_pfxs,
4153 "Playback Switch",
4154 true, &spec->vmaster_mute.sw_kctl);
4155 if (err < 0)
4156 return err;
4157 if (spec->vmaster_mute.hook)
4158 snd_hda_add_vmaster_hook(codec, &spec->vmaster_mute,
4159 spec->vmaster_mute_enum);
4160 }
4161
4162 free_kctls(spec); /* no longer needed */
4163
4164 if (spec->shared_mic_hp) {
4165 int err;
4166 int nid = spec->autocfg.inputs[1].pin;
4167 err = snd_hda_jack_add_kctl(codec, nid, "Headphone Mic", 0);
4168 if (err < 0)
4169 return err;
4170 err = snd_hda_jack_detect_enable(codec, nid, 0);
4171 if (err < 0)
4172 return err;
4173 }
4174
4175 err = snd_hda_jack_add_kctls(codec, &spec->autocfg);
4176 if (err < 0)
4177 return err;
4178
4179 return 0;
4180 }
4181 EXPORT_SYMBOL_HDA(snd_hda_gen_build_controls);
4182
4183
4184 /*
4185 * PCM definitions
4186 */
4187
4188 static void call_pcm_playback_hook(struct hda_pcm_stream *hinfo,
4189 struct hda_codec *codec,
4190 struct snd_pcm_substream *substream,
4191 int action)
4192 {
4193 struct hda_gen_spec *spec = codec->spec;
4194 if (spec->pcm_playback_hook)
4195 spec->pcm_playback_hook(hinfo, codec, substream, action);
4196 }
4197
4198 static void call_pcm_capture_hook(struct hda_pcm_stream *hinfo,
4199 struct hda_codec *codec,
4200 struct snd_pcm_substream *substream,
4201 int action)
4202 {
4203 struct hda_gen_spec *spec = codec->spec;
4204 if (spec->pcm_capture_hook)
4205 spec->pcm_capture_hook(hinfo, codec, substream, action);
4206 }
4207
4208 /*
4209 * Analog playback callbacks
4210 */
4211 static int playback_pcm_open(struct hda_pcm_stream *hinfo,
4212 struct hda_codec *codec,
4213 struct snd_pcm_substream *substream)
4214 {
4215 struct hda_gen_spec *spec = codec->spec;
4216 int err;
4217
4218 mutex_lock(&spec->pcm_mutex);
4219 err = snd_hda_multi_out_analog_open(codec,
4220 &spec->multiout, substream,
4221 hinfo);
4222 if (!err) {
4223 spec->active_streams |= 1 << STREAM_MULTI_OUT;
4224 call_pcm_playback_hook(hinfo, codec, substream,
4225 HDA_GEN_PCM_ACT_OPEN);
4226 }
4227 mutex_unlock(&spec->pcm_mutex);
4228 return err;
4229 }
4230
4231 static int playback_pcm_prepare(struct hda_pcm_stream *hinfo,
4232 struct hda_codec *codec,
4233 unsigned int stream_tag,
4234 unsigned int format,
4235 struct snd_pcm_substream *substream)
4236 {
4237 struct hda_gen_spec *spec = codec->spec;
4238 int err;
4239
4240 err = snd_hda_multi_out_analog_prepare(codec, &spec->multiout,
4241 stream_tag, format, substream);
4242 if (!err)
4243 call_pcm_playback_hook(hinfo, codec, substream,
4244 HDA_GEN_PCM_ACT_PREPARE);
4245 return err;
4246 }
4247
4248 static int playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
4249 struct hda_codec *codec,
4250 struct snd_pcm_substream *substream)
4251 {
4252 struct hda_gen_spec *spec = codec->spec;
4253 int err;
4254
4255 err = snd_hda_multi_out_analog_cleanup(codec, &spec->multiout);
4256 if (!err)
4257 call_pcm_playback_hook(hinfo, codec, substream,
4258 HDA_GEN_PCM_ACT_CLEANUP);
4259 return err;
4260 }
4261
4262 static int playback_pcm_close(struct hda_pcm_stream *hinfo,
4263 struct hda_codec *codec,
4264 struct snd_pcm_substream *substream)
4265 {
4266 struct hda_gen_spec *spec = codec->spec;
4267 mutex_lock(&spec->pcm_mutex);
4268 spec->active_streams &= ~(1 << STREAM_MULTI_OUT);
4269 call_pcm_playback_hook(hinfo, codec, substream,
4270 HDA_GEN_PCM_ACT_CLOSE);
4271 mutex_unlock(&spec->pcm_mutex);
4272 return 0;
4273 }
4274
4275 static int capture_pcm_open(struct hda_pcm_stream *hinfo,
4276 struct hda_codec *codec,
4277 struct snd_pcm_substream *substream)
4278 {
4279 call_pcm_capture_hook(hinfo, codec, substream, HDA_GEN_PCM_ACT_OPEN);
4280 return 0;
4281 }
4282
4283 static int capture_pcm_prepare(struct hda_pcm_stream *hinfo,
4284 struct hda_codec *codec,
4285 unsigned int stream_tag,
4286 unsigned int format,
4287 struct snd_pcm_substream *substream)
4288 {
4289 snd_hda_codec_setup_stream(codec, hinfo->nid, stream_tag, 0, format);
4290 call_pcm_capture_hook(hinfo, codec, substream,
4291 HDA_GEN_PCM_ACT_PREPARE);
4292 return 0;
4293 }
4294
4295 static int capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
4296 struct hda_codec *codec,
4297 struct snd_pcm_substream *substream)
4298 {
4299 snd_hda_codec_cleanup_stream(codec, hinfo->nid);
4300 call_pcm_capture_hook(hinfo, codec, substream,
4301 HDA_GEN_PCM_ACT_CLEANUP);
4302 return 0;
4303 }
4304
4305 static int capture_pcm_close(struct hda_pcm_stream *hinfo,
4306 struct hda_codec *codec,
4307 struct snd_pcm_substream *substream)
4308 {
4309 call_pcm_capture_hook(hinfo, codec, substream, HDA_GEN_PCM_ACT_CLOSE);
4310 return 0;
4311 }
4312
4313 static int alt_playback_pcm_open(struct hda_pcm_stream *hinfo,
4314 struct hda_codec *codec,
4315 struct snd_pcm_substream *substream)
4316 {
4317 struct hda_gen_spec *spec = codec->spec;
4318 int err = 0;
4319
4320 mutex_lock(&spec->pcm_mutex);
4321 if (!spec->indep_hp_enabled)
4322 err = -EBUSY;
4323 else
4324 spec->active_streams |= 1 << STREAM_INDEP_HP;
4325 call_pcm_playback_hook(hinfo, codec, substream,
4326 HDA_GEN_PCM_ACT_OPEN);
4327 mutex_unlock(&spec->pcm_mutex);
4328 return err;
4329 }
4330
4331 static int alt_playback_pcm_close(struct hda_pcm_stream *hinfo,
4332 struct hda_codec *codec,
4333 struct snd_pcm_substream *substream)
4334 {
4335 struct hda_gen_spec *spec = codec->spec;
4336 mutex_lock(&spec->pcm_mutex);
4337 spec->active_streams &= ~(1 << STREAM_INDEP_HP);
4338 call_pcm_playback_hook(hinfo, codec, substream,
4339 HDA_GEN_PCM_ACT_CLOSE);
4340 mutex_unlock(&spec->pcm_mutex);
4341 return 0;
4342 }
4343
4344 static int alt_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
4345 struct hda_codec *codec,
4346 unsigned int stream_tag,
4347 unsigned int format,
4348 struct snd_pcm_substream *substream)
4349 {
4350 snd_hda_codec_setup_stream(codec, hinfo->nid, stream_tag, 0, format);
4351 call_pcm_playback_hook(hinfo, codec, substream,
4352 HDA_GEN_PCM_ACT_PREPARE);
4353 return 0;
4354 }
4355
4356 static int alt_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
4357 struct hda_codec *codec,
4358 struct snd_pcm_substream *substream)
4359 {
4360 snd_hda_codec_cleanup_stream(codec, hinfo->nid);
4361 call_pcm_playback_hook(hinfo, codec, substream,
4362 HDA_GEN_PCM_ACT_CLEANUP);
4363 return 0;
4364 }
4365
4366 /*
4367 * Digital out
4368 */
4369 static int dig_playback_pcm_open(struct hda_pcm_stream *hinfo,
4370 struct hda_codec *codec,
4371 struct snd_pcm_substream *substream)
4372 {
4373 struct hda_gen_spec *spec = codec->spec;
4374 return snd_hda_multi_out_dig_open(codec, &spec->multiout);
4375 }
4376
4377 static int dig_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
4378 struct hda_codec *codec,
4379 unsigned int stream_tag,
4380 unsigned int format,
4381 struct snd_pcm_substream *substream)
4382 {
4383 struct hda_gen_spec *spec = codec->spec;
4384 return snd_hda_multi_out_dig_prepare(codec, &spec->multiout,
4385 stream_tag, format, substream);
4386 }
4387
4388 static int dig_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
4389 struct hda_codec *codec,
4390 struct snd_pcm_substream *substream)
4391 {
4392 struct hda_gen_spec *spec = codec->spec;
4393 return snd_hda_multi_out_dig_cleanup(codec, &spec->multiout);
4394 }
4395
4396 static int dig_playback_pcm_close(struct hda_pcm_stream *hinfo,
4397 struct hda_codec *codec,
4398 struct snd_pcm_substream *substream)
4399 {
4400 struct hda_gen_spec *spec = codec->spec;
4401 return snd_hda_multi_out_dig_close(codec, &spec->multiout);
4402 }
4403
4404 /*
4405 * Analog capture
4406 */
4407 #define alt_capture_pcm_open capture_pcm_open
4408 #define alt_capture_pcm_close capture_pcm_close
4409
4410 static int alt_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
4411 struct hda_codec *codec,
4412 unsigned int stream_tag,
4413 unsigned int format,
4414 struct snd_pcm_substream *substream)
4415 {
4416 struct hda_gen_spec *spec = codec->spec;
4417
4418 snd_hda_codec_setup_stream(codec, spec->adc_nids[substream->number + 1],
4419 stream_tag, 0, format);
4420 call_pcm_capture_hook(hinfo, codec, substream,
4421 HDA_GEN_PCM_ACT_PREPARE);
4422 return 0;
4423 }
4424
4425 static int alt_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
4426 struct hda_codec *codec,
4427 struct snd_pcm_substream *substream)
4428 {
4429 struct hda_gen_spec *spec = codec->spec;
4430
4431 snd_hda_codec_cleanup_stream(codec,
4432 spec->adc_nids[substream->number + 1]);
4433 call_pcm_capture_hook(hinfo, codec, substream,
4434 HDA_GEN_PCM_ACT_CLEANUP);
4435 return 0;
4436 }
4437
4438 /*
4439 */
4440 static const struct hda_pcm_stream pcm_analog_playback = {
4441 .substreams = 1,
4442 .channels_min = 2,
4443 .channels_max = 8,
4444 /* NID is set in build_pcms */
4445 .ops = {
4446 .open = playback_pcm_open,
4447 .close = playback_pcm_close,
4448 .prepare = playback_pcm_prepare,
4449 .cleanup = playback_pcm_cleanup
4450 },
4451 };
4452
4453 static const struct hda_pcm_stream pcm_analog_capture = {
4454 .substreams = 1,
4455 .channels_min = 2,
4456 .channels_max = 2,
4457 /* NID is set in build_pcms */
4458 .ops = {
4459 .open = capture_pcm_open,
4460 .close = capture_pcm_close,
4461 .prepare = capture_pcm_prepare,
4462 .cleanup = capture_pcm_cleanup
4463 },
4464 };
4465
4466 static const struct hda_pcm_stream pcm_analog_alt_playback = {
4467 .substreams = 1,
4468 .channels_min = 2,
4469 .channels_max = 2,
4470 /* NID is set in build_pcms */
4471 .ops = {
4472 .open = alt_playback_pcm_open,
4473 .close = alt_playback_pcm_close,
4474 .prepare = alt_playback_pcm_prepare,
4475 .cleanup = alt_playback_pcm_cleanup
4476 },
4477 };
4478
4479 static const struct hda_pcm_stream pcm_analog_alt_capture = {
4480 .substreams = 2, /* can be overridden */
4481 .channels_min = 2,
4482 .channels_max = 2,
4483 /* NID is set in build_pcms */
4484 .ops = {
4485 .open = alt_capture_pcm_open,
4486 .close = alt_capture_pcm_close,
4487 .prepare = alt_capture_pcm_prepare,
4488 .cleanup = alt_capture_pcm_cleanup
4489 },
4490 };
4491
4492 static const struct hda_pcm_stream pcm_digital_playback = {
4493 .substreams = 1,
4494 .channels_min = 2,
4495 .channels_max = 2,
4496 /* NID is set in build_pcms */
4497 .ops = {
4498 .open = dig_playback_pcm_open,
4499 .close = dig_playback_pcm_close,
4500 .prepare = dig_playback_pcm_prepare,
4501 .cleanup = dig_playback_pcm_cleanup
4502 },
4503 };
4504
4505 static const struct hda_pcm_stream pcm_digital_capture = {
4506 .substreams = 1,
4507 .channels_min = 2,
4508 .channels_max = 2,
4509 /* NID is set in build_pcms */
4510 };
4511
4512 /* Used by build_pcms to flag that a PCM has no playback stream */
4513 static const struct hda_pcm_stream pcm_null_stream = {
4514 .substreams = 0,
4515 .channels_min = 0,
4516 .channels_max = 0,
4517 };
4518
4519 /*
4520 * dynamic changing ADC PCM streams
4521 */
4522 static bool dyn_adc_pcm_resetup(struct hda_codec *codec, int cur)
4523 {
4524 struct hda_gen_spec *spec = codec->spec;
4525 hda_nid_t new_adc = spec->adc_nids[spec->dyn_adc_idx[cur]];
4526
4527 if (spec->cur_adc && spec->cur_adc != new_adc) {
4528 /* stream is running, let's swap the current ADC */
4529 __snd_hda_codec_cleanup_stream(codec, spec->cur_adc, 1);
4530 spec->cur_adc = new_adc;
4531 snd_hda_codec_setup_stream(codec, new_adc,
4532 spec->cur_adc_stream_tag, 0,
4533 spec->cur_adc_format);
4534 return true;
4535 }
4536 return false;
4537 }
4538
4539 /* analog capture with dynamic dual-adc changes */
4540 static int dyn_adc_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
4541 struct hda_codec *codec,
4542 unsigned int stream_tag,
4543 unsigned int format,
4544 struct snd_pcm_substream *substream)
4545 {
4546 struct hda_gen_spec *spec = codec->spec;
4547 spec->cur_adc = spec->adc_nids[spec->dyn_adc_idx[spec->cur_mux[0]]];
4548 spec->cur_adc_stream_tag = stream_tag;
4549 spec->cur_adc_format = format;
4550 snd_hda_codec_setup_stream(codec, spec->cur_adc, stream_tag, 0, format);
4551 return 0;
4552 }
4553
4554 static int dyn_adc_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
4555 struct hda_codec *codec,
4556 struct snd_pcm_substream *substream)
4557 {
4558 struct hda_gen_spec *spec = codec->spec;
4559 snd_hda_codec_cleanup_stream(codec, spec->cur_adc);
4560 spec->cur_adc = 0;
4561 return 0;
4562 }
4563
4564 static const struct hda_pcm_stream dyn_adc_pcm_analog_capture = {
4565 .substreams = 1,
4566 .channels_min = 2,
4567 .channels_max = 2,
4568 .nid = 0, /* fill later */
4569 .ops = {
4570 .prepare = dyn_adc_capture_pcm_prepare,
4571 .cleanup = dyn_adc_capture_pcm_cleanup
4572 },
4573 };
4574
4575 static void fill_pcm_stream_name(char *str, size_t len, const char *sfx,
4576 const char *chip_name)
4577 {
4578 char *p;
4579
4580 if (*str)
4581 return;
4582 strlcpy(str, chip_name, len);
4583
4584 /* drop non-alnum chars after a space */
4585 for (p = strchr(str, ' '); p; p = strchr(p + 1, ' ')) {
4586 if (!isalnum(p[1])) {
4587 *p = 0;
4588 break;
4589 }
4590 }
4591 strlcat(str, sfx, len);
4592 }
4593
4594 /* build PCM streams based on the parsed results */
4595 int snd_hda_gen_build_pcms(struct hda_codec *codec)
4596 {
4597 struct hda_gen_spec *spec = codec->spec;
4598 struct hda_pcm *info = spec->pcm_rec;
4599 const struct hda_pcm_stream *p;
4600 bool have_multi_adcs;
4601
4602 codec->num_pcms = 1;
4603 codec->pcm_info = info;
4604
4605 if (spec->no_analog)
4606 goto skip_analog;
4607
4608 fill_pcm_stream_name(spec->stream_name_analog,
4609 sizeof(spec->stream_name_analog),
4610 " Analog", codec->chip_name);
4611 info->name = spec->stream_name_analog;
4612
4613 if (spec->multiout.num_dacs > 0) {
4614 p = spec->stream_analog_playback;
4615 if (!p)
4616 p = &pcm_analog_playback;
4617 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *p;
4618 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dac_nids[0];
4619 info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max =
4620 spec->multiout.max_channels;
4621 if (spec->autocfg.line_out_type == AUTO_PIN_SPEAKER_OUT &&
4622 spec->autocfg.line_outs == 2)
4623 info->stream[SNDRV_PCM_STREAM_PLAYBACK].chmap =
4624 snd_pcm_2_1_chmaps;
4625 }
4626 if (spec->num_adc_nids) {
4627 p = spec->stream_analog_capture;
4628 if (!p) {
4629 if (spec->dyn_adc_switch)
4630 p = &dyn_adc_pcm_analog_capture;
4631 else
4632 p = &pcm_analog_capture;
4633 }
4634 info->stream[SNDRV_PCM_STREAM_CAPTURE] = *p;
4635 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adc_nids[0];
4636 }
4637
4638 skip_analog:
4639 /* SPDIF for stream index #1 */
4640 if (spec->multiout.dig_out_nid || spec->dig_in_nid) {
4641 fill_pcm_stream_name(spec->stream_name_digital,
4642 sizeof(spec->stream_name_digital),
4643 " Digital", codec->chip_name);
4644 codec->num_pcms = 2;
4645 codec->slave_dig_outs = spec->multiout.slave_dig_outs;
4646 info = spec->pcm_rec + 1;
4647 info->name = spec->stream_name_digital;
4648 if (spec->dig_out_type)
4649 info->pcm_type = spec->dig_out_type;
4650 else
4651 info->pcm_type = HDA_PCM_TYPE_SPDIF;
4652 if (spec->multiout.dig_out_nid) {
4653 p = spec->stream_digital_playback;
4654 if (!p)
4655 p = &pcm_digital_playback;
4656 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *p;
4657 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dig_out_nid;
4658 }
4659 if (spec->dig_in_nid) {
4660 p = spec->stream_digital_capture;
4661 if (!p)
4662 p = &pcm_digital_capture;
4663 info->stream[SNDRV_PCM_STREAM_CAPTURE] = *p;
4664 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->dig_in_nid;
4665 }
4666 }
4667
4668 if (spec->no_analog)
4669 return 0;
4670
4671 /* If the use of more than one ADC is requested for the current
4672 * model, configure a second analog capture-only PCM.
4673 */
4674 have_multi_adcs = (spec->num_adc_nids > 1) &&
4675 !spec->dyn_adc_switch && !spec->auto_mic;
4676 /* Additional Analaog capture for index #2 */
4677 if (spec->alt_dac_nid || have_multi_adcs) {
4678 fill_pcm_stream_name(spec->stream_name_alt_analog,
4679 sizeof(spec->stream_name_alt_analog),
4680 " Alt Analog", codec->chip_name);
4681 codec->num_pcms = 3;
4682 info = spec->pcm_rec + 2;
4683 info->name = spec->stream_name_alt_analog;
4684 if (spec->alt_dac_nid) {
4685 p = spec->stream_analog_alt_playback;
4686 if (!p)
4687 p = &pcm_analog_alt_playback;
4688 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *p;
4689 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid =
4690 spec->alt_dac_nid;
4691 } else {
4692 info->stream[SNDRV_PCM_STREAM_PLAYBACK] =
4693 pcm_null_stream;
4694 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = 0;
4695 }
4696 if (have_multi_adcs) {
4697 p = spec->stream_analog_alt_capture;
4698 if (!p)
4699 p = &pcm_analog_alt_capture;
4700 info->stream[SNDRV_PCM_STREAM_CAPTURE] = *p;
4701 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid =
4702 spec->adc_nids[1];
4703 info->stream[SNDRV_PCM_STREAM_CAPTURE].substreams =
4704 spec->num_adc_nids - 1;
4705 } else {
4706 info->stream[SNDRV_PCM_STREAM_CAPTURE] =
4707 pcm_null_stream;
4708 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = 0;
4709 }
4710 }
4711
4712 return 0;
4713 }
4714 EXPORT_SYMBOL_HDA(snd_hda_gen_build_pcms);
4715
4716
4717 /*
4718 * Standard auto-parser initializations
4719 */
4720
4721 /* configure the given path as a proper output */
4722 static void set_output_and_unmute(struct hda_codec *codec, int path_idx)
4723 {
4724 struct nid_path *path;
4725 hda_nid_t pin;
4726
4727 path = snd_hda_get_path_from_idx(codec, path_idx);
4728 if (!path || !path->depth)
4729 return;
4730 pin = path->path[path->depth - 1];
4731 restore_pin_ctl(codec, pin);
4732 snd_hda_activate_path(codec, path, path->active, true);
4733 set_pin_eapd(codec, pin, path->active);
4734 }
4735
4736 /* initialize primary output paths */
4737 static void init_multi_out(struct hda_codec *codec)
4738 {
4739 struct hda_gen_spec *spec = codec->spec;
4740 int i;
4741
4742 for (i = 0; i < spec->autocfg.line_outs; i++)
4743 set_output_and_unmute(codec, spec->out_paths[i]);
4744 }
4745
4746
4747 static void __init_extra_out(struct hda_codec *codec, int num_outs, int *paths)
4748 {
4749 int i;
4750
4751 for (i = 0; i < num_outs; i++)
4752 set_output_and_unmute(codec, paths[i]);
4753 }
4754
4755 /* initialize hp and speaker paths */
4756 static void init_extra_out(struct hda_codec *codec)
4757 {
4758 struct hda_gen_spec *spec = codec->spec;
4759
4760 if (spec->autocfg.line_out_type != AUTO_PIN_HP_OUT)
4761 __init_extra_out(codec, spec->autocfg.hp_outs, spec->hp_paths);
4762 if (spec->autocfg.line_out_type != AUTO_PIN_SPEAKER_OUT)
4763 __init_extra_out(codec, spec->autocfg.speaker_outs,
4764 spec->speaker_paths);
4765 }
4766
4767 /* initialize multi-io paths */
4768 static void init_multi_io(struct hda_codec *codec)
4769 {
4770 struct hda_gen_spec *spec = codec->spec;
4771 int i;
4772
4773 for (i = 0; i < spec->multi_ios; i++) {
4774 hda_nid_t pin = spec->multi_io[i].pin;
4775 struct nid_path *path;
4776 path = get_multiio_path(codec, i);
4777 if (!path)
4778 continue;
4779 if (!spec->multi_io[i].ctl_in)
4780 spec->multi_io[i].ctl_in =
4781 snd_hda_codec_get_pin_target(codec, pin);
4782 snd_hda_activate_path(codec, path, path->active, true);
4783 }
4784 }
4785
4786 /* set up input pins and loopback paths */
4787 static void init_analog_input(struct hda_codec *codec)
4788 {
4789 struct hda_gen_spec *spec = codec->spec;
4790 struct auto_pin_cfg *cfg = &spec->autocfg;
4791 int i;
4792
4793 for (i = 0; i < cfg->num_inputs; i++) {
4794 hda_nid_t nid = cfg->inputs[i].pin;
4795 if (is_input_pin(codec, nid))
4796 restore_pin_ctl(codec, nid);
4797
4798 /* init loopback inputs */
4799 if (spec->mixer_nid) {
4800 resume_path_from_idx(codec, spec->loopback_paths[i]);
4801 resume_path_from_idx(codec, spec->loopback_merge_path);
4802 }
4803 }
4804 }
4805
4806 /* initialize ADC paths */
4807 static void init_input_src(struct hda_codec *codec)
4808 {
4809 struct hda_gen_spec *spec = codec->spec;
4810 struct hda_input_mux *imux = &spec->input_mux;
4811 struct nid_path *path;
4812 int i, c, nums;
4813
4814 if (spec->dyn_adc_switch)
4815 nums = 1;
4816 else
4817 nums = spec->num_adc_nids;
4818
4819 for (c = 0; c < nums; c++) {
4820 for (i = 0; i < imux->num_items; i++) {
4821 path = get_input_path(codec, c, i);
4822 if (path) {
4823 bool active = path->active;
4824 if (i == spec->cur_mux[c])
4825 active = true;
4826 snd_hda_activate_path(codec, path, active, false);
4827 }
4828 }
4829 }
4830
4831 if (spec->shared_mic_hp)
4832 update_shared_mic_hp(codec, spec->cur_mux[0]);
4833
4834 if (spec->cap_sync_hook)
4835 spec->cap_sync_hook(codec, NULL);
4836 }
4837
4838 /* set right pin controls for digital I/O */
4839 static void init_digital(struct hda_codec *codec)
4840 {
4841 struct hda_gen_spec *spec = codec->spec;
4842 int i;
4843 hda_nid_t pin;
4844
4845 for (i = 0; i < spec->autocfg.dig_outs; i++)
4846 set_output_and_unmute(codec, spec->digout_paths[i]);
4847 pin = spec->autocfg.dig_in_pin;
4848 if (pin) {
4849 restore_pin_ctl(codec, pin);
4850 resume_path_from_idx(codec, spec->digin_path);
4851 }
4852 }
4853
4854 /* clear unsol-event tags on unused pins; Conexant codecs seem to leave
4855 * invalid unsol tags by some reason
4856 */
4857 static void clear_unsol_on_unused_pins(struct hda_codec *codec)
4858 {
4859 int i;
4860
4861 for (i = 0; i < codec->init_pins.used; i++) {
4862 struct hda_pincfg *pin = snd_array_elem(&codec->init_pins, i);
4863 hda_nid_t nid = pin->nid;
4864 if (is_jack_detectable(codec, nid) &&
4865 !snd_hda_jack_tbl_get(codec, nid))
4866 snd_hda_codec_update_cache(codec, nid, 0,
4867 AC_VERB_SET_UNSOLICITED_ENABLE, 0);
4868 }
4869 }
4870
4871 /*
4872 * initialize the generic spec;
4873 * this can be put as patch_ops.init function
4874 */
4875 int snd_hda_gen_init(struct hda_codec *codec)
4876 {
4877 struct hda_gen_spec *spec = codec->spec;
4878
4879 if (spec->init_hook)
4880 spec->init_hook(codec);
4881
4882 snd_hda_apply_verbs(codec);
4883
4884 codec->cached_write = 1;
4885
4886 init_multi_out(codec);
4887 init_extra_out(codec);
4888 init_multi_io(codec);
4889 init_analog_input(codec);
4890 init_input_src(codec);
4891 init_digital(codec);
4892
4893 clear_unsol_on_unused_pins(codec);
4894
4895 /* call init functions of standard auto-mute helpers */
4896 update_automute_all(codec);
4897
4898 snd_hda_codec_flush_cache(codec);
4899
4900 if (spec->vmaster_mute.sw_kctl && spec->vmaster_mute.hook)
4901 snd_hda_sync_vmaster_hook(&spec->vmaster_mute);
4902
4903 hda_call_check_power_status(codec, 0x01);
4904 return 0;
4905 }
4906 EXPORT_SYMBOL_HDA(snd_hda_gen_init);
4907
4908 /*
4909 * free the generic spec;
4910 * this can be put as patch_ops.free function
4911 */
4912 void snd_hda_gen_free(struct hda_codec *codec)
4913 {
4914 snd_hda_gen_spec_free(codec->spec);
4915 kfree(codec->spec);
4916 codec->spec = NULL;
4917 }
4918 EXPORT_SYMBOL_HDA(snd_hda_gen_free);
4919
4920 #ifdef CONFIG_PM
4921 /*
4922 * check the loopback power save state;
4923 * this can be put as patch_ops.check_power_status function
4924 */
4925 int snd_hda_gen_check_power_status(struct hda_codec *codec, hda_nid_t nid)
4926 {
4927 struct hda_gen_spec *spec = codec->spec;
4928 return snd_hda_check_amp_list_power(codec, &spec->loopback, nid);
4929 }
4930 EXPORT_SYMBOL_HDA(snd_hda_gen_check_power_status);
4931 #endif
4932
4933
4934 /*
4935 * the generic codec support
4936 */
4937
4938 static const struct hda_codec_ops generic_patch_ops = {
4939 .build_controls = snd_hda_gen_build_controls,
4940 .build_pcms = snd_hda_gen_build_pcms,
4941 .init = snd_hda_gen_init,
4942 .free = snd_hda_gen_free,
4943 .unsol_event = snd_hda_jack_unsol_event,
4944 #ifdef CONFIG_PM
4945 .check_power_status = snd_hda_gen_check_power_status,
4946 #endif
4947 };
4948
4949 int snd_hda_parse_generic_codec(struct hda_codec *codec)
4950 {
4951 struct hda_gen_spec *spec;
4952 int err;
4953
4954 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
4955 if (!spec)
4956 return -ENOMEM;
4957 snd_hda_gen_spec_init(spec);
4958 codec->spec = spec;
4959
4960 err = snd_hda_parse_pin_defcfg(codec, &spec->autocfg, NULL, 0);
4961 if (err < 0)
4962 return err;
4963
4964 err = snd_hda_gen_parse_auto_config(codec, &spec->autocfg);
4965 if (err < 0)
4966 goto error;
4967
4968 codec->patch_ops = generic_patch_ops;
4969 return 0;
4970
4971 error:
4972 snd_hda_gen_free(codec);
4973 return err;
4974 }
4975 EXPORT_SYMBOL_HDA(snd_hda_parse_generic_codec);
Linux 2.6 libata-dev (mirror)