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