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