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