blob: 11436c1159535aa4e47d21c073b32cf44bee3822 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
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
Linus Torvalds1da177e2005-04-16 15:20:36 -070023#include <linux/init.h>
24#include <linux/slab.h>
Paul Gortmakerd81a6d72011-09-22 09:34:58 -040025#include <linux/export.h>
Takashi Iwai352f7f92012-12-19 12:52:06 +010026#include <linux/sort.h>
Takashi Iwaif873e532012-12-20 16:58:39 +010027#include <linux/ctype.h>
28#include <linux/string.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070029#include <sound/core.h>
Takashi Iwai352f7f92012-12-19 12:52:06 +010030#include <sound/jack.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070031#include "hda_codec.h"
32#include "hda_local.h"
Takashi Iwai352f7f92012-12-19 12:52:06 +010033#include "hda_auto_parser.h"
34#include "hda_jack.h"
35#include "hda_generic.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070036
Linus Torvalds1da177e2005-04-16 15:20:36 -070037
Takashi Iwai352f7f92012-12-19 12:52:06 +010038/* initialize hda_gen_spec struct */
39int snd_hda_gen_spec_init(struct hda_gen_spec *spec)
Linus Torvalds1da177e2005-04-16 15:20:36 -070040{
Takashi Iwai352f7f92012-12-19 12:52:06 +010041 snd_array_init(&spec->kctls, sizeof(struct snd_kcontrol_new), 32);
Takashi Iwai352f7f92012-12-19 12:52:06 +010042 snd_array_init(&spec->paths, sizeof(struct nid_path), 8);
Takashi Iwai38cf6f12012-12-21 14:09:42 +010043 mutex_init(&spec->pcm_mutex);
Takashi Iwai352f7f92012-12-19 12:52:06 +010044 return 0;
45}
46EXPORT_SYMBOL_HDA(snd_hda_gen_spec_init);
Linus Torvalds1da177e2005-04-16 15:20:36 -070047
Takashi Iwai12c93df2012-12-19 14:38:33 +010048struct snd_kcontrol_new *
49snd_hda_gen_add_kctl(struct hda_gen_spec *spec, const char *name,
50 const struct snd_kcontrol_new *temp)
Takashi Iwai352f7f92012-12-19 12:52:06 +010051{
52 struct snd_kcontrol_new *knew = snd_array_new(&spec->kctls);
53 if (!knew)
54 return NULL;
55 *knew = *temp;
56 if (name)
57 knew->name = kstrdup(name, GFP_KERNEL);
58 else if (knew->name)
59 knew->name = kstrdup(knew->name, GFP_KERNEL);
60 if (!knew->name)
61 return NULL;
62 return knew;
63}
Takashi Iwai12c93df2012-12-19 14:38:33 +010064EXPORT_SYMBOL_HDA(snd_hda_gen_add_kctl);
Takashi Iwai352f7f92012-12-19 12:52:06 +010065
66static void free_kctls(struct hda_gen_spec *spec)
67{
68 if (spec->kctls.list) {
69 struct snd_kcontrol_new *kctl = spec->kctls.list;
70 int i;
71 for (i = 0; i < spec->kctls.used; i++)
72 kfree(kctl[i].name);
73 }
74 snd_array_free(&spec->kctls);
75}
76
Takashi Iwai352f7f92012-12-19 12:52:06 +010077void snd_hda_gen_spec_free(struct hda_gen_spec *spec)
78{
79 if (!spec)
Linus Torvalds1da177e2005-04-16 15:20:36 -070080 return;
Takashi Iwai352f7f92012-12-19 12:52:06 +010081 free_kctls(spec);
Takashi Iwai352f7f92012-12-19 12:52:06 +010082 snd_array_free(&spec->paths);
Linus Torvalds1da177e2005-04-16 15:20:36 -070083}
Takashi Iwai352f7f92012-12-19 12:52:06 +010084EXPORT_SYMBOL_HDA(snd_hda_gen_spec_free);
Linus Torvalds1da177e2005-04-16 15:20:36 -070085
86/*
Takashi Iwai352f7f92012-12-19 12:52:06 +010087 * parsing paths
Linus Torvalds1da177e2005-04-16 15:20:36 -070088 */
Linus Torvalds1da177e2005-04-16 15:20:36 -070089
Takashi Iwaif5172a72013-01-04 13:19:55 +010090static struct nid_path *get_nid_path(struct hda_codec *codec,
91 hda_nid_t from_nid, hda_nid_t to_nid,
92 int with_aa_mix)
Linus Torvalds1da177e2005-04-16 15:20:36 -070093{
Takashi Iwai352f7f92012-12-19 12:52:06 +010094 struct hda_gen_spec *spec = codec->spec;
95 int i;
Linus Torvalds1da177e2005-04-16 15:20:36 -070096
Takashi Iwai352f7f92012-12-19 12:52:06 +010097 for (i = 0; i < spec->paths.used; i++) {
98 struct nid_path *path = snd_array_elem(&spec->paths, i);
99 if (path->depth <= 0)
100 continue;
101 if ((!from_nid || path->path[0] == from_nid) &&
Takashi Iwaif5172a72013-01-04 13:19:55 +0100102 (!to_nid || path->path[path->depth - 1] == to_nid)) {
103 if (with_aa_mix == HDA_PARSE_ALL ||
104 path->with_aa_mix == with_aa_mix)
105 return path;
106 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700107 }
108 return NULL;
109}
Takashi Iwaif5172a72013-01-04 13:19:55 +0100110
111/* get the path between the given NIDs;
112 * passing 0 to either @pin or @dac behaves as a wildcard
113 */
114struct nid_path *snd_hda_get_nid_path(struct hda_codec *codec,
115 hda_nid_t from_nid, hda_nid_t to_nid)
116{
117 return get_nid_path(codec, from_nid, to_nid, HDA_PARSE_ALL);
118}
Takashi Iwai352f7f92012-12-19 12:52:06 +0100119EXPORT_SYMBOL_HDA(snd_hda_get_nid_path);
120
Takashi Iwai196c17662013-01-04 15:01:40 +0100121/* get the index number corresponding to the path instance;
122 * the index starts from 1, for easier checking the invalid value
123 */
124int snd_hda_get_path_idx(struct hda_codec *codec, struct nid_path *path)
125{
126 struct hda_gen_spec *spec = codec->spec;
127 struct nid_path *array = spec->paths.list;
128 ssize_t idx;
129
130 if (!spec->paths.used)
131 return 0;
132 idx = path - array;
133 if (idx < 0 || idx >= spec->paths.used)
134 return 0;
135 return idx + 1;
136}
137
138/* get the path instance corresponding to the given index number */
139struct nid_path *snd_hda_get_path_from_idx(struct hda_codec *codec, int idx)
140{
141 struct hda_gen_spec *spec = codec->spec;
142
143 if (idx <= 0 || idx > spec->paths.used)
144 return NULL;
145 return snd_array_elem(&spec->paths, idx - 1);
146}
147
Takashi Iwai352f7f92012-12-19 12:52:06 +0100148/* check whether the given DAC is already found in any existing paths */
149static bool is_dac_already_used(struct hda_codec *codec, hda_nid_t nid)
150{
151 struct hda_gen_spec *spec = codec->spec;
152 int i;
153
154 for (i = 0; i < spec->paths.used; i++) {
155 struct nid_path *path = snd_array_elem(&spec->paths, i);
156 if (path->path[0] == nid)
157 return true;
158 }
159 return false;
160}
161
162/* check whether the given two widgets can be connected */
163static bool is_reachable_path(struct hda_codec *codec,
164 hda_nid_t from_nid, hda_nid_t to_nid)
165{
166 if (!from_nid || !to_nid)
167 return false;
168 return snd_hda_get_conn_index(codec, to_nid, from_nid, true) >= 0;
169}
170
171/* nid, dir and idx */
172#define AMP_VAL_COMPARE_MASK (0xffff | (1U << 18) | (0x0f << 19))
173
174/* check whether the given ctl is already assigned in any path elements */
175static bool is_ctl_used(struct hda_codec *codec, unsigned int val, int type)
176{
177 struct hda_gen_spec *spec = codec->spec;
178 int i;
179
180 val &= AMP_VAL_COMPARE_MASK;
181 for (i = 0; i < spec->paths.used; i++) {
182 struct nid_path *path = snd_array_elem(&spec->paths, i);
183 if ((path->ctls[type] & AMP_VAL_COMPARE_MASK) == val)
184 return true;
185 }
186 return false;
187}
188
189/* check whether a control with the given (nid, dir, idx) was assigned */
190static bool is_ctl_associated(struct hda_codec *codec, hda_nid_t nid,
191 int dir, int idx)
192{
193 unsigned int val = HDA_COMPOSE_AMP_VAL(nid, 3, idx, dir);
194 return is_ctl_used(codec, val, NID_PATH_VOL_CTL) ||
195 is_ctl_used(codec, val, NID_PATH_MUTE_CTL);
196}
197
Takashi Iwai0c8c0f52012-12-20 17:54:22 +0100198static void print_nid_path(const char *pfx, struct nid_path *path)
199{
200 char buf[40];
201 int i;
202
203
204 buf[0] = 0;
205 for (i = 0; i < path->depth; i++) {
206 char tmp[4];
207 sprintf(tmp, ":%02x", path->path[i]);
208 strlcat(buf, tmp, sizeof(buf));
209 }
210 snd_printdd("%s path: depth=%d %s\n", pfx, path->depth, buf);
211}
212
Takashi Iwai352f7f92012-12-19 12:52:06 +0100213/* called recursively */
214static bool __parse_nid_path(struct hda_codec *codec,
215 hda_nid_t from_nid, hda_nid_t to_nid,
216 int with_aa_mix, struct nid_path *path, int depth)
217{
218 struct hda_gen_spec *spec = codec->spec;
Takashi Iwaiee8e7652013-01-03 15:25:11 +0100219 const hda_nid_t *conn;
Takashi Iwai352f7f92012-12-19 12:52:06 +0100220 int i, nums;
221
222 if (to_nid == spec->mixer_nid) {
Takashi Iwai4ac0eef2012-12-20 18:10:51 +0100223 if (with_aa_mix == HDA_PARSE_NO_AAMIX)
Takashi Iwai352f7f92012-12-19 12:52:06 +0100224 return false;
Takashi Iwai4ac0eef2012-12-20 18:10:51 +0100225 with_aa_mix = HDA_PARSE_ALL; /* mark aa-mix is included */
Takashi Iwai352f7f92012-12-19 12:52:06 +0100226 }
227
Takashi Iwaiee8e7652013-01-03 15:25:11 +0100228 nums = snd_hda_get_conn_list(codec, to_nid, &conn);
Takashi Iwai352f7f92012-12-19 12:52:06 +0100229 for (i = 0; i < nums; i++) {
230 if (conn[i] != from_nid) {
231 /* special case: when from_nid is 0,
232 * try to find an empty DAC
233 */
234 if (from_nid ||
235 get_wcaps_type(get_wcaps(codec, conn[i])) != AC_WID_AUD_OUT ||
236 is_dac_already_used(codec, conn[i]))
237 continue;
238 }
239 /* aa-mix is requested but not included? */
Takashi Iwai4ac0eef2012-12-20 18:10:51 +0100240 if (!(spec->mixer_nid && with_aa_mix == HDA_PARSE_ONLY_AAMIX))
Takashi Iwai352f7f92012-12-19 12:52:06 +0100241 goto found;
242 }
243 if (depth >= MAX_NID_PATH_DEPTH)
244 return false;
245 for (i = 0; i < nums; i++) {
246 unsigned int type;
247 type = get_wcaps_type(get_wcaps(codec, conn[i]));
248 if (type == AC_WID_AUD_OUT || type == AC_WID_AUD_IN ||
249 type == AC_WID_PIN)
250 continue;
251 if (__parse_nid_path(codec, from_nid, conn[i],
252 with_aa_mix, path, depth + 1))
253 goto found;
254 }
255 return false;
256
257 found:
258 path->path[path->depth] = conn[i];
Takashi Iwaif5172a72013-01-04 13:19:55 +0100259 if (conn[i] == spec->mixer_nid)
260 path->with_aa_mix = true;
Takashi Iwai352f7f92012-12-19 12:52:06 +0100261 path->idx[path->depth + 1] = i;
262 if (nums > 1 && get_wcaps_type(get_wcaps(codec, to_nid)) != AC_WID_AUD_MIX)
263 path->multi[path->depth + 1] = 1;
264 path->depth++;
265 return true;
266}
267
268/* parse the widget path from the given nid to the target nid;
269 * when @from_nid is 0, try to find an empty DAC;
Takashi Iwai4ac0eef2012-12-20 18:10:51 +0100270 * when @with_aa_mix is HDA_PARSE_NO_AAMIX, paths with spec->mixer_nid are
271 * excluded, only the paths that don't go through the mixer will be chosen.
272 * when @with_aa_mix is HDA_PARSE_ONLY_AAMIX, only the paths going through
273 * spec->mixer_nid will be chosen.
274 * when @with_aa_mix is HDA_PARSE_ALL, no special handling about mixer widget.
Takashi Iwai352f7f92012-12-19 12:52:06 +0100275 */
276bool snd_hda_parse_nid_path(struct hda_codec *codec, hda_nid_t from_nid,
277 hda_nid_t to_nid, int with_aa_mix,
278 struct nid_path *path)
279{
280 if (__parse_nid_path(codec, from_nid, to_nid, with_aa_mix, path, 1)) {
281 path->path[path->depth] = to_nid;
282 path->depth++;
Takashi Iwai352f7f92012-12-19 12:52:06 +0100283 return true;
284 }
285 return false;
286}
287EXPORT_SYMBOL_HDA(snd_hda_parse_nid_path);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700288
289/*
Takashi Iwai352f7f92012-12-19 12:52:06 +0100290 * parse the path between the given NIDs and add to the path list.
291 * if no valid path is found, return NULL
Linus Torvalds1da177e2005-04-16 15:20:36 -0700292 */
Takashi Iwai352f7f92012-12-19 12:52:06 +0100293struct nid_path *
294snd_hda_add_new_path(struct hda_codec *codec, hda_nid_t from_nid,
295 hda_nid_t to_nid, int with_aa_mix)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700296{
Takashi Iwai352f7f92012-12-19 12:52:06 +0100297 struct hda_gen_spec *spec = codec->spec;
298 struct nid_path *path;
299
300 if (from_nid && to_nid && !is_reachable_path(codec, from_nid, to_nid))
301 return NULL;
302
Takashi Iwaif5172a72013-01-04 13:19:55 +0100303 /* check whether the path has been already added */
304 path = get_nid_path(codec, from_nid, to_nid, with_aa_mix);
305 if (path)
306 return path;
307
Takashi Iwai352f7f92012-12-19 12:52:06 +0100308 path = snd_array_new(&spec->paths);
309 if (!path)
310 return NULL;
311 memset(path, 0, sizeof(*path));
312 if (snd_hda_parse_nid_path(codec, from_nid, to_nid, with_aa_mix, path))
313 return path;
314 /* push back */
315 spec->paths.used--;
316 return NULL;
317}
318EXPORT_SYMBOL_HDA(snd_hda_add_new_path);
319
320/* look for an empty DAC slot */
321static hda_nid_t look_for_dac(struct hda_codec *codec, hda_nid_t pin,
322 bool is_digital)
323{
324 struct hda_gen_spec *spec = codec->spec;
325 bool cap_digital;
326 int i;
327
328 for (i = 0; i < spec->num_all_dacs; i++) {
329 hda_nid_t nid = spec->all_dacs[i];
330 if (!nid || is_dac_already_used(codec, nid))
331 continue;
332 cap_digital = !!(get_wcaps(codec, nid) & AC_WCAP_DIGITAL);
333 if (is_digital != cap_digital)
334 continue;
335 if (is_reachable_path(codec, nid, pin))
336 return nid;
337 }
338 return 0;
339}
340
341/* replace the channels in the composed amp value with the given number */
342static unsigned int amp_val_replace_channels(unsigned int val, unsigned int chs)
343{
344 val &= ~(0x3U << 16);
345 val |= chs << 16;
346 return val;
347}
348
349/* check whether the widget has the given amp capability for the direction */
350static bool check_amp_caps(struct hda_codec *codec, hda_nid_t nid,
351 int dir, unsigned int bits)
352{
353 if (!nid)
354 return false;
355 if (get_wcaps(codec, nid) & (1 << (dir + 1)))
356 if (query_amp_caps(codec, nid, dir) & bits)
357 return true;
358 return false;
359}
360
361#define nid_has_mute(codec, nid, dir) \
362 check_amp_caps(codec, nid, dir, AC_AMPCAP_MUTE)
363#define nid_has_volume(codec, nid, dir) \
364 check_amp_caps(codec, nid, dir, AC_AMPCAP_NUM_STEPS)
365
366/* look for a widget suitable for assigning a mute switch in the path */
367static hda_nid_t look_for_out_mute_nid(struct hda_codec *codec,
368 struct nid_path *path)
369{
370 int i;
371
372 for (i = path->depth - 1; i >= 0; i--) {
373 if (nid_has_mute(codec, path->path[i], HDA_OUTPUT))
374 return path->path[i];
375 if (i != path->depth - 1 && i != 0 &&
376 nid_has_mute(codec, path->path[i], HDA_INPUT))
377 return path->path[i];
378 }
379 return 0;
380}
381
382/* look for a widget suitable for assigning a volume ctl in the path */
383static hda_nid_t look_for_out_vol_nid(struct hda_codec *codec,
384 struct nid_path *path)
385{
386 int i;
387
388 for (i = path->depth - 1; i >= 0; i--) {
389 if (nid_has_volume(codec, path->path[i], HDA_OUTPUT))
390 return path->path[i];
391 }
Takashi Iwai82beb8f2007-08-10 17:09:26 +0200392 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700393}
394
395/*
Takashi Iwai352f7f92012-12-19 12:52:06 +0100396 * path activation / deactivation
Linus Torvalds1da177e2005-04-16 15:20:36 -0700397 */
Takashi Iwai352f7f92012-12-19 12:52:06 +0100398
399/* can have the amp-in capability? */
400static bool has_amp_in(struct hda_codec *codec, struct nid_path *path, int idx)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700401{
Takashi Iwai352f7f92012-12-19 12:52:06 +0100402 hda_nid_t nid = path->path[idx];
403 unsigned int caps = get_wcaps(codec, nid);
404 unsigned int type = get_wcaps_type(caps);
405
406 if (!(caps & AC_WCAP_IN_AMP))
407 return false;
408 if (type == AC_WID_PIN && idx > 0) /* only for input pins */
409 return false;
410 return true;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700411}
412
Takashi Iwai352f7f92012-12-19 12:52:06 +0100413/* can have the amp-out capability? */
414static bool has_amp_out(struct hda_codec *codec, struct nid_path *path, int idx)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700415{
Takashi Iwai352f7f92012-12-19 12:52:06 +0100416 hda_nid_t nid = path->path[idx];
417 unsigned int caps = get_wcaps(codec, nid);
418 unsigned int type = get_wcaps_type(caps);
419
420 if (!(caps & AC_WCAP_OUT_AMP))
421 return false;
422 if (type == AC_WID_PIN && !idx) /* only for output pins */
423 return false;
424 return true;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700425}
426
Takashi Iwai352f7f92012-12-19 12:52:06 +0100427/* check whether the given (nid,dir,idx) is active */
428static bool is_active_nid(struct hda_codec *codec, hda_nid_t nid,
429 unsigned int idx, unsigned int dir)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700430{
Takashi Iwai352f7f92012-12-19 12:52:06 +0100431 struct hda_gen_spec *spec = codec->spec;
432 int i, n;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700433
Takashi Iwai352f7f92012-12-19 12:52:06 +0100434 for (n = 0; n < spec->paths.used; n++) {
435 struct nid_path *path = snd_array_elem(&spec->paths, n);
436 if (!path->active)
437 continue;
438 for (i = 0; i < path->depth; i++) {
439 if (path->path[i] == nid) {
440 if (dir == HDA_OUTPUT || path->idx[i] == idx)
441 return true;
442 break;
443 }
444 }
445 }
446 return false;
447}
448
449/* get the default amp value for the target state */
450static int get_amp_val_to_activate(struct hda_codec *codec, hda_nid_t nid,
451 int dir, bool enable)
452{
453 unsigned int caps;
454 unsigned int val = 0;
455
456 caps = query_amp_caps(codec, nid, dir);
457 if (caps & AC_AMPCAP_NUM_STEPS) {
458 /* set to 0dB */
459 if (enable)
460 val = (caps & AC_AMPCAP_OFFSET) >> AC_AMPCAP_OFFSET_SHIFT;
461 }
462 if (caps & AC_AMPCAP_MUTE) {
463 if (!enable)
464 val |= HDA_AMP_MUTE;
465 }
466 return val;
467}
468
469/* initialize the amp value (only at the first time) */
470static void init_amp(struct hda_codec *codec, hda_nid_t nid, int dir, int idx)
471{
472 int val = get_amp_val_to_activate(codec, nid, dir, false);
473 snd_hda_codec_amp_init_stereo(codec, nid, dir, idx, 0xff, val);
474}
475
476static void activate_amp(struct hda_codec *codec, hda_nid_t nid, int dir,
477 int idx, bool enable)
478{
479 int val;
480 if (is_ctl_associated(codec, nid, dir, idx) ||
Takashi Iwai985803c2013-01-03 16:30:04 +0100481 (!enable && is_active_nid(codec, nid, dir, idx)))
Takashi Iwai352f7f92012-12-19 12:52:06 +0100482 return;
483 val = get_amp_val_to_activate(codec, nid, dir, enable);
484 snd_hda_codec_amp_stereo(codec, nid, dir, idx, 0xff, val);
485}
486
487static void activate_amp_out(struct hda_codec *codec, struct nid_path *path,
488 int i, bool enable)
489{
490 hda_nid_t nid = path->path[i];
491 init_amp(codec, nid, HDA_OUTPUT, 0);
492 activate_amp(codec, nid, HDA_OUTPUT, 0, enable);
493}
494
495static void activate_amp_in(struct hda_codec *codec, struct nid_path *path,
496 int i, bool enable, bool add_aamix)
497{
498 struct hda_gen_spec *spec = codec->spec;
Takashi Iwaiee8e7652013-01-03 15:25:11 +0100499 const hda_nid_t *conn;
Takashi Iwai352f7f92012-12-19 12:52:06 +0100500 int n, nums, idx;
501 int type;
502 hda_nid_t nid = path->path[i];
503
Takashi Iwaiee8e7652013-01-03 15:25:11 +0100504 nums = snd_hda_get_conn_list(codec, nid, &conn);
Takashi Iwai352f7f92012-12-19 12:52:06 +0100505 type = get_wcaps_type(get_wcaps(codec, nid));
506 if (type == AC_WID_PIN ||
507 (type == AC_WID_AUD_IN && codec->single_adc_amp)) {
508 nums = 1;
509 idx = 0;
510 } else
511 idx = path->idx[i];
512
513 for (n = 0; n < nums; n++)
514 init_amp(codec, nid, HDA_INPUT, n);
515
516 if (is_ctl_associated(codec, nid, HDA_INPUT, idx))
517 return;
518
519 /* here is a little bit tricky in comparison with activate_amp_out();
520 * when aa-mixer is available, we need to enable the path as well
521 */
522 for (n = 0; n < nums; n++) {
523 if (n != idx && (!add_aamix || conn[n] != spec->mixer_nid))
524 continue;
525 activate_amp(codec, nid, HDA_INPUT, n, enable);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700526 }
527}
528
Takashi Iwai352f7f92012-12-19 12:52:06 +0100529/* activate or deactivate the given path
530 * if @add_aamix is set, enable the input from aa-mix NID as well (if any)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700531 */
Takashi Iwai352f7f92012-12-19 12:52:06 +0100532void snd_hda_activate_path(struct hda_codec *codec, struct nid_path *path,
533 bool enable, bool add_aamix)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700534{
Takashi Iwai352f7f92012-12-19 12:52:06 +0100535 int i;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700536
Takashi Iwai352f7f92012-12-19 12:52:06 +0100537 if (!enable)
538 path->active = false;
539
540 for (i = path->depth - 1; i >= 0; i--) {
541 if (enable && path->multi[i])
542 snd_hda_codec_write_cache(codec, path->path[i], 0,
543 AC_VERB_SET_CONNECT_SEL,
544 path->idx[i]);
545 if (has_amp_in(codec, path, i))
546 activate_amp_in(codec, path, i, enable, add_aamix);
547 if (has_amp_out(codec, path, i))
548 activate_amp_out(codec, path, i, enable);
549 }
550
551 if (enable)
552 path->active = true;
553}
554EXPORT_SYMBOL_HDA(snd_hda_activate_path);
555
Takashi Iwaid5a9f1b2012-12-20 15:36:30 +0100556/* turn on/off EAPD on the given pin */
557static void set_pin_eapd(struct hda_codec *codec, hda_nid_t pin, bool enable)
558{
559 struct hda_gen_spec *spec = codec->spec;
560 if (spec->own_eapd_ctl ||
561 !(snd_hda_query_pin_caps(codec, pin) & AC_PINCAP_EAPD))
562 return;
Takashi Iwaiecac3ed2012-12-21 15:23:01 +0100563 if (codec->inv_eapd)
564 enable = !enable;
Takashi Iwaid5a9f1b2012-12-20 15:36:30 +0100565 snd_hda_codec_update_cache(codec, pin, 0,
566 AC_VERB_SET_EAPD_BTLENABLE,
567 enable ? 0x02 : 0x00);
568}
569
Takashi Iwai352f7f92012-12-19 12:52:06 +0100570
571/*
572 * Helper functions for creating mixer ctl elements
573 */
574
575enum {
576 HDA_CTL_WIDGET_VOL,
577 HDA_CTL_WIDGET_MUTE,
578 HDA_CTL_BIND_MUTE,
Takashi Iwai352f7f92012-12-19 12:52:06 +0100579};
580static const struct snd_kcontrol_new control_templates[] = {
581 HDA_CODEC_VOLUME(NULL, 0, 0, 0),
582 HDA_CODEC_MUTE(NULL, 0, 0, 0),
583 HDA_BIND_MUTE(NULL, 0, 0, 0),
Takashi Iwai352f7f92012-12-19 12:52:06 +0100584};
585
586/* add dynamic controls from template */
587static int add_control(struct hda_gen_spec *spec, int type, const char *name,
588 int cidx, unsigned long val)
589{
590 struct snd_kcontrol_new *knew;
591
Takashi Iwai12c93df2012-12-19 14:38:33 +0100592 knew = snd_hda_gen_add_kctl(spec, name, &control_templates[type]);
Takashi Iwai352f7f92012-12-19 12:52:06 +0100593 if (!knew)
594 return -ENOMEM;
595 knew->index = cidx;
596 if (get_amp_nid_(val))
597 knew->subdevice = HDA_SUBDEV_AMP_FLAG;
598 knew->private_value = val;
599 return 0;
600}
601
602static int add_control_with_pfx(struct hda_gen_spec *spec, int type,
603 const char *pfx, const char *dir,
604 const char *sfx, int cidx, unsigned long val)
605{
606 char name[32];
607 snprintf(name, sizeof(name), "%s %s %s", pfx, dir, sfx);
608 return add_control(spec, type, name, cidx, val);
609}
610
611#define add_pb_vol_ctrl(spec, type, pfx, val) \
612 add_control_with_pfx(spec, type, pfx, "Playback", "Volume", 0, val)
613#define add_pb_sw_ctrl(spec, type, pfx, val) \
614 add_control_with_pfx(spec, type, pfx, "Playback", "Switch", 0, val)
615#define __add_pb_vol_ctrl(spec, type, pfx, cidx, val) \
616 add_control_with_pfx(spec, type, pfx, "Playback", "Volume", cidx, val)
617#define __add_pb_sw_ctrl(spec, type, pfx, cidx, val) \
618 add_control_with_pfx(spec, type, pfx, "Playback", "Switch", cidx, val)
619
620static int add_vol_ctl(struct hda_codec *codec, const char *pfx, int cidx,
621 unsigned int chs, struct nid_path *path)
622{
623 unsigned int val;
624 if (!path)
625 return 0;
626 val = path->ctls[NID_PATH_VOL_CTL];
627 if (!val)
628 return 0;
629 val = amp_val_replace_channels(val, chs);
630 return __add_pb_vol_ctrl(codec->spec, HDA_CTL_WIDGET_VOL, pfx, cidx, val);
631}
632
633/* return the channel bits suitable for the given path->ctls[] */
634static int get_default_ch_nums(struct hda_codec *codec, struct nid_path *path,
635 int type)
636{
637 int chs = 1; /* mono (left only) */
638 if (path) {
639 hda_nid_t nid = get_amp_nid_(path->ctls[type]);
640 if (nid && (get_wcaps(codec, nid) & AC_WCAP_STEREO))
641 chs = 3; /* stereo */
642 }
643 return chs;
644}
645
646static int add_stereo_vol(struct hda_codec *codec, const char *pfx, int cidx,
647 struct nid_path *path)
648{
649 int chs = get_default_ch_nums(codec, path, NID_PATH_VOL_CTL);
650 return add_vol_ctl(codec, pfx, cidx, chs, path);
651}
652
653/* create a mute-switch for the given mixer widget;
654 * if it has multiple sources (e.g. DAC and loopback), create a bind-mute
655 */
656static int add_sw_ctl(struct hda_codec *codec, const char *pfx, int cidx,
657 unsigned int chs, struct nid_path *path)
658{
659 unsigned int val;
660 int type = HDA_CTL_WIDGET_MUTE;
661
662 if (!path)
663 return 0;
664 val = path->ctls[NID_PATH_MUTE_CTL];
665 if (!val)
666 return 0;
667 val = amp_val_replace_channels(val, chs);
668 if (get_amp_direction_(val) == HDA_INPUT) {
669 hda_nid_t nid = get_amp_nid_(val);
670 int nums = snd_hda_get_num_conns(codec, nid);
671 if (nums > 1) {
672 type = HDA_CTL_BIND_MUTE;
673 val |= nums << 19;
674 }
675 }
676 return __add_pb_sw_ctrl(codec->spec, type, pfx, cidx, val);
677}
678
679static int add_stereo_sw(struct hda_codec *codec, const char *pfx,
680 int cidx, struct nid_path *path)
681{
682 int chs = get_default_ch_nums(codec, path, NID_PATH_MUTE_CTL);
683 return add_sw_ctl(codec, pfx, cidx, chs, path);
684}
685
686static const char * const channel_name[4] = {
687 "Front", "Surround", "CLFE", "Side"
688};
689
690/* give some appropriate ctl name prefix for the given line out channel */
691static const char *get_line_out_pfx(struct hda_gen_spec *spec, int ch,
692 bool can_be_master, int *index)
693{
694 struct auto_pin_cfg *cfg = &spec->autocfg;
695
696 *index = 0;
697 if (cfg->line_outs == 1 && !spec->multi_ios &&
698 !cfg->hp_outs && !cfg->speaker_outs && can_be_master)
699 return spec->vmaster_mute.hook ? "PCM" : "Master";
700
701 /* if there is really a single DAC used in the whole output paths,
702 * use it master (or "PCM" if a vmaster hook is present)
703 */
704 if (spec->multiout.num_dacs == 1 && !spec->mixer_nid &&
705 !spec->multiout.hp_out_nid[0] && !spec->multiout.extra_out_nid[0])
706 return spec->vmaster_mute.hook ? "PCM" : "Master";
707
708 switch (cfg->line_out_type) {
709 case AUTO_PIN_SPEAKER_OUT:
710 if (cfg->line_outs == 1)
711 return "Speaker";
712 if (cfg->line_outs == 2)
713 return ch ? "Bass Speaker" : "Speaker";
714 break;
715 case AUTO_PIN_HP_OUT:
716 /* for multi-io case, only the primary out */
717 if (ch && spec->multi_ios)
718 break;
719 *index = ch;
720 return "Headphone";
721 default:
722 if (cfg->line_outs == 1 && !spec->multi_ios)
723 return "PCM";
724 break;
725 }
726 if (ch >= ARRAY_SIZE(channel_name)) {
727 snd_BUG();
728 return "PCM";
729 }
730
731 return channel_name[ch];
732}
733
734/*
735 * Parse output paths
736 */
737
738/* badness definition */
739enum {
740 /* No primary DAC is found for the main output */
741 BAD_NO_PRIMARY_DAC = 0x10000,
742 /* No DAC is found for the extra output */
743 BAD_NO_DAC = 0x4000,
744 /* No possible multi-ios */
745 BAD_MULTI_IO = 0x103,
746 /* No individual DAC for extra output */
747 BAD_NO_EXTRA_DAC = 0x102,
748 /* No individual DAC for extra surrounds */
749 BAD_NO_EXTRA_SURR_DAC = 0x101,
750 /* Primary DAC shared with main surrounds */
751 BAD_SHARED_SURROUND = 0x100,
752 /* Primary DAC shared with main CLFE */
753 BAD_SHARED_CLFE = 0x10,
754 /* Primary DAC shared with extra surrounds */
755 BAD_SHARED_EXTRA_SURROUND = 0x10,
756 /* Volume widget is shared */
757 BAD_SHARED_VOL = 0x10,
758};
759
760/* look for widgets in the path between the given NIDs appropriate for
761 * volume and mute controls, and assign the values to ctls[].
762 *
763 * When no appropriate widget is found in the path, the badness value
764 * is incremented depending on the situation. The function returns the
765 * total badness for both volume and mute controls.
766 */
767static int assign_out_path_ctls(struct hda_codec *codec, hda_nid_t pin,
768 hda_nid_t dac)
769{
770 struct nid_path *path = snd_hda_get_nid_path(codec, dac, pin);
771 hda_nid_t nid;
772 unsigned int val;
773 int badness = 0;
774
775 if (!path)
776 return BAD_SHARED_VOL * 2;
777 nid = look_for_out_vol_nid(codec, path);
778 if (nid) {
779 val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
780 if (is_ctl_used(codec, val, NID_PATH_VOL_CTL))
781 badness += BAD_SHARED_VOL;
782 else
783 path->ctls[NID_PATH_VOL_CTL] = val;
784 } else
785 badness += BAD_SHARED_VOL;
786 nid = look_for_out_mute_nid(codec, path);
787 if (nid) {
788 unsigned int wid_type = get_wcaps_type(get_wcaps(codec, nid));
789 if (wid_type == AC_WID_PIN || wid_type == AC_WID_AUD_OUT ||
790 nid_has_mute(codec, nid, HDA_OUTPUT))
791 val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
792 else
793 val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT);
794 if (is_ctl_used(codec, val, NID_PATH_MUTE_CTL))
795 badness += BAD_SHARED_VOL;
796 else
797 path->ctls[NID_PATH_MUTE_CTL] = val;
798 } else
799 badness += BAD_SHARED_VOL;
800 return badness;
801}
802
803struct badness_table {
804 int no_primary_dac; /* no primary DAC */
805 int no_dac; /* no secondary DACs */
806 int shared_primary; /* primary DAC is shared with main output */
807 int shared_surr; /* secondary DAC shared with main or primary */
808 int shared_clfe; /* third DAC shared with main or primary */
809 int shared_surr_main; /* secondary DAC sahred with main/DAC0 */
810};
811
812static struct badness_table main_out_badness = {
813 .no_primary_dac = BAD_NO_PRIMARY_DAC,
814 .no_dac = BAD_NO_DAC,
815 .shared_primary = BAD_NO_PRIMARY_DAC,
816 .shared_surr = BAD_SHARED_SURROUND,
817 .shared_clfe = BAD_SHARED_CLFE,
818 .shared_surr_main = BAD_SHARED_SURROUND,
819};
820
821static struct badness_table extra_out_badness = {
822 .no_primary_dac = BAD_NO_DAC,
823 .no_dac = BAD_NO_DAC,
824 .shared_primary = BAD_NO_EXTRA_DAC,
825 .shared_surr = BAD_SHARED_EXTRA_SURROUND,
826 .shared_clfe = BAD_SHARED_EXTRA_SURROUND,
827 .shared_surr_main = BAD_NO_EXTRA_SURR_DAC,
828};
829
Takashi Iwai7385df62013-01-07 09:50:52 +0100830/* get the DAC of the primary output corresponding to the given array index */
831static hda_nid_t get_primary_out(struct hda_codec *codec, int idx)
832{
833 struct hda_gen_spec *spec = codec->spec;
834 struct auto_pin_cfg *cfg = &spec->autocfg;
835
836 if (cfg->line_outs > idx)
837 return spec->private_dac_nids[idx];
838 idx -= cfg->line_outs;
839 if (spec->multi_ios > idx)
840 return spec->multi_io[idx].dac;
841 return 0;
842}
843
844/* return the DAC if it's reachable, otherwise zero */
845static inline hda_nid_t try_dac(struct hda_codec *codec,
846 hda_nid_t dac, hda_nid_t pin)
847{
848 return is_reachable_path(codec, dac, pin) ? dac : 0;
849}
850
Takashi Iwai352f7f92012-12-19 12:52:06 +0100851/* try to assign DACs to pins and return the resultant badness */
852static int try_assign_dacs(struct hda_codec *codec, int num_outs,
853 const hda_nid_t *pins, hda_nid_t *dacs,
Takashi Iwai196c17662013-01-04 15:01:40 +0100854 int *path_idx,
Takashi Iwai352f7f92012-12-19 12:52:06 +0100855 const struct badness_table *bad)
856{
857 struct hda_gen_spec *spec = codec->spec;
Takashi Iwai352f7f92012-12-19 12:52:06 +0100858 int i, j;
859 int badness = 0;
860 hda_nid_t dac;
861
862 if (!num_outs)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700863 return 0;
864
Takashi Iwai352f7f92012-12-19 12:52:06 +0100865 for (i = 0; i < num_outs; i++) {
Takashi Iwai0c8c0f52012-12-20 17:54:22 +0100866 struct nid_path *path;
Takashi Iwai352f7f92012-12-19 12:52:06 +0100867 hda_nid_t pin = pins[i];
Takashi Iwai1e0b5282013-01-04 12:56:52 +0100868
869 if (dacs[i]) {
870 badness += assign_out_path_ctls(codec, pin, dacs[i]);
871 continue;
872 }
873
874 dacs[i] = look_for_dac(codec, pin, false);
Takashi Iwai352f7f92012-12-19 12:52:06 +0100875 if (!dacs[i] && !i) {
876 for (j = 1; j < num_outs; j++) {
877 if (is_reachable_path(codec, dacs[j], pin)) {
878 dacs[0] = dacs[j];
879 dacs[j] = 0;
Takashi Iwai196c17662013-01-04 15:01:40 +0100880 path_idx[j] = 0;
Takashi Iwai352f7f92012-12-19 12:52:06 +0100881 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700882 }
883 }
Takashi Iwai352f7f92012-12-19 12:52:06 +0100884 }
885 dac = dacs[i];
886 if (!dac) {
Takashi Iwai7385df62013-01-07 09:50:52 +0100887 if (num_outs > 2)
888 dac = try_dac(codec, get_primary_out(codec, i), pin);
889 if (!dac)
890 dac = try_dac(codec, dacs[0], pin);
891 if (!dac)
892 dac = try_dac(codec, get_primary_out(codec, i), pin);
Takashi Iwai352f7f92012-12-19 12:52:06 +0100893 if (dac) {
894 if (!i)
895 badness += bad->shared_primary;
896 else if (i == 1)
897 badness += bad->shared_surr;
898 else
899 badness += bad->shared_clfe;
900 } else if (is_reachable_path(codec, spec->private_dac_nids[0], pin)) {
901 dac = spec->private_dac_nids[0];
902 badness += bad->shared_surr_main;
903 } else if (!i)
904 badness += bad->no_primary_dac;
905 else
906 badness += bad->no_dac;
907 }
Takashi Iwai4ac0eef2012-12-20 18:10:51 +0100908 path = snd_hda_add_new_path(codec, dac, pin, HDA_PARSE_NO_AAMIX);
Takashi Iwai117688a2013-01-04 15:41:41 +0100909 if (!path && !i && spec->mixer_nid) {
Takashi Iwaib3a8c742012-12-20 18:29:16 +0100910 /* try with aamix */
911 path = snd_hda_add_new_path(codec, dac, pin, HDA_PARSE_ALL);
912 }
Takashi Iwai0c8c0f52012-12-20 17:54:22 +0100913 if (!path)
Takashi Iwai352f7f92012-12-19 12:52:06 +0100914 dac = dacs[i] = 0;
Takashi Iwaie1284af2013-01-03 16:33:02 +0100915 else {
Takashi Iwai0c8c0f52012-12-20 17:54:22 +0100916 print_nid_path("output", path);
Takashi Iwaie1284af2013-01-03 16:33:02 +0100917 path->active = true;
Takashi Iwai196c17662013-01-04 15:01:40 +0100918 path_idx[i] = snd_hda_get_path_idx(codec, path);
Takashi Iwaie1284af2013-01-03 16:33:02 +0100919 }
Takashi Iwai352f7f92012-12-19 12:52:06 +0100920 if (dac)
921 badness += assign_out_path_ctls(codec, pin, dac);
922 }
923
924 return badness;
925}
926
927/* return NID if the given pin has only a single connection to a certain DAC */
928static hda_nid_t get_dac_if_single(struct hda_codec *codec, hda_nid_t pin)
929{
930 struct hda_gen_spec *spec = codec->spec;
931 int i;
932 hda_nid_t nid_found = 0;
933
934 for (i = 0; i < spec->num_all_dacs; i++) {
935 hda_nid_t nid = spec->all_dacs[i];
936 if (!nid || is_dac_already_used(codec, nid))
937 continue;
938 if (is_reachable_path(codec, nid, pin)) {
939 if (nid_found)
940 return 0;
941 nid_found = nid;
942 }
943 }
944 return nid_found;
945}
946
947/* check whether the given pin can be a multi-io pin */
948static bool can_be_multiio_pin(struct hda_codec *codec,
949 unsigned int location, hda_nid_t nid)
950{
951 unsigned int defcfg, caps;
952
953 defcfg = snd_hda_codec_get_pincfg(codec, nid);
954 if (get_defcfg_connect(defcfg) != AC_JACK_PORT_COMPLEX)
955 return false;
956 if (location && get_defcfg_location(defcfg) != location)
957 return false;
958 caps = snd_hda_query_pin_caps(codec, nid);
959 if (!(caps & AC_PINCAP_OUT))
960 return false;
961 return true;
962}
963
Takashi Iwaie22aab72013-01-04 14:50:04 +0100964/* count the number of input pins that are capable to be multi-io */
965static int count_multiio_pins(struct hda_codec *codec, hda_nid_t reference_pin)
966{
967 struct hda_gen_spec *spec = codec->spec;
968 struct auto_pin_cfg *cfg = &spec->autocfg;
969 unsigned int defcfg = snd_hda_codec_get_pincfg(codec, reference_pin);
970 unsigned int location = get_defcfg_location(defcfg);
971 int type, i;
972 int num_pins = 0;
973
974 for (type = AUTO_PIN_LINE_IN; type >= AUTO_PIN_MIC; type--) {
975 for (i = 0; i < cfg->num_inputs; i++) {
976 if (cfg->inputs[i].type != type)
977 continue;
978 if (can_be_multiio_pin(codec, location,
979 cfg->inputs[i].pin))
980 num_pins++;
981 }
982 }
983 return num_pins;
984}
985
Takashi Iwai352f7f92012-12-19 12:52:06 +0100986/*
987 * multi-io helper
988 *
989 * When hardwired is set, try to fill ony hardwired pins, and returns
990 * zero if any pins are filled, non-zero if nothing found.
991 * When hardwired is off, try to fill possible input pins, and returns
992 * the badness value.
993 */
994static int fill_multi_ios(struct hda_codec *codec,
995 hda_nid_t reference_pin,
Takashi Iwaie22aab72013-01-04 14:50:04 +0100996 bool hardwired)
Takashi Iwai352f7f92012-12-19 12:52:06 +0100997{
998 struct hda_gen_spec *spec = codec->spec;
999 struct auto_pin_cfg *cfg = &spec->autocfg;
Takashi Iwaie22aab72013-01-04 14:50:04 +01001000 int type, i, j, num_pins, old_pins;
Takashi Iwai352f7f92012-12-19 12:52:06 +01001001 unsigned int defcfg = snd_hda_codec_get_pincfg(codec, reference_pin);
1002 unsigned int location = get_defcfg_location(defcfg);
1003 int badness = 0;
1004
1005 old_pins = spec->multi_ios;
1006 if (old_pins >= 2)
1007 goto end_fill;
1008
Takashi Iwaie22aab72013-01-04 14:50:04 +01001009 num_pins = count_multiio_pins(codec, reference_pin);
Takashi Iwai352f7f92012-12-19 12:52:06 +01001010 if (num_pins < 2)
1011 goto end_fill;
1012
Takashi Iwai352f7f92012-12-19 12:52:06 +01001013 for (type = AUTO_PIN_LINE_IN; type >= AUTO_PIN_MIC; type--) {
1014 for (i = 0; i < cfg->num_inputs; i++) {
Takashi Iwai0c8c0f52012-12-20 17:54:22 +01001015 struct nid_path *path;
Takashi Iwai352f7f92012-12-19 12:52:06 +01001016 hda_nid_t nid = cfg->inputs[i].pin;
1017 hda_nid_t dac = 0;
1018
1019 if (cfg->inputs[i].type != type)
1020 continue;
1021 if (!can_be_multiio_pin(codec, location, nid))
1022 continue;
1023 for (j = 0; j < spec->multi_ios; j++) {
1024 if (nid == spec->multi_io[j].pin)
1025 break;
1026 }
1027 if (j < spec->multi_ios)
1028 continue;
1029
Takashi Iwai352f7f92012-12-19 12:52:06 +01001030 if (hardwired)
1031 dac = get_dac_if_single(codec, nid);
1032 else if (!dac)
1033 dac = look_for_dac(codec, nid, false);
1034 if (!dac) {
1035 badness++;
1036 continue;
1037 }
Takashi Iwai4ac0eef2012-12-20 18:10:51 +01001038 path = snd_hda_add_new_path(codec, dac, nid, HDA_PARSE_NO_AAMIX);
Takashi Iwai0c8c0f52012-12-20 17:54:22 +01001039 if (!path) {
Takashi Iwai352f7f92012-12-19 12:52:06 +01001040 badness++;
1041 continue;
1042 }
Takashi Iwai0c8c0f52012-12-20 17:54:22 +01001043 print_nid_path("multiio", path);
Takashi Iwai352f7f92012-12-19 12:52:06 +01001044 spec->multi_io[spec->multi_ios].pin = nid;
1045 spec->multi_io[spec->multi_ios].dac = dac;
Takashi Iwai196c17662013-01-04 15:01:40 +01001046 spec->out_paths[cfg->line_outs + spec->multi_ios] =
1047 snd_hda_get_path_idx(codec, path);
Takashi Iwai352f7f92012-12-19 12:52:06 +01001048 spec->multi_ios++;
1049 if (spec->multi_ios >= 2)
1050 break;
1051 }
1052 }
1053 end_fill:
1054 if (badness)
1055 badness = BAD_MULTI_IO;
1056 if (old_pins == spec->multi_ios) {
1057 if (hardwired)
1058 return 1; /* nothing found */
1059 else
1060 return badness; /* no badness if nothing found */
1061 }
1062 if (!hardwired && spec->multi_ios < 2) {
1063 /* cancel newly assigned paths */
1064 spec->paths.used -= spec->multi_ios - old_pins;
1065 spec->multi_ios = old_pins;
1066 return badness;
1067 }
1068
1069 /* assign volume and mute controls */
1070 for (i = old_pins; i < spec->multi_ios; i++)
1071 badness += assign_out_path_ctls(codec, spec->multi_io[i].pin,
1072 spec->multi_io[i].dac);
1073
1074 return badness;
1075}
1076
1077/* map DACs for all pins in the list if they are single connections */
1078static bool map_singles(struct hda_codec *codec, int outs,
Takashi Iwai196c17662013-01-04 15:01:40 +01001079 const hda_nid_t *pins, hda_nid_t *dacs, int *path_idx)
Takashi Iwai352f7f92012-12-19 12:52:06 +01001080{
Takashi Iwaib3a8c742012-12-20 18:29:16 +01001081 struct hda_gen_spec *spec = codec->spec;
Takashi Iwai352f7f92012-12-19 12:52:06 +01001082 int i;
1083 bool found = false;
1084 for (i = 0; i < outs; i++) {
Takashi Iwai0c8c0f52012-12-20 17:54:22 +01001085 struct nid_path *path;
Takashi Iwai352f7f92012-12-19 12:52:06 +01001086 hda_nid_t dac;
1087 if (dacs[i])
1088 continue;
1089 dac = get_dac_if_single(codec, pins[i]);
1090 if (!dac)
1091 continue;
Takashi Iwai4ac0eef2012-12-20 18:10:51 +01001092 path = snd_hda_add_new_path(codec, dac, pins[i], HDA_PARSE_NO_AAMIX);
Takashi Iwai117688a2013-01-04 15:41:41 +01001093 if (!path && !i && spec->mixer_nid)
Takashi Iwaib3a8c742012-12-20 18:29:16 +01001094 path = snd_hda_add_new_path(codec, dac, pins[i], HDA_PARSE_ALL);
Takashi Iwai0c8c0f52012-12-20 17:54:22 +01001095 if (path) {
Takashi Iwai352f7f92012-12-19 12:52:06 +01001096 dacs[i] = dac;
1097 found = true;
Takashi Iwai0c8c0f52012-12-20 17:54:22 +01001098 print_nid_path("output", path);
Takashi Iwaie1284af2013-01-03 16:33:02 +01001099 path->active = true;
Takashi Iwai196c17662013-01-04 15:01:40 +01001100 path_idx[i] = snd_hda_get_path_idx(codec, path);
Takashi Iwai352f7f92012-12-19 12:52:06 +01001101 }
1102 }
1103 return found;
1104}
1105
Takashi Iwaic30aa7b2013-01-04 16:42:48 +01001106/* create a new path including aamix if available, and return its index */
1107static int check_aamix_out_path(struct hda_codec *codec, int path_idx)
1108{
1109 struct nid_path *path;
1110
1111 path = snd_hda_get_path_from_idx(codec, path_idx);
1112 if (!path || !path->depth || path->with_aa_mix)
1113 return 0;
1114 path = snd_hda_add_new_path(codec, path->path[0],
1115 path->path[path->depth - 1],
1116 HDA_PARSE_ONLY_AAMIX);
1117 if (!path)
1118 return 0;
1119 print_nid_path("output-aamix", path);
1120 path->active = false; /* unused as default */
1121 return snd_hda_get_path_idx(codec, path);
1122}
1123
Takashi Iwai352f7f92012-12-19 12:52:06 +01001124/* fill in the dac_nids table from the parsed pin configuration */
1125static int fill_and_eval_dacs(struct hda_codec *codec,
1126 bool fill_hardwired,
1127 bool fill_mio_first)
1128{
1129 struct hda_gen_spec *spec = codec->spec;
1130 struct auto_pin_cfg *cfg = &spec->autocfg;
1131 int i, err, badness;
1132
1133 /* set num_dacs once to full for look_for_dac() */
1134 spec->multiout.num_dacs = cfg->line_outs;
1135 spec->multiout.dac_nids = spec->private_dac_nids;
1136 memset(spec->private_dac_nids, 0, sizeof(spec->private_dac_nids));
1137 memset(spec->multiout.hp_out_nid, 0, sizeof(spec->multiout.hp_out_nid));
1138 memset(spec->multiout.extra_out_nid, 0, sizeof(spec->multiout.extra_out_nid));
1139 spec->multi_ios = 0;
1140 snd_array_free(&spec->paths);
1141 badness = 0;
1142
1143 /* fill hard-wired DACs first */
1144 if (fill_hardwired) {
1145 bool mapped;
1146 do {
1147 mapped = map_singles(codec, cfg->line_outs,
1148 cfg->line_out_pins,
Takashi Iwai196c17662013-01-04 15:01:40 +01001149 spec->private_dac_nids,
1150 spec->out_paths);
Takashi Iwai352f7f92012-12-19 12:52:06 +01001151 mapped |= map_singles(codec, cfg->hp_outs,
1152 cfg->hp_pins,
Takashi Iwai196c17662013-01-04 15:01:40 +01001153 spec->multiout.hp_out_nid,
1154 spec->hp_paths);
Takashi Iwai352f7f92012-12-19 12:52:06 +01001155 mapped |= map_singles(codec, cfg->speaker_outs,
1156 cfg->speaker_pins,
Takashi Iwai196c17662013-01-04 15:01:40 +01001157 spec->multiout.extra_out_nid,
1158 spec->speaker_paths);
Takashi Iwai352f7f92012-12-19 12:52:06 +01001159 if (fill_mio_first && cfg->line_outs == 1 &&
1160 cfg->line_out_type != AUTO_PIN_SPEAKER_OUT) {
Takashi Iwaie22aab72013-01-04 14:50:04 +01001161 err = fill_multi_ios(codec, cfg->line_out_pins[0], true);
Takashi Iwai352f7f92012-12-19 12:52:06 +01001162 if (!err)
1163 mapped = true;
1164 }
1165 } while (mapped);
1166 }
1167
1168 badness += try_assign_dacs(codec, cfg->line_outs, cfg->line_out_pins,
Takashi Iwai196c17662013-01-04 15:01:40 +01001169 spec->private_dac_nids, spec->out_paths,
Takashi Iwai352f7f92012-12-19 12:52:06 +01001170 &main_out_badness);
1171
1172 /* re-count num_dacs and squash invalid entries */
1173 spec->multiout.num_dacs = 0;
1174 for (i = 0; i < cfg->line_outs; i++) {
1175 if (spec->private_dac_nids[i])
1176 spec->multiout.num_dacs++;
1177 else {
1178 memmove(spec->private_dac_nids + i,
1179 spec->private_dac_nids + i + 1,
1180 sizeof(hda_nid_t) * (cfg->line_outs - i - 1));
1181 spec->private_dac_nids[cfg->line_outs - 1] = 0;
1182 }
1183 }
1184
1185 if (fill_mio_first &&
1186 cfg->line_outs == 1 && cfg->line_out_type != AUTO_PIN_SPEAKER_OUT) {
1187 /* try to fill multi-io first */
Takashi Iwaie22aab72013-01-04 14:50:04 +01001188 err = fill_multi_ios(codec, cfg->line_out_pins[0], false);
Takashi Iwai352f7f92012-12-19 12:52:06 +01001189 if (err < 0)
1190 return err;
1191 /* we don't count badness at this stage yet */
1192 }
1193
1194 if (cfg->line_out_type != AUTO_PIN_HP_OUT) {
1195 err = try_assign_dacs(codec, cfg->hp_outs, cfg->hp_pins,
1196 spec->multiout.hp_out_nid,
Takashi Iwai196c17662013-01-04 15:01:40 +01001197 spec->hp_paths,
Takashi Iwai352f7f92012-12-19 12:52:06 +01001198 &extra_out_badness);
1199 if (err < 0)
1200 return err;
1201 badness += err;
1202 }
1203 if (cfg->line_out_type != AUTO_PIN_SPEAKER_OUT) {
1204 err = try_assign_dacs(codec, cfg->speaker_outs,
1205 cfg->speaker_pins,
1206 spec->multiout.extra_out_nid,
Takashi Iwai196c17662013-01-04 15:01:40 +01001207 spec->speaker_paths,
1208 &extra_out_badness);
Takashi Iwai352f7f92012-12-19 12:52:06 +01001209 if (err < 0)
1210 return err;
1211 badness += err;
1212 }
1213 if (cfg->line_outs == 1 && cfg->line_out_type != AUTO_PIN_SPEAKER_OUT) {
Takashi Iwaie22aab72013-01-04 14:50:04 +01001214 err = fill_multi_ios(codec, cfg->line_out_pins[0], false);
Takashi Iwai352f7f92012-12-19 12:52:06 +01001215 if (err < 0)
1216 return err;
1217 badness += err;
1218 }
Takashi Iwaie22aab72013-01-04 14:50:04 +01001219
Takashi Iwaic30aa7b2013-01-04 16:42:48 +01001220 if (spec->mixer_nid) {
1221 spec->aamix_out_paths[0] =
1222 check_aamix_out_path(codec, spec->out_paths[0]);
1223 if (cfg->line_out_type != AUTO_PIN_HP_OUT)
1224 spec->aamix_out_paths[1] =
1225 check_aamix_out_path(codec, spec->hp_paths[0]);
1226 if (cfg->line_out_type != AUTO_PIN_SPEAKER_OUT)
1227 spec->aamix_out_paths[2] =
1228 check_aamix_out_path(codec, spec->speaker_paths[0]);
1229 }
1230
Takashi Iwaie22aab72013-01-04 14:50:04 +01001231 if (cfg->hp_outs && cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
1232 if (count_multiio_pins(codec, cfg->hp_pins[0]) >= 2)
1233 spec->multi_ios = 1; /* give badness */
Takashi Iwai352f7f92012-12-19 12:52:06 +01001234
1235 if (spec->multi_ios == 2) {
1236 for (i = 0; i < 2; i++)
1237 spec->private_dac_nids[spec->multiout.num_dacs++] =
1238 spec->multi_io[i].dac;
1239 spec->ext_channel_count = 2;
1240 } else if (spec->multi_ios) {
1241 spec->multi_ios = 0;
1242 badness += BAD_MULTI_IO;
1243 }
1244
1245 return badness;
1246}
1247
1248#define DEBUG_BADNESS
1249
1250#ifdef DEBUG_BADNESS
1251#define debug_badness snd_printdd
1252#else
1253#define debug_badness(...)
1254#endif
1255
1256static void debug_show_configs(struct hda_gen_spec *spec, struct auto_pin_cfg *cfg)
1257{
1258 debug_badness("multi_outs = %x/%x/%x/%x : %x/%x/%x/%x\n",
1259 cfg->line_out_pins[0], cfg->line_out_pins[1],
Takashi Iwai708122e2012-12-20 17:56:57 +01001260 cfg->line_out_pins[2], cfg->line_out_pins[3],
Takashi Iwai352f7f92012-12-19 12:52:06 +01001261 spec->multiout.dac_nids[0],
1262 spec->multiout.dac_nids[1],
1263 spec->multiout.dac_nids[2],
1264 spec->multiout.dac_nids[3]);
1265 if (spec->multi_ios > 0)
1266 debug_badness("multi_ios(%d) = %x/%x : %x/%x\n",
1267 spec->multi_ios,
1268 spec->multi_io[0].pin, spec->multi_io[1].pin,
1269 spec->multi_io[0].dac, spec->multi_io[1].dac);
1270 debug_badness("hp_outs = %x/%x/%x/%x : %x/%x/%x/%x\n",
1271 cfg->hp_pins[0], cfg->hp_pins[1],
Takashi Iwai708122e2012-12-20 17:56:57 +01001272 cfg->hp_pins[2], cfg->hp_pins[3],
Takashi Iwai352f7f92012-12-19 12:52:06 +01001273 spec->multiout.hp_out_nid[0],
1274 spec->multiout.hp_out_nid[1],
1275 spec->multiout.hp_out_nid[2],
1276 spec->multiout.hp_out_nid[3]);
1277 debug_badness("spk_outs = %x/%x/%x/%x : %x/%x/%x/%x\n",
1278 cfg->speaker_pins[0], cfg->speaker_pins[1],
1279 cfg->speaker_pins[2], cfg->speaker_pins[3],
1280 spec->multiout.extra_out_nid[0],
1281 spec->multiout.extra_out_nid[1],
1282 spec->multiout.extra_out_nid[2],
1283 spec->multiout.extra_out_nid[3]);
1284}
1285
1286/* find all available DACs of the codec */
1287static void fill_all_dac_nids(struct hda_codec *codec)
1288{
1289 struct hda_gen_spec *spec = codec->spec;
1290 int i;
1291 hda_nid_t nid = codec->start_nid;
1292
1293 spec->num_all_dacs = 0;
1294 memset(spec->all_dacs, 0, sizeof(spec->all_dacs));
1295 for (i = 0; i < codec->num_nodes; i++, nid++) {
1296 if (get_wcaps_type(get_wcaps(codec, nid)) != AC_WID_AUD_OUT)
1297 continue;
1298 if (spec->num_all_dacs >= ARRAY_SIZE(spec->all_dacs)) {
1299 snd_printk(KERN_ERR "hda: Too many DACs!\n");
1300 break;
1301 }
1302 spec->all_dacs[spec->num_all_dacs++] = nid;
1303 }
1304}
1305
1306static int parse_output_paths(struct hda_codec *codec)
1307{
1308 struct hda_gen_spec *spec = codec->spec;
1309 struct auto_pin_cfg *cfg = &spec->autocfg;
1310 struct auto_pin_cfg *best_cfg;
1311 int best_badness = INT_MAX;
1312 int badness;
1313 bool fill_hardwired = true, fill_mio_first = true;
1314 bool best_wired = true, best_mio = true;
1315 bool hp_spk_swapped = false;
1316
1317 fill_all_dac_nids(codec);
1318
1319 best_cfg = kmalloc(sizeof(*best_cfg), GFP_KERNEL);
1320 if (!best_cfg)
1321 return -ENOMEM;
1322 *best_cfg = *cfg;
1323
1324 for (;;) {
1325 badness = fill_and_eval_dacs(codec, fill_hardwired,
1326 fill_mio_first);
1327 if (badness < 0) {
1328 kfree(best_cfg);
1329 return badness;
1330 }
1331 debug_badness("==> lo_type=%d, wired=%d, mio=%d, badness=0x%x\n",
1332 cfg->line_out_type, fill_hardwired, fill_mio_first,
1333 badness);
1334 debug_show_configs(spec, cfg);
1335 if (badness < best_badness) {
1336 best_badness = badness;
1337 *best_cfg = *cfg;
1338 best_wired = fill_hardwired;
1339 best_mio = fill_mio_first;
1340 }
1341 if (!badness)
1342 break;
1343 fill_mio_first = !fill_mio_first;
1344 if (!fill_mio_first)
1345 continue;
1346 fill_hardwired = !fill_hardwired;
1347 if (!fill_hardwired)
1348 continue;
1349 if (hp_spk_swapped)
1350 break;
1351 hp_spk_swapped = true;
1352 if (cfg->speaker_outs > 0 &&
1353 cfg->line_out_type == AUTO_PIN_HP_OUT) {
1354 cfg->hp_outs = cfg->line_outs;
1355 memcpy(cfg->hp_pins, cfg->line_out_pins,
1356 sizeof(cfg->hp_pins));
1357 cfg->line_outs = cfg->speaker_outs;
1358 memcpy(cfg->line_out_pins, cfg->speaker_pins,
1359 sizeof(cfg->speaker_pins));
1360 cfg->speaker_outs = 0;
1361 memset(cfg->speaker_pins, 0, sizeof(cfg->speaker_pins));
1362 cfg->line_out_type = AUTO_PIN_SPEAKER_OUT;
1363 fill_hardwired = true;
1364 continue;
1365 }
1366 if (cfg->hp_outs > 0 &&
1367 cfg->line_out_type == AUTO_PIN_SPEAKER_OUT) {
1368 cfg->speaker_outs = cfg->line_outs;
1369 memcpy(cfg->speaker_pins, cfg->line_out_pins,
1370 sizeof(cfg->speaker_pins));
1371 cfg->line_outs = cfg->hp_outs;
1372 memcpy(cfg->line_out_pins, cfg->hp_pins,
1373 sizeof(cfg->hp_pins));
1374 cfg->hp_outs = 0;
1375 memset(cfg->hp_pins, 0, sizeof(cfg->hp_pins));
1376 cfg->line_out_type = AUTO_PIN_HP_OUT;
1377 fill_hardwired = true;
1378 continue;
1379 }
1380 break;
1381 }
1382
1383 if (badness) {
Takashi Iwai0c8c0f52012-12-20 17:54:22 +01001384 debug_badness("==> restoring best_cfg\n");
Takashi Iwai352f7f92012-12-19 12:52:06 +01001385 *cfg = *best_cfg;
1386 fill_and_eval_dacs(codec, best_wired, best_mio);
1387 }
1388 debug_badness("==> Best config: lo_type=%d, wired=%d, mio=%d\n",
1389 cfg->line_out_type, best_wired, best_mio);
1390 debug_show_configs(spec, cfg);
1391
1392 if (cfg->line_out_pins[0]) {
1393 struct nid_path *path;
Takashi Iwai196c17662013-01-04 15:01:40 +01001394 path = snd_hda_get_path_from_idx(codec, spec->out_paths[0]);
Takashi Iwai352f7f92012-12-19 12:52:06 +01001395 if (path)
1396 spec->vmaster_nid = look_for_out_vol_nid(codec, path);
1397 }
1398
1399 kfree(best_cfg);
1400 return 0;
1401}
1402
1403/* add playback controls from the parsed DAC table */
1404static int create_multi_out_ctls(struct hda_codec *codec,
1405 const struct auto_pin_cfg *cfg)
1406{
1407 struct hda_gen_spec *spec = codec->spec;
1408 int i, err, noutputs;
1409
1410 noutputs = cfg->line_outs;
1411 if (spec->multi_ios > 0 && cfg->line_outs < 3)
1412 noutputs += spec->multi_ios;
1413
1414 for (i = 0; i < noutputs; i++) {
1415 const char *name;
1416 int index;
Takashi Iwai196c17662013-01-04 15:01:40 +01001417 hda_nid_t dac;
Takashi Iwai352f7f92012-12-19 12:52:06 +01001418 struct nid_path *path;
1419
1420 dac = spec->multiout.dac_nids[i];
1421 if (!dac)
1422 continue;
1423 if (i >= cfg->line_outs) {
Takashi Iwai352f7f92012-12-19 12:52:06 +01001424 index = 0;
1425 name = channel_name[i];
1426 } else {
Takashi Iwai352f7f92012-12-19 12:52:06 +01001427 name = get_line_out_pfx(spec, i, true, &index);
1428 }
1429
Takashi Iwai196c17662013-01-04 15:01:40 +01001430 path = snd_hda_get_path_from_idx(codec, spec->out_paths[i]);
Takashi Iwai352f7f92012-12-19 12:52:06 +01001431 if (!path)
1432 continue;
1433 if (!name || !strcmp(name, "CLFE")) {
1434 /* Center/LFE */
1435 err = add_vol_ctl(codec, "Center", 0, 1, path);
1436 if (err < 0)
1437 return err;
1438 err = add_vol_ctl(codec, "LFE", 0, 2, path);
1439 if (err < 0)
1440 return err;
1441 err = add_sw_ctl(codec, "Center", 0, 1, path);
1442 if (err < 0)
1443 return err;
1444 err = add_sw_ctl(codec, "LFE", 0, 2, path);
1445 if (err < 0)
1446 return err;
1447 } else {
1448 err = add_stereo_vol(codec, name, index, path);
1449 if (err < 0)
1450 return err;
1451 err = add_stereo_sw(codec, name, index, path);
1452 if (err < 0)
1453 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001454 }
1455 }
1456 return 0;
1457}
1458
Takashi Iwaic2c80382013-01-07 10:33:57 +01001459static int create_extra_out(struct hda_codec *codec, int path_idx,
Takashi Iwai196c17662013-01-04 15:01:40 +01001460 const char *pfx, int cidx)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001461{
Takashi Iwai352f7f92012-12-19 12:52:06 +01001462 struct nid_path *path;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001463 int err;
1464
Takashi Iwai196c17662013-01-04 15:01:40 +01001465 path = snd_hda_get_path_from_idx(codec, path_idx);
Takashi Iwai352f7f92012-12-19 12:52:06 +01001466 if (!path)
1467 return 0;
Takashi Iwaic2c80382013-01-07 10:33:57 +01001468 err = add_stereo_vol(codec, pfx, cidx, path);
1469 if (err < 0)
1470 return err;
Takashi Iwai352f7f92012-12-19 12:52:06 +01001471 err = add_stereo_sw(codec, pfx, cidx, path);
1472 if (err < 0)
1473 return err;
1474 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001475}
1476
Takashi Iwai352f7f92012-12-19 12:52:06 +01001477/* add playback controls for speaker and HP outputs */
1478static int create_extra_outs(struct hda_codec *codec, int num_pins,
Takashi Iwai196c17662013-01-04 15:01:40 +01001479 const int *paths, const char *pfx)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001480{
Takashi Iwaic2c80382013-01-07 10:33:57 +01001481 int i;
Takashi Iwai352f7f92012-12-19 12:52:06 +01001482
1483 for (i = 0; i < num_pins; i++) {
Takashi Iwaic2c80382013-01-07 10:33:57 +01001484 const char *name;
1485 char tmp[44];
1486 int err, idx = 0;
1487
1488 if (num_pins == 2 && i == 1 && !strcmp(pfx, "Speaker"))
1489 name = "Bass Speaker";
1490 else if (num_pins >= 3) {
1491 snprintf(tmp, sizeof(tmp), "%s %s",
Takashi Iwai352f7f92012-12-19 12:52:06 +01001492 pfx, channel_name[i]);
Takashi Iwaic2c80382013-01-07 10:33:57 +01001493 name = tmp;
Takashi Iwai352f7f92012-12-19 12:52:06 +01001494 } else {
Takashi Iwaic2c80382013-01-07 10:33:57 +01001495 name = pfx;
1496 idx = i;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001497 }
Takashi Iwaic2c80382013-01-07 10:33:57 +01001498 err = create_extra_out(codec, paths[i], name, idx);
Takashi Iwai352f7f92012-12-19 12:52:06 +01001499 if (err < 0)
1500 return err;
1501 }
1502 return 0;
1503}
Takashi Iwai97ec5582006-03-21 11:29:07 +01001504
Takashi Iwai352f7f92012-12-19 12:52:06 +01001505static int create_hp_out_ctls(struct hda_codec *codec)
1506{
1507 struct hda_gen_spec *spec = codec->spec;
1508 return create_extra_outs(codec, spec->autocfg.hp_outs,
Takashi Iwai196c17662013-01-04 15:01:40 +01001509 spec->hp_paths,
Takashi Iwai352f7f92012-12-19 12:52:06 +01001510 "Headphone");
1511}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001512
Takashi Iwai352f7f92012-12-19 12:52:06 +01001513static int create_speaker_out_ctls(struct hda_codec *codec)
1514{
1515 struct hda_gen_spec *spec = codec->spec;
1516 return create_extra_outs(codec, spec->autocfg.speaker_outs,
Takashi Iwai196c17662013-01-04 15:01:40 +01001517 spec->speaker_paths,
Takashi Iwai352f7f92012-12-19 12:52:06 +01001518 "Speaker");
1519}
1520
1521/*
Takashi Iwai38cf6f12012-12-21 14:09:42 +01001522 * independent HP controls
1523 */
1524
1525static int indep_hp_info(struct snd_kcontrol *kcontrol,
1526 struct snd_ctl_elem_info *uinfo)
1527{
1528 return snd_hda_enum_bool_helper_info(kcontrol, uinfo);
1529}
1530
1531static int indep_hp_get(struct snd_kcontrol *kcontrol,
1532 struct snd_ctl_elem_value *ucontrol)
1533{
1534 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1535 struct hda_gen_spec *spec = codec->spec;
1536 ucontrol->value.enumerated.item[0] = spec->indep_hp_enabled;
1537 return 0;
1538}
1539
1540static int indep_hp_put(struct snd_kcontrol *kcontrol,
1541 struct snd_ctl_elem_value *ucontrol)
1542{
1543 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1544 struct hda_gen_spec *spec = codec->spec;
1545 unsigned int select = ucontrol->value.enumerated.item[0];
1546 int ret = 0;
1547
1548 mutex_lock(&spec->pcm_mutex);
1549 if (spec->active_streams) {
1550 ret = -EBUSY;
1551 goto unlock;
1552 }
1553
1554 if (spec->indep_hp_enabled != select) {
1555 spec->indep_hp_enabled = select;
1556 if (spec->indep_hp_enabled)
1557 spec->multiout.hp_out_nid[0] = 0;
1558 else
1559 spec->multiout.hp_out_nid[0] = spec->alt_dac_nid;
1560 ret = 1;
1561 }
1562 unlock:
1563 mutex_unlock(&spec->pcm_mutex);
1564 return ret;
1565}
1566
1567static const struct snd_kcontrol_new indep_hp_ctl = {
1568 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1569 .name = "Independent HP",
1570 .info = indep_hp_info,
1571 .get = indep_hp_get,
1572 .put = indep_hp_put,
1573};
1574
1575
1576static int create_indep_hp_ctls(struct hda_codec *codec)
1577{
1578 struct hda_gen_spec *spec = codec->spec;
1579
1580 if (!spec->indep_hp)
1581 return 0;
1582 if (!spec->multiout.hp_out_nid[0]) {
1583 spec->indep_hp = 0;
1584 return 0;
1585 }
1586
1587 spec->indep_hp_enabled = false;
1588 spec->alt_dac_nid = spec->multiout.hp_out_nid[0];
1589 if (!snd_hda_gen_add_kctl(spec, NULL, &indep_hp_ctl))
1590 return -ENOMEM;
1591 return 0;
1592}
1593
1594/*
Takashi Iwai352f7f92012-12-19 12:52:06 +01001595 * channel mode enum control
1596 */
1597
1598static int ch_mode_info(struct snd_kcontrol *kcontrol,
1599 struct snd_ctl_elem_info *uinfo)
1600{
1601 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1602 struct hda_gen_spec *spec = codec->spec;
1603
1604 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
1605 uinfo->count = 1;
1606 uinfo->value.enumerated.items = spec->multi_ios + 1;
1607 if (uinfo->value.enumerated.item > spec->multi_ios)
1608 uinfo->value.enumerated.item = spec->multi_ios;
1609 sprintf(uinfo->value.enumerated.name, "%dch",
1610 (uinfo->value.enumerated.item + 1) * 2);
1611 return 0;
1612}
1613
1614static int ch_mode_get(struct snd_kcontrol *kcontrol,
1615 struct snd_ctl_elem_value *ucontrol)
1616{
1617 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1618 struct hda_gen_spec *spec = codec->spec;
1619 ucontrol->value.enumerated.item[0] = (spec->ext_channel_count - 1) / 2;
1620 return 0;
1621}
1622
Takashi Iwai196c17662013-01-04 15:01:40 +01001623static inline struct nid_path *
1624get_multiio_path(struct hda_codec *codec, int idx)
1625{
1626 struct hda_gen_spec *spec = codec->spec;
1627 return snd_hda_get_path_from_idx(codec,
1628 spec->out_paths[spec->autocfg.line_outs + idx]);
1629}
1630
Takashi Iwai352f7f92012-12-19 12:52:06 +01001631static int set_multi_io(struct hda_codec *codec, int idx, bool output)
1632{
1633 struct hda_gen_spec *spec = codec->spec;
1634 hda_nid_t nid = spec->multi_io[idx].pin;
1635 struct nid_path *path;
1636
Takashi Iwai196c17662013-01-04 15:01:40 +01001637 path = get_multiio_path(codec, idx);
Takashi Iwai352f7f92012-12-19 12:52:06 +01001638 if (!path)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001639 return -EINVAL;
Takashi Iwai352f7f92012-12-19 12:52:06 +01001640
1641 if (path->active == output)
1642 return 0;
1643
1644 if (output) {
1645 snd_hda_set_pin_ctl_cache(codec, nid, PIN_OUT);
1646 snd_hda_activate_path(codec, path, true, true);
Takashi Iwaid5a9f1b2012-12-20 15:36:30 +01001647 set_pin_eapd(codec, nid, true);
Takashi Iwai352f7f92012-12-19 12:52:06 +01001648 } else {
Takashi Iwaid5a9f1b2012-12-20 15:36:30 +01001649 set_pin_eapd(codec, nid, false);
Takashi Iwai352f7f92012-12-19 12:52:06 +01001650 snd_hda_activate_path(codec, path, false, true);
1651 snd_hda_set_pin_ctl_cache(codec, nid,
1652 spec->multi_io[idx].ctl_in);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001653 }
Takashi Iwai352f7f92012-12-19 12:52:06 +01001654 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001655}
1656
Takashi Iwai352f7f92012-12-19 12:52:06 +01001657static int ch_mode_put(struct snd_kcontrol *kcontrol,
1658 struct snd_ctl_elem_value *ucontrol)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001659{
Takashi Iwai352f7f92012-12-19 12:52:06 +01001660 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1661 struct hda_gen_spec *spec = codec->spec;
1662 int i, ch;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001663
Takashi Iwai352f7f92012-12-19 12:52:06 +01001664 ch = ucontrol->value.enumerated.item[0];
1665 if (ch < 0 || ch > spec->multi_ios)
1666 return -EINVAL;
1667 if (ch == (spec->ext_channel_count - 1) / 2)
1668 return 0;
1669 spec->ext_channel_count = (ch + 1) * 2;
1670 for (i = 0; i < spec->multi_ios; i++)
1671 set_multi_io(codec, i, i < ch);
1672 spec->multiout.max_channels = max(spec->ext_channel_count,
1673 spec->const_channel_count);
1674 if (spec->need_dac_fix)
1675 spec->multiout.num_dacs = spec->multiout.max_channels / 2;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001676 return 1;
1677}
1678
Takashi Iwai352f7f92012-12-19 12:52:06 +01001679static const struct snd_kcontrol_new channel_mode_enum = {
1680 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1681 .name = "Channel Mode",
1682 .info = ch_mode_info,
1683 .get = ch_mode_get,
1684 .put = ch_mode_put,
1685};
Linus Torvalds1da177e2005-04-16 15:20:36 -07001686
Takashi Iwai352f7f92012-12-19 12:52:06 +01001687static int create_multi_channel_mode(struct hda_codec *codec)
1688{
1689 struct hda_gen_spec *spec = codec->spec;
1690
1691 if (spec->multi_ios > 0) {
Takashi Iwai12c93df2012-12-19 14:38:33 +01001692 if (!snd_hda_gen_add_kctl(spec, NULL, &channel_mode_enum))
Takashi Iwai352f7f92012-12-19 12:52:06 +01001693 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001694 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001695 return 0;
1696}
1697
Takashi Iwai352f7f92012-12-19 12:52:06 +01001698/*
Takashi Iwaic30aa7b2013-01-04 16:42:48 +01001699 * aamix loopback enable/disable switch
1700 */
1701
1702#define loopback_mixing_info indep_hp_info
1703
1704static int loopback_mixing_get(struct snd_kcontrol *kcontrol,
1705 struct snd_ctl_elem_value *ucontrol)
1706{
1707 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1708 struct hda_gen_spec *spec = codec->spec;
1709 ucontrol->value.enumerated.item[0] = spec->aamix_mode;
1710 return 0;
1711}
1712
1713static void update_aamix_paths(struct hda_codec *codec, bool do_mix,
1714 int nomix_path_idx, int mix_path_idx)
1715{
1716 struct nid_path *nomix_path, *mix_path;
1717
1718 nomix_path = snd_hda_get_path_from_idx(codec, nomix_path_idx);
1719 mix_path = snd_hda_get_path_from_idx(codec, mix_path_idx);
1720 if (!nomix_path || !mix_path)
1721 return;
1722 if (do_mix) {
1723 snd_hda_activate_path(codec, nomix_path, false, true);
1724 snd_hda_activate_path(codec, mix_path, true, true);
1725 } else {
1726 snd_hda_activate_path(codec, mix_path, false, true);
1727 snd_hda_activate_path(codec, nomix_path, true, true);
1728 }
1729}
1730
1731static int loopback_mixing_put(struct snd_kcontrol *kcontrol,
1732 struct snd_ctl_elem_value *ucontrol)
1733{
1734 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1735 struct hda_gen_spec *spec = codec->spec;
1736 unsigned int val = ucontrol->value.enumerated.item[0];
1737
1738 if (val == spec->aamix_mode)
1739 return 0;
1740 spec->aamix_mode = val;
1741 update_aamix_paths(codec, val, spec->out_paths[0],
1742 spec->aamix_out_paths[0]);
1743 update_aamix_paths(codec, val, spec->hp_paths[0],
1744 spec->aamix_out_paths[1]);
1745 update_aamix_paths(codec, val, spec->speaker_paths[0],
1746 spec->aamix_out_paths[2]);
1747 return 1;
1748}
1749
1750static const struct snd_kcontrol_new loopback_mixing_enum = {
1751 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1752 .name = "Loopback Mixing",
1753 .info = loopback_mixing_info,
1754 .get = loopback_mixing_get,
1755 .put = loopback_mixing_put,
1756};
1757
1758static int create_loopback_mixing_ctl(struct hda_codec *codec)
1759{
1760 struct hda_gen_spec *spec = codec->spec;
1761
1762 if (!spec->mixer_nid)
1763 return 0;
1764 if (!(spec->aamix_out_paths[0] || spec->aamix_out_paths[1] ||
1765 spec->aamix_out_paths[2]))
1766 return 0;
1767 if (!snd_hda_gen_add_kctl(spec, NULL, &loopback_mixing_enum))
1768 return -ENOMEM;
1769 return 0;
1770}
1771
1772/*
Takashi Iwai352f7f92012-12-19 12:52:06 +01001773 * shared headphone/mic handling
1774 */
Takashi Iwaicb53c622007-08-10 17:21:45 +02001775
Takashi Iwai352f7f92012-12-19 12:52:06 +01001776static void call_update_outputs(struct hda_codec *codec);
1777
1778/* for shared I/O, change the pin-control accordingly */
1779static void update_shared_mic_hp(struct hda_codec *codec, bool set_as_mic)
1780{
1781 struct hda_gen_spec *spec = codec->spec;
1782 unsigned int val;
1783 hda_nid_t pin = spec->autocfg.inputs[1].pin;
1784 /* NOTE: this assumes that there are only two inputs, the
1785 * first is the real internal mic and the second is HP/mic jack.
1786 */
1787
1788 val = snd_hda_get_default_vref(codec, pin);
1789
1790 /* This pin does not have vref caps - let's enable vref on pin 0x18
1791 instead, as suggested by Realtek */
1792 if (val == AC_PINCTL_VREF_HIZ && spec->shared_mic_vref_pin) {
1793 const hda_nid_t vref_pin = spec->shared_mic_vref_pin;
1794 unsigned int vref_val = snd_hda_get_default_vref(codec, vref_pin);
1795 if (vref_val != AC_PINCTL_VREF_HIZ)
Takashi Iwai7594aa32012-12-20 15:38:40 +01001796 snd_hda_set_pin_ctl_cache(codec, vref_pin,
1797 PIN_IN | (set_as_mic ? vref_val : 0));
Takashi Iwaicb53c622007-08-10 17:21:45 +02001798 }
Takashi Iwai352f7f92012-12-19 12:52:06 +01001799
1800 val = set_as_mic ? val | PIN_IN : PIN_HP;
Takashi Iwai7594aa32012-12-20 15:38:40 +01001801 snd_hda_set_pin_ctl_cache(codec, pin, val);
Takashi Iwai352f7f92012-12-19 12:52:06 +01001802
1803 spec->automute_speaker = !set_as_mic;
1804 call_update_outputs(codec);
1805}
1806
1807/* create a shared input with the headphone out */
1808static int create_shared_input(struct hda_codec *codec)
1809{
1810 struct hda_gen_spec *spec = codec->spec;
1811 struct auto_pin_cfg *cfg = &spec->autocfg;
1812 unsigned int defcfg;
1813 hda_nid_t nid;
1814
1815 /* only one internal input pin? */
1816 if (cfg->num_inputs != 1)
1817 return 0;
1818 defcfg = snd_hda_codec_get_pincfg(codec, cfg->inputs[0].pin);
1819 if (snd_hda_get_input_pin_attr(defcfg) != INPUT_PIN_ATTR_INT)
1820 return 0;
1821
1822 if (cfg->hp_outs == 1 && cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
1823 nid = cfg->hp_pins[0]; /* OK, we have a single HP-out */
1824 else if (cfg->line_outs == 1 && cfg->line_out_type == AUTO_PIN_HP_OUT)
1825 nid = cfg->line_out_pins[0]; /* OK, we have a single line-out */
1826 else
1827 return 0; /* both not available */
1828
1829 if (!(snd_hda_query_pin_caps(codec, nid) & AC_PINCAP_IN))
1830 return 0; /* no input */
1831
1832 cfg->inputs[1].pin = nid;
1833 cfg->inputs[1].type = AUTO_PIN_MIC;
1834 cfg->num_inputs = 2;
1835 spec->shared_mic_hp = 1;
1836 snd_printdd("hda-codec: Enable shared I/O jack on NID 0x%x\n", nid);
1837 return 0;
1838}
1839
1840
1841/*
1842 * Parse input paths
1843 */
1844
1845#ifdef CONFIG_PM
1846/* add the powersave loopback-list entry */
1847static void add_loopback_list(struct hda_gen_spec *spec, hda_nid_t mix, int idx)
1848{
1849 struct hda_amp_list *list;
1850
1851 if (spec->num_loopbacks >= ARRAY_SIZE(spec->loopback_list) - 1)
1852 return;
1853 list = spec->loopback_list + spec->num_loopbacks;
1854 list->nid = mix;
1855 list->dir = HDA_INPUT;
1856 list->idx = idx;
1857 spec->num_loopbacks++;
Takashi Iwaicb53c622007-08-10 17:21:45 +02001858 spec->loopback.amplist = spec->loopback_list;
1859}
1860#else
Takashi Iwai352f7f92012-12-19 12:52:06 +01001861#define add_loopback_list(spec, mix, idx) /* NOP */
Takashi Iwaicb53c622007-08-10 17:21:45 +02001862#endif
1863
Takashi Iwai352f7f92012-12-19 12:52:06 +01001864/* create input playback/capture controls for the given pin */
Takashi Iwai196c17662013-01-04 15:01:40 +01001865static int new_analog_input(struct hda_codec *codec, int input_idx,
1866 hda_nid_t pin, const char *ctlname, int ctlidx,
Takashi Iwai352f7f92012-12-19 12:52:06 +01001867 hda_nid_t mix_nid)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001868{
Takashi Iwai352f7f92012-12-19 12:52:06 +01001869 struct hda_gen_spec *spec = codec->spec;
1870 struct nid_path *path;
1871 unsigned int val;
1872 int err, idx;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001873
Takashi Iwai352f7f92012-12-19 12:52:06 +01001874 if (!nid_has_volume(codec, mix_nid, HDA_INPUT) &&
1875 !nid_has_mute(codec, mix_nid, HDA_INPUT))
1876 return 0; /* no need for analog loopback */
1877
Takashi Iwai4ac0eef2012-12-20 18:10:51 +01001878 path = snd_hda_add_new_path(codec, pin, mix_nid, HDA_PARSE_ALL);
Takashi Iwai352f7f92012-12-19 12:52:06 +01001879 if (!path)
1880 return -EINVAL;
Takashi Iwai0c8c0f52012-12-20 17:54:22 +01001881 print_nid_path("loopback", path);
Takashi Iwai196c17662013-01-04 15:01:40 +01001882 spec->loopback_paths[input_idx] = snd_hda_get_path_idx(codec, path);
Takashi Iwai352f7f92012-12-19 12:52:06 +01001883
1884 idx = path->idx[path->depth - 1];
1885 if (nid_has_volume(codec, mix_nid, HDA_INPUT)) {
1886 val = HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT);
1887 err = __add_pb_vol_ctrl(spec, HDA_CTL_WIDGET_VOL, ctlname, ctlidx, val);
Takashi Iwaid13bd412008-07-30 15:01:45 +02001888 if (err < 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001889 return err;
Takashi Iwai352f7f92012-12-19 12:52:06 +01001890 path->ctls[NID_PATH_VOL_CTL] = val;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001891 }
1892
Takashi Iwai352f7f92012-12-19 12:52:06 +01001893 if (nid_has_mute(codec, mix_nid, HDA_INPUT)) {
1894 val = HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT);
1895 err = __add_pb_sw_ctrl(spec, HDA_CTL_WIDGET_MUTE, ctlname, ctlidx, val);
Takashi Iwaid13bd412008-07-30 15:01:45 +02001896 if (err < 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001897 return err;
Takashi Iwai352f7f92012-12-19 12:52:06 +01001898 path->ctls[NID_PATH_MUTE_CTL] = val;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001899 }
1900
Takashi Iwai352f7f92012-12-19 12:52:06 +01001901 path->active = true;
1902 add_loopback_list(spec, mix_nid, idx);
1903 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001904}
1905
Takashi Iwai352f7f92012-12-19 12:52:06 +01001906static int is_input_pin(struct hda_codec *codec, hda_nid_t nid)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001907{
Takashi Iwai352f7f92012-12-19 12:52:06 +01001908 unsigned int pincap = snd_hda_query_pin_caps(codec, nid);
1909 return (pincap & AC_PINCAP_IN) != 0;
1910}
1911
1912/* Parse the codec tree and retrieve ADCs */
1913static int fill_adc_nids(struct hda_codec *codec)
1914{
1915 struct hda_gen_spec *spec = codec->spec;
1916 hda_nid_t nid;
1917 hda_nid_t *adc_nids = spec->adc_nids;
1918 int max_nums = ARRAY_SIZE(spec->adc_nids);
1919 int i, nums = 0;
1920
1921 nid = codec->start_nid;
1922 for (i = 0; i < codec->num_nodes; i++, nid++) {
1923 unsigned int caps = get_wcaps(codec, nid);
1924 int type = get_wcaps_type(caps);
1925
1926 if (type != AC_WID_AUD_IN || (caps & AC_WCAP_DIGITAL))
1927 continue;
1928 adc_nids[nums] = nid;
1929 if (++nums >= max_nums)
1930 break;
1931 }
1932 spec->num_adc_nids = nums;
1933 return nums;
1934}
1935
1936/* filter out invalid adc_nids that don't give all active input pins;
1937 * if needed, check whether dynamic ADC-switching is available
1938 */
1939static int check_dyn_adc_switch(struct hda_codec *codec)
1940{
1941 struct hda_gen_spec *spec = codec->spec;
1942 struct hda_input_mux *imux = &spec->input_mux;
1943 hda_nid_t adc_nids[ARRAY_SIZE(spec->adc_nids)];
1944 int i, n, nums;
1945 hda_nid_t pin, adc;
1946
1947 again:
1948 nums = 0;
1949 for (n = 0; n < spec->num_adc_nids; n++) {
1950 adc = spec->adc_nids[n];
1951 for (i = 0; i < imux->num_items; i++) {
1952 pin = spec->imux_pins[i];
1953 if (!is_reachable_path(codec, pin, adc))
1954 break;
1955 }
1956 if (i >= imux->num_items)
1957 adc_nids[nums++] = adc;
1958 }
1959
1960 if (!nums) {
1961 if (spec->shared_mic_hp) {
1962 spec->shared_mic_hp = 0;
1963 imux->num_items = 1;
1964 goto again;
1965 }
1966
1967 /* check whether ADC-switch is possible */
1968 for (i = 0; i < imux->num_items; i++) {
1969 pin = spec->imux_pins[i];
1970 for (n = 0; n < spec->num_adc_nids; n++) {
1971 adc = spec->adc_nids[n];
1972 if (is_reachable_path(codec, pin, adc)) {
1973 spec->dyn_adc_idx[i] = n;
1974 break;
1975 }
1976 }
1977 }
1978
1979 snd_printdd("hda-codec: enabling ADC switching\n");
1980 spec->dyn_adc_switch = 1;
1981 } else if (nums != spec->num_adc_nids) {
1982 memcpy(spec->adc_nids, adc_nids, nums * sizeof(hda_nid_t));
1983 spec->num_adc_nids = nums;
1984 }
1985
1986 if (imux->num_items == 1 || spec->shared_mic_hp) {
1987 snd_printdd("hda-codec: reducing to a single ADC\n");
1988 spec->num_adc_nids = 1; /* reduce to a single ADC */
1989 }
1990
1991 /* single index for individual volumes ctls */
1992 if (!spec->dyn_adc_switch && spec->multi_cap_vol)
1993 spec->num_adc_nids = 1;
1994
Linus Torvalds1da177e2005-04-16 15:20:36 -07001995 return 0;
1996}
1997
1998/*
Takashi Iwai352f7f92012-12-19 12:52:06 +01001999 * create playback/capture controls for input pins
Linus Torvalds1da177e2005-04-16 15:20:36 -07002000 */
Takashi Iwai352f7f92012-12-19 12:52:06 +01002001static int create_input_ctls(struct hda_codec *codec)
Takashi Iwaia7da6ce2006-09-06 14:03:14 +02002002{
Takashi Iwai352f7f92012-12-19 12:52:06 +01002003 struct hda_gen_spec *spec = codec->spec;
2004 const struct auto_pin_cfg *cfg = &spec->autocfg;
2005 hda_nid_t mixer = spec->mixer_nid;
2006 struct hda_input_mux *imux = &spec->input_mux;
2007 int num_adcs;
2008 int i, c, err, type_idx = 0;
2009 const char *prev_label = NULL;
Takashi Iwaia7da6ce2006-09-06 14:03:14 +02002010
Takashi Iwai352f7f92012-12-19 12:52:06 +01002011 num_adcs = fill_adc_nids(codec);
2012 if (num_adcs < 0)
2013 return 0;
Takashi Iwaia7da6ce2006-09-06 14:03:14 +02002014
Takashi Iwai352f7f92012-12-19 12:52:06 +01002015 for (i = 0; i < cfg->num_inputs; i++) {
2016 hda_nid_t pin;
2017 const char *label;
2018 bool imux_added;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002019
Takashi Iwai352f7f92012-12-19 12:52:06 +01002020 pin = cfg->inputs[i].pin;
2021 if (!is_input_pin(codec, pin))
2022 continue;
2023
2024 label = hda_get_autocfg_input_label(codec, cfg, i);
2025 if (spec->shared_mic_hp && !strcmp(label, "Misc"))
2026 label = "Headphone Mic";
2027 if (prev_label && !strcmp(label, prev_label))
2028 type_idx++;
Takashi Iwaia7da6ce2006-09-06 14:03:14 +02002029 else
Takashi Iwai352f7f92012-12-19 12:52:06 +01002030 type_idx = 0;
2031 prev_label = label;
2032
2033 if (mixer) {
2034 if (is_reachable_path(codec, pin, mixer)) {
Takashi Iwai196c17662013-01-04 15:01:40 +01002035 err = new_analog_input(codec, i, pin,
Takashi Iwai352f7f92012-12-19 12:52:06 +01002036 label, type_idx, mixer);
2037 if (err < 0)
2038 return err;
2039 }
2040 }
2041
2042 imux_added = false;
2043 for (c = 0; c < num_adcs; c++) {
2044 struct nid_path *path;
2045 hda_nid_t adc = spec->adc_nids[c];
2046
2047 if (!is_reachable_path(codec, pin, adc))
2048 continue;
2049 path = snd_array_new(&spec->paths);
2050 if (!path)
2051 return -ENOMEM;
2052 memset(path, 0, sizeof(*path));
Takashi Iwai4ac0eef2012-12-20 18:10:51 +01002053 if (!snd_hda_parse_nid_path(codec, pin, adc, HDA_PARSE_ALL, path)) {
Takashi Iwai352f7f92012-12-19 12:52:06 +01002054 snd_printd(KERN_ERR
2055 "invalid input path 0x%x -> 0x%x\n",
2056 pin, adc);
2057 spec->paths.used--;
2058 continue;
2059 }
Takashi Iwai0c8c0f52012-12-20 17:54:22 +01002060 print_nid_path("input", path);
Takashi Iwai352f7f92012-12-19 12:52:06 +01002061
2062 if (!imux_added) {
2063 spec->imux_pins[imux->num_items] = pin;
2064 snd_hda_add_imux_item(imux, label,
2065 imux->num_items, NULL);
2066 imux_added = true;
2067 }
2068 }
2069 }
2070
2071 return 0;
2072}
2073
2074
2075/*
2076 * input source mux
2077 */
2078
2079/* get the ADC NID corresponding to the given index */
2080static hda_nid_t get_adc_nid(struct hda_codec *codec, int adc_idx, int imux_idx)
2081{
2082 struct hda_gen_spec *spec = codec->spec;
2083 if (spec->dyn_adc_switch)
2084 adc_idx = spec->dyn_adc_idx[imux_idx];
2085 return spec->adc_nids[adc_idx];
2086}
2087
2088static int mux_select(struct hda_codec *codec, unsigned int adc_idx,
2089 unsigned int idx);
2090
2091static int mux_enum_info(struct snd_kcontrol *kcontrol,
2092 struct snd_ctl_elem_info *uinfo)
2093{
2094 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2095 struct hda_gen_spec *spec = codec->spec;
2096 return snd_hda_input_mux_info(&spec->input_mux, uinfo);
2097}
2098
2099static int mux_enum_get(struct snd_kcontrol *kcontrol,
2100 struct snd_ctl_elem_value *ucontrol)
2101{
2102 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2103 struct hda_gen_spec *spec = codec->spec;
2104 unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
2105
2106 ucontrol->value.enumerated.item[0] = spec->cur_mux[adc_idx];
2107 return 0;
2108}
2109
2110static int mux_enum_put(struct snd_kcontrol *kcontrol,
2111 struct snd_ctl_elem_value *ucontrol)
2112{
2113 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2114 unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
2115 return mux_select(codec, adc_idx,
2116 ucontrol->value.enumerated.item[0]);
2117}
2118
Takashi Iwai352f7f92012-12-19 12:52:06 +01002119static const struct snd_kcontrol_new cap_src_temp = {
2120 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2121 .name = "Input Source",
2122 .info = mux_enum_info,
2123 .get = mux_enum_get,
2124 .put = mux_enum_put,
2125};
2126
Takashi Iwai47d46ab2012-12-20 11:48:54 +01002127/*
2128 * capture volume and capture switch ctls
2129 */
2130
Takashi Iwai352f7f92012-12-19 12:52:06 +01002131typedef int (*put_call_t)(struct snd_kcontrol *kcontrol,
2132 struct snd_ctl_elem_value *ucontrol);
2133
Takashi Iwai47d46ab2012-12-20 11:48:54 +01002134/* call the given amp update function for all amps in the imux list at once */
Takashi Iwai352f7f92012-12-19 12:52:06 +01002135static int cap_put_caller(struct snd_kcontrol *kcontrol,
2136 struct snd_ctl_elem_value *ucontrol,
2137 put_call_t func, int type)
2138{
2139 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2140 struct hda_gen_spec *spec = codec->spec;
2141 const struct hda_input_mux *imux;
2142 struct nid_path *path;
2143 int i, adc_idx, err = 0;
2144
2145 imux = &spec->input_mux;
2146 adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
2147 mutex_lock(&codec->control_mutex);
Takashi Iwai47d46ab2012-12-20 11:48:54 +01002148 /* we use the cache-only update at first since multiple input paths
2149 * may shared the same amp; by updating only caches, the redundant
2150 * writes to hardware can be reduced.
2151 */
Takashi Iwai352f7f92012-12-19 12:52:06 +01002152 codec->cached_write = 1;
2153 for (i = 0; i < imux->num_items; i++) {
2154 path = snd_hda_get_nid_path(codec, spec->imux_pins[i],
2155 get_adc_nid(codec, adc_idx, i));
2156 if (!path->ctls[type])
2157 continue;
2158 kcontrol->private_value = path->ctls[type];
2159 err = func(kcontrol, ucontrol);
2160 if (err < 0)
2161 goto error;
2162 }
2163 error:
2164 codec->cached_write = 0;
2165 mutex_unlock(&codec->control_mutex);
Takashi Iwai47d46ab2012-12-20 11:48:54 +01002166 snd_hda_codec_flush_amp_cache(codec); /* flush the updates */
Takashi Iwai352f7f92012-12-19 12:52:06 +01002167 if (err >= 0 && spec->cap_sync_hook)
2168 spec->cap_sync_hook(codec);
2169 return err;
2170}
2171
2172/* capture volume ctl callbacks */
2173#define cap_vol_info snd_hda_mixer_amp_volume_info
2174#define cap_vol_get snd_hda_mixer_amp_volume_get
2175#define cap_vol_tlv snd_hda_mixer_amp_tlv
2176
2177static int cap_vol_put(struct snd_kcontrol *kcontrol,
2178 struct snd_ctl_elem_value *ucontrol)
2179{
2180 return cap_put_caller(kcontrol, ucontrol,
2181 snd_hda_mixer_amp_volume_put,
2182 NID_PATH_VOL_CTL);
2183}
2184
2185static const struct snd_kcontrol_new cap_vol_temp = {
2186 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2187 .name = "Capture Volume",
2188 .access = (SNDRV_CTL_ELEM_ACCESS_READWRITE |
2189 SNDRV_CTL_ELEM_ACCESS_TLV_READ |
2190 SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK),
2191 .info = cap_vol_info,
2192 .get = cap_vol_get,
2193 .put = cap_vol_put,
2194 .tlv = { .c = cap_vol_tlv },
2195};
2196
2197/* capture switch ctl callbacks */
2198#define cap_sw_info snd_ctl_boolean_stereo_info
2199#define cap_sw_get snd_hda_mixer_amp_switch_get
2200
2201static int cap_sw_put(struct snd_kcontrol *kcontrol,
2202 struct snd_ctl_elem_value *ucontrol)
2203{
2204 return cap_put_caller(kcontrol, ucontrol,
2205 snd_hda_mixer_amp_switch_put,
2206 NID_PATH_MUTE_CTL);
2207}
2208
2209static const struct snd_kcontrol_new cap_sw_temp = {
2210 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2211 .name = "Capture Switch",
2212 .info = cap_sw_info,
2213 .get = cap_sw_get,
2214 .put = cap_sw_put,
2215};
2216
2217static int parse_capvol_in_path(struct hda_codec *codec, struct nid_path *path)
2218{
2219 hda_nid_t nid;
2220 int i, depth;
2221
2222 path->ctls[NID_PATH_VOL_CTL] = path->ctls[NID_PATH_MUTE_CTL] = 0;
2223 for (depth = 0; depth < 3; depth++) {
2224 if (depth >= path->depth)
2225 return -EINVAL;
2226 i = path->depth - depth - 1;
2227 nid = path->path[i];
2228 if (!path->ctls[NID_PATH_VOL_CTL]) {
2229 if (nid_has_volume(codec, nid, HDA_OUTPUT))
2230 path->ctls[NID_PATH_VOL_CTL] =
2231 HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
2232 else if (nid_has_volume(codec, nid, HDA_INPUT)) {
2233 int idx = path->idx[i];
2234 if (!depth && codec->single_adc_amp)
2235 idx = 0;
2236 path->ctls[NID_PATH_VOL_CTL] =
2237 HDA_COMPOSE_AMP_VAL(nid, 3, idx, HDA_INPUT);
2238 }
2239 }
2240 if (!path->ctls[NID_PATH_MUTE_CTL]) {
2241 if (nid_has_mute(codec, nid, HDA_OUTPUT))
2242 path->ctls[NID_PATH_MUTE_CTL] =
2243 HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
2244 else if (nid_has_mute(codec, nid, HDA_INPUT)) {
2245 int idx = path->idx[i];
2246 if (!depth && codec->single_adc_amp)
2247 idx = 0;
2248 path->ctls[NID_PATH_MUTE_CTL] =
2249 HDA_COMPOSE_AMP_VAL(nid, 3, idx, HDA_INPUT);
2250 }
2251 }
Takashi Iwai97ec5582006-03-21 11:29:07 +01002252 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002253 return 0;
2254}
2255
Takashi Iwai352f7f92012-12-19 12:52:06 +01002256static bool is_inv_dmic_pin(struct hda_codec *codec, hda_nid_t nid)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002257{
Takashi Iwai352f7f92012-12-19 12:52:06 +01002258 struct hda_gen_spec *spec = codec->spec;
2259 struct auto_pin_cfg *cfg = &spec->autocfg;
2260 unsigned int val;
2261 int i;
2262
2263 if (!spec->inv_dmic_split)
2264 return false;
2265 for (i = 0; i < cfg->num_inputs; i++) {
2266 if (cfg->inputs[i].pin != nid)
2267 continue;
2268 if (cfg->inputs[i].type != AUTO_PIN_MIC)
2269 return false;
2270 val = snd_hda_codec_get_pincfg(codec, nid);
2271 return snd_hda_get_input_pin_attr(val) == INPUT_PIN_ATTR_INT;
2272 }
2273 return false;
2274}
2275
2276static int add_single_cap_ctl(struct hda_codec *codec, const char *label,
2277 int idx, bool is_switch, unsigned int ctl,
2278 bool inv_dmic)
2279{
2280 struct hda_gen_spec *spec = codec->spec;
2281 char tmpname[44];
2282 int type = is_switch ? HDA_CTL_WIDGET_MUTE : HDA_CTL_WIDGET_VOL;
2283 const char *sfx = is_switch ? "Switch" : "Volume";
2284 unsigned int chs = inv_dmic ? 1 : 3;
2285 int err;
2286
2287 if (!ctl)
2288 return 0;
2289
2290 if (label)
2291 snprintf(tmpname, sizeof(tmpname),
2292 "%s Capture %s", label, sfx);
2293 else
2294 snprintf(tmpname, sizeof(tmpname),
2295 "Capture %s", sfx);
2296 err = add_control(spec, type, tmpname, idx,
2297 amp_val_replace_channels(ctl, chs));
2298 if (err < 0 || !inv_dmic)
2299 return err;
2300
2301 /* Make independent right kcontrol */
2302 if (label)
2303 snprintf(tmpname, sizeof(tmpname),
2304 "Inverted %s Capture %s", label, sfx);
2305 else
2306 snprintf(tmpname, sizeof(tmpname),
2307 "Inverted Capture %s", sfx);
2308 return add_control(spec, type, tmpname, idx,
2309 amp_val_replace_channels(ctl, 2));
2310}
2311
2312/* create single (and simple) capture volume and switch controls */
2313static int create_single_cap_vol_ctl(struct hda_codec *codec, int idx,
2314 unsigned int vol_ctl, unsigned int sw_ctl,
2315 bool inv_dmic)
2316{
2317 int err;
2318 err = add_single_cap_ctl(codec, NULL, idx, false, vol_ctl, inv_dmic);
2319 if (err < 0)
2320 return err;
2321 err = add_single_cap_ctl(codec, NULL, idx, true, sw_ctl, inv_dmic);
2322 if (err < 0)
2323 return err;
2324 return 0;
2325}
2326
2327/* create bound capture volume and switch controls */
2328static int create_bind_cap_vol_ctl(struct hda_codec *codec, int idx,
2329 unsigned int vol_ctl, unsigned int sw_ctl)
2330{
2331 struct hda_gen_spec *spec = codec->spec;
2332 struct snd_kcontrol_new *knew;
2333
2334 if (vol_ctl) {
Takashi Iwai12c93df2012-12-19 14:38:33 +01002335 knew = snd_hda_gen_add_kctl(spec, NULL, &cap_vol_temp);
Takashi Iwai352f7f92012-12-19 12:52:06 +01002336 if (!knew)
2337 return -ENOMEM;
2338 knew->index = idx;
2339 knew->private_value = vol_ctl;
2340 knew->subdevice = HDA_SUBDEV_AMP_FLAG;
2341 }
2342 if (sw_ctl) {
Takashi Iwai12c93df2012-12-19 14:38:33 +01002343 knew = snd_hda_gen_add_kctl(spec, NULL, &cap_sw_temp);
Takashi Iwai352f7f92012-12-19 12:52:06 +01002344 if (!knew)
2345 return -ENOMEM;
2346 knew->index = idx;
2347 knew->private_value = sw_ctl;
2348 knew->subdevice = HDA_SUBDEV_AMP_FLAG;
2349 }
2350 return 0;
2351}
2352
2353/* return the vol ctl when used first in the imux list */
2354static unsigned int get_first_cap_ctl(struct hda_codec *codec, int idx, int type)
2355{
2356 struct hda_gen_spec *spec = codec->spec;
2357 struct nid_path *path;
2358 unsigned int ctl;
2359 int i;
2360
2361 path = snd_hda_get_nid_path(codec, spec->imux_pins[idx],
2362 get_adc_nid(codec, 0, idx));
2363 if (!path)
2364 return 0;
2365 ctl = path->ctls[type];
2366 if (!ctl)
2367 return 0;
2368 for (i = 0; i < idx - 1; i++) {
2369 path = snd_hda_get_nid_path(codec, spec->imux_pins[i],
2370 get_adc_nid(codec, 0, i));
2371 if (path && path->ctls[type] == ctl)
2372 return 0;
2373 }
2374 return ctl;
2375}
2376
2377/* create individual capture volume and switch controls per input */
2378static int create_multi_cap_vol_ctl(struct hda_codec *codec)
2379{
2380 struct hda_gen_spec *spec = codec->spec;
2381 struct hda_input_mux *imux = &spec->input_mux;
2382 int i, err, type, type_idx = 0;
2383 const char *prev_label = NULL;
2384
2385 for (i = 0; i < imux->num_items; i++) {
2386 const char *label;
2387 bool inv_dmic;
2388 label = hda_get_autocfg_input_label(codec, &spec->autocfg, i);
2389 if (prev_label && !strcmp(label, prev_label))
2390 type_idx++;
2391 else
2392 type_idx = 0;
2393 prev_label = label;
2394 inv_dmic = is_inv_dmic_pin(codec, spec->imux_pins[i]);
2395
2396 for (type = 0; type < 2; type++) {
2397 err = add_single_cap_ctl(codec, label, type_idx, type,
2398 get_first_cap_ctl(codec, i, type),
2399 inv_dmic);
2400 if (err < 0)
2401 return err;
2402 }
2403 }
2404 return 0;
2405}
2406
2407static int create_capture_mixers(struct hda_codec *codec)
2408{
2409 struct hda_gen_spec *spec = codec->spec;
2410 struct hda_input_mux *imux = &spec->input_mux;
2411 int i, n, nums, err;
2412
2413 if (spec->dyn_adc_switch)
2414 nums = 1;
2415 else
2416 nums = spec->num_adc_nids;
2417
2418 if (!spec->auto_mic && imux->num_items > 1) {
2419 struct snd_kcontrol_new *knew;
Takashi Iwai624d9142012-12-19 17:41:52 +01002420 const char *name;
2421 name = nums > 1 ? "Input Source" : "Capture Source";
2422 knew = snd_hda_gen_add_kctl(spec, name, &cap_src_temp);
Takashi Iwai352f7f92012-12-19 12:52:06 +01002423 if (!knew)
2424 return -ENOMEM;
2425 knew->count = nums;
2426 }
2427
2428 for (n = 0; n < nums; n++) {
2429 bool multi = false;
2430 bool inv_dmic = false;
2431 int vol, sw;
2432
2433 vol = sw = 0;
2434 for (i = 0; i < imux->num_items; i++) {
2435 struct nid_path *path;
2436 path = snd_hda_get_nid_path(codec, spec->imux_pins[i],
2437 get_adc_nid(codec, n, i));
2438 if (!path)
2439 continue;
2440 parse_capvol_in_path(codec, path);
2441 if (!vol)
2442 vol = path->ctls[NID_PATH_VOL_CTL];
2443 else if (vol != path->ctls[NID_PATH_VOL_CTL])
2444 multi = true;
2445 if (!sw)
2446 sw = path->ctls[NID_PATH_MUTE_CTL];
2447 else if (sw != path->ctls[NID_PATH_MUTE_CTL])
2448 multi = true;
2449 if (is_inv_dmic_pin(codec, spec->imux_pins[i]))
2450 inv_dmic = true;
2451 }
2452
2453 if (!multi)
2454 err = create_single_cap_vol_ctl(codec, n, vol, sw,
2455 inv_dmic);
2456 else if (!spec->multi_cap_vol)
2457 err = create_bind_cap_vol_ctl(codec, n, vol, sw);
2458 else
2459 err = create_multi_cap_vol_ctl(codec);
2460 if (err < 0)
2461 return err;
2462 }
2463
2464 return 0;
2465}
2466
2467/*
2468 * add mic boosts if needed
2469 */
2470static int parse_mic_boost(struct hda_codec *codec)
2471{
2472 struct hda_gen_spec *spec = codec->spec;
2473 struct auto_pin_cfg *cfg = &spec->autocfg;
Takashi Iwai071c73a2006-08-23 18:34:06 +02002474 int i, err;
Takashi Iwai352f7f92012-12-19 12:52:06 +01002475 int type_idx = 0;
2476 hda_nid_t nid;
2477 const char *prev_label = NULL;
2478
2479 for (i = 0; i < cfg->num_inputs; i++) {
2480 if (cfg->inputs[i].type > AUTO_PIN_MIC)
2481 break;
2482 nid = cfg->inputs[i].pin;
2483 if (get_wcaps(codec, nid) & AC_WCAP_IN_AMP) {
2484 const char *label;
Takashi Iwai5abd4882013-01-07 09:43:18 +01002485 char boost_label[44];
Takashi Iwai352f7f92012-12-19 12:52:06 +01002486 struct nid_path *path;
2487 unsigned int val;
2488
2489 label = hda_get_autocfg_input_label(codec, cfg, i);
2490 if (spec->shared_mic_hp && !strcmp(label, "Misc"))
2491 label = "Headphone Mic";
2492 if (prev_label && !strcmp(label, prev_label))
2493 type_idx++;
2494 else
2495 type_idx = 0;
2496 prev_label = label;
2497
2498 snprintf(boost_label, sizeof(boost_label),
2499 "%s Boost Volume", label);
2500 val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT);
2501 err = add_control(spec, HDA_CTL_WIDGET_VOL,
2502 boost_label, type_idx, val);
2503 if (err < 0)
2504 return err;
2505
2506 path = snd_hda_get_nid_path(codec, nid, 0);
2507 if (path)
2508 path->ctls[NID_PATH_BOOST_CTL] = val;
2509 }
2510 }
2511 return 0;
2512}
2513
2514/*
2515 * parse digital I/Os and set up NIDs in BIOS auto-parse mode
2516 */
2517static void parse_digital(struct hda_codec *codec)
2518{
2519 struct hda_gen_spec *spec = codec->spec;
Takashi Iwai0c8c0f52012-12-20 17:54:22 +01002520 struct nid_path *path;
Takashi Iwai352f7f92012-12-19 12:52:06 +01002521 int i, nums;
2522 hda_nid_t dig_nid;
2523
2524 /* support multiple SPDIFs; the secondary is set up as a slave */
2525 nums = 0;
2526 for (i = 0; i < spec->autocfg.dig_outs; i++) {
2527 hda_nid_t pin = spec->autocfg.dig_out_pins[i];
2528 dig_nid = look_for_dac(codec, pin, true);
2529 if (!dig_nid)
2530 continue;
Takashi Iwai4ac0eef2012-12-20 18:10:51 +01002531 path = snd_hda_add_new_path(codec, dig_nid, pin, HDA_PARSE_ALL);
Takashi Iwai0c8c0f52012-12-20 17:54:22 +01002532 if (!path)
Takashi Iwai352f7f92012-12-19 12:52:06 +01002533 continue;
Takashi Iwai0c8c0f52012-12-20 17:54:22 +01002534 print_nid_path("digout", path);
Takashi Iwaie1284af2013-01-03 16:33:02 +01002535 path->active = true;
Takashi Iwai196c17662013-01-04 15:01:40 +01002536 spec->digout_paths[i] = snd_hda_get_path_idx(codec, path);
Takashi Iwai352f7f92012-12-19 12:52:06 +01002537 if (!nums) {
2538 spec->multiout.dig_out_nid = dig_nid;
2539 spec->dig_out_type = spec->autocfg.dig_out_type[0];
2540 } else {
2541 spec->multiout.slave_dig_outs = spec->slave_dig_outs;
2542 if (nums >= ARRAY_SIZE(spec->slave_dig_outs) - 1)
2543 break;
2544 spec->slave_dig_outs[nums - 1] = dig_nid;
2545 }
2546 nums++;
2547 }
2548
2549 if (spec->autocfg.dig_in_pin) {
2550 dig_nid = codec->start_nid;
2551 for (i = 0; i < codec->num_nodes; i++, dig_nid++) {
Takashi Iwai352f7f92012-12-19 12:52:06 +01002552 unsigned int wcaps = get_wcaps(codec, dig_nid);
2553 if (get_wcaps_type(wcaps) != AC_WID_AUD_IN)
2554 continue;
2555 if (!(wcaps & AC_WCAP_DIGITAL))
2556 continue;
2557 path = snd_hda_add_new_path(codec,
2558 spec->autocfg.dig_in_pin,
Takashi Iwai4ac0eef2012-12-20 18:10:51 +01002559 dig_nid, HDA_PARSE_ALL);
Takashi Iwai352f7f92012-12-19 12:52:06 +01002560 if (path) {
Takashi Iwai0c8c0f52012-12-20 17:54:22 +01002561 print_nid_path("digin", path);
Takashi Iwai352f7f92012-12-19 12:52:06 +01002562 path->active = true;
2563 spec->dig_in_nid = dig_nid;
Takashi Iwai2430d7b2013-01-04 15:09:42 +01002564 spec->digin_path = snd_hda_get_path_idx(codec, path);
Takashi Iwai352f7f92012-12-19 12:52:06 +01002565 break;
2566 }
2567 }
2568 }
2569}
2570
2571
2572/*
2573 * input MUX handling
2574 */
2575
2576static bool dyn_adc_pcm_resetup(struct hda_codec *codec, int cur);
2577
2578/* select the given imux item; either unmute exclusively or select the route */
2579static int mux_select(struct hda_codec *codec, unsigned int adc_idx,
2580 unsigned int idx)
2581{
2582 struct hda_gen_spec *spec = codec->spec;
2583 const struct hda_input_mux *imux;
2584 struct nid_path *path;
2585
2586 imux = &spec->input_mux;
2587 if (!imux->num_items)
2588 return 0;
2589
2590 if (idx >= imux->num_items)
2591 idx = imux->num_items - 1;
2592 if (spec->cur_mux[adc_idx] == idx)
2593 return 0;
2594
2595 path = snd_hda_get_nid_path(codec,
2596 spec->imux_pins[spec->cur_mux[adc_idx]],
2597 spec->adc_nids[adc_idx]);
2598 if (!path)
2599 return 0;
2600 if (path->active)
2601 snd_hda_activate_path(codec, path, false, false);
2602
2603 spec->cur_mux[adc_idx] = idx;
2604
2605 if (spec->shared_mic_hp)
2606 update_shared_mic_hp(codec, spec->cur_mux[adc_idx]);
2607
2608 if (spec->dyn_adc_switch)
2609 dyn_adc_pcm_resetup(codec, idx);
2610
2611 path = snd_hda_get_nid_path(codec, spec->imux_pins[idx],
2612 get_adc_nid(codec, adc_idx, idx));
2613 if (!path)
2614 return 0;
2615 if (path->active)
2616 return 0;
2617 snd_hda_activate_path(codec, path, true, false);
2618 if (spec->cap_sync_hook)
2619 spec->cap_sync_hook(codec);
2620 return 1;
2621}
2622
2623
2624/*
2625 * Jack detections for HP auto-mute and mic-switch
2626 */
2627
2628/* check each pin in the given array; returns true if any of them is plugged */
2629static bool detect_jacks(struct hda_codec *codec, int num_pins, hda_nid_t *pins)
2630{
2631 int i, present = 0;
2632
2633 for (i = 0; i < num_pins; i++) {
2634 hda_nid_t nid = pins[i];
2635 if (!nid)
2636 break;
2637 present |= snd_hda_jack_detect(codec, nid);
2638 }
2639 return present;
2640}
2641
2642/* standard HP/line-out auto-mute helper */
2643static void do_automute(struct hda_codec *codec, int num_pins, hda_nid_t *pins,
2644 bool mute, bool hp_out)
2645{
2646 struct hda_gen_spec *spec = codec->spec;
2647 unsigned int pin_bits = mute ? 0 : (hp_out ? PIN_HP : PIN_OUT);
2648 int i;
2649
2650 for (i = 0; i < num_pins; i++) {
2651 hda_nid_t nid = pins[i];
2652 unsigned int val;
2653 if (!nid)
2654 break;
2655 /* don't reset VREF value in case it's controlling
2656 * the amp (see alc861_fixup_asus_amp_vref_0f())
2657 */
2658 if (spec->keep_vref_in_automute) {
2659 val = snd_hda_codec_read(codec, nid, 0,
2660 AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
2661 val &= ~PIN_HP;
2662 } else
2663 val = 0;
2664 val |= pin_bits;
Takashi Iwai7594aa32012-12-20 15:38:40 +01002665 snd_hda_set_pin_ctl_cache(codec, nid, val);
Takashi Iwaid5a9f1b2012-12-20 15:36:30 +01002666 set_pin_eapd(codec, nid, !mute);
Takashi Iwai352f7f92012-12-19 12:52:06 +01002667 }
2668}
2669
2670/* Toggle outputs muting */
Takashi Iwai5d550e12012-12-19 15:16:44 +01002671void snd_hda_gen_update_outputs(struct hda_codec *codec)
Takashi Iwai352f7f92012-12-19 12:52:06 +01002672{
2673 struct hda_gen_spec *spec = codec->spec;
2674 int on;
2675
2676 /* Control HP pins/amps depending on master_mute state;
2677 * in general, HP pins/amps control should be enabled in all cases,
2678 * but currently set only for master_mute, just to be safe
2679 */
2680 if (!spec->shared_mic_hp) /* don't change HP-pin when shared with mic */
2681 do_automute(codec, ARRAY_SIZE(spec->autocfg.hp_pins),
2682 spec->autocfg.hp_pins, spec->master_mute, true);
2683
2684 if (!spec->automute_speaker)
2685 on = 0;
2686 else
2687 on = spec->hp_jack_present | spec->line_jack_present;
2688 on |= spec->master_mute;
2689 do_automute(codec, ARRAY_SIZE(spec->autocfg.speaker_pins),
2690 spec->autocfg.speaker_pins, on, false);
2691
2692 /* toggle line-out mutes if needed, too */
2693 /* if LO is a copy of either HP or Speaker, don't need to handle it */
2694 if (spec->autocfg.line_out_pins[0] == spec->autocfg.hp_pins[0] ||
2695 spec->autocfg.line_out_pins[0] == spec->autocfg.speaker_pins[0])
2696 return;
2697 if (!spec->automute_lo)
2698 on = 0;
2699 else
2700 on = spec->hp_jack_present;
2701 on |= spec->master_mute;
2702 do_automute(codec, ARRAY_SIZE(spec->autocfg.line_out_pins),
2703 spec->autocfg.line_out_pins, on, false);
2704}
Takashi Iwai5d550e12012-12-19 15:16:44 +01002705EXPORT_SYMBOL_HDA(snd_hda_gen_update_outputs);
Takashi Iwai352f7f92012-12-19 12:52:06 +01002706
2707static void call_update_outputs(struct hda_codec *codec)
2708{
2709 struct hda_gen_spec *spec = codec->spec;
2710 if (spec->automute_hook)
2711 spec->automute_hook(codec);
2712 else
Takashi Iwai5d550e12012-12-19 15:16:44 +01002713 snd_hda_gen_update_outputs(codec);
Takashi Iwai352f7f92012-12-19 12:52:06 +01002714}
2715
2716/* standard HP-automute helper */
Takashi Iwai5d550e12012-12-19 15:16:44 +01002717void snd_hda_gen_hp_automute(struct hda_codec *codec, struct hda_jack_tbl *jack)
Takashi Iwai352f7f92012-12-19 12:52:06 +01002718{
2719 struct hda_gen_spec *spec = codec->spec;
2720
2721 spec->hp_jack_present =
2722 detect_jacks(codec, ARRAY_SIZE(spec->autocfg.hp_pins),
2723 spec->autocfg.hp_pins);
2724 if (!spec->detect_hp || (!spec->automute_speaker && !spec->automute_lo))
2725 return;
2726 call_update_outputs(codec);
2727}
Takashi Iwai5d550e12012-12-19 15:16:44 +01002728EXPORT_SYMBOL_HDA(snd_hda_gen_hp_automute);
Takashi Iwai352f7f92012-12-19 12:52:06 +01002729
2730/* standard line-out-automute helper */
Takashi Iwai5d550e12012-12-19 15:16:44 +01002731void snd_hda_gen_line_automute(struct hda_codec *codec, struct hda_jack_tbl *jack)
Takashi Iwai352f7f92012-12-19 12:52:06 +01002732{
2733 struct hda_gen_spec *spec = codec->spec;
2734
2735 if (spec->autocfg.line_out_type == AUTO_PIN_SPEAKER_OUT)
2736 return;
2737 /* check LO jack only when it's different from HP */
2738 if (spec->autocfg.line_out_pins[0] == spec->autocfg.hp_pins[0])
2739 return;
2740
2741 spec->line_jack_present =
2742 detect_jacks(codec, ARRAY_SIZE(spec->autocfg.line_out_pins),
2743 spec->autocfg.line_out_pins);
2744 if (!spec->automute_speaker || !spec->detect_lo)
2745 return;
2746 call_update_outputs(codec);
2747}
Takashi Iwai5d550e12012-12-19 15:16:44 +01002748EXPORT_SYMBOL_HDA(snd_hda_gen_line_automute);
Takashi Iwai352f7f92012-12-19 12:52:06 +01002749
2750/* standard mic auto-switch helper */
Takashi Iwai5d550e12012-12-19 15:16:44 +01002751void snd_hda_gen_mic_autoswitch(struct hda_codec *codec, struct hda_jack_tbl *jack)
Takashi Iwai352f7f92012-12-19 12:52:06 +01002752{
2753 struct hda_gen_spec *spec = codec->spec;
2754 int i;
2755
2756 if (!spec->auto_mic)
2757 return;
2758
2759 for (i = spec->am_num_entries - 1; i > 0; i--) {
2760 if (snd_hda_jack_detect(codec, spec->am_entry[i].pin)) {
2761 mux_select(codec, 0, spec->am_entry[i].idx);
2762 return;
2763 }
2764 }
2765 mux_select(codec, 0, spec->am_entry[0].idx);
2766}
Takashi Iwai5d550e12012-12-19 15:16:44 +01002767EXPORT_SYMBOL_HDA(snd_hda_gen_mic_autoswitch);
Takashi Iwai352f7f92012-12-19 12:52:06 +01002768
2769/*
2770 * Auto-Mute mode mixer enum support
2771 */
2772static int automute_mode_info(struct snd_kcontrol *kcontrol,
2773 struct snd_ctl_elem_info *uinfo)
2774{
2775 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2776 struct hda_gen_spec *spec = codec->spec;
2777 static const char * const texts3[] = {
2778 "Disabled", "Speaker Only", "Line Out+Speaker"
Takashi Iwai071c73a2006-08-23 18:34:06 +02002779 };
Linus Torvalds1da177e2005-04-16 15:20:36 -07002780
Takashi Iwai352f7f92012-12-19 12:52:06 +01002781 if (spec->automute_speaker_possible && spec->automute_lo_possible)
2782 return snd_hda_enum_helper_info(kcontrol, uinfo, 3, texts3);
2783 return snd_hda_enum_bool_helper_info(kcontrol, uinfo);
2784}
Linus Torvalds1da177e2005-04-16 15:20:36 -07002785
Takashi Iwai352f7f92012-12-19 12:52:06 +01002786static int automute_mode_get(struct snd_kcontrol *kcontrol,
2787 struct snd_ctl_elem_value *ucontrol)
2788{
2789 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2790 struct hda_gen_spec *spec = codec->spec;
2791 unsigned int val = 0;
2792 if (spec->automute_speaker)
2793 val++;
2794 if (spec->automute_lo)
2795 val++;
Takashi Iwai071c73a2006-08-23 18:34:06 +02002796
Takashi Iwai352f7f92012-12-19 12:52:06 +01002797 ucontrol->value.enumerated.item[0] = val;
2798 return 0;
2799}
2800
2801static int automute_mode_put(struct snd_kcontrol *kcontrol,
2802 struct snd_ctl_elem_value *ucontrol)
2803{
2804 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2805 struct hda_gen_spec *spec = codec->spec;
2806
2807 switch (ucontrol->value.enumerated.item[0]) {
2808 case 0:
2809 if (!spec->automute_speaker && !spec->automute_lo)
2810 return 0;
2811 spec->automute_speaker = 0;
2812 spec->automute_lo = 0;
2813 break;
2814 case 1:
2815 if (spec->automute_speaker_possible) {
2816 if (!spec->automute_lo && spec->automute_speaker)
2817 return 0;
2818 spec->automute_speaker = 1;
2819 spec->automute_lo = 0;
2820 } else if (spec->automute_lo_possible) {
2821 if (spec->automute_lo)
2822 return 0;
2823 spec->automute_lo = 1;
2824 } else
2825 return -EINVAL;
2826 break;
2827 case 2:
2828 if (!spec->automute_lo_possible || !spec->automute_speaker_possible)
2829 return -EINVAL;
2830 if (spec->automute_speaker && spec->automute_lo)
2831 return 0;
2832 spec->automute_speaker = 1;
2833 spec->automute_lo = 1;
2834 break;
2835 default:
2836 return -EINVAL;
2837 }
2838 call_update_outputs(codec);
2839 return 1;
2840}
2841
2842static const struct snd_kcontrol_new automute_mode_enum = {
2843 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2844 .name = "Auto-Mute Mode",
2845 .info = automute_mode_info,
2846 .get = automute_mode_get,
2847 .put = automute_mode_put,
2848};
2849
2850static int add_automute_mode_enum(struct hda_codec *codec)
2851{
2852 struct hda_gen_spec *spec = codec->spec;
2853
Takashi Iwai12c93df2012-12-19 14:38:33 +01002854 if (!snd_hda_gen_add_kctl(spec, NULL, &automute_mode_enum))
Takashi Iwai352f7f92012-12-19 12:52:06 +01002855 return -ENOMEM;
2856 return 0;
2857}
2858
2859/*
2860 * Check the availability of HP/line-out auto-mute;
2861 * Set up appropriately if really supported
2862 */
2863static int check_auto_mute_availability(struct hda_codec *codec)
2864{
2865 struct hda_gen_spec *spec = codec->spec;
2866 struct auto_pin_cfg *cfg = &spec->autocfg;
2867 int present = 0;
2868 int i, err;
2869
2870 if (cfg->hp_pins[0])
2871 present++;
2872 if (cfg->line_out_pins[0])
2873 present++;
2874 if (cfg->speaker_pins[0])
2875 present++;
2876 if (present < 2) /* need two different output types */
Takashi Iwai071c73a2006-08-23 18:34:06 +02002877 return 0;
Takashi Iwai352f7f92012-12-19 12:52:06 +01002878
2879 if (!cfg->speaker_pins[0] &&
2880 cfg->line_out_type == AUTO_PIN_SPEAKER_OUT) {
2881 memcpy(cfg->speaker_pins, cfg->line_out_pins,
2882 sizeof(cfg->speaker_pins));
2883 cfg->speaker_outs = cfg->line_outs;
Takashi Iwai071c73a2006-08-23 18:34:06 +02002884 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002885
Takashi Iwai352f7f92012-12-19 12:52:06 +01002886 if (!cfg->hp_pins[0] &&
2887 cfg->line_out_type == AUTO_PIN_HP_OUT) {
2888 memcpy(cfg->hp_pins, cfg->line_out_pins,
2889 sizeof(cfg->hp_pins));
2890 cfg->hp_outs = cfg->line_outs;
2891 }
2892
2893 for (i = 0; i < cfg->hp_outs; i++) {
2894 hda_nid_t nid = cfg->hp_pins[i];
2895 if (!is_jack_detectable(codec, nid))
2896 continue;
2897 snd_printdd("hda-codec: Enable HP auto-muting on NID 0x%x\n",
2898 nid);
2899 snd_hda_jack_detect_enable_callback(codec, nid, HDA_GEN_HP_EVENT,
Takashi Iwai2e03e952013-01-03 15:55:06 +01002900 spec->hp_automute_hook ?
2901 spec->hp_automute_hook :
Takashi Iwai5d550e12012-12-19 15:16:44 +01002902 snd_hda_gen_hp_automute);
Takashi Iwai352f7f92012-12-19 12:52:06 +01002903 spec->detect_hp = 1;
2904 }
2905
2906 if (cfg->line_out_type == AUTO_PIN_LINE_OUT && cfg->line_outs) {
2907 if (cfg->speaker_outs)
2908 for (i = 0; i < cfg->line_outs; i++) {
2909 hda_nid_t nid = cfg->line_out_pins[i];
2910 if (!is_jack_detectable(codec, nid))
2911 continue;
2912 snd_printdd("hda-codec: Enable Line-Out auto-muting on NID 0x%x\n", nid);
2913 snd_hda_jack_detect_enable_callback(codec, nid,
2914 HDA_GEN_FRONT_EVENT,
Takashi Iwai2e03e952013-01-03 15:55:06 +01002915 spec->line_automute_hook ?
2916 spec->line_automute_hook :
Takashi Iwai5d550e12012-12-19 15:16:44 +01002917 snd_hda_gen_line_automute);
Takashi Iwai352f7f92012-12-19 12:52:06 +01002918 spec->detect_lo = 1;
2919 }
2920 spec->automute_lo_possible = spec->detect_hp;
2921 }
2922
2923 spec->automute_speaker_possible = cfg->speaker_outs &&
2924 (spec->detect_hp || spec->detect_lo);
2925
2926 spec->automute_lo = spec->automute_lo_possible;
2927 spec->automute_speaker = spec->automute_speaker_possible;
2928
2929 if (spec->automute_speaker_possible || spec->automute_lo_possible) {
2930 /* create a control for automute mode */
2931 err = add_automute_mode_enum(codec);
2932 if (err < 0)
2933 return err;
2934 }
2935 return 0;
2936}
2937
2938/* return the position of NID in the list, or -1 if not found */
2939static int find_idx_in_nid_list(hda_nid_t nid, const hda_nid_t *list, int nums)
2940{
2941 int i;
2942 for (i = 0; i < nums; i++)
2943 if (list[i] == nid)
2944 return i;
2945 return -1;
2946}
2947
2948/* check whether all auto-mic pins are valid; setup indices if OK */
2949static bool auto_mic_check_imux(struct hda_codec *codec)
2950{
2951 struct hda_gen_spec *spec = codec->spec;
2952 const struct hda_input_mux *imux;
2953 int i;
2954
2955 imux = &spec->input_mux;
2956 for (i = 0; i < spec->am_num_entries; i++) {
2957 spec->am_entry[i].idx =
2958 find_idx_in_nid_list(spec->am_entry[i].pin,
2959 spec->imux_pins, imux->num_items);
2960 if (spec->am_entry[i].idx < 0)
2961 return false; /* no corresponding imux */
2962 }
2963
2964 /* we don't need the jack detection for the first pin */
2965 for (i = 1; i < spec->am_num_entries; i++)
2966 snd_hda_jack_detect_enable_callback(codec,
2967 spec->am_entry[i].pin,
2968 HDA_GEN_MIC_EVENT,
Takashi Iwai2e03e952013-01-03 15:55:06 +01002969 spec->mic_autoswitch_hook ?
2970 spec->mic_autoswitch_hook :
Takashi Iwai5d550e12012-12-19 15:16:44 +01002971 snd_hda_gen_mic_autoswitch);
Takashi Iwai352f7f92012-12-19 12:52:06 +01002972 return true;
2973}
2974
2975static int compare_attr(const void *ap, const void *bp)
2976{
2977 const struct automic_entry *a = ap;
2978 const struct automic_entry *b = bp;
2979 return (int)(a->attr - b->attr);
2980}
2981
2982/*
2983 * Check the availability of auto-mic switch;
2984 * Set up if really supported
2985 */
2986static int check_auto_mic_availability(struct hda_codec *codec)
2987{
2988 struct hda_gen_spec *spec = codec->spec;
2989 struct auto_pin_cfg *cfg = &spec->autocfg;
2990 unsigned int types;
2991 int i, num_pins;
2992
2993 types = 0;
2994 num_pins = 0;
2995 for (i = 0; i < cfg->num_inputs; i++) {
2996 hda_nid_t nid = cfg->inputs[i].pin;
2997 unsigned int attr;
2998 attr = snd_hda_codec_get_pincfg(codec, nid);
2999 attr = snd_hda_get_input_pin_attr(attr);
3000 if (types & (1 << attr))
3001 return 0; /* already occupied */
3002 switch (attr) {
3003 case INPUT_PIN_ATTR_INT:
3004 if (cfg->inputs[i].type != AUTO_PIN_MIC)
3005 return 0; /* invalid type */
3006 break;
3007 case INPUT_PIN_ATTR_UNUSED:
3008 return 0; /* invalid entry */
3009 default:
3010 if (cfg->inputs[i].type > AUTO_PIN_LINE_IN)
3011 return 0; /* invalid type */
3012 if (!spec->line_in_auto_switch &&
3013 cfg->inputs[i].type != AUTO_PIN_MIC)
3014 return 0; /* only mic is allowed */
3015 if (!is_jack_detectable(codec, nid))
3016 return 0; /* no unsol support */
3017 break;
3018 }
3019 if (num_pins >= MAX_AUTO_MIC_PINS)
3020 return 0;
3021 types |= (1 << attr);
3022 spec->am_entry[num_pins].pin = nid;
3023 spec->am_entry[num_pins].attr = attr;
3024 num_pins++;
3025 }
3026
3027 if (num_pins < 2)
3028 return 0;
3029
3030 spec->am_num_entries = num_pins;
3031 /* sort the am_entry in the order of attr so that the pin with a
3032 * higher attr will be selected when the jack is plugged.
3033 */
3034 sort(spec->am_entry, num_pins, sizeof(spec->am_entry[0]),
3035 compare_attr, NULL);
3036
3037 if (!auto_mic_check_imux(codec))
3038 return 0;
3039
3040 spec->auto_mic = 1;
3041 spec->num_adc_nids = 1;
3042 spec->cur_mux[0] = spec->am_entry[0].idx;
3043 snd_printdd("hda-codec: Enable auto-mic switch on NID 0x%x/0x%x/0x%x\n",
3044 spec->am_entry[0].pin,
3045 spec->am_entry[1].pin,
3046 spec->am_entry[2].pin);
3047
3048 return 0;
3049}
3050
3051
Takashi Iwai9eb413e2012-12-19 14:41:21 +01003052/*
3053 * Parse the given BIOS configuration and set up the hda_gen_spec
3054 *
3055 * return 1 if successful, 0 if the proper config is not found,
Takashi Iwai352f7f92012-12-19 12:52:06 +01003056 * or a negative error code
3057 */
3058int snd_hda_gen_parse_auto_config(struct hda_codec *codec,
Takashi Iwai9eb413e2012-12-19 14:41:21 +01003059 struct auto_pin_cfg *cfg)
Takashi Iwai352f7f92012-12-19 12:52:06 +01003060{
3061 struct hda_gen_spec *spec = codec->spec;
Takashi Iwai352f7f92012-12-19 12:52:06 +01003062 int err;
3063
Takashi Iwai9eb413e2012-12-19 14:41:21 +01003064 if (cfg != &spec->autocfg) {
3065 spec->autocfg = *cfg;
3066 cfg = &spec->autocfg;
3067 }
3068
Takashi Iwai352f7f92012-12-19 12:52:06 +01003069 if (!cfg->line_outs) {
3070 if (cfg->dig_outs || cfg->dig_in_pin) {
3071 spec->multiout.max_channels = 2;
3072 spec->no_analog = 1;
3073 goto dig_only;
3074 }
3075 return 0; /* can't find valid BIOS pin config */
3076 }
3077
3078 if (!spec->no_primary_hp &&
3079 cfg->line_out_type == AUTO_PIN_SPEAKER_OUT &&
3080 cfg->line_outs <= cfg->hp_outs) {
3081 /* use HP as primary out */
3082 cfg->speaker_outs = cfg->line_outs;
3083 memcpy(cfg->speaker_pins, cfg->line_out_pins,
3084 sizeof(cfg->speaker_pins));
3085 cfg->line_outs = cfg->hp_outs;
3086 memcpy(cfg->line_out_pins, cfg->hp_pins, sizeof(cfg->hp_pins));
3087 cfg->hp_outs = 0;
3088 memset(cfg->hp_pins, 0, sizeof(cfg->hp_pins));
3089 cfg->line_out_type = AUTO_PIN_HP_OUT;
3090 }
3091
3092 err = parse_output_paths(codec);
3093 if (err < 0)
3094 return err;
3095 err = create_multi_channel_mode(codec);
3096 if (err < 0)
3097 return err;
3098 err = create_multi_out_ctls(codec, cfg);
3099 if (err < 0)
3100 return err;
3101 err = create_hp_out_ctls(codec);
3102 if (err < 0)
3103 return err;
3104 err = create_speaker_out_ctls(codec);
3105 if (err < 0)
3106 return err;
Takashi Iwai38cf6f12012-12-21 14:09:42 +01003107 err = create_indep_hp_ctls(codec);
3108 if (err < 0)
3109 return err;
Takashi Iwaic30aa7b2013-01-04 16:42:48 +01003110 err = create_loopback_mixing_ctl(codec);
3111 if (err < 0)
3112 return err;
Takashi Iwai352f7f92012-12-19 12:52:06 +01003113 err = create_shared_input(codec);
3114 if (err < 0)
3115 return err;
3116 err = create_input_ctls(codec);
Takashi Iwaid13bd412008-07-30 15:01:45 +02003117 if (err < 0)
Takashi Iwai071c73a2006-08-23 18:34:06 +02003118 return err;
3119
Takashi Iwai352f7f92012-12-19 12:52:06 +01003120 /* check the multiple speaker pins */
3121 if (cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
3122 spec->const_channel_count = cfg->line_outs * 2;
3123 else
3124 spec->const_channel_count = cfg->speaker_outs * 2;
Takashi Iwai071c73a2006-08-23 18:34:06 +02003125
Takashi Iwai352f7f92012-12-19 12:52:06 +01003126 if (spec->multi_ios > 0)
3127 spec->multiout.max_channels = max(spec->ext_channel_count,
3128 spec->const_channel_count);
3129 else
3130 spec->multiout.max_channels = spec->multiout.num_dacs * 2;
3131
3132 err = check_auto_mute_availability(codec);
3133 if (err < 0)
3134 return err;
3135
3136 err = check_dyn_adc_switch(codec);
3137 if (err < 0)
3138 return err;
3139
3140 if (!spec->shared_mic_hp) {
3141 err = check_auto_mic_availability(codec);
Takashi Iwaid13bd412008-07-30 15:01:45 +02003142 if (err < 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003143 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003144 }
Takashi Iwai071c73a2006-08-23 18:34:06 +02003145
Takashi Iwai352f7f92012-12-19 12:52:06 +01003146 err = create_capture_mixers(codec);
3147 if (err < 0)
3148 return err;
3149
3150 err = parse_mic_boost(codec);
3151 if (err < 0)
3152 return err;
3153
3154 dig_only:
3155 parse_digital(codec);
3156
3157 return 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003158}
Takashi Iwai352f7f92012-12-19 12:52:06 +01003159EXPORT_SYMBOL_HDA(snd_hda_gen_parse_auto_config);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003160
3161
3162/*
Takashi Iwai352f7f92012-12-19 12:52:06 +01003163 * Build control elements
Linus Torvalds1da177e2005-04-16 15:20:36 -07003164 */
Takashi Iwai352f7f92012-12-19 12:52:06 +01003165
3166/* slave controls for virtual master */
3167static const char * const slave_pfxs[] = {
3168 "Front", "Surround", "Center", "LFE", "Side",
3169 "Headphone", "Speaker", "Mono", "Line Out",
3170 "CLFE", "Bass Speaker", "PCM",
Takashi Iwaiee79c692013-01-07 09:57:42 +01003171 "Speaker Front", "Speaker Surround", "Speaker CLFE", "Speaker Side",
3172 "Headphone Front", "Headphone Surround", "Headphone CLFE",
3173 "Headphone Side",
Takashi Iwai352f7f92012-12-19 12:52:06 +01003174 NULL,
3175};
3176
3177int snd_hda_gen_build_controls(struct hda_codec *codec)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003178{
Takashi Iwai352f7f92012-12-19 12:52:06 +01003179 struct hda_gen_spec *spec = codec->spec;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003180 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003181
Takashi Iwai36502d02012-12-19 15:15:10 +01003182 if (spec->kctls.used) {
3183 err = snd_hda_add_new_ctls(codec, spec->kctls.list);
3184 if (err < 0)
3185 return err;
3186 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003187
Takashi Iwai352f7f92012-12-19 12:52:06 +01003188 if (spec->multiout.dig_out_nid) {
3189 err = snd_hda_create_dig_out_ctls(codec,
3190 spec->multiout.dig_out_nid,
3191 spec->multiout.dig_out_nid,
3192 spec->pcm_rec[1].pcm_type);
3193 if (err < 0)
3194 return err;
3195 if (!spec->no_analog) {
3196 err = snd_hda_create_spdif_share_sw(codec,
3197 &spec->multiout);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003198 if (err < 0)
3199 return err;
Takashi Iwai352f7f92012-12-19 12:52:06 +01003200 spec->multiout.share_spdif = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003201 }
3202 }
Takashi Iwai352f7f92012-12-19 12:52:06 +01003203 if (spec->dig_in_nid) {
3204 err = snd_hda_create_spdif_in_ctls(codec, spec->dig_in_nid);
3205 if (err < 0)
3206 return err;
3207 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003208
Takashi Iwai352f7f92012-12-19 12:52:06 +01003209 /* if we have no master control, let's create it */
3210 if (!spec->no_analog &&
3211 !snd_hda_find_mixer_ctl(codec, "Master Playback Volume")) {
3212 unsigned int vmaster_tlv[4];
3213 snd_hda_set_vmaster_tlv(codec, spec->vmaster_nid,
3214 HDA_OUTPUT, vmaster_tlv);
3215 err = snd_hda_add_vmaster(codec, "Master Playback Volume",
3216 vmaster_tlv, slave_pfxs,
3217 "Playback Volume");
3218 if (err < 0)
3219 return err;
3220 }
3221 if (!spec->no_analog &&
3222 !snd_hda_find_mixer_ctl(codec, "Master Playback Switch")) {
3223 err = __snd_hda_add_vmaster(codec, "Master Playback Switch",
3224 NULL, slave_pfxs,
3225 "Playback Switch",
3226 true, &spec->vmaster_mute.sw_kctl);
3227 if (err < 0)
3228 return err;
3229 if (spec->vmaster_mute.hook)
Takashi Iwaifd25a972012-12-20 14:57:18 +01003230 snd_hda_add_vmaster_hook(codec, &spec->vmaster_mute,
3231 spec->vmaster_mute_enum);
Takashi Iwai352f7f92012-12-19 12:52:06 +01003232 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003233
Takashi Iwai352f7f92012-12-19 12:52:06 +01003234 free_kctls(spec); /* no longer needed */
3235
3236 if (spec->shared_mic_hp) {
3237 int err;
3238 int nid = spec->autocfg.inputs[1].pin;
3239 err = snd_hda_jack_add_kctl(codec, nid, "Headphone Mic", 0);
3240 if (err < 0)
3241 return err;
3242 err = snd_hda_jack_detect_enable(codec, nid, 0);
3243 if (err < 0)
3244 return err;
3245 }
3246
3247 err = snd_hda_jack_add_kctls(codec, &spec->autocfg);
3248 if (err < 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003249 return err;
3250
3251 return 0;
3252}
Takashi Iwai352f7f92012-12-19 12:52:06 +01003253EXPORT_SYMBOL_HDA(snd_hda_gen_build_controls);
3254
Linus Torvalds1da177e2005-04-16 15:20:36 -07003255
3256/*
Takashi Iwai352f7f92012-12-19 12:52:06 +01003257 * PCM definitions
Linus Torvalds1da177e2005-04-16 15:20:36 -07003258 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003259
Takashi Iwaie6b85f32013-01-07 11:54:34 +01003260static void call_pcm_playback_hook(struct hda_pcm_stream *hinfo,
3261 struct hda_codec *codec,
3262 struct snd_pcm_substream *substream,
3263 int action)
3264{
3265 struct hda_gen_spec *spec = codec->spec;
3266 if (spec->pcm_playback_hook)
3267 spec->pcm_playback_hook(hinfo, codec, substream, action);
3268}
3269
Takashi Iwai352f7f92012-12-19 12:52:06 +01003270/*
3271 * Analog playback callbacks
3272 */
3273static int playback_pcm_open(struct hda_pcm_stream *hinfo,
3274 struct hda_codec *codec,
3275 struct snd_pcm_substream *substream)
3276{
3277 struct hda_gen_spec *spec = codec->spec;
Takashi Iwai38cf6f12012-12-21 14:09:42 +01003278 int err;
3279
3280 mutex_lock(&spec->pcm_mutex);
3281 err = snd_hda_multi_out_analog_open(codec,
3282 &spec->multiout, substream,
Takashi Iwai352f7f92012-12-19 12:52:06 +01003283 hinfo);
Takashi Iwaie6b85f32013-01-07 11:54:34 +01003284 if (!err) {
Takashi Iwai38cf6f12012-12-21 14:09:42 +01003285 spec->active_streams |= 1 << STREAM_MULTI_OUT;
Takashi Iwaie6b85f32013-01-07 11:54:34 +01003286 call_pcm_playback_hook(hinfo, codec, substream,
3287 HDA_GEN_PCM_ACT_OPEN);
3288 }
Takashi Iwai38cf6f12012-12-21 14:09:42 +01003289 mutex_unlock(&spec->pcm_mutex);
3290 return err;
Takashi Iwai352f7f92012-12-19 12:52:06 +01003291}
3292
3293static int playback_pcm_prepare(struct hda_pcm_stream *hinfo,
Takashi Iwai97ec5582006-03-21 11:29:07 +01003294 struct hda_codec *codec,
3295 unsigned int stream_tag,
3296 unsigned int format,
3297 struct snd_pcm_substream *substream)
3298{
Takashi Iwai352f7f92012-12-19 12:52:06 +01003299 struct hda_gen_spec *spec = codec->spec;
Takashi Iwaie6b85f32013-01-07 11:54:34 +01003300 int err;
3301
3302 err = snd_hda_multi_out_analog_prepare(codec, &spec->multiout,
3303 stream_tag, format, substream);
3304 if (!err)
3305 call_pcm_playback_hook(hinfo, codec, substream,
3306 HDA_GEN_PCM_ACT_PREPARE);
3307 return err;
Takashi Iwai352f7f92012-12-19 12:52:06 +01003308}
Takashi Iwai97ec5582006-03-21 11:29:07 +01003309
Takashi Iwai352f7f92012-12-19 12:52:06 +01003310static int playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
3311 struct hda_codec *codec,
3312 struct snd_pcm_substream *substream)
3313{
3314 struct hda_gen_spec *spec = codec->spec;
Takashi Iwaie6b85f32013-01-07 11:54:34 +01003315 int err;
3316
3317 err = snd_hda_multi_out_analog_cleanup(codec, &spec->multiout);
3318 if (!err)
3319 call_pcm_playback_hook(hinfo, codec, substream,
3320 HDA_GEN_PCM_ACT_CLEANUP);
3321 return err;
Takashi Iwai352f7f92012-12-19 12:52:06 +01003322}
3323
Takashi Iwai38cf6f12012-12-21 14:09:42 +01003324static int playback_pcm_close(struct hda_pcm_stream *hinfo,
3325 struct hda_codec *codec,
3326 struct snd_pcm_substream *substream)
3327{
3328 struct hda_gen_spec *spec = codec->spec;
3329 mutex_lock(&spec->pcm_mutex);
3330 spec->active_streams &= ~(1 << STREAM_MULTI_OUT);
Takashi Iwaie6b85f32013-01-07 11:54:34 +01003331 call_pcm_playback_hook(hinfo, codec, substream,
3332 HDA_GEN_PCM_ACT_CLOSE);
Takashi Iwai38cf6f12012-12-21 14:09:42 +01003333 mutex_unlock(&spec->pcm_mutex);
3334 return 0;
3335}
3336
3337static int alt_playback_pcm_open(struct hda_pcm_stream *hinfo,
3338 struct hda_codec *codec,
3339 struct snd_pcm_substream *substream)
3340{
3341 struct hda_gen_spec *spec = codec->spec;
3342 int err = 0;
3343
3344 mutex_lock(&spec->pcm_mutex);
3345 if (!spec->indep_hp_enabled)
3346 err = -EBUSY;
3347 else
3348 spec->active_streams |= 1 << STREAM_INDEP_HP;
Takashi Iwaie6b85f32013-01-07 11:54:34 +01003349 call_pcm_playback_hook(hinfo, codec, substream,
3350 HDA_GEN_PCM_ACT_OPEN);
Takashi Iwai38cf6f12012-12-21 14:09:42 +01003351 mutex_unlock(&spec->pcm_mutex);
3352 return err;
3353}
3354
3355static int alt_playback_pcm_close(struct hda_pcm_stream *hinfo,
3356 struct hda_codec *codec,
3357 struct snd_pcm_substream *substream)
3358{
3359 struct hda_gen_spec *spec = codec->spec;
3360 mutex_lock(&spec->pcm_mutex);
3361 spec->active_streams &= ~(1 << STREAM_INDEP_HP);
Takashi Iwaie6b85f32013-01-07 11:54:34 +01003362 call_pcm_playback_hook(hinfo, codec, substream,
3363 HDA_GEN_PCM_ACT_CLOSE);
Takashi Iwai38cf6f12012-12-21 14:09:42 +01003364 mutex_unlock(&spec->pcm_mutex);
3365 return 0;
3366}
3367
Takashi Iwaie6b85f32013-01-07 11:54:34 +01003368static int alt_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
3369 struct hda_codec *codec,
3370 unsigned int stream_tag,
3371 unsigned int format,
3372 struct snd_pcm_substream *substream)
3373{
3374 snd_hda_codec_setup_stream(codec, hinfo->nid, stream_tag, 0, format);
3375 call_pcm_playback_hook(hinfo, codec, substream,
3376 HDA_GEN_PCM_ACT_PREPARE);
3377 return 0;
3378}
3379
3380static int alt_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
3381 struct hda_codec *codec,
3382 struct snd_pcm_substream *substream)
3383{
3384 snd_hda_codec_cleanup_stream(codec, hinfo->nid);
3385 call_pcm_playback_hook(hinfo, codec, substream,
3386 HDA_GEN_PCM_ACT_CLEANUP);
3387 return 0;
3388}
3389
Takashi Iwai352f7f92012-12-19 12:52:06 +01003390/*
3391 * Digital out
3392 */
3393static int dig_playback_pcm_open(struct hda_pcm_stream *hinfo,
3394 struct hda_codec *codec,
3395 struct snd_pcm_substream *substream)
3396{
3397 struct hda_gen_spec *spec = codec->spec;
3398 return snd_hda_multi_out_dig_open(codec, &spec->multiout);
3399}
3400
3401static int dig_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
3402 struct hda_codec *codec,
3403 unsigned int stream_tag,
3404 unsigned int format,
3405 struct snd_pcm_substream *substream)
3406{
3407 struct hda_gen_spec *spec = codec->spec;
3408 return snd_hda_multi_out_dig_prepare(codec, &spec->multiout,
3409 stream_tag, format, substream);
3410}
3411
3412static int dig_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
3413 struct hda_codec *codec,
3414 struct snd_pcm_substream *substream)
3415{
3416 struct hda_gen_spec *spec = codec->spec;
3417 return snd_hda_multi_out_dig_cleanup(codec, &spec->multiout);
3418}
3419
3420static int dig_playback_pcm_close(struct hda_pcm_stream *hinfo,
3421 struct hda_codec *codec,
3422 struct snd_pcm_substream *substream)
3423{
3424 struct hda_gen_spec *spec = codec->spec;
3425 return snd_hda_multi_out_dig_close(codec, &spec->multiout);
3426}
3427
3428/*
3429 * Analog capture
3430 */
3431static int alt_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
3432 struct hda_codec *codec,
3433 unsigned int stream_tag,
3434 unsigned int format,
3435 struct snd_pcm_substream *substream)
3436{
3437 struct hda_gen_spec *spec = codec->spec;
3438
3439 snd_hda_codec_setup_stream(codec, spec->adc_nids[substream->number + 1],
Takashi Iwai97ec5582006-03-21 11:29:07 +01003440 stream_tag, 0, format);
3441 return 0;
3442}
3443
Takashi Iwai352f7f92012-12-19 12:52:06 +01003444static int alt_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
3445 struct hda_codec *codec,
3446 struct snd_pcm_substream *substream)
Takashi Iwai97ec5582006-03-21 11:29:07 +01003447{
Takashi Iwai352f7f92012-12-19 12:52:06 +01003448 struct hda_gen_spec *spec = codec->spec;
Takashi Iwai97ec5582006-03-21 11:29:07 +01003449
Takashi Iwai352f7f92012-12-19 12:52:06 +01003450 snd_hda_codec_cleanup_stream(codec,
3451 spec->adc_nids[substream->number + 1]);
Takashi Iwai97ec5582006-03-21 11:29:07 +01003452 return 0;
3453}
3454
Takashi Iwai352f7f92012-12-19 12:52:06 +01003455/*
3456 */
3457static const struct hda_pcm_stream pcm_analog_playback = {
3458 .substreams = 1,
3459 .channels_min = 2,
3460 .channels_max = 8,
3461 /* NID is set in build_pcms */
3462 .ops = {
3463 .open = playback_pcm_open,
Takashi Iwai38cf6f12012-12-21 14:09:42 +01003464 .close = playback_pcm_close,
Takashi Iwai352f7f92012-12-19 12:52:06 +01003465 .prepare = playback_pcm_prepare,
3466 .cleanup = playback_pcm_cleanup
3467 },
3468};
Linus Torvalds1da177e2005-04-16 15:20:36 -07003469
Takashi Iwai352f7f92012-12-19 12:52:06 +01003470static const struct hda_pcm_stream pcm_analog_capture = {
3471 .substreams = 1,
3472 .channels_min = 2,
3473 .channels_max = 2,
3474 /* NID is set in build_pcms */
3475};
3476
3477static const struct hda_pcm_stream pcm_analog_alt_playback = {
3478 .substreams = 1,
3479 .channels_min = 2,
3480 .channels_max = 2,
3481 /* NID is set in build_pcms */
Takashi Iwai38cf6f12012-12-21 14:09:42 +01003482 .ops = {
3483 .open = alt_playback_pcm_open,
Takashi Iwaie6b85f32013-01-07 11:54:34 +01003484 .close = alt_playback_pcm_close,
3485 .prepare = alt_playback_pcm_prepare,
3486 .cleanup = alt_playback_pcm_cleanup
Takashi Iwai38cf6f12012-12-21 14:09:42 +01003487 },
Takashi Iwai352f7f92012-12-19 12:52:06 +01003488};
3489
3490static const struct hda_pcm_stream pcm_analog_alt_capture = {
3491 .substreams = 2, /* can be overridden */
3492 .channels_min = 2,
3493 .channels_max = 2,
3494 /* NID is set in build_pcms */
3495 .ops = {
3496 .prepare = alt_capture_pcm_prepare,
3497 .cleanup = alt_capture_pcm_cleanup
3498 },
3499};
3500
3501static const struct hda_pcm_stream pcm_digital_playback = {
3502 .substreams = 1,
3503 .channels_min = 2,
3504 .channels_max = 2,
3505 /* NID is set in build_pcms */
3506 .ops = {
3507 .open = dig_playback_pcm_open,
3508 .close = dig_playback_pcm_close,
3509 .prepare = dig_playback_pcm_prepare,
3510 .cleanup = dig_playback_pcm_cleanup
3511 },
3512};
3513
3514static const struct hda_pcm_stream pcm_digital_capture = {
3515 .substreams = 1,
3516 .channels_min = 2,
3517 .channels_max = 2,
3518 /* NID is set in build_pcms */
3519};
3520
3521/* Used by build_pcms to flag that a PCM has no playback stream */
3522static const struct hda_pcm_stream pcm_null_stream = {
3523 .substreams = 0,
3524 .channels_min = 0,
3525 .channels_max = 0,
3526};
3527
3528/*
3529 * dynamic changing ADC PCM streams
3530 */
3531static bool dyn_adc_pcm_resetup(struct hda_codec *codec, int cur)
3532{
3533 struct hda_gen_spec *spec = codec->spec;
3534 hda_nid_t new_adc = spec->adc_nids[spec->dyn_adc_idx[cur]];
3535
3536 if (spec->cur_adc && spec->cur_adc != new_adc) {
3537 /* stream is running, let's swap the current ADC */
3538 __snd_hda_codec_cleanup_stream(codec, spec->cur_adc, 1);
3539 spec->cur_adc = new_adc;
3540 snd_hda_codec_setup_stream(codec, new_adc,
3541 spec->cur_adc_stream_tag, 0,
3542 spec->cur_adc_format);
3543 return true;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003544 }
Takashi Iwai352f7f92012-12-19 12:52:06 +01003545 return false;
3546}
3547
3548/* analog capture with dynamic dual-adc changes */
3549static int dyn_adc_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
3550 struct hda_codec *codec,
3551 unsigned int stream_tag,
3552 unsigned int format,
3553 struct snd_pcm_substream *substream)
3554{
3555 struct hda_gen_spec *spec = codec->spec;
3556 spec->cur_adc = spec->adc_nids[spec->dyn_adc_idx[spec->cur_mux[0]]];
3557 spec->cur_adc_stream_tag = stream_tag;
3558 spec->cur_adc_format = format;
3559 snd_hda_codec_setup_stream(codec, spec->cur_adc, stream_tag, 0, format);
3560 return 0;
3561}
3562
3563static int dyn_adc_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
3564 struct hda_codec *codec,
3565 struct snd_pcm_substream *substream)
3566{
3567 struct hda_gen_spec *spec = codec->spec;
3568 snd_hda_codec_cleanup_stream(codec, spec->cur_adc);
3569 spec->cur_adc = 0;
3570 return 0;
3571}
3572
3573static const struct hda_pcm_stream dyn_adc_pcm_analog_capture = {
3574 .substreams = 1,
3575 .channels_min = 2,
3576 .channels_max = 2,
3577 .nid = 0, /* fill later */
3578 .ops = {
3579 .prepare = dyn_adc_capture_pcm_prepare,
3580 .cleanup = dyn_adc_capture_pcm_cleanup
3581 },
3582};
3583
Takashi Iwaif873e532012-12-20 16:58:39 +01003584static void fill_pcm_stream_name(char *str, size_t len, const char *sfx,
3585 const char *chip_name)
3586{
3587 char *p;
3588
3589 if (*str)
3590 return;
3591 strlcpy(str, chip_name, len);
3592
3593 /* drop non-alnum chars after a space */
3594 for (p = strchr(str, ' '); p; p = strchr(p + 1, ' ')) {
3595 if (!isalnum(p[1])) {
3596 *p = 0;
3597 break;
3598 }
3599 }
3600 strlcat(str, sfx, len);
3601}
3602
Takashi Iwai352f7f92012-12-19 12:52:06 +01003603/* build PCM streams based on the parsed results */
3604int snd_hda_gen_build_pcms(struct hda_codec *codec)
3605{
3606 struct hda_gen_spec *spec = codec->spec;
3607 struct hda_pcm *info = spec->pcm_rec;
3608 const struct hda_pcm_stream *p;
3609 bool have_multi_adcs;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003610
3611 codec->num_pcms = 1;
3612 codec->pcm_info = info;
3613
Takashi Iwai352f7f92012-12-19 12:52:06 +01003614 if (spec->no_analog)
3615 goto skip_analog;
3616
Takashi Iwaif873e532012-12-20 16:58:39 +01003617 fill_pcm_stream_name(spec->stream_name_analog,
3618 sizeof(spec->stream_name_analog),
3619 " Analog", codec->chip_name);
Takashi Iwai352f7f92012-12-19 12:52:06 +01003620 info->name = spec->stream_name_analog;
3621
3622 if (spec->multiout.num_dacs > 0) {
3623 p = spec->stream_analog_playback;
3624 if (!p)
3625 p = &pcm_analog_playback;
3626 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *p;
3627 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dac_nids[0];
3628 info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max =
3629 spec->multiout.max_channels;
3630 if (spec->autocfg.line_out_type == AUTO_PIN_SPEAKER_OUT &&
3631 spec->autocfg.line_outs == 2)
3632 info->stream[SNDRV_PCM_STREAM_PLAYBACK].chmap =
3633 snd_pcm_2_1_chmaps;
3634 }
3635 if (spec->num_adc_nids) {
3636 p = spec->stream_analog_capture;
3637 if (!p) {
3638 if (spec->dyn_adc_switch)
3639 p = &dyn_adc_pcm_analog_capture;
3640 else
3641 p = &pcm_analog_capture;
3642 }
3643 info->stream[SNDRV_PCM_STREAM_CAPTURE] = *p;
3644 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adc_nids[0];
3645 }
3646
Takashi Iwai352f7f92012-12-19 12:52:06 +01003647 skip_analog:
3648 /* SPDIF for stream index #1 */
3649 if (spec->multiout.dig_out_nid || spec->dig_in_nid) {
Takashi Iwaif873e532012-12-20 16:58:39 +01003650 fill_pcm_stream_name(spec->stream_name_digital,
3651 sizeof(spec->stream_name_digital),
3652 " Digital", codec->chip_name);
Takashi Iwai352f7f92012-12-19 12:52:06 +01003653 codec->num_pcms = 2;
3654 codec->slave_dig_outs = spec->multiout.slave_dig_outs;
3655 info = spec->pcm_rec + 1;
3656 info->name = spec->stream_name_digital;
3657 if (spec->dig_out_type)
3658 info->pcm_type = spec->dig_out_type;
3659 else
3660 info->pcm_type = HDA_PCM_TYPE_SPDIF;
3661 if (spec->multiout.dig_out_nid) {
3662 p = spec->stream_digital_playback;
3663 if (!p)
3664 p = &pcm_digital_playback;
3665 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *p;
3666 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dig_out_nid;
3667 }
3668 if (spec->dig_in_nid) {
3669 p = spec->stream_digital_capture;
3670 if (!p)
3671 p = &pcm_digital_capture;
3672 info->stream[SNDRV_PCM_STREAM_CAPTURE] = *p;
3673 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->dig_in_nid;
3674 }
3675 }
3676
3677 if (spec->no_analog)
3678 return 0;
3679
3680 /* If the use of more than one ADC is requested for the current
3681 * model, configure a second analog capture-only PCM.
3682 */
3683 have_multi_adcs = (spec->num_adc_nids > 1) &&
3684 !spec->dyn_adc_switch && !spec->auto_mic;
3685 /* Additional Analaog capture for index #2 */
3686 if (spec->alt_dac_nid || have_multi_adcs) {
3687 codec->num_pcms = 3;
3688 info = spec->pcm_rec + 2;
3689 info->name = spec->stream_name_analog;
3690 if (spec->alt_dac_nid) {
3691 p = spec->stream_analog_alt_playback;
3692 if (!p)
3693 p = &pcm_analog_alt_playback;
3694 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *p;
3695 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid =
3696 spec->alt_dac_nid;
3697 } else {
3698 info->stream[SNDRV_PCM_STREAM_PLAYBACK] =
3699 pcm_null_stream;
3700 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = 0;
3701 }
3702 if (have_multi_adcs) {
3703 p = spec->stream_analog_alt_capture;
3704 if (!p)
3705 p = &pcm_analog_alt_capture;
3706 info->stream[SNDRV_PCM_STREAM_CAPTURE] = *p;
3707 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid =
3708 spec->adc_nids[1];
3709 info->stream[SNDRV_PCM_STREAM_CAPTURE].substreams =
3710 spec->num_adc_nids - 1;
3711 } else {
3712 info->stream[SNDRV_PCM_STREAM_CAPTURE] =
3713 pcm_null_stream;
3714 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = 0;
3715 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003716 }
3717
3718 return 0;
3719}
Takashi Iwai352f7f92012-12-19 12:52:06 +01003720EXPORT_SYMBOL_HDA(snd_hda_gen_build_pcms);
3721
3722
3723/*
3724 * Standard auto-parser initializations
3725 */
3726
Takashi Iwaid4156932013-01-07 10:08:02 +01003727/* configure the given path as a proper output */
3728static void set_output_and_unmute(struct hda_codec *codec,
Takashi Iwai196c17662013-01-04 15:01:40 +01003729 int pin_type, int path_idx)
Takashi Iwai352f7f92012-12-19 12:52:06 +01003730{
3731 struct nid_path *path;
Takashi Iwaid4156932013-01-07 10:08:02 +01003732 hda_nid_t pin;
Takashi Iwai352f7f92012-12-19 12:52:06 +01003733
Takashi Iwai196c17662013-01-04 15:01:40 +01003734 path = snd_hda_get_path_from_idx(codec, path_idx);
Takashi Iwaid4156932013-01-07 10:08:02 +01003735 if (!path || !path->depth)
Takashi Iwai352f7f92012-12-19 12:52:06 +01003736 return;
Takashi Iwaid4156932013-01-07 10:08:02 +01003737 pin = path->path[path->depth - 1];
3738 snd_hda_set_pin_ctl_cache(codec, pin, pin_type);
Takashi Iwaie1284af2013-01-03 16:33:02 +01003739 snd_hda_activate_path(codec, path, path->active, true);
3740 set_pin_eapd(codec, pin, path->active);
Takashi Iwai352f7f92012-12-19 12:52:06 +01003741}
3742
3743/* initialize primary output paths */
3744static void init_multi_out(struct hda_codec *codec)
3745{
3746 struct hda_gen_spec *spec = codec->spec;
3747 int pin_type;
3748 int i;
3749
3750 if (spec->autocfg.line_out_type == AUTO_PIN_HP_OUT)
3751 pin_type = PIN_HP;
3752 else
3753 pin_type = PIN_OUT;
3754
Takashi Iwaid4156932013-01-07 10:08:02 +01003755 for (i = 0; i < spec->autocfg.line_outs; i++)
3756 set_output_and_unmute(codec, pin_type, spec->out_paths[i]);
Takashi Iwai352f7f92012-12-19 12:52:06 +01003757}
3758
Takashi Iwaidb23fd12012-12-20 15:27:24 +01003759
3760static void __init_extra_out(struct hda_codec *codec, int num_outs,
Takashi Iwaid4156932013-01-07 10:08:02 +01003761 int *paths, int type)
Takashi Iwai352f7f92012-12-19 12:52:06 +01003762{
Takashi Iwai352f7f92012-12-19 12:52:06 +01003763 int i;
Takashi Iwai352f7f92012-12-19 12:52:06 +01003764
Takashi Iwaid4156932013-01-07 10:08:02 +01003765 for (i = 0; i < num_outs; i++)
3766 set_output_and_unmute(codec, type, paths[i]);
Takashi Iwaidb23fd12012-12-20 15:27:24 +01003767}
3768
3769/* initialize hp and speaker paths */
3770static void init_extra_out(struct hda_codec *codec)
3771{
3772 struct hda_gen_spec *spec = codec->spec;
3773
3774 if (spec->autocfg.line_out_type != AUTO_PIN_HP_OUT)
3775 __init_extra_out(codec, spec->autocfg.hp_outs,
Takashi Iwai196c17662013-01-04 15:01:40 +01003776 spec->hp_paths, PIN_HP);
Takashi Iwaidb23fd12012-12-20 15:27:24 +01003777 if (spec->autocfg.line_out_type != AUTO_PIN_SPEAKER_OUT)
3778 __init_extra_out(codec, spec->autocfg.speaker_outs,
Takashi Iwai196c17662013-01-04 15:01:40 +01003779 spec->speaker_paths, PIN_OUT);
Takashi Iwai352f7f92012-12-19 12:52:06 +01003780}
3781
3782/* initialize multi-io paths */
3783static void init_multi_io(struct hda_codec *codec)
3784{
3785 struct hda_gen_spec *spec = codec->spec;
3786 int i;
3787
3788 for (i = 0; i < spec->multi_ios; i++) {
3789 hda_nid_t pin = spec->multi_io[i].pin;
3790 struct nid_path *path;
Takashi Iwai196c17662013-01-04 15:01:40 +01003791 path = get_multiio_path(codec, i);
Takashi Iwai352f7f92012-12-19 12:52:06 +01003792 if (!path)
3793 continue;
3794 if (!spec->multi_io[i].ctl_in)
3795 spec->multi_io[i].ctl_in =
3796 snd_hda_codec_update_cache(codec, pin, 0,
3797 AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
3798 snd_hda_activate_path(codec, path, path->active, true);
3799 }
3800}
3801
3802/* set up the input pin config, depending on the given auto-pin type */
3803static void set_input_pin(struct hda_codec *codec, hda_nid_t nid,
3804 int auto_pin_type)
3805{
3806 unsigned int val = PIN_IN;
3807 if (auto_pin_type == AUTO_PIN_MIC)
3808 val |= snd_hda_get_default_vref(codec, nid);
Takashi Iwai7594aa32012-12-20 15:38:40 +01003809 snd_hda_set_pin_ctl_cache(codec, nid, val);
Takashi Iwai352f7f92012-12-19 12:52:06 +01003810}
3811
3812/* set up input pins and loopback paths */
3813static void init_analog_input(struct hda_codec *codec)
3814{
3815 struct hda_gen_spec *spec = codec->spec;
3816 struct auto_pin_cfg *cfg = &spec->autocfg;
3817 int i;
3818
3819 for (i = 0; i < cfg->num_inputs; i++) {
3820 hda_nid_t nid = cfg->inputs[i].pin;
3821 if (is_input_pin(codec, nid))
3822 set_input_pin(codec, nid, cfg->inputs[i].type);
3823
3824 /* init loopback inputs */
3825 if (spec->mixer_nid) {
3826 struct nid_path *path;
Takashi Iwai196c17662013-01-04 15:01:40 +01003827 path = snd_hda_get_path_from_idx(codec, spec->loopback_paths[i]);
Takashi Iwai352f7f92012-12-19 12:52:06 +01003828 if (path)
3829 snd_hda_activate_path(codec, path,
3830 path->active, false);
3831 }
3832 }
3833}
3834
3835/* initialize ADC paths */
3836static void init_input_src(struct hda_codec *codec)
3837{
3838 struct hda_gen_spec *spec = codec->spec;
3839 struct hda_input_mux *imux = &spec->input_mux;
3840 struct nid_path *path;
3841 int i, c, nums;
3842
3843 if (spec->dyn_adc_switch)
3844 nums = 1;
3845 else
3846 nums = spec->num_adc_nids;
3847
3848 for (c = 0; c < nums; c++) {
3849 for (i = 0; i < imux->num_items; i++) {
3850 path = snd_hda_get_nid_path(codec, spec->imux_pins[i],
3851 get_adc_nid(codec, c, i));
3852 if (path) {
3853 bool active = path->active;
3854 if (i == spec->cur_mux[c])
3855 active = true;
3856 snd_hda_activate_path(codec, path, active, false);
3857 }
3858 }
3859 }
3860
3861 if (spec->shared_mic_hp)
3862 update_shared_mic_hp(codec, spec->cur_mux[0]);
3863
3864 if (spec->cap_sync_hook)
3865 spec->cap_sync_hook(codec);
3866}
3867
3868/* set right pin controls for digital I/O */
3869static void init_digital(struct hda_codec *codec)
3870{
3871 struct hda_gen_spec *spec = codec->spec;
3872 int i;
3873 hda_nid_t pin;
3874
Takashi Iwaid4156932013-01-07 10:08:02 +01003875 for (i = 0; i < spec->autocfg.dig_outs; i++)
3876 set_output_and_unmute(codec, PIN_OUT, spec->digout_paths[i]);
Takashi Iwai352f7f92012-12-19 12:52:06 +01003877 pin = spec->autocfg.dig_in_pin;
Takashi Iwai2430d7b2013-01-04 15:09:42 +01003878 if (pin) {
3879 struct nid_path *path;
Takashi Iwai7594aa32012-12-20 15:38:40 +01003880 snd_hda_set_pin_ctl_cache(codec, pin, PIN_IN);
Takashi Iwai2430d7b2013-01-04 15:09:42 +01003881 path = snd_hda_get_path_from_idx(codec, spec->digin_path);
3882 if (path)
3883 snd_hda_activate_path(codec, path, path->active, false);
3884 }
Takashi Iwai352f7f92012-12-19 12:52:06 +01003885}
3886
Takashi Iwai973e4972012-12-20 15:16:09 +01003887/* clear unsol-event tags on unused pins; Conexant codecs seem to leave
3888 * invalid unsol tags by some reason
3889 */
3890static void clear_unsol_on_unused_pins(struct hda_codec *codec)
3891{
3892 int i;
3893
3894 for (i = 0; i < codec->init_pins.used; i++) {
3895 struct hda_pincfg *pin = snd_array_elem(&codec->init_pins, i);
3896 hda_nid_t nid = pin->nid;
3897 if (is_jack_detectable(codec, nid) &&
3898 !snd_hda_jack_tbl_get(codec, nid))
3899 snd_hda_codec_update_cache(codec, nid, 0,
3900 AC_VERB_SET_UNSOLICITED_ENABLE, 0);
3901 }
3902}
3903
Takashi Iwai5187ac12013-01-07 12:52:16 +01003904/*
3905 * initialize the generic spec;
3906 * this can be put as patch_ops.init function
3907 */
Takashi Iwai352f7f92012-12-19 12:52:06 +01003908int snd_hda_gen_init(struct hda_codec *codec)
3909{
3910 struct hda_gen_spec *spec = codec->spec;
3911
3912 if (spec->init_hook)
3913 spec->init_hook(codec);
3914
3915 snd_hda_apply_verbs(codec);
3916
Takashi Iwai3bbcd272012-12-20 11:50:58 +01003917 codec->cached_write = 1;
3918
Takashi Iwai352f7f92012-12-19 12:52:06 +01003919 init_multi_out(codec);
3920 init_extra_out(codec);
3921 init_multi_io(codec);
3922 init_analog_input(codec);
3923 init_input_src(codec);
3924 init_digital(codec);
3925
Takashi Iwai973e4972012-12-20 15:16:09 +01003926 clear_unsol_on_unused_pins(codec);
3927
Takashi Iwai352f7f92012-12-19 12:52:06 +01003928 /* call init functions of standard auto-mute helpers */
Takashi Iwai5d550e12012-12-19 15:16:44 +01003929 snd_hda_gen_hp_automute(codec, NULL);
3930 snd_hda_gen_line_automute(codec, NULL);
3931 snd_hda_gen_mic_autoswitch(codec, NULL);
Takashi Iwai352f7f92012-12-19 12:52:06 +01003932
Takashi Iwai3bbcd272012-12-20 11:50:58 +01003933 snd_hda_codec_flush_amp_cache(codec);
3934 snd_hda_codec_flush_cmd_cache(codec);
3935
Takashi Iwai352f7f92012-12-19 12:52:06 +01003936 if (spec->vmaster_mute.sw_kctl && spec->vmaster_mute.hook)
3937 snd_hda_sync_vmaster_hook(&spec->vmaster_mute);
3938
3939 hda_call_check_power_status(codec, 0x01);
3940 return 0;
3941}
Takashi Iwaifce52a32013-01-07 12:42:48 +01003942EXPORT_SYMBOL_HDA(snd_hda_gen_init);
3943
Takashi Iwai5187ac12013-01-07 12:52:16 +01003944/*
3945 * free the generic spec;
3946 * this can be put as patch_ops.free function
3947 */
Takashi Iwaifce52a32013-01-07 12:42:48 +01003948void snd_hda_gen_free(struct hda_codec *codec)
3949{
3950 snd_hda_gen_spec_free(codec->spec);
3951 kfree(codec->spec);
3952 codec->spec = NULL;
3953}
3954EXPORT_SYMBOL_HDA(snd_hda_gen_free);
3955
3956#ifdef CONFIG_PM
Takashi Iwai5187ac12013-01-07 12:52:16 +01003957/*
3958 * check the loopback power save state;
3959 * this can be put as patch_ops.check_power_status function
3960 */
Takashi Iwaifce52a32013-01-07 12:42:48 +01003961int snd_hda_gen_check_power_status(struct hda_codec *codec, hda_nid_t nid)
3962{
3963 struct hda_gen_spec *spec = codec->spec;
3964 return snd_hda_check_amp_list_power(codec, &spec->loopback, nid);
3965}
3966EXPORT_SYMBOL_HDA(snd_hda_gen_check_power_status);
3967#endif
Takashi Iwai352f7f92012-12-19 12:52:06 +01003968
3969
3970/*
3971 * the generic codec support
3972 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003973
Takashi Iwai352f7f92012-12-19 12:52:06 +01003974static const struct hda_codec_ops generic_patch_ops = {
3975 .build_controls = snd_hda_gen_build_controls,
3976 .build_pcms = snd_hda_gen_build_pcms,
3977 .init = snd_hda_gen_init,
Takashi Iwaifce52a32013-01-07 12:42:48 +01003978 .free = snd_hda_gen_free,
Takashi Iwai352f7f92012-12-19 12:52:06 +01003979 .unsol_event = snd_hda_jack_unsol_event,
Takashi Iwai83012a72012-08-24 18:38:08 +02003980#ifdef CONFIG_PM
Takashi Iwaifce52a32013-01-07 12:42:48 +01003981 .check_power_status = snd_hda_gen_check_power_status,
Takashi Iwaicb53c622007-08-10 17:21:45 +02003982#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07003983};
3984
Linus Torvalds1da177e2005-04-16 15:20:36 -07003985int snd_hda_parse_generic_codec(struct hda_codec *codec)
3986{
Takashi Iwai352f7f92012-12-19 12:52:06 +01003987 struct hda_gen_spec *spec;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003988 int err;
3989
Takashi Iwaie560d8d2005-09-09 14:21:46 +02003990 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
Takashi Iwai352f7f92012-12-19 12:52:06 +01003991 if (!spec)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003992 return -ENOMEM;
Takashi Iwai352f7f92012-12-19 12:52:06 +01003993 snd_hda_gen_spec_init(spec);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003994 codec->spec = spec;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003995
Takashi Iwai9eb413e2012-12-19 14:41:21 +01003996 err = snd_hda_parse_pin_defcfg(codec, &spec->autocfg, NULL, 0);
3997 if (err < 0)
3998 return err;
3999
4000 err = snd_hda_gen_parse_auto_config(codec, &spec->autocfg);
Takashi Iwai352f7f92012-12-19 12:52:06 +01004001 if (err < 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004002 goto error;
4003
4004 codec->patch_ops = generic_patch_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004005 return 0;
4006
Takashi Iwai352f7f92012-12-19 12:52:06 +01004007error:
Takashi Iwaifce52a32013-01-07 12:42:48 +01004008 snd_hda_gen_free(codec);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004009 return err;
4010}
Takashi Iwaifce52a32013-01-07 12:42:48 +01004011EXPORT_SYMBOL_HDA(snd_hda_parse_generic_codec);