projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Merge branch 'perf-urgent-for-linus' of git://git.kernel.org/pub/scm/linux/kernel...
[deliverable/linux.git] / sound / pci / hda / hda_generic.c
CommitLineData
1da177e4
LT		 1/*
2 * Universal Interface for Intel High Definition Audio Codec
3 *
4 * Generic widget tree parser
5 *
6 * Copyright (c) 2004 Takashi Iwai <tiwai@suse.de>
7 *
8 * This driver is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 2 of the License, or
11 * (at your option) any later version.
12 *
13 * This driver is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
17 *
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, write to the Free Software
20 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
21 */
22
1da177e4
LT		 23#include <linux/init.h>
24#include <linux/slab.h>
d81a6d71 25#include <linux/export.h>
352f7f91 26#include <linux/sort.h>
55196fff 27#include <linux/delay.h>
f873e536
TI		 28#include <linux/ctype.h>
29#include <linux/string.h>
29476558 30#include <linux/bitops.h>
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
TI		 3220 /* add stereo mix when explicitly enabled via hint */
3221 if (mixer && spec->add_stereo_mix_input &&
3222 snd_hda_get_bool_hint(codec, "add_stereo_mix_input") > 0) {
9dba205b 3223 err = parse_capture_source(codec, mixer, CFG_IDX_MIX, num_adcs,
f3fc0b0b
TI		 3224 "Stereo Mix", 0);
3225 if (err < 0)
3226 return err;
352f7f91
TI		 3227 }
3228
3229 return 0;
3230}
3231
3232
3233/*
3234 * input source mux
3235 */
3236
c697b716
TI		 3237/* get the input path specified by the given adc and imux indices */
3238static struct nid_path *get_input_path(struct hda_codec *codec, int adc_idx, int imux_idx)
352f7f91
TI		 3239{
3240 struct hda_gen_spec *spec = codec->spec;
b56fa1ed
DH		 3241 if (imux_idx < 0 || imux_idx >= HDA_MAX_NUM_INPUTS) {
3242 snd_BUG();
3243 return NULL;
3244 }
352f7f91
TI		 3245 if (spec->dyn_adc_switch)
3246 adc_idx = spec->dyn_adc_idx[imux_idx];
d3d982f7 3247 if (adc_idx < 0 || adc_idx >= AUTO_CFG_MAX_INS) {
b56fa1ed
DH		 3248 snd_BUG();
3249 return NULL;
3250 }
c697b716 3251 return snd_hda_get_path_from_idx(codec, spec->input_paths[imux_idx][adc_idx]);
352f7f91
TI		 3252}
3253
3254static int mux_select(struct hda_codec *codec, unsigned int adc_idx,
3255 unsigned int idx);
3256
3257static int mux_enum_info(struct snd_kcontrol *kcontrol,
3258 struct snd_ctl_elem_info *uinfo)
3259{
3260 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3261 struct hda_gen_spec *spec = codec->spec;
3262 return snd_hda_input_mux_info(&spec->input_mux, uinfo);
3263}
3264
3265static int mux_enum_get(struct snd_kcontrol *kcontrol,
3266 struct snd_ctl_elem_value *ucontrol)
3267{
3268 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3269 struct hda_gen_spec *spec = codec->spec;
2a8d5391
TI		 3270 /* the ctls are created at once with multiple counts */
3271 unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
352f7f91
TI		 3272
3273 ucontrol->value.enumerated.item[0] = spec->cur_mux[adc_idx];
3274 return 0;
3275}
3276
3277static int mux_enum_put(struct snd_kcontrol *kcontrol,
3278 struct snd_ctl_elem_value *ucontrol)
3279{
3280 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2a8d5391 3281 unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
352f7f91
TI		 3282 return mux_select(codec, adc_idx,
3283 ucontrol->value.enumerated.item[0]);
3284}
3285
352f7f91
TI		 3286static const struct snd_kcontrol_new cap_src_temp = {
3287 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3288 .name = "Input Source",
3289 .info = mux_enum_info,
3290 .get = mux_enum_get,
3291 .put = mux_enum_put,
3292};
3293
47d46abb
TI		 3294/*
3295 * capture volume and capture switch ctls
3296 */
3297
352f7f91
TI		 3298typedef int (*put_call_t)(struct snd_kcontrol *kcontrol,
3299 struct snd_ctl_elem_value *ucontrol);
3300
47d46abb 3301/* call the given amp update function for all amps in the imux list at once */
352f7f91
TI		 3302static int cap_put_caller(struct snd_kcontrol *kcontrol,
3303 struct snd_ctl_elem_value *ucontrol,
3304 put_call_t func, int type)
3305{
3306 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3307 struct hda_gen_spec *spec = codec->spec;
3308 const struct hda_input_mux *imux;
3309 struct nid_path *path;
3310 int i, adc_idx, err = 0;
3311
3312 imux = &spec->input_mux;
a053d1e3 3313 adc_idx = kcontrol->id.index;
352f7f91 3314 mutex_lock(&codec->control_mutex);
47d46abb
TI		 3315 /* we use the cache-only update at first since multiple input paths
3316 * may shared the same amp; by updating only caches, the redundant
3317 * writes to hardware can be reduced.
3318 */
352f7f91
TI		 3319 codec->cached_write = 1;
3320 for (i = 0; i < imux->num_items; i++) {
c697b716
TI		 3321 path = get_input_path(codec, adc_idx, i);
3322 if (!path || !path->ctls[type])
352f7f91
TI		 3323 continue;
3324 kcontrol->private_value = path->ctls[type];
3325 err = func(kcontrol, ucontrol);
3326 if (err < 0)
3327 goto error;
3328 }
3329 error:
3330 codec->cached_write = 0;
3331 mutex_unlock(&codec->control_mutex);
dc870f38 3332 snd_hda_codec_flush_cache(codec); /* flush the updates */
352f7f91 3333 if (err >= 0 && spec->cap_sync_hook)
7fe30711 3334 spec->cap_sync_hook(codec, kcontrol, ucontrol);
352f7f91
TI		 3335 return err;
3336}
3337
3338/* capture volume ctl callbacks */
3339#define cap_vol_info snd_hda_mixer_amp_volume_info
3340#define cap_vol_get snd_hda_mixer_amp_volume_get
3341#define cap_vol_tlv snd_hda_mixer_amp_tlv
3342
3343static int cap_vol_put(struct snd_kcontrol *kcontrol,
3344 struct snd_ctl_elem_value *ucontrol)
3345{
3346 return cap_put_caller(kcontrol, ucontrol,
3347 snd_hda_mixer_amp_volume_put,
3348 NID_PATH_VOL_CTL);
3349}
3350
3351static const struct snd_kcontrol_new cap_vol_temp = {
3352 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3353 .name = "Capture Volume",
3354 .access = (SNDRV_CTL_ELEM_ACCESS_READWRITE |
3355 SNDRV_CTL_ELEM_ACCESS_TLV_READ |
3356 SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK),
3357 .info = cap_vol_info,
3358 .get = cap_vol_get,
3359 .put = cap_vol_put,
3360 .tlv = { .c = cap_vol_tlv },
3361};
3362
3363/* capture switch ctl callbacks */
3364#define cap_sw_info snd_ctl_boolean_stereo_info
3365#define cap_sw_get snd_hda_mixer_amp_switch_get
3366
3367static int cap_sw_put(struct snd_kcontrol *kcontrol,
3368 struct snd_ctl_elem_value *ucontrol)
3369{
a90229e0 3370 return cap_put_caller(kcontrol, ucontrol,
352f7f91
TI		 3371 snd_hda_mixer_amp_switch_put,
3372 NID_PATH_MUTE_CTL);
3373}
3374
3375static const struct snd_kcontrol_new cap_sw_temp = {
3376 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3377 .name = "Capture Switch",
3378 .info = cap_sw_info,
3379 .get = cap_sw_get,
3380 .put = cap_sw_put,
3381};
3382
3383static int parse_capvol_in_path(struct hda_codec *codec, struct nid_path *path)
3384{
3385 hda_nid_t nid;
3386 int i, depth;
3387
3388 path->ctls[NID_PATH_VOL_CTL] = path->ctls[NID_PATH_MUTE_CTL] = 0;
3389 for (depth = 0; depth < 3; depth++) {
3390 if (depth >= path->depth)
3391 return -EINVAL;
3392 i = path->depth - depth - 1;
3393 nid = path->path[i];
3394 if (!path->ctls[NID_PATH_VOL_CTL]) {
3395 if (nid_has_volume(codec, nid, HDA_OUTPUT))
3396 path->ctls[NID_PATH_VOL_CTL] =
3397 HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
3398 else if (nid_has_volume(codec, nid, HDA_INPUT)) {
3399 int idx = path->idx[i];
3400 if (!depth && codec->single_adc_amp)
3401 idx = 0;
3402 path->ctls[NID_PATH_VOL_CTL] =
3403 HDA_COMPOSE_AMP_VAL(nid, 3, idx, HDA_INPUT);
3404 }
3405 }
3406 if (!path->ctls[NID_PATH_MUTE_CTL]) {
3407 if (nid_has_mute(codec, nid, HDA_OUTPUT))
3408 path->ctls[NID_PATH_MUTE_CTL] =
3409 HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
3410 else if (nid_has_mute(codec, nid, HDA_INPUT)) {
3411 int idx = path->idx[i];
3412 if (!depth && codec->single_adc_amp)
3413 idx = 0;
3414 path->ctls[NID_PATH_MUTE_CTL] =
3415 HDA_COMPOSE_AMP_VAL(nid, 3, idx, HDA_INPUT);
3416 }
3417 }
3418 }
3419 return 0;
3420}
3421
3422static bool is_inv_dmic_pin(struct hda_codec *codec, hda_nid_t nid)
3423{
3424 struct hda_gen_spec *spec = codec->spec;
3425 struct auto_pin_cfg *cfg = &spec->autocfg;
3426 unsigned int val;
3427 int i;
3428
3429 if (!spec->inv_dmic_split)
3430 return false;
3431 for (i = 0; i < cfg->num_inputs; i++) {
3432 if (cfg->inputs[i].pin != nid)
3433 continue;
3434 if (cfg->inputs[i].type != AUTO_PIN_MIC)
3435 return false;
3436 val = snd_hda_codec_get_pincfg(codec, nid);
3437 return snd_hda_get_input_pin_attr(val) == INPUT_PIN_ATTR_INT;
3438 }
3439 return false;
3440}
3441
a90229e0 3442/* capture switch put callback for a single control with hook call */
a35bd1e3
TI		 3443static int cap_single_sw_put(struct snd_kcontrol *kcontrol,
3444 struct snd_ctl_elem_value *ucontrol)
3445{
3446 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3447 struct hda_gen_spec *spec = codec->spec;
3448 int ret;
3449
3450 ret = snd_hda_mixer_amp_switch_put(kcontrol, ucontrol);
3451 if (ret < 0)
3452 return ret;
3453
a90229e0 3454 if (spec->cap_sync_hook)
7fe30711 3455 spec->cap_sync_hook(codec, kcontrol, ucontrol);
a35bd1e3
TI		 3456
3457 return ret;
3458}
3459
352f7f91
TI		 3460static int add_single_cap_ctl(struct hda_codec *codec, const char *label,
3461 int idx, bool is_switch, unsigned int ctl,
3462 bool inv_dmic)
3463{
3464 struct hda_gen_spec *spec = codec->spec;
975cc02a 3465 char tmpname[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];
352f7f91
TI		 3466 int type = is_switch ? HDA_CTL_WIDGET_MUTE : HDA_CTL_WIDGET_VOL;
3467 const char *sfx = is_switch ? "Switch" : "Volume";
3468 unsigned int chs = inv_dmic ? 1 : 3;
a35bd1e3 3469 struct snd_kcontrol_new *knew;
352f7f91
TI		 3470
3471 if (!ctl)
3472 return 0;
3473
3474 if (label)
3475 snprintf(tmpname, sizeof(tmpname),
3476 "%s Capture %s", label, sfx);
3477 else
3478 snprintf(tmpname, sizeof(tmpname),
3479 "Capture %s", sfx);
a35bd1e3
TI		 3480 knew = add_control(spec, type, tmpname, idx,
3481 amp_val_replace_channels(ctl, chs));
3482 if (!knew)
3483 return -ENOMEM;
a90229e0 3484 if (is_switch)
a35bd1e3
TI		 3485 knew->put = cap_single_sw_put;
3486 if (!inv_dmic)
3487 return 0;
352f7f91
TI		 3488
3489 /* Make independent right kcontrol */
3490 if (label)
3491 snprintf(tmpname, sizeof(tmpname),
3492 "Inverted %s Capture %s", label, sfx);
3493 else
3494 snprintf(tmpname, sizeof(tmpname),
3495 "Inverted Capture %s", sfx);
a35bd1e3 3496 knew = add_control(spec, type, tmpname, idx,
352f7f91 3497 amp_val_replace_channels(ctl, 2));
a35bd1e3
TI		 3498 if (!knew)
3499 return -ENOMEM;
a90229e0 3500 if (is_switch)
a35bd1e3
TI		 3501 knew->put = cap_single_sw_put;
3502 return 0;
352f7f91
TI		 3503}
3504
3505/* create single (and simple) capture volume and switch controls */
3506static int create_single_cap_vol_ctl(struct hda_codec *codec, int idx,
3507 unsigned int vol_ctl, unsigned int sw_ctl,
3508 bool inv_dmic)
3509{
3510 int err;
3511 err = add_single_cap_ctl(codec, NULL, idx, false, vol_ctl, inv_dmic);
3512 if (err < 0)
3513 return err;
3514 err = add_single_cap_ctl(codec, NULL, idx, true, sw_ctl, inv_dmic);
3515 if (err < 0)
3516 return err;
3517 return 0;
3518}
3519
3520/* create bound capture volume and switch controls */
3521static int create_bind_cap_vol_ctl(struct hda_codec *codec, int idx,
3522 unsigned int vol_ctl, unsigned int sw_ctl)
3523{
3524 struct hda_gen_spec *spec = codec->spec;
3525 struct snd_kcontrol_new *knew;
3526
3527 if (vol_ctl) {
12c93df6 3528 knew = snd_hda_gen_add_kctl(spec, NULL, &cap_vol_temp);
352f7f91
TI		 3529 if (!knew)
3530 return -ENOMEM;
3531 knew->index = idx;
3532 knew->private_value = vol_ctl;
3533 knew->subdevice = HDA_SUBDEV_AMP_FLAG;
3534 }
3535 if (sw_ctl) {
12c93df6 3536 knew = snd_hda_gen_add_kctl(spec, NULL, &cap_sw_temp);
352f7f91
TI		 3537 if (!knew)
3538 return -ENOMEM;
3539 knew->index = idx;
3540 knew->private_value = sw_ctl;
3541 knew->subdevice = HDA_SUBDEV_AMP_FLAG;
3542 }
3543 return 0;
3544}
3545
3546/* return the vol ctl when used first in the imux list */
3547static unsigned int get_first_cap_ctl(struct hda_codec *codec, int idx, int type)
3548{
352f7f91
TI		 3549 struct nid_path *path;
3550 unsigned int ctl;
3551 int i;
3552
c697b716 3553 path = get_input_path(codec, 0, idx);
352f7f91
TI		 3554 if (!path)
3555 return 0;
3556 ctl = path->ctls[type];
3557 if (!ctl)
3558 return 0;
3559 for (i = 0; i < idx - 1; i++) {
c697b716 3560 path = get_input_path(codec, 0, i);
352f7f91
TI		 3561 if (path && path->ctls[type] == ctl)
3562 return 0;
3563 }
3564 return ctl;
3565}
3566
3567/* create individual capture volume and switch controls per input */
3568static int create_multi_cap_vol_ctl(struct hda_codec *codec)
3569{
3570 struct hda_gen_spec *spec = codec->spec;
3571 struct hda_input_mux *imux = &spec->input_mux;
c970042c 3572 int i, err, type;
352f7f91
TI		 3573
3574 for (i = 0; i < imux->num_items; i++) {
352f7f91 3575 bool inv_dmic;
c970042c 3576 int idx;
9dba205b 3577
c970042c
TI		 3578 idx = imux->items[i].index;
3579 if (idx >= spec->autocfg.num_inputs)
9dba205b 3580 continue;
352f7f91
TI		 3581 inv_dmic = is_inv_dmic_pin(codec, spec->imux_pins[i]);
3582
3583 for (type = 0; type < 2; type++) {
c970042c
TI		 3584 err = add_single_cap_ctl(codec,
3585 spec->input_labels[idx],
3586 spec->input_label_idxs[idx],
3587 type,
352f7f91
TI		 3588 get_first_cap_ctl(codec, i, type),
3589 inv_dmic);
3590 if (err < 0)
3591 return err;
3592 }
3593 }
3594 return 0;
3595}
3596
3597static int create_capture_mixers(struct hda_codec *codec)
3598{
3599 struct hda_gen_spec *spec = codec->spec;
3600 struct hda_input_mux *imux = &spec->input_mux;
3601 int i, n, nums, err;
3602
3603 if (spec->dyn_adc_switch)
3604 nums = 1;
3605 else
3606 nums = spec->num_adc_nids;
3607
3608 if (!spec->auto_mic && imux->num_items > 1) {
3609 struct snd_kcontrol_new *knew;
624d914d
TI		 3610 const char *name;
3611 name = nums > 1 ? "Input Source" : "Capture Source";
3612 knew = snd_hda_gen_add_kctl(spec, name, &cap_src_temp);
352f7f91
TI		 3613 if (!knew)
3614 return -ENOMEM;
3615 knew->count = nums;
3616 }
3617
3618 for (n = 0; n < nums; n++) {
3619 bool multi = false;
99a5592d 3620 bool multi_cap_vol = spec->multi_cap_vol;
352f7f91
TI		 3621 bool inv_dmic = false;
3622 int vol, sw;
3623
3624 vol = sw = 0;
3625 for (i = 0; i < imux->num_items; i++) {
3626 struct nid_path *path;
c697b716 3627 path = get_input_path(codec, n, i);
352f7f91
TI		 3628 if (!path)
3629 continue;
3630 parse_capvol_in_path(codec, path);
3631 if (!vol)
3632 vol = path->ctls[NID_PATH_VOL_CTL];
99a5592d 3633 else if (vol != path->ctls[NID_PATH_VOL_CTL]) {
352f7f91 3634 multi = true;
99a5592d
DH		 3635 if (!same_amp_caps(codec, vol,
3636 path->ctls[NID_PATH_VOL_CTL], HDA_INPUT))
3637 multi_cap_vol = true;
3638 }
352f7f91
TI		 3639 if (!sw)
3640 sw = path->ctls[NID_PATH_MUTE_CTL];
99a5592d 3641 else if (sw != path->ctls[NID_PATH_MUTE_CTL]) {
352f7f91 3642 multi = true;
99a5592d
DH		 3643 if (!same_amp_caps(codec, sw,
3644 path->ctls[NID_PATH_MUTE_CTL], HDA_INPUT))
3645 multi_cap_vol = true;
3646 }
352f7f91
TI		 3647 if (is_inv_dmic_pin(codec, spec->imux_pins[i]))
3648 inv_dmic = true;
3649 }
3650
3651 if (!multi)
3652 err = create_single_cap_vol_ctl(codec, n, vol, sw,
3653 inv_dmic);
ccb04157 3654 else if (!multi_cap_vol && !inv_dmic)
352f7f91
TI		 3655 err = create_bind_cap_vol_ctl(codec, n, vol, sw);
3656 else
3657 err = create_multi_cap_vol_ctl(codec);
3658 if (err < 0)
3659 return err;
3660 }
3661
3662 return 0;
3663}
3664
3665/*
3666 * add mic boosts if needed
3667 */
6f7c83af
TI		 3668
3669/* check whether the given amp is feasible as a boost volume */
3670static bool check_boost_vol(struct hda_codec *codec, hda_nid_t nid,
3671 int dir, int idx)
3672{
3673 unsigned int step;
3674
3675 if (!nid_has_volume(codec, nid, dir) ||
3676 is_ctl_associated(codec, nid, dir, idx, NID_PATH_VOL_CTL) ||
3677 is_ctl_associated(codec, nid, dir, idx, NID_PATH_BOOST_CTL))
3678 return false;
3679
3680 step = (query_amp_caps(codec, nid, dir) & AC_AMPCAP_STEP_SIZE)
3681 >> AC_AMPCAP_STEP_SIZE_SHIFT;
3682 if (step < 0x20)
3683 return false;
3684 return true;
3685}
3686
3687/* look for a boost amp in a widget close to the pin */
3688static unsigned int look_for_boost_amp(struct hda_codec *codec,
3689 struct nid_path *path)
3690{
3691 unsigned int val = 0;
3692 hda_nid_t nid;
3693 int depth;
3694
3695 for (depth = 0; depth < 3; depth++) {
3696 if (depth >= path->depth - 1)
3697 break;
3698 nid = path->path[depth];
3699 if (depth && check_boost_vol(codec, nid, HDA_OUTPUT, 0)) {
3700 val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
3701 break;
3702 } else if (check_boost_vol(codec, nid, HDA_INPUT,
3703 path->idx[depth])) {
3704 val = HDA_COMPOSE_AMP_VAL(nid, 3, path->idx[depth],
3705 HDA_INPUT);
3706 break;
3707 }
3708 }
3709
3710 return val;
3711}
3712
352f7f91
TI		 3713static int parse_mic_boost(struct hda_codec *codec)
3714{
3715 struct hda_gen_spec *spec = codec->spec;
3716 struct auto_pin_cfg *cfg = &spec->autocfg;
6f7c83af 3717 struct hda_input_mux *imux = &spec->input_mux;
a35bd1e3 3718 int i;
352f7f91 3719
6f7c83af
TI		 3720 if (!spec->num_adc_nids)
3721 return 0;
352f7f91 3722
6f7c83af
TI		 3723 for (i = 0; i < imux->num_items; i++) {
3724 struct nid_path *path;
3725 unsigned int val;
3726 int idx;
975cc02a 3727 char boost_label[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];
02aba550 3728
6f7c83af
TI		 3729 idx = imux->items[i].index;
3730 if (idx >= imux->num_items)
3731 continue;
352f7f91 3732
6f7c83af 3733 /* check only line-in and mic pins */
1799cdd5 3734 if (cfg->inputs[idx].type > AUTO_PIN_LINE_IN)
6f7c83af
TI		 3735 continue;
3736
3737 path = get_input_path(codec, 0, i);
3738 if (!path)
3739 continue;
3740
3741 val = look_for_boost_amp(codec, path);
3742 if (!val)
3743 continue;
3744
3745 /* create a boost control */
3746 snprintf(boost_label, sizeof(boost_label),
3747 "%s Boost Volume", spec->input_labels[idx]);
a35bd1e3
TI		 3748 if (!add_control(spec, HDA_CTL_WIDGET_VOL, boost_label,
3749 spec->input_label_idxs[idx], val))
3750 return -ENOMEM;
6f7c83af
TI		 3751
3752 path->ctls[NID_PATH_BOOST_CTL] = val;
352f7f91
TI		 3753 }
3754 return 0;
3755}
3756
3757/*
3758 * parse digital I/Os and set up NIDs in BIOS auto-parse mode
3759 */
3760static void parse_digital(struct hda_codec *codec)
3761{
3762 struct hda_gen_spec *spec = codec->spec;
0c8c0f56 3763 struct nid_path *path;
352f7f91 3764 int i, nums;
2c12c30d 3765 hda_nid_t dig_nid, pin;
352f7f91
TI		 3766
3767 /* support multiple SPDIFs; the secondary is set up as a slave */
3768 nums = 0;
3769 for (i = 0; i < spec->autocfg.dig_outs; i++) {
2c12c30d 3770 pin = spec->autocfg.dig_out_pins[i];
352f7f91
TI		 3771 dig_nid = look_for_dac(codec, pin, true);
3772 if (!dig_nid)
3773 continue;
3ca529d3 3774 path = snd_hda_add_new_path(codec, dig_nid, pin, 0);
0c8c0f56 3775 if (!path)
352f7f91 3776 continue;
4e76a883 3777 print_nid_path(codec, "digout", path);
e1284af7 3778 path->active = true;
196c1766 3779 spec->digout_paths[i] = snd_hda_get_path_idx(codec, path);
2c12c30d 3780 set_pin_target(codec, pin, PIN_OUT, false);
352f7f91
TI		 3781 if (!nums) {
3782 spec->multiout.dig_out_nid = dig_nid;
3783 spec->dig_out_type = spec->autocfg.dig_out_type[0];
3784 } else {
3785 spec->multiout.slave_dig_outs = spec->slave_dig_outs;
3786 if (nums >= ARRAY_SIZE(spec->slave_dig_outs) - 1)
d576422e 3787 break;
352f7f91
TI		 3788 spec->slave_dig_outs[nums - 1] = dig_nid;
3789 }
3790 nums++;
3791 }
3792
3793 if (spec->autocfg.dig_in_pin) {
2c12c30d 3794 pin = spec->autocfg.dig_in_pin;
352f7f91
TI		 3795 dig_nid = codec->start_nid;
3796 for (i = 0; i < codec->num_nodes; i++, dig_nid++) {
352f7f91
TI		 3797 unsigned int wcaps = get_wcaps(codec, dig_nid);
3798 if (get_wcaps_type(wcaps) != AC_WID_AUD_IN)
3799 continue;
3800 if (!(wcaps & AC_WCAP_DIGITAL))
3801 continue;
2c12c30d 3802 path = snd_hda_add_new_path(codec, pin, dig_nid, 0);
352f7f91 3803 if (path) {
4e76a883 3804 print_nid_path(codec, "digin", path);
352f7f91
TI		 3805 path->active = true;
3806 spec->dig_in_nid = dig_nid;
2430d7b7 3807 spec->digin_path = snd_hda_get_path_idx(codec, path);
2c12c30d 3808 set_pin_target(codec, pin, PIN_IN, false);
352f7f91
TI		 3809 break;
3810 }
3811 }
3812 }
3813}
3814
3815
3816/*
3817 * input MUX handling
3818 */
3819
3820static bool dyn_adc_pcm_resetup(struct hda_codec *codec, int cur);
3821
3822/* select the given imux item; either unmute exclusively or select the route */
3823static int mux_select(struct hda_codec *codec, unsigned int adc_idx,
3824 unsigned int idx)
3825{
3826 struct hda_gen_spec *spec = codec->spec;
3827 const struct hda_input_mux *imux;
55196fff 3828 struct nid_path *old_path, *path;
352f7f91
TI		 3829
3830 imux = &spec->input_mux;
3831 if (!imux->num_items)
3832 return 0;
3833
3834 if (idx >= imux->num_items)
3835 idx = imux->num_items - 1;
3836 if (spec->cur_mux[adc_idx] == idx)
3837 return 0;
3838
55196fff
TI		 3839 old_path = get_input_path(codec, adc_idx, spec->cur_mux[adc_idx]);
3840 if (!old_path)
352f7f91 3841 return 0;
55196fff
TI		 3842 if (old_path->active)
3843 snd_hda_activate_path(codec, old_path, false, false);
352f7f91
TI		 3844
3845 spec->cur_mux[adc_idx] = idx;
3846
967303da
TI		 3847 if (spec->hp_mic)
3848 update_hp_mic(codec, adc_idx, false);
352f7f91
TI		 3849
3850 if (spec->dyn_adc_switch)
3851 dyn_adc_pcm_resetup(codec, idx);
3852
c697b716 3853 path = get_input_path(codec, adc_idx, idx);
352f7f91
TI		 3854 if (!path)
3855 return 0;
3856 if (path->active)
3857 return 0;
3858 snd_hda_activate_path(codec, path, true, false);
3859 if (spec->cap_sync_hook)
7fe30711 3860 spec->cap_sync_hook(codec, NULL, NULL);
55196fff 3861 path_power_down_sync(codec, old_path);
352f7f91
TI		 3862 return 1;
3863}
3864
3865
3866/*
3867 * Jack detections for HP auto-mute and mic-switch
3868 */
3869
3870/* check each pin in the given array; returns true if any of them is plugged */
3871static bool detect_jacks(struct hda_codec *codec, int num_pins, hda_nid_t *pins)
3872{
60ea8ca2
TI		 3873 int i;
3874 bool present = false;
352f7f91
TI		 3875
3876 for (i = 0; i < num_pins; i++) {
3877 hda_nid_t nid = pins[i];
3878 if (!nid)
3879 break;
0b4df931
TI		 3880 /* don't detect pins retasked as inputs */
3881 if (snd_hda_codec_get_pin_target(codec, nid) & AC_PINCTL_IN_EN)
3882 continue;
60ea8ca2
TI		 3883 if (snd_hda_jack_detect_state(codec, nid) == HDA_JACK_PRESENT)
3884 present = true;
352f7f91
TI		 3885 }
3886 return present;
3887}
3888
3889/* standard HP/line-out auto-mute helper */
3890static void do_automute(struct hda_codec *codec, int num_pins, hda_nid_t *pins,
e80c60f3 3891 int *paths, bool mute)
352f7f91
TI		 3892{
3893 struct hda_gen_spec *spec = codec->spec;
352f7f91
TI		 3894 int i;
3895
3896 for (i = 0; i < num_pins; i++) {
3897 hda_nid_t nid = pins[i];
967303da 3898 unsigned int val, oldval;
352f7f91
TI		 3899 if (!nid)
3900 break;
7eebffd3
TI		 3901
3902 if (spec->auto_mute_via_amp) {
e80c60f3
TI		 3903 struct nid_path *path;
3904 hda_nid_t mute_nid;
3905
3906 path = snd_hda_get_path_from_idx(codec, paths[i]);
3907 if (!path)
3908 continue;
3909 mute_nid = get_amp_nid_(path->ctls[NID_PATH_MUTE_CTL]);
3910 if (!mute_nid)
3911 continue;
7eebffd3 3912 if (mute)
e80c60f3 3913 spec->mute_bits |= (1ULL << mute_nid);
7eebffd3 3914 else
e80c60f3 3915 spec->mute_bits &= ~(1ULL << mute_nid);
7eebffd3
TI		 3916 set_pin_eapd(codec, nid, !mute);
3917 continue;
3918 }
3919
967303da
TI		 3920 oldval = snd_hda_codec_get_pin_target(codec, nid);
3921 if (oldval & PIN_IN)
3922 continue; /* no mute for inputs */
352f7f91
TI		 3923 /* don't reset VREF value in case it's controlling
3924 * the amp (see alc861_fixup_asus_amp_vref_0f())
3925 */
2c12c30d 3926 if (spec->keep_vref_in_automute)
967303da 3927 val = oldval & ~PIN_HP;
2c12c30d 3928 else
352f7f91 3929 val = 0;
2c12c30d 3930 if (!mute)
967303da 3931 val |= oldval;
2c12c30d
TI		 3932 /* here we call update_pin_ctl() so that the pinctl is changed
3933 * without changing the pinctl target value;
3934 * the original target value will be still referred at the
3935 * init / resume again
3936 */
3937 update_pin_ctl(codec, nid, val);
d5a9f1bb 3938 set_pin_eapd(codec, nid, !mute);
352f7f91
TI		 3939 }
3940}
3941
dda42bd0
TI		 3942/**
3943 * snd_hda_gen_update_outputs - Toggle outputs muting
3944 * @codec: the HDA codec
3945 *
3946 * Update the mute status of all outputs based on the current jack states.
3947 */
5d550e15 3948void snd_hda_gen_update_outputs(struct hda_codec *codec)
352f7f91
TI		 3949{
3950 struct hda_gen_spec *spec = codec->spec;
e80c60f3 3951 int *paths;
352f7f91
TI		 3952 int on;
3953
3954 /* Control HP pins/amps depending on master_mute state;
3955 * in general, HP pins/amps control should be enabled in all cases,
3956 * but currently set only for master_mute, just to be safe
3957 */
e80c60f3
TI		 3958 if (spec->autocfg.line_out_type == AUTO_PIN_HP_OUT)
3959 paths = spec->out_paths;
3960 else
3961 paths = spec->hp_paths;
967303da 3962 do_automute(codec, ARRAY_SIZE(spec->autocfg.hp_pins),
e80c60f3 3963 spec->autocfg.hp_pins, paths, spec->master_mute);
352f7f91
TI		 3964
3965 if (!spec->automute_speaker)
3966 on = 0;
3967 else
3968 on = spec->hp_jack_present | spec->line_jack_present;
3969 on |= spec->master_mute;
47b9ddb8 3970 spec->speaker_muted = on;
e80c60f3
TI		 3971 if (spec->autocfg.line_out_type == AUTO_PIN_SPEAKER_OUT)
3972 paths = spec->out_paths;
3973 else
3974 paths = spec->speaker_paths;
352f7f91 3975 do_automute(codec, ARRAY_SIZE(spec->autocfg.speaker_pins),
e80c60f3 3976 spec->autocfg.speaker_pins, paths, on);
352f7f91
TI		 3977
3978 /* toggle line-out mutes if needed, too */
3979 /* if LO is a copy of either HP or Speaker, don't need to handle it */
3980 if (spec->autocfg.line_out_pins[0] == spec->autocfg.hp_pins[0] ||
3981 spec->autocfg.line_out_pins[0] == spec->autocfg.speaker_pins[0])
3982 return;
3983 if (!spec->automute_lo)
3984 on = 0;
3985 else
3986 on = spec->hp_jack_present;
3987 on |= spec->master_mute;
47b9ddb8 3988 spec->line_out_muted = on;
e80c60f3 3989 paths = spec->out_paths;
352f7f91 3990 do_automute(codec, ARRAY_SIZE(spec->autocfg.line_out_pins),
e80c60f3 3991 spec->autocfg.line_out_pins, paths, on);
352f7f91 3992}
2698ea98 3993EXPORT_SYMBOL_GPL(snd_hda_gen_update_outputs);
352f7f91
TI		 3994
3995static void call_update_outputs(struct hda_codec *codec)
3996{
3997 struct hda_gen_spec *spec = codec->spec;
3998 if (spec->automute_hook)
3999 spec->automute_hook(codec);
4000 else
5d550e15 4001 snd_hda_gen_update_outputs(codec);
7eebffd3
TI		 4002
4003 /* sync the whole vmaster slaves to reflect the new auto-mute status */
4004 if (spec->auto_mute_via_amp && !codec->bus->shutdown)
4005 snd_ctl_sync_vmaster(spec->vmaster_mute.sw_kctl, false);
352f7f91
TI		 4006}
4007
dda42bd0
TI		 4008/**
4009 * snd_hda_gen_hp_automute - standard HP-automute helper
4010 * @codec: the HDA codec
4011 * @jack: jack object, NULL for the whole
4012 */
1a4f69d5
TI		 4013void snd_hda_gen_hp_automute(struct hda_codec *codec,
4014 struct hda_jack_callback *jack)
352f7f91
TI		 4015{
4016 struct hda_gen_spec *spec = codec->spec;
92603c59
TI		 4017 hda_nid_t *pins = spec->autocfg.hp_pins;
4018 int num_pins = ARRAY_SIZE(spec->autocfg.hp_pins);
4019
4020 /* No detection for the first HP jack during indep-HP mode */
4021 if (spec->indep_hp_enabled) {
4022 pins++;
4023 num_pins--;
4024 }
352f7f91 4025
92603c59 4026 spec->hp_jack_present = detect_jacks(codec, num_pins, pins);
352f7f91
TI		 4027 if (!spec->detect_hp || (!spec->automute_speaker && !spec->automute_lo))
4028 return;
4029 call_update_outputs(codec);
4030}
2698ea98 4031EXPORT_SYMBOL_GPL(snd_hda_gen_hp_automute);
352f7f91 4032
dda42bd0
TI		 4033/**
4034 * snd_hda_gen_line_automute - standard line-out-automute helper
4035 * @codec: the HDA codec
4036 * @jack: jack object, NULL for the whole
4037 */
1a4f69d5
TI		 4038void snd_hda_gen_line_automute(struct hda_codec *codec,
4039 struct hda_jack_callback *jack)
352f7f91
TI		 4040{
4041 struct hda_gen_spec *spec = codec->spec;
4042
4043 if (spec->autocfg.line_out_type == AUTO_PIN_SPEAKER_OUT)
4044 return;
4045 /* check LO jack only when it's different from HP */
4046 if (spec->autocfg.line_out_pins[0] == spec->autocfg.hp_pins[0])
4047 return;
4048
4049 spec->line_jack_present =
4050 detect_jacks(codec, ARRAY_SIZE(spec->autocfg.line_out_pins),
4051 spec->autocfg.line_out_pins);
4052 if (!spec->automute_speaker || !spec->detect_lo)
4053 return;
4054 call_update_outputs(codec);
4055}
2698ea98 4056EXPORT_SYMBOL_GPL(snd_hda_gen_line_automute);
352f7f91 4057
dda42bd0
TI		 4058/**
4059 * snd_hda_gen_mic_autoswitch - standard mic auto-switch helper
4060 * @codec: the HDA codec
4061 * @jack: jack object, NULL for the whole
4062 */
1a4f69d5
TI		 4063void snd_hda_gen_mic_autoswitch(struct hda_codec *codec,
4064 struct hda_jack_callback *jack)
352f7f91
TI		 4065{
4066 struct hda_gen_spec *spec = codec->spec;
4067 int i;
4068
4069 if (!spec->auto_mic)
4070 return;
4071
4072 for (i = spec->am_num_entries - 1; i > 0; i--) {
0b4df931
TI		 4073 hda_nid_t pin = spec->am_entry[i].pin;
4074 /* don't detect pins retasked as outputs */
4075 if (snd_hda_codec_get_pin_target(codec, pin) & AC_PINCTL_OUT_EN)
4076 continue;
60ea8ca2 4077 if (snd_hda_jack_detect_state(codec, pin) == HDA_JACK_PRESENT) {
352f7f91
TI		 4078 mux_select(codec, 0, spec->am_entry[i].idx);
4079 return;
4080 }
4081 }
4082 mux_select(codec, 0, spec->am_entry[0].idx);
4083}
2698ea98 4084EXPORT_SYMBOL_GPL(snd_hda_gen_mic_autoswitch);
352f7f91 4085
77afe0e9 4086/* call appropriate hooks */
1a4f69d5
TI		 4087static void call_hp_automute(struct hda_codec *codec,
4088 struct hda_jack_callback *jack)
77afe0e9
TI		 4089{
4090 struct hda_gen_spec *spec = codec->spec;
4091 if (spec->hp_automute_hook)
4092 spec->hp_automute_hook(codec, jack);
4093 else
4094 snd_hda_gen_hp_automute(codec, jack);
4095}
4096
4097static void call_line_automute(struct hda_codec *codec,
1a4f69d5 4098 struct hda_jack_callback *jack)
77afe0e9
TI		 4099{
4100 struct hda_gen_spec *spec = codec->spec;
4101 if (spec->line_automute_hook)
4102 spec->line_automute_hook(codec, jack);
4103 else
4104 snd_hda_gen_line_automute(codec, jack);
4105}
4106
4107static void call_mic_autoswitch(struct hda_codec *codec,
1a4f69d5 4108 struct hda_jack_callback *jack)
77afe0e9
TI		 4109{
4110 struct hda_gen_spec *spec = codec->spec;
4111 if (spec->mic_autoswitch_hook)
4112 spec->mic_autoswitch_hook(codec, jack);
4113 else
4114 snd_hda_gen_mic_autoswitch(codec, jack);
4115}
4116
963afde9
TI		 4117/* update jack retasking */
4118static void update_automute_all(struct hda_codec *codec)
4119{
4120 call_hp_automute(codec, NULL);
4121 call_line_automute(codec, NULL);
4122 call_mic_autoswitch(codec, NULL);
4123}
4124
352f7f91
TI		 4125/*
4126 * Auto-Mute mode mixer enum support
4127 */
4128static int automute_mode_info(struct snd_kcontrol *kcontrol,
4129 struct snd_ctl_elem_info *uinfo)
4130{
4131 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
4132 struct hda_gen_spec *spec = codec->spec;
4133 static const char * const texts3[] = {
4134 "Disabled", "Speaker Only", "Line Out+Speaker"
4135 };
4136
4137 if (spec->automute_speaker_possible && spec->automute_lo_possible)
4138 return snd_hda_enum_helper_info(kcontrol, uinfo, 3, texts3);
4139 return snd_hda_enum_bool_helper_info(kcontrol, uinfo);
4140}
4141
4142static int automute_mode_get(struct snd_kcontrol *kcontrol,
4143 struct snd_ctl_elem_value *ucontrol)
4144{
4145 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
4146 struct hda_gen_spec *spec = codec->spec;
4147 unsigned int val = 0;
4148 if (spec->automute_speaker)
4149 val++;
4150 if (spec->automute_lo)
4151 val++;
4152
4153 ucontrol->value.enumerated.item[0] = val;
4154 return 0;
4155}
4156
4157static int automute_mode_put(struct snd_kcontrol *kcontrol,
4158 struct snd_ctl_elem_value *ucontrol)
4159{
4160 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
4161 struct hda_gen_spec *spec = codec->spec;
4162
4163 switch (ucontrol->value.enumerated.item[0]) {
4164 case 0:
4165 if (!spec->automute_speaker && !spec->automute_lo)
4166 return 0;
4167 spec->automute_speaker = 0;
4168 spec->automute_lo = 0;
4169 break;
4170 case 1:
4171 if (spec->automute_speaker_possible) {
4172 if (!spec->automute_lo && spec->automute_speaker)
4173 return 0;
4174 spec->automute_speaker = 1;
4175 spec->automute_lo = 0;
4176 } else if (spec->automute_lo_possible) {
4177 if (spec->automute_lo)
4178 return 0;
4179 spec->automute_lo = 1;
4180 } else
4181 return -EINVAL;
4182 break;
4183 case 2:
4184 if (!spec->automute_lo_possible || !spec->automute_speaker_possible)
4185 return -EINVAL;
4186 if (spec->automute_speaker && spec->automute_lo)
4187 return 0;
4188 spec->automute_speaker = 1;
4189 spec->automute_lo = 1;
4190 break;
4191 default:
4192 return -EINVAL;
4193 }
4194 call_update_outputs(codec);
4195 return 1;
4196}
4197
4198static const struct snd_kcontrol_new automute_mode_enum = {
4199 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
4200 .name = "Auto-Mute Mode",
4201 .info = automute_mode_info,
4202 .get = automute_mode_get,
4203 .put = automute_mode_put,
4204};
4205
4206static int add_automute_mode_enum(struct hda_codec *codec)
4207{
4208 struct hda_gen_spec *spec = codec->spec;
4209
12c93df6 4210 if (!snd_hda_gen_add_kctl(spec, NULL, &automute_mode_enum))
352f7f91
TI		 4211 return -ENOMEM;
4212 return 0;
4213}
4214
4215/*
4216 * Check the availability of HP/line-out auto-mute;
4217 * Set up appropriately if really supported
4218 */
4219static int check_auto_mute_availability(struct hda_codec *codec)
4220{
4221 struct hda_gen_spec *spec = codec->spec;
4222 struct auto_pin_cfg *cfg = &spec->autocfg;
4223 int present = 0;
4224 int i, err;
4225
f72706be
TI		 4226 if (spec->suppress_auto_mute)
4227 return 0;
4228
352f7f91
TI		 4229 if (cfg->hp_pins[0])
4230 present++;
4231 if (cfg->line_out_pins[0])
4232 present++;
4233 if (cfg->speaker_pins[0])
4234 present++;
4235 if (present < 2) /* need two different output types */
4236 return 0;
4237
4238 if (!cfg->speaker_pins[0] &&
4239 cfg->line_out_type == AUTO_PIN_SPEAKER_OUT) {
4240 memcpy(cfg->speaker_pins, cfg->line_out_pins,
4241 sizeof(cfg->speaker_pins));
4242 cfg->speaker_outs = cfg->line_outs;
4243 }
4244
4245 if (!cfg->hp_pins[0] &&
4246 cfg->line_out_type == AUTO_PIN_HP_OUT) {
4247 memcpy(cfg->hp_pins, cfg->line_out_pins,
4248 sizeof(cfg->hp_pins));
4249 cfg->hp_outs = cfg->line_outs;
4250 }
4251
4252 for (i = 0; i < cfg->hp_outs; i++) {
4253 hda_nid_t nid = cfg->hp_pins[i];
4254 if (!is_jack_detectable(codec, nid))
4255 continue;
4e76a883 4256 codec_dbg(codec, "Enable HP auto-muting on NID 0x%x\n", nid);
62f949bf 4257 snd_hda_jack_detect_enable_callback(codec, nid,
77afe0e9 4258 call_hp_automute);
352f7f91
TI		 4259 spec->detect_hp = 1;
4260 }
4261
4262 if (cfg->line_out_type == AUTO_PIN_LINE_OUT && cfg->line_outs) {
4263 if (cfg->speaker_outs)
4264 for (i = 0; i < cfg->line_outs; i++) {
4265 hda_nid_t nid = cfg->line_out_pins[i];
4266 if (!is_jack_detectable(codec, nid))
4267 continue;
4e76a883 4268 codec_dbg(codec, "Enable Line-Out auto-muting on NID 0x%x\n", nid);
352f7f91 4269 snd_hda_jack_detect_enable_callback(codec, nid,
77afe0e9 4270 call_line_automute);
352f7f91
TI		 4271 spec->detect_lo = 1;
4272 }
4273 spec->automute_lo_possible = spec->detect_hp;
4274 }
4275
4276 spec->automute_speaker_possible = cfg->speaker_outs &&
4277 (spec->detect_hp || spec->detect_lo);
4278
4279 spec->automute_lo = spec->automute_lo_possible;
4280 spec->automute_speaker = spec->automute_speaker_possible;
4281
4282 if (spec->automute_speaker_possible || spec->automute_lo_possible) {
4283 /* create a control for automute mode */
4284 err = add_automute_mode_enum(codec);
4285 if (err < 0)
4286 return err;
4287 }
4288 return 0;
4289}
352f7f91
TI		 4290
4291/* check whether all auto-mic pins are valid; setup indices if OK */
4292static bool auto_mic_check_imux(struct hda_codec *codec)
4293{
4294 struct hda_gen_spec *spec = codec->spec;
4295 const struct hda_input_mux *imux;
4296 int i;
4297
4298 imux = &spec->input_mux;
4299 for (i = 0; i < spec->am_num_entries; i++) {
4300 spec->am_entry[i].idx =
4301 find_idx_in_nid_list(spec->am_entry[i].pin,
4302 spec->imux_pins, imux->num_items);
4303 if (spec->am_entry[i].idx < 0)
4304 return false; /* no corresponding imux */
4305 }
4306
4307 /* we don't need the jack detection for the first pin */
4308 for (i = 1; i < spec->am_num_entries; i++)
4309 snd_hda_jack_detect_enable_callback(codec,
4310 spec->am_entry[i].pin,
77afe0e9 4311 call_mic_autoswitch);
352f7f91
TI		 4312 return true;
4313}
4314
4315static int compare_attr(const void *ap, const void *bp)
4316{
4317 const struct automic_entry *a = ap;
4318 const struct automic_entry *b = bp;
4319 return (int)(a->attr - b->attr);
4320}
1da177e4
LT		 4321
4322/*
352f7f91
TI		 4323 * Check the availability of auto-mic switch;
4324 * Set up if really supported
1da177e4 4325 */
352f7f91
TI		 4326static int check_auto_mic_availability(struct hda_codec *codec)
4327{
4328 struct hda_gen_spec *spec = codec->spec;
4329 struct auto_pin_cfg *cfg = &spec->autocfg;
4330 unsigned int types;
4331 int i, num_pins;
4332
d12daf6f
TI		 4333 if (spec->suppress_auto_mic)
4334 return 0;
4335
352f7f91
TI		 4336 types = 0;
4337 num_pins = 0;
4338 for (i = 0; i < cfg->num_inputs; i++) {
4339 hda_nid_t nid = cfg->inputs[i].pin;
4340 unsigned int attr;
4341 attr = snd_hda_codec_get_pincfg(codec, nid);
4342 attr = snd_hda_get_input_pin_attr(attr);
4343 if (types & (1 << attr))
4344 return 0; /* already occupied */
4345 switch (attr) {
4346 case INPUT_PIN_ATTR_INT:
4347 if (cfg->inputs[i].type != AUTO_PIN_MIC)
4348 return 0; /* invalid type */
4349 break;
4350 case INPUT_PIN_ATTR_UNUSED:
4351 return 0; /* invalid entry */
4352 default:
4353 if (cfg->inputs[i].type > AUTO_PIN_LINE_IN)
4354 return 0; /* invalid type */
4355 if (!spec->line_in_auto_switch &&
4356 cfg->inputs[i].type != AUTO_PIN_MIC)
4357 return 0; /* only mic is allowed */
4358 if (!is_jack_detectable(codec, nid))
4359 return 0; /* no unsol support */
4360 break;
4361 }
4362 if (num_pins >= MAX_AUTO_MIC_PINS)
4363 return 0;
4364 types |= (1 << attr);
4365 spec->am_entry[num_pins].pin = nid;
4366 spec->am_entry[num_pins].attr = attr;
4367 num_pins++;
4368 }
4369
4370 if (num_pins < 2)
4371 return 0;
4372
4373 spec->am_num_entries = num_pins;
4374 /* sort the am_entry in the order of attr so that the pin with a
4375 * higher attr will be selected when the jack is plugged.
4376 */
4377 sort(spec->am_entry, num_pins, sizeof(spec->am_entry[0]),
4378 compare_attr, NULL);
4379
4380 if (!auto_mic_check_imux(codec))
4381 return 0;
4382
4383 spec->auto_mic = 1;
4384 spec->num_adc_nids = 1;
4385 spec->cur_mux[0] = spec->am_entry[0].idx;
4e76a883 4386 codec_dbg(codec, "Enable auto-mic switch on NID 0x%x/0x%x/0x%x\n",
352f7f91
TI		 4387 spec->am_entry[0].pin,
4388 spec->am_entry[1].pin,
4389 spec->am_entry[2].pin);
4390
1da177e4
LT		 4391 return 0;
4392}
4393
dda42bd0
TI		 4394/**
4395 * snd_hda_gen_path_power_filter - power_filter hook to make inactive widgets
4396 * into power down
4397 * @codec: the HDA codec
4398 * @nid: NID to evalute
4399 * @power_state: target power state
4400 */
dfc6e469 4401unsigned int snd_hda_gen_path_power_filter(struct hda_codec *codec,
55196fff
TI		 4402 hda_nid_t nid,
4403 unsigned int power_state)
4404{
dfc6e469 4405 if (power_state != AC_PWRST_D0 || nid == codec->afg)
55196fff
TI		 4406 return power_state;
4407 if (get_wcaps_type(get_wcaps(codec, nid)) >= AC_WID_POWER)
4408 return power_state;
b1b9fbd0 4409 if (is_active_nid_for_any(codec, nid))
55196fff
TI		 4410 return power_state;
4411 return AC_PWRST_D3;
4412}
dfc6e469 4413EXPORT_SYMBOL_GPL(snd_hda_gen_path_power_filter);
55196fff 4414
ebb93c05
TI		 4415/* mute all aamix inputs initially; parse up to the first leaves */
4416static void mute_all_mixer_nid(struct hda_codec *codec, hda_nid_t mix)
4417{
4418 int i, nums;
4419 const hda_nid_t *conn;
4420 bool has_amp;
4421
4422 nums = snd_hda_get_conn_list(codec, mix, &conn);
4423 has_amp = nid_has_mute(codec, mix, HDA_INPUT);
4424 for (i = 0; i < nums; i++) {
4425 if (has_amp)
4426 snd_hda_codec_amp_stereo(codec, mix,
4427 HDA_INPUT, i,
4428 0xff, HDA_AMP_MUTE);
4429 else if (nid_has_volume(codec, conn[i], HDA_OUTPUT))
4430 snd_hda_codec_amp_stereo(codec, conn[i],
4431 HDA_OUTPUT, 0,
4432 0xff, HDA_AMP_MUTE);
4433 }
4434}
1da177e4 4435
dda42bd0
TI		 4436/**
4437 * snd_hda_gen_parse_auto_config - Parse the given BIOS configuration and
4438 * set up the hda_gen_spec
4439 * @codec: the HDA codec
4440 * @cfg: Parsed pin configuration
9eb413e5
TI		 4441 *
4442 * return 1 if successful, 0 if the proper config is not found,
352f7f91
TI		 4443 * or a negative error code
4444 */
4445int snd_hda_gen_parse_auto_config(struct hda_codec *codec,
9eb413e5 4446 struct auto_pin_cfg *cfg)
352f7f91
TI		 4447{
4448 struct hda_gen_spec *spec = codec->spec;
352f7f91
TI		 4449 int err;
4450
1c70a583
TI		 4451 parse_user_hints(codec);
4452
e4a395e7
TI		 4453 if (spec->mixer_nid && !spec->mixer_merge_nid)
4454 spec->mixer_merge_nid = spec->mixer_nid;
4455
9eb413e5
TI		 4456 if (cfg != &spec->autocfg) {
4457 spec->autocfg = *cfg;
4458 cfg = &spec->autocfg;
4459 }
4460
98bd1115
TI		 4461 if (!spec->main_out_badness)
4462 spec->main_out_badness = &hda_main_out_badness;
4463 if (!spec->extra_out_badness)
4464 spec->extra_out_badness = &hda_extra_out_badness;
4465
6fc4cb97
DH		 4466 fill_all_dac_nids(codec);
4467
352f7f91
TI		 4468 if (!cfg->line_outs) {
4469 if (cfg->dig_outs || cfg->dig_in_pin) {
4470 spec->multiout.max_channels = 2;
4471 spec->no_analog = 1;
4472 goto dig_only;
4473 }
c9e4bdb7
TI		 4474 if (!cfg->num_inputs && !cfg->dig_in_pin)
4475 return 0; /* can't find valid BIOS pin config */
352f7f91
TI		 4476 }
4477
4478 if (!spec->no_primary_hp &&
4479 cfg->line_out_type == AUTO_PIN_SPEAKER_OUT &&
4480 cfg->line_outs <= cfg->hp_outs) {
4481 /* use HP as primary out */
4482 cfg->speaker_outs = cfg->line_outs;
4483 memcpy(cfg->speaker_pins, cfg->line_out_pins,
4484 sizeof(cfg->speaker_pins));
4485 cfg->line_outs = cfg->hp_outs;
4486 memcpy(cfg->line_out_pins, cfg->hp_pins, sizeof(cfg->hp_pins));
4487 cfg->hp_outs = 0;
4488 memset(cfg->hp_pins, 0, sizeof(cfg->hp_pins));
4489 cfg->line_out_type = AUTO_PIN_HP_OUT;
4490 }
4491
4492 err = parse_output_paths(codec);
4493 if (err < 0)
4494 return err;
4495 err = create_multi_channel_mode(codec);
4496 if (err < 0)
4497 return err;
4498 err = create_multi_out_ctls(codec, cfg);
4499 if (err < 0)
4500 return err;
4501 err = create_hp_out_ctls(codec);
4502 if (err < 0)
4503 return err;
4504 err = create_speaker_out_ctls(codec);
38cf6f1a
TI		 4505 if (err < 0)
4506 return err;
4507 err = create_indep_hp_ctls(codec);
c30aa7b2
TI		 4508 if (err < 0)
4509 return err;
4510 err = create_loopback_mixing_ctl(codec);
352f7f91
TI		 4511 if (err < 0)
4512 return err;
967303da 4513 err = create_hp_mic(codec);
352f7f91
TI		 4514 if (err < 0)
4515 return err;
4516 err = create_input_ctls(codec);
4517 if (err < 0)
4518 return err;
4519
a07a949b
TI		 4520 spec->const_channel_count = spec->ext_channel_count;
4521 /* check the multiple speaker and headphone pins */
4522 if (cfg->line_out_type != AUTO_PIN_SPEAKER_OUT)
4523 spec->const_channel_count = max(spec->const_channel_count,
4524 cfg->speaker_outs * 2);
4525 if (cfg->line_out_type != AUTO_PIN_HP_OUT)
4526 spec->const_channel_count = max(spec->const_channel_count,
4527 cfg->hp_outs * 2);
4528 spec->multiout.max_channels = max(spec->ext_channel_count,
4529 spec->const_channel_count);
352f7f91
TI		 4530
4531 err = check_auto_mute_availability(codec);
4532 if (err < 0)
4533 return err;
4534
4535 err = check_dyn_adc_switch(codec);
4536 if (err < 0)
4537 return err;
4538
967303da
TI		 4539 err = check_auto_mic_availability(codec);
4540 if (err < 0)
4541 return err;
1da177e4 4542
f1e762dd
TI		 4543 /* add stereo mix if available and not enabled yet */
4544 if (!spec->auto_mic && spec->mixer_nid &&
4545 spec->add_stereo_mix_input &&
4546 spec->input_mux.num_items > 1 &&
4547 snd_hda_get_bool_hint(codec, "add_stereo_mix_input") < 0) {
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 kernel - Deliverables
This page took 1.0176 seconds and 5 git commands to generate.