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