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