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