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