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