projects / linux-2.6-block.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
ALSA: hda - Record the current speaker / LO mute status in hda_gen_spec
[linux-2.6-block.git] / sound / pci / hda / hda_generic.c
CommitLineData
1da177e4
LT		 1/*
2 * Universal Interface for Intel High Definition Audio Codec
3 *
4 * Generic widget tree parser
5 *
6 * Copyright (c) 2004 Takashi Iwai <tiwai@suse.de>
7 *
8 * This driver is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 2 of the License, or
11 * (at your option) any later version.
12 *
13 * This driver is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
17 *
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, write to the Free Software
20 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
21 */
22
1da177e4
LT		 23#include <linux/init.h>
24#include <linux/slab.h>
d81a6d71 25#include <linux/export.h>
352f7f91 26#include <linux/sort.h>
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;
47b9ddb8 3050 spec->speaker_muted = on;
352f7f91 3051 do_automute(codec, ARRAY_SIZE(spec->autocfg.speaker_pins),
2c12c30d 3052 spec->autocfg.speaker_pins, on);
352f7f91
TI		 3053
3054 /* toggle line-out mutes if needed, too */
3055 /* if LO is a copy of either HP or Speaker, don't need to handle it */
3056 if (spec->autocfg.line_out_pins[0] == spec->autocfg.hp_pins[0] ||
3057 spec->autocfg.line_out_pins[0] == spec->autocfg.speaker_pins[0])
3058 return;
3059 if (!spec->automute_lo)
3060 on = 0;
3061 else
3062 on = spec->hp_jack_present;
3063 on |= spec->master_mute;
47b9ddb8 3064 spec->line_out_muted = on;
352f7f91 3065 do_automute(codec, ARRAY_SIZE(spec->autocfg.line_out_pins),
2c12c30d 3066 spec->autocfg.line_out_pins, on);
352f7f91 3067}
5d550e15 3068EXPORT_SYMBOL_HDA(snd_hda_gen_update_outputs);
352f7f91
TI		 3069
3070static void call_update_outputs(struct hda_codec *codec)
3071{
3072 struct hda_gen_spec *spec = codec->spec;
3073 if (spec->automute_hook)
3074 spec->automute_hook(codec);
3075 else
5d550e15 3076 snd_hda_gen_update_outputs(codec);
352f7f91
TI		 3077}
3078
3079/* standard HP-automute helper */
5d550e15 3080void snd_hda_gen_hp_automute(struct hda_codec *codec, struct hda_jack_tbl *jack)
352f7f91
TI		 3081{
3082 struct hda_gen_spec *spec = codec->spec;
3083
3084 spec->hp_jack_present =
3085 detect_jacks(codec, ARRAY_SIZE(spec->autocfg.hp_pins),
3086 spec->autocfg.hp_pins);
3087 if (!spec->detect_hp || (!spec->automute_speaker && !spec->automute_lo))
3088 return;
3089 call_update_outputs(codec);
3090}
5d550e15 3091EXPORT_SYMBOL_HDA(snd_hda_gen_hp_automute);
352f7f91
TI		 3092
3093/* standard line-out-automute helper */
5d550e15 3094void snd_hda_gen_line_automute(struct hda_codec *codec, struct hda_jack_tbl *jack)
352f7f91
TI		 3095{
3096 struct hda_gen_spec *spec = codec->spec;
3097
3098 if (spec->autocfg.line_out_type == AUTO_PIN_SPEAKER_OUT)
3099 return;
3100 /* check LO jack only when it's different from HP */
3101 if (spec->autocfg.line_out_pins[0] == spec->autocfg.hp_pins[0])
3102 return;
3103
3104 spec->line_jack_present =
3105 detect_jacks(codec, ARRAY_SIZE(spec->autocfg.line_out_pins),
3106 spec->autocfg.line_out_pins);
3107 if (!spec->automute_speaker || !spec->detect_lo)
3108 return;
3109 call_update_outputs(codec);
3110}
5d550e15 3111EXPORT_SYMBOL_HDA(snd_hda_gen_line_automute);
352f7f91
TI		 3112
3113/* standard mic auto-switch helper */
5d550e15 3114void snd_hda_gen_mic_autoswitch(struct hda_codec *codec, struct hda_jack_tbl *jack)
352f7f91
TI		 3115{
3116 struct hda_gen_spec *spec = codec->spec;
3117 int i;
3118
3119 if (!spec->auto_mic)
3120 return;
3121
3122 for (i = spec->am_num_entries - 1; i > 0; i--) {
0b4df931
TI		 3123 hda_nid_t pin = spec->am_entry[i].pin;
3124 /* don't detect pins retasked as outputs */
3125 if (snd_hda_codec_get_pin_target(codec, pin) & AC_PINCTL_OUT_EN)
3126 continue;
3127 if (snd_hda_jack_detect(codec, pin)) {
352f7f91
TI		 3128 mux_select(codec, 0, spec->am_entry[i].idx);
3129 return;
3130 }
3131 }
3132 mux_select(codec, 0, spec->am_entry[0].idx);
3133}
5d550e15 3134EXPORT_SYMBOL_HDA(snd_hda_gen_mic_autoswitch);
352f7f91 3135
a5cc2509
TI		 3136/* update jack retasking */
3137static void update_automute_all(struct hda_codec *codec)
3138{
3139 struct hda_gen_spec *spec = codec->spec;
3140
3141 if (spec->hp_automute_hook)
3142 spec->hp_automute_hook(codec, NULL);
3143 else
3144 snd_hda_gen_hp_automute(codec, NULL);
3145 if (spec->line_automute_hook)
3146 spec->line_automute_hook(codec, NULL);
3147 else
3148 snd_hda_gen_line_automute(codec, NULL);
3149 if (spec->mic_autoswitch_hook)
3150 spec->mic_autoswitch_hook(codec, NULL);
3151 else
3152 snd_hda_gen_mic_autoswitch(codec, NULL);
3153}
3154
352f7f91
TI		 3155/*
3156 * Auto-Mute mode mixer enum support
3157 */
3158static int automute_mode_info(struct snd_kcontrol *kcontrol,
3159 struct snd_ctl_elem_info *uinfo)
3160{
3161 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3162 struct hda_gen_spec *spec = codec->spec;
3163 static const char * const texts3[] = {
3164 "Disabled", "Speaker Only", "Line Out+Speaker"
3165 };
3166
3167 if (spec->automute_speaker_possible && spec->automute_lo_possible)
3168 return snd_hda_enum_helper_info(kcontrol, uinfo, 3, texts3);
3169 return snd_hda_enum_bool_helper_info(kcontrol, uinfo);
3170}
3171
3172static int automute_mode_get(struct snd_kcontrol *kcontrol,
3173 struct snd_ctl_elem_value *ucontrol)
3174{
3175 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3176 struct hda_gen_spec *spec = codec->spec;
3177 unsigned int val = 0;
3178 if (spec->automute_speaker)
3179 val++;
3180 if (spec->automute_lo)
3181 val++;
3182
3183 ucontrol->value.enumerated.item[0] = val;
3184 return 0;
3185}
3186
3187static int automute_mode_put(struct snd_kcontrol *kcontrol,
3188 struct snd_ctl_elem_value *ucontrol)
3189{
3190 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3191 struct hda_gen_spec *spec = codec->spec;
3192
3193 switch (ucontrol->value.enumerated.item[0]) {
3194 case 0:
3195 if (!spec->automute_speaker && !spec->automute_lo)
3196 return 0;
3197 spec->automute_speaker = 0;
3198 spec->automute_lo = 0;
3199 break;
3200 case 1:
3201 if (spec->automute_speaker_possible) {
3202 if (!spec->automute_lo && spec->automute_speaker)
3203 return 0;
3204 spec->automute_speaker = 1;
3205 spec->automute_lo = 0;
3206 } else if (spec->automute_lo_possible) {
3207 if (spec->automute_lo)
3208 return 0;
3209 spec->automute_lo = 1;
3210 } else
3211 return -EINVAL;
3212 break;
3213 case 2:
3214 if (!spec->automute_lo_possible || !spec->automute_speaker_possible)
3215 return -EINVAL;
3216 if (spec->automute_speaker && spec->automute_lo)
3217 return 0;
3218 spec->automute_speaker = 1;
3219 spec->automute_lo = 1;
3220 break;
3221 default:
3222 return -EINVAL;
3223 }
3224 call_update_outputs(codec);
3225 return 1;
3226}
3227
3228static const struct snd_kcontrol_new automute_mode_enum = {
3229 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3230 .name = "Auto-Mute Mode",
3231 .info = automute_mode_info,
3232 .get = automute_mode_get,
3233 .put = automute_mode_put,
3234};
3235
3236static int add_automute_mode_enum(struct hda_codec *codec)
3237{
3238 struct hda_gen_spec *spec = codec->spec;
3239
12c93df6 3240 if (!snd_hda_gen_add_kctl(spec, NULL, &automute_mode_enum))
352f7f91
TI		 3241 return -ENOMEM;
3242 return 0;
3243}
3244
3245/*
3246 * Check the availability of HP/line-out auto-mute;
3247 * Set up appropriately if really supported
3248 */
3249static int check_auto_mute_availability(struct hda_codec *codec)
3250{
3251 struct hda_gen_spec *spec = codec->spec;
3252 struct auto_pin_cfg *cfg = &spec->autocfg;
3253 int present = 0;
3254 int i, err;
3255
3256 if (cfg->hp_pins[0])
3257 present++;
3258 if (cfg->line_out_pins[0])
3259 present++;
3260 if (cfg->speaker_pins[0])
3261 present++;
3262 if (present < 2) /* need two different output types */
3263 return 0;
3264
3265 if (!cfg->speaker_pins[0] &&
3266 cfg->line_out_type == AUTO_PIN_SPEAKER_OUT) {
3267 memcpy(cfg->speaker_pins, cfg->line_out_pins,
3268 sizeof(cfg->speaker_pins));
3269 cfg->speaker_outs = cfg->line_outs;
3270 }
3271
3272 if (!cfg->hp_pins[0] &&
3273 cfg->line_out_type == AUTO_PIN_HP_OUT) {
3274 memcpy(cfg->hp_pins, cfg->line_out_pins,
3275 sizeof(cfg->hp_pins));
3276 cfg->hp_outs = cfg->line_outs;
3277 }
3278
3279 for (i = 0; i < cfg->hp_outs; i++) {
3280 hda_nid_t nid = cfg->hp_pins[i];
3281 if (!is_jack_detectable(codec, nid))
3282 continue;
3283 snd_printdd("hda-codec: Enable HP auto-muting on NID 0x%x\n",
3284 nid);
3285 snd_hda_jack_detect_enable_callback(codec, nid, HDA_GEN_HP_EVENT,
2e03e952
TI		 3286 spec->hp_automute_hook ?
3287 spec->hp_automute_hook :
5d550e15 3288 snd_hda_gen_hp_automute);
352f7f91
TI		 3289 spec->detect_hp = 1;
3290 }
3291
3292 if (cfg->line_out_type == AUTO_PIN_LINE_OUT && cfg->line_outs) {
3293 if (cfg->speaker_outs)
3294 for (i = 0; i < cfg->line_outs; i++) {
3295 hda_nid_t nid = cfg->line_out_pins[i];
3296 if (!is_jack_detectable(codec, nid))
3297 continue;
3298 snd_printdd("hda-codec: Enable Line-Out auto-muting on NID 0x%x\n", nid);
3299 snd_hda_jack_detect_enable_callback(codec, nid,
3300 HDA_GEN_FRONT_EVENT,
2e03e952
TI		 3301 spec->line_automute_hook ?
3302 spec->line_automute_hook :
5d550e15 3303 snd_hda_gen_line_automute);
352f7f91
TI		 3304 spec->detect_lo = 1;
3305 }
3306 spec->automute_lo_possible = spec->detect_hp;
3307 }
3308
3309 spec->automute_speaker_possible = cfg->speaker_outs &&
3310 (spec->detect_hp || spec->detect_lo);
3311
3312 spec->automute_lo = spec->automute_lo_possible;
3313 spec->automute_speaker = spec->automute_speaker_possible;
3314
3315 if (spec->automute_speaker_possible || spec->automute_lo_possible) {
3316 /* create a control for automute mode */
3317 err = add_automute_mode_enum(codec);
3318 if (err < 0)
3319 return err;
3320 }
3321 return 0;
3322}
352f7f91
TI		 3323
3324/* check whether all auto-mic pins are valid; setup indices if OK */
3325static bool auto_mic_check_imux(struct hda_codec *codec)
3326{
3327 struct hda_gen_spec *spec = codec->spec;
3328 const struct hda_input_mux *imux;
3329 int i;
3330
3331 imux = &spec->input_mux;
3332 for (i = 0; i < spec->am_num_entries; i++) {
3333 spec->am_entry[i].idx =
3334 find_idx_in_nid_list(spec->am_entry[i].pin,
3335 spec->imux_pins, imux->num_items);
3336 if (spec->am_entry[i].idx < 0)
3337 return false; /* no corresponding imux */
3338 }
3339
3340 /* we don't need the jack detection for the first pin */
3341 for (i = 1; i < spec->am_num_entries; i++)
3342 snd_hda_jack_detect_enable_callback(codec,
3343 spec->am_entry[i].pin,
3344 HDA_GEN_MIC_EVENT,
2e03e952
TI		 3345 spec->mic_autoswitch_hook ?
3346 spec->mic_autoswitch_hook :
5d550e15 3347 snd_hda_gen_mic_autoswitch);
352f7f91
TI		 3348 return true;
3349}
3350
3351static int compare_attr(const void *ap, const void *bp)
3352{
3353 const struct automic_entry *a = ap;
3354 const struct automic_entry *b = bp;
3355 return (int)(a->attr - b->attr);
3356}
1da177e4
LT		 3357
3358/*
352f7f91
TI		 3359 * Check the availability of auto-mic switch;
3360 * Set up if really supported
1da177e4 3361 */
352f7f91
TI		 3362static int check_auto_mic_availability(struct hda_codec *codec)
3363{
3364 struct hda_gen_spec *spec = codec->spec;
3365 struct auto_pin_cfg *cfg = &spec->autocfg;
3366 unsigned int types;
3367 int i, num_pins;
3368
d12daf6f
TI		 3369 if (spec->suppress_auto_mic)
3370 return 0;
3371
352f7f91
TI		 3372 types = 0;
3373 num_pins = 0;
3374 for (i = 0; i < cfg->num_inputs; i++) {
3375 hda_nid_t nid = cfg->inputs[i].pin;
3376 unsigned int attr;
3377 attr = snd_hda_codec_get_pincfg(codec, nid);
3378 attr = snd_hda_get_input_pin_attr(attr);
3379 if (types & (1 << attr))
3380 return 0; /* already occupied */
3381 switch (attr) {
3382 case INPUT_PIN_ATTR_INT:
3383 if (cfg->inputs[i].type != AUTO_PIN_MIC)
3384 return 0; /* invalid type */
3385 break;
3386 case INPUT_PIN_ATTR_UNUSED:
3387 return 0; /* invalid entry */
3388 default:
3389 if (cfg->inputs[i].type > AUTO_PIN_LINE_IN)
3390 return 0; /* invalid type */
3391 if (!spec->line_in_auto_switch &&
3392 cfg->inputs[i].type != AUTO_PIN_MIC)
3393 return 0; /* only mic is allowed */
3394 if (!is_jack_detectable(codec, nid))
3395 return 0; /* no unsol support */
3396 break;
3397 }
3398 if (num_pins >= MAX_AUTO_MIC_PINS)
3399 return 0;
3400 types |= (1 << attr);
3401 spec->am_entry[num_pins].pin = nid;
3402 spec->am_entry[num_pins].attr = attr;
3403 num_pins++;
3404 }
3405
3406 if (num_pins < 2)
3407 return 0;
3408
3409 spec->am_num_entries = num_pins;
3410 /* sort the am_entry in the order of attr so that the pin with a
3411 * higher attr will be selected when the jack is plugged.
3412 */
3413 sort(spec->am_entry, num_pins, sizeof(spec->am_entry[0]),
3414 compare_attr, NULL);
3415
3416 if (!auto_mic_check_imux(codec))
3417 return 0;
3418
3419 spec->auto_mic = 1;
3420 spec->num_adc_nids = 1;
3421 spec->cur_mux[0] = spec->am_entry[0].idx;
3422 snd_printdd("hda-codec: Enable auto-mic switch on NID 0x%x/0x%x/0x%x\n",
3423 spec->am_entry[0].pin,
3424 spec->am_entry[1].pin,
3425 spec->am_entry[2].pin);
3426
1da177e4
LT		 3427 return 0;
3428}
3429
1da177e4 3430
9eb413e5
TI		 3431/*
3432 * Parse the given BIOS configuration and set up the hda_gen_spec
3433 *
3434 * return 1 if successful, 0 if the proper config is not found,
352f7f91
TI		 3435 * or a negative error code
3436 */
3437int snd_hda_gen_parse_auto_config(struct hda_codec *codec,
9eb413e5 3438 struct auto_pin_cfg *cfg)
352f7f91
TI		 3439{
3440 struct hda_gen_spec *spec = codec->spec;
352f7f91
TI		 3441 int err;
3442
1c70a583
TI		 3443 parse_user_hints(codec);
3444
9eb413e5
TI		 3445 if (cfg != &spec->autocfg) {
3446 spec->autocfg = *cfg;
3447 cfg = &spec->autocfg;
3448 }
3449
6fc4cb97
DH		 3450 fill_all_dac_nids(codec);
3451
352f7f91
TI		 3452 if (!cfg->line_outs) {
3453 if (cfg->dig_outs || cfg->dig_in_pin) {
3454 spec->multiout.max_channels = 2;
3455 spec->no_analog = 1;
3456 goto dig_only;
3457 }
3458 return 0; /* can't find valid BIOS pin config */
3459 }
3460
3461 if (!spec->no_primary_hp &&
3462 cfg->line_out_type == AUTO_PIN_SPEAKER_OUT &&
3463 cfg->line_outs <= cfg->hp_outs) {
3464 /* use HP as primary out */
3465 cfg->speaker_outs = cfg->line_outs;
3466 memcpy(cfg->speaker_pins, cfg->line_out_pins,
3467 sizeof(cfg->speaker_pins));
3468 cfg->line_outs = cfg->hp_outs;
3469 memcpy(cfg->line_out_pins, cfg->hp_pins, sizeof(cfg->hp_pins));
3470 cfg->hp_outs = 0;
3471 memset(cfg->hp_pins, 0, sizeof(cfg->hp_pins));
3472 cfg->line_out_type = AUTO_PIN_HP_OUT;
3473 }
3474
3475 err = parse_output_paths(codec);
3476 if (err < 0)
3477 return err;
3478 err = create_multi_channel_mode(codec);
3479 if (err < 0)
3480 return err;
3481 err = create_multi_out_ctls(codec, cfg);
3482 if (err < 0)
3483 return err;
3484 err = create_hp_out_ctls(codec);
3485 if (err < 0)
3486 return err;
3487 err = create_speaker_out_ctls(codec);
38cf6f1a
TI		 3488 if (err < 0)
3489 return err;
3490 err = create_indep_hp_ctls(codec);
c30aa7b2
TI		 3491 if (err < 0)
3492 return err;
3493 err = create_loopback_mixing_ctl(codec);
352f7f91
TI		 3494 if (err < 0)
3495 return err;
3496 err = create_shared_input(codec);
3497 if (err < 0)
3498 return err;
3499 err = create_input_ctls(codec);
3500 if (err < 0)
3501 return err;
3502
a07a949b
TI		 3503 spec->const_channel_count = spec->ext_channel_count;
3504 /* check the multiple speaker and headphone pins */
3505 if (cfg->line_out_type != AUTO_PIN_SPEAKER_OUT)
3506 spec->const_channel_count = max(spec->const_channel_count,
3507 cfg->speaker_outs * 2);
3508 if (cfg->line_out_type != AUTO_PIN_HP_OUT)
3509 spec->const_channel_count = max(spec->const_channel_count,
3510 cfg->hp_outs * 2);
3511 spec->multiout.max_channels = max(spec->ext_channel_count,
3512 spec->const_channel_count);
352f7f91
TI		 3513
3514 err = check_auto_mute_availability(codec);
3515 if (err < 0)
3516 return err;
3517
3518 err = check_dyn_adc_switch(codec);
3519 if (err < 0)
3520 return err;
3521
3522 if (!spec->shared_mic_hp) {
3523 err = check_auto_mic_availability(codec);
97ec558a
TI		 3524 if (err < 0)
3525 return err;
3526 }
1da177e4 3527
352f7f91
TI		 3528 err = create_capture_mixers(codec);
3529 if (err < 0)
3530 return err;
a7da6ce5 3531
352f7f91
TI		 3532 err = parse_mic_boost(codec);
3533 if (err < 0)
3534 return err;
3535
978e77e7
TI		 3536 if (spec->add_out_jack_modes) {
3537 if (cfg->line_out_type != AUTO_PIN_SPEAKER_OUT) {
3538 err = create_out_jack_modes(codec, cfg->line_outs,
3539 cfg->line_out_pins);
3540 if (err < 0)
3541 return err;
3542 }
3543 if (cfg->line_out_type != AUTO_PIN_HP_OUT) {
3544 err = create_out_jack_modes(codec, cfg->hp_outs,
3545 cfg->hp_pins);
3546 if (err < 0)
3547 return err;
3548 }
3549 }
3550
352f7f91
TI		 3551 dig_only:
3552 parse_digital(codec);
3553
3554 return 1;
a7da6ce5 3555}
352f7f91 3556EXPORT_SYMBOL_HDA(snd_hda_gen_parse_auto_config);
a7da6ce5 3557
071c73ad 3558
352f7f91
TI		 3559/*
3560 * Build control elements
3561 */
3562
3563/* slave controls for virtual master */
3564static const char * const slave_pfxs[] = {
3565 "Front", "Surround", "Center", "LFE", "Side",
3566 "Headphone", "Speaker", "Mono", "Line Out",
3567 "CLFE", "Bass Speaker", "PCM",
ee79c69a
TI		 3568 "Speaker Front", "Speaker Surround", "Speaker CLFE", "Speaker Side",
3569 "Headphone Front", "Headphone Surround", "Headphone CLFE",
3570 "Headphone Side",
352f7f91
TI		 3571 NULL,
3572};
3573
3574int snd_hda_gen_build_controls(struct hda_codec *codec)
3575{
3576 struct hda_gen_spec *spec = codec->spec;
3577 int err;
1da177e4 3578
36502d02
TI		 3579 if (spec->kctls.used) {
3580 err = snd_hda_add_new_ctls(codec, spec->kctls.list);
3581 if (err < 0)
3582 return err;
3583 }
071c73ad 3584
352f7f91
TI		 3585 if (spec->multiout.dig_out_nid) {
3586 err = snd_hda_create_dig_out_ctls(codec,
3587 spec->multiout.dig_out_nid,
3588 spec->multiout.dig_out_nid,
3589 spec->pcm_rec[1].pcm_type);
3590 if (err < 0)
3591 return err;
3592 if (!spec->no_analog) {
3593 err = snd_hda_create_spdif_share_sw(codec,
3594 &spec->multiout);
3595 if (err < 0)
3596 return err;
3597 spec->multiout.share_spdif = 1;
3598 }
3599 }
3600 if (spec->dig_in_nid) {
3601 err = snd_hda_create_spdif_in_ctls(codec, spec->dig_in_nid);
071c73ad
TI		 3602 if (err < 0)
3603 return err;
071c73ad 3604 }
1da177e4 3605
352f7f91
TI		 3606 /* if we have no master control, let's create it */
3607 if (!spec->no_analog &&
3608 !snd_hda_find_mixer_ctl(codec, "Master Playback Volume")) {
3609 unsigned int vmaster_tlv[4];
3610 snd_hda_set_vmaster_tlv(codec, spec->vmaster_nid,
3611 HDA_OUTPUT, vmaster_tlv);
3612 err = snd_hda_add_vmaster(codec, "Master Playback Volume",
3613 vmaster_tlv, slave_pfxs,
3614 "Playback Volume");
3615 if (err < 0)
3616 return err;
3617 }
3618 if (!spec->no_analog &&
3619 !snd_hda_find_mixer_ctl(codec, "Master Playback Switch")) {
3620 err = __snd_hda_add_vmaster(codec, "Master Playback Switch",
3621 NULL, slave_pfxs,
3622 "Playback Switch",
3623 true, &spec->vmaster_mute.sw_kctl);
3624 if (err < 0)
3625 return err;
3626 if (spec->vmaster_mute.hook)
fd25a97a
TI		 3627 snd_hda_add_vmaster_hook(codec, &spec->vmaster_mute,
3628 spec->vmaster_mute_enum);
352f7f91 3629 }
071c73ad 3630
352f7f91 3631 free_kctls(spec); /* no longer needed */
071c73ad 3632
352f7f91
TI		 3633 if (spec->shared_mic_hp) {
3634 int err;
3635 int nid = spec->autocfg.inputs[1].pin;
3636 err = snd_hda_jack_add_kctl(codec, nid, "Headphone Mic", 0);
3637 if (err < 0)
3638 return err;
3639 err = snd_hda_jack_detect_enable(codec, nid, 0);
d13bd412 3640 if (err < 0)
1da177e4 3641 return err;
1da177e4 3642 }
071c73ad 3643
352f7f91
TI		 3644 err = snd_hda_jack_add_kctls(codec, &spec->autocfg);
3645 if (err < 0)
3646 return err;
3647
1da177e4
LT		 3648 return 0;
3649}
352f7f91 3650EXPORT_SYMBOL_HDA(snd_hda_gen_build_controls);
1da177e4
LT		 3651
3652
3653/*
352f7f91 3654 * PCM definitions
1da177e4 3655 */
1da177e4 3656
e6b85f3c
TI		 3657static void call_pcm_playback_hook(struct hda_pcm_stream *hinfo,
3658 struct hda_codec *codec,
3659 struct snd_pcm_substream *substream,
3660 int action)
3661{
3662 struct hda_gen_spec *spec = codec->spec;
3663 if (spec->pcm_playback_hook)
3664 spec->pcm_playback_hook(hinfo, codec, substream, action);
3665}
3666
352f7f91
TI		 3667/*
3668 * Analog playback callbacks
3669 */
3670static int playback_pcm_open(struct hda_pcm_stream *hinfo,
3671 struct hda_codec *codec,
3672 struct snd_pcm_substream *substream)
3673{
3674 struct hda_gen_spec *spec = codec->spec;
38cf6f1a
TI		 3675 int err;
3676
3677 mutex_lock(&spec->pcm_mutex);
3678 err = snd_hda_multi_out_analog_open(codec,
3679 &spec->multiout, substream,
352f7f91 3680 hinfo);
e6b85f3c 3681 if (!err) {
38cf6f1a 3682 spec->active_streams |= 1 << STREAM_MULTI_OUT;
e6b85f3c
TI		 3683 call_pcm_playback_hook(hinfo, codec, substream,
3684 HDA_GEN_PCM_ACT_OPEN);
3685 }
38cf6f1a
TI		 3686 mutex_unlock(&spec->pcm_mutex);
3687 return err;
352f7f91 3688}
1da177e4 3689
352f7f91
TI		 3690static int playback_pcm_prepare(struct hda_pcm_stream *hinfo,
3691 struct hda_codec *codec,
3692 unsigned int stream_tag,
3693 unsigned int format,
3694 struct snd_pcm_substream *substream)
3695{
3696 struct hda_gen_spec *spec = codec->spec;
e6b85f3c
TI		 3697 int err;
3698
3699 err = snd_hda_multi_out_analog_prepare(codec, &spec->multiout,
3700 stream_tag, format, substream);
3701 if (!err)
3702 call_pcm_playback_hook(hinfo, codec, substream,
3703 HDA_GEN_PCM_ACT_PREPARE);
3704 return err;
352f7f91 3705}
1da177e4 3706
352f7f91
TI		 3707static int playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
3708 struct hda_codec *codec,
3709 struct snd_pcm_substream *substream)
3710{
3711 struct hda_gen_spec *spec = codec->spec;
e6b85f3c
TI		 3712 int err;
3713
3714 err = snd_hda_multi_out_analog_cleanup(codec, &spec->multiout);
3715 if (!err)
3716 call_pcm_playback_hook(hinfo, codec, substream,
3717 HDA_GEN_PCM_ACT_CLEANUP);
3718 return err;
1da177e4
LT		 3719}
3720
38cf6f1a
TI		 3721static int playback_pcm_close(struct hda_pcm_stream *hinfo,
3722 struct hda_codec *codec,
3723 struct snd_pcm_substream *substream)
3724{
3725 struct hda_gen_spec *spec = codec->spec;
3726 mutex_lock(&spec->pcm_mutex);
3727 spec->active_streams &= ~(1 << STREAM_MULTI_OUT);
e6b85f3c
TI		 3728 call_pcm_playback_hook(hinfo, codec, substream,
3729 HDA_GEN_PCM_ACT_CLOSE);
38cf6f1a
TI		 3730 mutex_unlock(&spec->pcm_mutex);
3731 return 0;
3732}
3733
3734static int alt_playback_pcm_open(struct hda_pcm_stream *hinfo,
3735 struct hda_codec *codec,
3736 struct snd_pcm_substream *substream)
3737{
3738 struct hda_gen_spec *spec = codec->spec;
3739 int err = 0;
3740
3741 mutex_lock(&spec->pcm_mutex);
3742 if (!spec->indep_hp_enabled)
3743 err = -EBUSY;
3744 else
3745 spec->active_streams |= 1 << STREAM_INDEP_HP;
e6b85f3c
TI		 3746 call_pcm_playback_hook(hinfo, codec, substream,
3747 HDA_GEN_PCM_ACT_OPEN);
38cf6f1a
TI		 3748 mutex_unlock(&spec->pcm_mutex);
3749 return err;
3750}
3751
3752static int alt_playback_pcm_close(struct hda_pcm_stream *hinfo,
3753 struct hda_codec *codec,
3754 struct snd_pcm_substream *substream)
3755{
3756 struct hda_gen_spec *spec = codec->spec;
3757 mutex_lock(&spec->pcm_mutex);
3758 spec->active_streams &= ~(1 << STREAM_INDEP_HP);
e6b85f3c
TI		 3759 call_pcm_playback_hook(hinfo, codec, substream,
3760 HDA_GEN_PCM_ACT_CLOSE);
38cf6f1a
TI		 3761 mutex_unlock(&spec->pcm_mutex);
3762 return 0;
3763}
3764
e6b85f3c
TI		 3765static int alt_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
3766 struct hda_codec *codec,
3767 unsigned int stream_tag,
3768 unsigned int format,
3769 struct snd_pcm_substream *substream)
3770{
3771 snd_hda_codec_setup_stream(codec, hinfo->nid, stream_tag, 0, format);
3772 call_pcm_playback_hook(hinfo, codec, substream,
3773 HDA_GEN_PCM_ACT_PREPARE);
3774 return 0;
3775}
3776
3777static int alt_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
3778 struct hda_codec *codec,
3779 struct snd_pcm_substream *substream)
3780{
3781 snd_hda_codec_cleanup_stream(codec, hinfo->nid);
3782 call_pcm_playback_hook(hinfo, codec, substream,
3783 HDA_GEN_PCM_ACT_CLEANUP);
3784 return 0;
3785}
3786
1da177e4 3787/*
352f7f91 3788 * Digital out
1da177e4 3789 */
352f7f91
TI		 3790static int dig_playback_pcm_open(struct hda_pcm_stream *hinfo,
3791 struct hda_codec *codec,
3792 struct snd_pcm_substream *substream)
1da177e4 3793{
352f7f91
TI		 3794 struct hda_gen_spec *spec = codec->spec;
3795 return snd_hda_multi_out_dig_open(codec, &spec->multiout);
3796}
1da177e4 3797
352f7f91
TI		 3798static int dig_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
3799 struct hda_codec *codec,
3800 unsigned int stream_tag,
3801 unsigned int format,
3802 struct snd_pcm_substream *substream)
3803{
3804 struct hda_gen_spec *spec = codec->spec;
3805 return snd_hda_multi_out_dig_prepare(codec, &spec->multiout,
3806 stream_tag, format, substream);
3807}
1da177e4 3808
352f7f91
TI		 3809static int dig_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
3810 struct hda_codec *codec,
3811 struct snd_pcm_substream *substream)
3812{
3813 struct hda_gen_spec *spec = codec->spec;
3814 return snd_hda_multi_out_dig_cleanup(codec, &spec->multiout);
3815}
3816
3817static int dig_playback_pcm_close(struct hda_pcm_stream *hinfo,
3818 struct hda_codec *codec,
3819 struct snd_pcm_substream *substream)
3820{
3821 struct hda_gen_spec *spec = codec->spec;
3822 return snd_hda_multi_out_dig_close(codec, &spec->multiout);
1da177e4
LT		 3823}
3824
3825/*
352f7f91 3826 * Analog capture
1da177e4 3827 */
352f7f91
TI		 3828static int alt_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
3829 struct hda_codec *codec,
3830 unsigned int stream_tag,
3831 unsigned int format,
3832 struct snd_pcm_substream *substream)
1da177e4 3833{
352f7f91 3834 struct hda_gen_spec *spec = codec->spec;
1da177e4 3835
352f7f91
TI		 3836 snd_hda_codec_setup_stream(codec, spec->adc_nids[substream->number + 1],
3837 stream_tag, 0, format);
3838 return 0;
3839}
3840
3841static int alt_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
3842 struct hda_codec *codec,
3843 struct snd_pcm_substream *substream)
3844{
3845 struct hda_gen_spec *spec = codec->spec;
1da177e4 3846
352f7f91
TI		 3847 snd_hda_codec_cleanup_stream(codec,
3848 spec->adc_nids[substream->number + 1]);
1da177e4
LT		 3849 return 0;
3850}
3851
3852/*
1da177e4 3853 */
352f7f91
TI		 3854static const struct hda_pcm_stream pcm_analog_playback = {
3855 .substreams = 1,
3856 .channels_min = 2,
3857 .channels_max = 8,
3858 /* NID is set in build_pcms */
3859 .ops = {
3860 .open = playback_pcm_open,
38cf6f1a 3861 .close = playback_pcm_close,
352f7f91
TI		 3862 .prepare = playback_pcm_prepare,
3863 .cleanup = playback_pcm_cleanup
3864 },
3865};
3866
3867static const struct hda_pcm_stream pcm_analog_capture = {
1da177e4
LT		 3868 .substreams = 1,
3869 .channels_min = 2,
3870 .channels_max = 2,
352f7f91 3871 /* NID is set in build_pcms */
1da177e4
LT		 3872};
3873
352f7f91
TI		 3874static const struct hda_pcm_stream pcm_analog_alt_playback = {
3875 .substreams = 1,
3876 .channels_min = 2,
3877 .channels_max = 2,
3878 /* NID is set in build_pcms */
38cf6f1a
TI		 3879 .ops = {
3880 .open = alt_playback_pcm_open,
e6b85f3c
TI		 3881 .close = alt_playback_pcm_close,
3882 .prepare = alt_playback_pcm_prepare,
3883 .cleanup = alt_playback_pcm_cleanup
38cf6f1a 3884 },
352f7f91
TI		 3885};
3886
3887static const struct hda_pcm_stream pcm_analog_alt_capture = {
3888 .substreams = 2, /* can be overridden */
3889 .channels_min = 2,
3890 .channels_max = 2,
3891 /* NID is set in build_pcms */
3892 .ops = {
3893 .prepare = alt_capture_pcm_prepare,
3894 .cleanup = alt_capture_pcm_cleanup
3895 },
3896};
3897
3898static const struct hda_pcm_stream pcm_digital_playback = {
3899 .substreams = 1,
3900 .channels_min = 2,
3901 .channels_max = 2,
3902 /* NID is set in build_pcms */
3903 .ops = {
3904 .open = dig_playback_pcm_open,
3905 .close = dig_playback_pcm_close,
3906 .prepare = dig_playback_pcm_prepare,
3907 .cleanup = dig_playback_pcm_cleanup
3908 },
3909};
3910
3911static const struct hda_pcm_stream pcm_digital_capture = {
3912 .substreams = 1,
3913 .channels_min = 2,
3914 .channels_max = 2,
3915 /* NID is set in build_pcms */
3916};
3917
3918/* Used by build_pcms to flag that a PCM has no playback stream */
3919static const struct hda_pcm_stream pcm_null_stream = {
3920 .substreams = 0,
3921 .channels_min = 0,
3922 .channels_max = 0,
3923};
3924
3925/*
3926 * dynamic changing ADC PCM streams
3927 */
3928static bool dyn_adc_pcm_resetup(struct hda_codec *codec, int cur)
97ec558a 3929{
352f7f91
TI		 3930 struct hda_gen_spec *spec = codec->spec;
3931 hda_nid_t new_adc = spec->adc_nids[spec->dyn_adc_idx[cur]];
3932
3933 if (spec->cur_adc && spec->cur_adc != new_adc) {
3934 /* stream is running, let's swap the current ADC */
3935 __snd_hda_codec_cleanup_stream(codec, spec->cur_adc, 1);
3936 spec->cur_adc = new_adc;
3937 snd_hda_codec_setup_stream(codec, new_adc,
3938 spec->cur_adc_stream_tag, 0,
3939 spec->cur_adc_format);
3940 return true;
3941 }
3942 return false;
3943}
97ec558a 3944
352f7f91
TI		 3945/* analog capture with dynamic dual-adc changes */
3946static int dyn_adc_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
3947 struct hda_codec *codec,
3948 unsigned int stream_tag,
3949 unsigned int format,
3950 struct snd_pcm_substream *substream)
3951{
3952 struct hda_gen_spec *spec = codec->spec;
3953 spec->cur_adc = spec->adc_nids[spec->dyn_adc_idx[spec->cur_mux[0]]];
3954 spec->cur_adc_stream_tag = stream_tag;
3955 spec->cur_adc_format = format;
3956 snd_hda_codec_setup_stream(codec, spec->cur_adc, stream_tag, 0, format);
97ec558a
TI		 3957 return 0;
3958}
3959
352f7f91
TI		 3960static int dyn_adc_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
3961 struct hda_codec *codec,
3962 struct snd_pcm_substream *substream)
97ec558a 3963{
352f7f91
TI		 3964 struct hda_gen_spec *spec = codec->spec;
3965 snd_hda_codec_cleanup_stream(codec, spec->cur_adc);
3966 spec->cur_adc = 0;
97ec558a
TI		 3967 return 0;
3968}
3969
352f7f91
TI		 3970static const struct hda_pcm_stream dyn_adc_pcm_analog_capture = {
3971 .substreams = 1,
3972 .channels_min = 2,
3973 .channels_max = 2,
3974 .nid = 0, /* fill later */
3975 .ops = {
3976 .prepare = dyn_adc_capture_pcm_prepare,
3977 .cleanup = dyn_adc_capture_pcm_cleanup
3978 },
3979};
3980
f873e536
TI		 3981static void fill_pcm_stream_name(char *str, size_t len, const char *sfx,
3982 const char *chip_name)
3983{
3984 char *p;
3985
3986 if (*str)
3987 return;
3988 strlcpy(str, chip_name, len);
3989
3990 /* drop non-alnum chars after a space */
3991 for (p = strchr(str, ' '); p; p = strchr(p + 1, ' ')) {
3992 if (!isalnum(p[1])) {
3993 *p = 0;
3994 break;
3995 }
3996 }
3997 strlcat(str, sfx, len);
3998}
3999
352f7f91
TI		 4000/* build PCM streams based on the parsed results */
4001int snd_hda_gen_build_pcms(struct hda_codec *codec)
1da177e4 4002{
352f7f91
TI		 4003 struct hda_gen_spec *spec = codec->spec;
4004 struct hda_pcm *info = spec->pcm_rec;
4005 const struct hda_pcm_stream *p;
4006 bool have_multi_adcs;
352f7f91
TI		 4007
4008 codec->num_pcms = 1;
4009 codec->pcm_info = info;
4010
4011 if (spec->no_analog)
4012 goto skip_analog;
4013
f873e536
TI		 4014 fill_pcm_stream_name(spec->stream_name_analog,
4015 sizeof(spec->stream_name_analog),
4016 " Analog", codec->chip_name);
352f7f91
TI		 4017 info->name = spec->stream_name_analog;
4018
4019 if (spec->multiout.num_dacs > 0) {
4020 p = spec->stream_analog_playback;
4021 if (!p)
4022 p = &pcm_analog_playback;
4023 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *p;
4024 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dac_nids[0];
4025 info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max =
4026 spec->multiout.max_channels;
4027 if (spec->autocfg.line_out_type == AUTO_PIN_SPEAKER_OUT &&
4028 spec->autocfg.line_outs == 2)
4029 info->stream[SNDRV_PCM_STREAM_PLAYBACK].chmap =
4030 snd_pcm_2_1_chmaps;
4031 }
4032 if (spec->num_adc_nids) {
4033 p = spec->stream_analog_capture;
4034 if (!p) {
4035 if (spec->dyn_adc_switch)
4036 p = &dyn_adc_pcm_analog_capture;
4037 else
4038 p = &pcm_analog_capture;
4039 }
4040 info->stream[SNDRV_PCM_STREAM_CAPTURE] = *p;
4041 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adc_nids[0];
4042 }
4043
352f7f91
TI		 4044 skip_analog:
4045 /* SPDIF for stream index #1 */
4046 if (spec->multiout.dig_out_nid || spec->dig_in_nid) {
f873e536
TI		 4047 fill_pcm_stream_name(spec->stream_name_digital,
4048 sizeof(spec->stream_name_digital),
4049 " Digital", codec->chip_name);
352f7f91
TI		 4050 codec->num_pcms = 2;
4051 codec->slave_dig_outs = spec->multiout.slave_dig_outs;
4052 info = spec->pcm_rec + 1;
4053 info->name = spec->stream_name_digital;
4054 if (spec->dig_out_type)
4055 info->pcm_type = spec->dig_out_type;
4056 else
4057 info->pcm_type = HDA_PCM_TYPE_SPDIF;
4058 if (spec->multiout.dig_out_nid) {
4059 p = spec->stream_digital_playback;
4060 if (!p)
4061 p = &pcm_digital_playback;
4062 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *p;
4063 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dig_out_nid;
4064 }
4065 if (spec->dig_in_nid) {
4066 p = spec->stream_digital_capture;
4067 if (!p)
4068 p = &pcm_digital_capture;
4069 info->stream[SNDRV_PCM_STREAM_CAPTURE] = *p;
4070 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->dig_in_nid;
4071 }
4072 }
1da177e4 4073
352f7f91 4074 if (spec->no_analog)
1da177e4 4075 return 0;
352f7f91
TI		 4076
4077 /* If the use of more than one ADC is requested for the current
4078 * model, configure a second analog capture-only PCM.
4079 */
4080 have_multi_adcs = (spec->num_adc_nids > 1) &&
4081 !spec->dyn_adc_switch && !spec->auto_mic;
4082 /* Additional Analaog capture for index #2 */
4083 if (spec->alt_dac_nid || have_multi_adcs) {
4084 codec->num_pcms = 3;
4085 info = spec->pcm_rec + 2;
4086 info->name = spec->stream_name_analog;
4087 if (spec->alt_dac_nid) {
4088 p = spec->stream_analog_alt_playback;
4089 if (!p)
4090 p = &pcm_analog_alt_playback;
4091 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *p;
4092 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid =
4093 spec->alt_dac_nid;
4094 } else {
4095 info->stream[SNDRV_PCM_STREAM_PLAYBACK] =
4096 pcm_null_stream;
4097 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = 0;
4098 }
4099 if (have_multi_adcs) {
4100 p = spec->stream_analog_alt_capture;
4101 if (!p)
4102 p = &pcm_analog_alt_capture;
4103 info->stream[SNDRV_PCM_STREAM_CAPTURE] = *p;
4104 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid =
4105 spec->adc_nids[1];
4106 info->stream[SNDRV_PCM_STREAM_CAPTURE].substreams =
4107 spec->num_adc_nids - 1;
4108 } else {
4109 info->stream[SNDRV_PCM_STREAM_CAPTURE] =
4110 pcm_null_stream;
4111 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = 0;
4112 }
1da177e4
LT		 4113 }
4114
352f7f91
TI		 4115 return 0;
4116}
4117EXPORT_SYMBOL_HDA(snd_hda_gen_build_pcms);
4118
4119
4120/*
4121 * Standard auto-parser initializations
4122 */
4123
d4156930 4124/* configure the given path as a proper output */
2c12c30d 4125static void set_output_and_unmute(struct hda_codec *codec, int path_idx)
352f7f91
TI		 4126{
4127 struct nid_path *path;
d4156930 4128 hda_nid_t pin;
352f7f91 4129
196c1766 4130 path = snd_hda_get_path_from_idx(codec, path_idx);
d4156930 4131 if (!path || !path->depth)
352f7f91 4132 return;
d4156930 4133 pin = path->path[path->depth - 1];
2c12c30d 4134 restore_pin_ctl(codec, pin);
e1284af7
TI		 4135 snd_hda_activate_path(codec, path, path->active, true);
4136 set_pin_eapd(codec, pin, path->active);
352f7f91
TI		 4137}
4138
4139/* initialize primary output paths */
4140static void init_multi_out(struct hda_codec *codec)
4141{
4142 struct hda_gen_spec *spec = codec->spec;
352f7f91
TI		 4143 int i;
4144
d4156930 4145 for (i = 0; i < spec->autocfg.line_outs; i++)
2c12c30d 4146 set_output_and_unmute(codec, spec->out_paths[i]);
352f7f91
TI		 4147}
4148
db23fd19 4149
2c12c30d 4150static void __init_extra_out(struct hda_codec *codec, int num_outs, int *paths)
352f7f91 4151{
352f7f91 4152 int i;
352f7f91 4153
d4156930 4154 for (i = 0; i < num_outs; i++)
2c12c30d 4155 set_output_and_unmute(codec, paths[i]);
352f7f91
TI		 4156}
4157
db23fd19
TI		 4158/* initialize hp and speaker paths */
4159static void init_extra_out(struct hda_codec *codec)
4160{
4161 struct hda_gen_spec *spec = codec->spec;
4162
4163 if (spec->autocfg.line_out_type != AUTO_PIN_HP_OUT)
2c12c30d 4164 __init_extra_out(codec, spec->autocfg.hp_outs, spec->hp_paths);
db23fd19
TI		 4165 if (spec->autocfg.line_out_type != AUTO_PIN_SPEAKER_OUT)
4166 __init_extra_out(codec, spec->autocfg.speaker_outs,
2c12c30d 4167 spec->speaker_paths);
db23fd19
TI		 4168}
4169
352f7f91
TI		 4170/* initialize multi-io paths */
4171static void init_multi_io(struct hda_codec *codec)
4172{
4173 struct hda_gen_spec *spec = codec->spec;
4174 int i;
4175
4176 for (i = 0; i < spec->multi_ios; i++) {
4177 hda_nid_t pin = spec->multi_io[i].pin;
4178 struct nid_path *path;
196c1766 4179 path = get_multiio_path(codec, i);
352f7f91
TI		 4180 if (!path)
4181 continue;
4182 if (!spec->multi_io[i].ctl_in)
4183 spec->multi_io[i].ctl_in =
2c12c30d 4184 snd_hda_codec_get_pin_target(codec, pin);
352f7f91
TI		 4185 snd_hda_activate_path(codec, path, path->active, true);
4186 }
4187}
4188
352f7f91
TI		 4189/* set up input pins and loopback paths */
4190static void init_analog_input(struct hda_codec *codec)
4191{
4192 struct hda_gen_spec *spec = codec->spec;
4193 struct auto_pin_cfg *cfg = &spec->autocfg;
4194 int i;
4195
4196 for (i = 0; i < cfg->num_inputs; i++) {
4197 hda_nid_t nid = cfg->inputs[i].pin;
4198 if (is_input_pin(codec, nid))
2c12c30d 4199 restore_pin_ctl(codec, nid);
352f7f91
TI		 4200
4201 /* init loopback inputs */
4202 if (spec->mixer_nid) {
4203 struct nid_path *path;
196c1766 4204 path = snd_hda_get_path_from_idx(codec, spec->loopback_paths[i]);
352f7f91
TI		 4205 if (path)
4206 snd_hda_activate_path(codec, path,
4207 path->active, false);
4208 }
4209 }
4210}
4211
4212/* initialize ADC paths */
4213static void init_input_src(struct hda_codec *codec)
4214{
4215 struct hda_gen_spec *spec = codec->spec;
4216 struct hda_input_mux *imux = &spec->input_mux;
4217 struct nid_path *path;
4218 int i, c, nums;
1da177e4 4219
352f7f91
TI		 4220 if (spec->dyn_adc_switch)
4221 nums = 1;
4222 else
4223 nums = spec->num_adc_nids;
4224
4225 for (c = 0; c < nums; c++) {
4226 for (i = 0; i < imux->num_items; i++) {
c697b716 4227 path = get_input_path(codec, c, i);
352f7f91
TI		 4228 if (path) {
4229 bool active = path->active;
4230 if (i == spec->cur_mux[c])
4231 active = true;
4232 snd_hda_activate_path(codec, path, active, false);
4233 }
97ec558a 4234 }
1da177e4 4235 }
352f7f91
TI		 4236
4237 if (spec->shared_mic_hp)
4238 update_shared_mic_hp(codec, spec->cur_mux[0]);
4239
4240 if (spec->cap_sync_hook)
4241 spec->cap_sync_hook(codec);
4242}
4243
4244/* set right pin controls for digital I/O */
4245static void init_digital(struct hda_codec *codec)
4246{
4247 struct hda_gen_spec *spec = codec->spec;
4248 int i;
4249 hda_nid_t pin;
4250
d4156930 4251 for (i = 0; i < spec->autocfg.dig_outs; i++)
2c12c30d 4252 set_output_and_unmute(codec, spec->digout_paths[i]);
352f7f91 4253 pin = spec->autocfg.dig_in_pin;
2430d7b7
TI		 4254 if (pin) {
4255 struct nid_path *path;
2c12c30d 4256 restore_pin_ctl(codec, pin);
2430d7b7
TI		 4257 path = snd_hda_get_path_from_idx(codec, spec->digin_path);
4258 if (path)
4259 snd_hda_activate_path(codec, path, path->active, false);
4260 }
352f7f91
TI		 4261}
4262
973e4972
TI		 4263/* clear unsol-event tags on unused pins; Conexant codecs seem to leave
4264 * invalid unsol tags by some reason
4265 */
4266static void clear_unsol_on_unused_pins(struct hda_codec *codec)
4267{
4268 int i;
4269
4270 for (i = 0; i < codec->init_pins.used; i++) {
4271 struct hda_pincfg *pin = snd_array_elem(&codec->init_pins, i);
4272 hda_nid_t nid = pin->nid;
4273 if (is_jack_detectable(codec, nid) &&
4274 !snd_hda_jack_tbl_get(codec, nid))
4275 snd_hda_codec_update_cache(codec, nid, 0,
4276 AC_VERB_SET_UNSOLICITED_ENABLE, 0);
4277 }
4278}
4279
5187ac16
TI		 4280/*
4281 * initialize the generic spec;
4282 * this can be put as patch_ops.init function
4283 */
352f7f91
TI		 4284int snd_hda_gen_init(struct hda_codec *codec)
4285{
4286 struct hda_gen_spec *spec = codec->spec;
4287
4288 if (spec->init_hook)
4289 spec->init_hook(codec);
4290
4291 snd_hda_apply_verbs(codec);
4292
3bbcd274
TI		 4293 codec->cached_write = 1;
4294
352f7f91
TI		 4295 init_multi_out(codec);
4296 init_extra_out(codec);
4297 init_multi_io(codec);
4298 init_analog_input(codec);
4299 init_input_src(codec);
4300 init_digital(codec);
1da177e4 4301
973e4972
TI		 4302 clear_unsol_on_unused_pins(codec);
4303
352f7f91 4304 /* call init functions of standard auto-mute helpers */
a5cc2509 4305 update_automute_all(codec);
352f7f91 4306
3bbcd274
TI		 4307 snd_hda_codec_flush_amp_cache(codec);
4308 snd_hda_codec_flush_cmd_cache(codec);
4309
352f7f91
TI		 4310 if (spec->vmaster_mute.sw_kctl && spec->vmaster_mute.hook)
4311 snd_hda_sync_vmaster_hook(&spec->vmaster_mute);
4312
4313 hda_call_check_power_status(codec, 0x01);
1da177e4
LT		 4314 return 0;
4315}
fce52a3b 4316EXPORT_SYMBOL_HDA(snd_hda_gen_init);
352f7f91 4317
5187ac16
TI		 4318/*
4319 * free the generic spec;
4320 * this can be put as patch_ops.free function
4321 */
fce52a3b
TI		 4322void snd_hda_gen_free(struct hda_codec *codec)
4323{
4324 snd_hda_gen_spec_free(codec->spec);
4325 kfree(codec->spec);
4326 codec->spec = NULL;
4327}
4328EXPORT_SYMBOL_HDA(snd_hda_gen_free);
1da177e4 4329
83012a7c 4330#ifdef CONFIG_PM
5187ac16
TI		 4331/*
4332 * check the loopback power save state;
4333 * this can be put as patch_ops.check_power_status function
4334 */
fce52a3b 4335int snd_hda_gen_check_power_status(struct hda_codec *codec, hda_nid_t nid)
cb53c626 4336{
352f7f91 4337 struct hda_gen_spec *spec = codec->spec;
cb53c626
TI		 4338 return snd_hda_check_amp_list_power(codec, &spec->loopback, nid);
4339}
fce52a3b 4340EXPORT_SYMBOL_HDA(snd_hda_gen_check_power_status);
cb53c626
TI		 4341#endif
4342
fce52a3b
TI		 4343
4344/*
4345 * the generic codec support
4346 */
1da177e4 4347
352f7f91
TI		 4348static const struct hda_codec_ops generic_patch_ops = {
4349 .build_controls = snd_hda_gen_build_controls,
4350 .build_pcms = snd_hda_gen_build_pcms,
4351 .init = snd_hda_gen_init,
fce52a3b 4352 .free = snd_hda_gen_free,
352f7f91 4353 .unsol_event = snd_hda_jack_unsol_event,
83012a7c 4354#ifdef CONFIG_PM
fce52a3b 4355 .check_power_status = snd_hda_gen_check_power_status,
cb53c626 4356#endif
1da177e4
LT		 4357};
4358
1da177e4
LT		 4359int snd_hda_parse_generic_codec(struct hda_codec *codec)
4360{
352f7f91 4361 struct hda_gen_spec *spec;
1da177e4
LT		 4362 int err;
4363
e560d8d8 4364 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
352f7f91 4365 if (!spec)
1da177e4 4366 return -ENOMEM;
352f7f91 4367 snd_hda_gen_spec_init(spec);
1da177e4 4368 codec->spec = spec;
1da177e4 4369
9eb413e5
TI		 4370 err = snd_hda_parse_pin_defcfg(codec, &spec->autocfg, NULL, 0);
4371 if (err < 0)
4372 return err;
4373
4374 err = snd_hda_gen_parse_auto_config(codec, &spec->autocfg);
352f7f91 4375 if (err < 0)
1da177e4
LT		 4376 goto error;
4377
4378 codec->patch_ops = generic_patch_ops;
1da177e4
LT		 4379 return 0;
4380
352f7f91 4381error:
fce52a3b 4382 snd_hda_gen_free(codec);
1da177e4
LT		 4383 return err;
4384}
fce52a3b 4385EXPORT_SYMBOL_HDA(snd_hda_parse_generic_codec);
Linux 6.x block layer and io_uring tree(s)