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