~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/sound/pci/hda/hda_generic.c

Version: ~ [ linux-4.18-rc5 ] ~ [ linux-4.17.6 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.55 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.112 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.140 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.115 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.57 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.39.4 ] ~ [ linux-2.6.38.8 ] ~ [ linux-2.6.37.6 ] ~ [ linux-2.6.36.4 ] ~ [ linux-2.6.35.14 ] ~ [ linux-2.6.34.15 ] ~ [ linux-2.6.33.20 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.27.62 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

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

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp