Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 /*
0003  * Universal Interface for Intel High Definition Audio Codec
0004  *
0005  * Generic widget tree parser
0006  *
0007  * Copyright (c) 2004 Takashi Iwai <tiwai@suse.de>
0008  */
0009 
0010 #include <linux/init.h>
0011 #include <linux/slab.h>
0012 #include <linux/export.h>
0013 #include <linux/sort.h>
0014 #include <linux/delay.h>
0015 #include <linux/ctype.h>
0016 #include <linux/string.h>
0017 #include <linux/bitops.h>
0018 #include <linux/module.h>
0019 #include <linux/leds.h>
0020 #include <sound/core.h>
0021 #include <sound/jack.h>
0022 #include <sound/tlv.h>
0023 #include <sound/hda_codec.h>
0024 #include "hda_local.h"
0025 #include "hda_auto_parser.h"
0026 #include "hda_jack.h"
0027 #include "hda_beep.h"
0028 #include "hda_generic.h"
0029 
0030 
0031 /**
0032  * snd_hda_gen_spec_init - initialize hda_gen_spec struct
0033  * @spec: hda_gen_spec object to initialize
0034  *
0035  * Initialize the given hda_gen_spec object.
0036  */
0037 int snd_hda_gen_spec_init(struct hda_gen_spec *spec)
0038 {
0039     snd_array_init(&spec->kctls, sizeof(struct snd_kcontrol_new), 32);
0040     snd_array_init(&spec->paths, sizeof(struct nid_path), 8);
0041     snd_array_init(&spec->loopback_list, sizeof(struct hda_amp_list), 8);
0042     mutex_init(&spec->pcm_mutex);
0043     return 0;
0044 }
0045 EXPORT_SYMBOL_GPL(snd_hda_gen_spec_init);
0046 
0047 /**
0048  * snd_hda_gen_add_kctl - Add a new kctl_new struct from the template
0049  * @spec: hda_gen_spec object
0050  * @name: name string to override the template, NULL if unchanged
0051  * @temp: template for the new kctl
0052  *
0053  * Add a new kctl (actually snd_kcontrol_new to be instantiated later)
0054  * element based on the given snd_kcontrol_new template @temp and the
0055  * name string @name to the list in @spec.
0056  * Returns the newly created object or NULL as error.
0057  */
0058 struct snd_kcontrol_new *
0059 snd_hda_gen_add_kctl(struct hda_gen_spec *spec, const char *name,
0060              const struct snd_kcontrol_new *temp)
0061 {
0062     struct snd_kcontrol_new *knew = snd_array_new(&spec->kctls);
0063     if (!knew)
0064         return NULL;
0065     *knew = *temp;
0066     if (name)
0067         knew->name = kstrdup(name, GFP_KERNEL);
0068     else if (knew->name)
0069         knew->name = kstrdup(knew->name, GFP_KERNEL);
0070     if (!knew->name)
0071         return NULL;
0072     return knew;
0073 }
0074 EXPORT_SYMBOL_GPL(snd_hda_gen_add_kctl);
0075 
0076 static void free_kctls(struct hda_gen_spec *spec)
0077 {
0078     if (spec->kctls.list) {
0079         struct snd_kcontrol_new *kctl = spec->kctls.list;
0080         int i;
0081         for (i = 0; i < spec->kctls.used; i++)
0082             kfree(kctl[i].name);
0083     }
0084     snd_array_free(&spec->kctls);
0085 }
0086 
0087 static void snd_hda_gen_spec_free(struct hda_gen_spec *spec)
0088 {
0089     if (!spec)
0090         return;
0091     free_kctls(spec);
0092     snd_array_free(&spec->paths);
0093     snd_array_free(&spec->loopback_list);
0094 #ifdef CONFIG_SND_HDA_GENERIC_LEDS
0095     if (spec->led_cdevs[LED_AUDIO_MUTE])
0096         led_classdev_unregister(spec->led_cdevs[LED_AUDIO_MUTE]);
0097     if (spec->led_cdevs[LED_AUDIO_MICMUTE])
0098         led_classdev_unregister(spec->led_cdevs[LED_AUDIO_MICMUTE]);
0099 #endif
0100 }
0101 
0102 /*
0103  * store user hints
0104  */
0105 static void parse_user_hints(struct hda_codec *codec)
0106 {
0107     struct hda_gen_spec *spec = codec->spec;
0108     int val;
0109 
0110     val = snd_hda_get_bool_hint(codec, "jack_detect");
0111     if (val >= 0)
0112         codec->no_jack_detect = !val;
0113     val = snd_hda_get_bool_hint(codec, "inv_jack_detect");
0114     if (val >= 0)
0115         codec->inv_jack_detect = !!val;
0116     val = snd_hda_get_bool_hint(codec, "trigger_sense");
0117     if (val >= 0)
0118         codec->no_trigger_sense = !val;
0119     val = snd_hda_get_bool_hint(codec, "inv_eapd");
0120     if (val >= 0)
0121         codec->inv_eapd = !!val;
0122     val = snd_hda_get_bool_hint(codec, "pcm_format_first");
0123     if (val >= 0)
0124         codec->pcm_format_first = !!val;
0125     val = snd_hda_get_bool_hint(codec, "sticky_stream");
0126     if (val >= 0)
0127         codec->no_sticky_stream = !val;
0128     val = snd_hda_get_bool_hint(codec, "spdif_status_reset");
0129     if (val >= 0)
0130         codec->spdif_status_reset = !!val;
0131     val = snd_hda_get_bool_hint(codec, "pin_amp_workaround");
0132     if (val >= 0)
0133         codec->pin_amp_workaround = !!val;
0134     val = snd_hda_get_bool_hint(codec, "single_adc_amp");
0135     if (val >= 0)
0136         codec->single_adc_amp = !!val;
0137     val = snd_hda_get_bool_hint(codec, "power_save_node");
0138     if (val >= 0)
0139         codec->power_save_node = !!val;
0140 
0141     val = snd_hda_get_bool_hint(codec, "auto_mute");
0142     if (val >= 0)
0143         spec->suppress_auto_mute = !val;
0144     val = snd_hda_get_bool_hint(codec, "auto_mic");
0145     if (val >= 0)
0146         spec->suppress_auto_mic = !val;
0147     val = snd_hda_get_bool_hint(codec, "line_in_auto_switch");
0148     if (val >= 0)
0149         spec->line_in_auto_switch = !!val;
0150     val = snd_hda_get_bool_hint(codec, "auto_mute_via_amp");
0151     if (val >= 0)
0152         spec->auto_mute_via_amp = !!val;
0153     val = snd_hda_get_bool_hint(codec, "need_dac_fix");
0154     if (val >= 0)
0155         spec->need_dac_fix = !!val;
0156     val = snd_hda_get_bool_hint(codec, "primary_hp");
0157     if (val >= 0)
0158         spec->no_primary_hp = !val;
0159     val = snd_hda_get_bool_hint(codec, "multi_io");
0160     if (val >= 0)
0161         spec->no_multi_io = !val;
0162     val = snd_hda_get_bool_hint(codec, "multi_cap_vol");
0163     if (val >= 0)
0164         spec->multi_cap_vol = !!val;
0165     val = snd_hda_get_bool_hint(codec, "inv_dmic_split");
0166     if (val >= 0)
0167         spec->inv_dmic_split = !!val;
0168     val = snd_hda_get_bool_hint(codec, "indep_hp");
0169     if (val >= 0)
0170         spec->indep_hp = !!val;
0171     val = snd_hda_get_bool_hint(codec, "add_stereo_mix_input");
0172     if (val >= 0)
0173         spec->add_stereo_mix_input = !!val;
0174     /* the following two are just for compatibility */
0175     val = snd_hda_get_bool_hint(codec, "add_out_jack_modes");
0176     if (val >= 0)
0177         spec->add_jack_modes = !!val;
0178     val = snd_hda_get_bool_hint(codec, "add_in_jack_modes");
0179     if (val >= 0)
0180         spec->add_jack_modes = !!val;
0181     val = snd_hda_get_bool_hint(codec, "add_jack_modes");
0182     if (val >= 0)
0183         spec->add_jack_modes = !!val;
0184     val = snd_hda_get_bool_hint(codec, "power_down_unused");
0185     if (val >= 0)
0186         spec->power_down_unused = !!val;
0187     val = snd_hda_get_bool_hint(codec, "add_hp_mic");
0188     if (val >= 0)
0189         spec->hp_mic = !!val;
0190     val = snd_hda_get_bool_hint(codec, "hp_mic_detect");
0191     if (val >= 0)
0192         spec->suppress_hp_mic_detect = !val;
0193     val = snd_hda_get_bool_hint(codec, "vmaster");
0194     if (val >= 0)
0195         spec->suppress_vmaster = !val;
0196 
0197     if (!snd_hda_get_int_hint(codec, "mixer_nid", &val))
0198         spec->mixer_nid = val;
0199 }
0200 
0201 /*
0202  * pin control value accesses
0203  */
0204 
0205 #define update_pin_ctl(codec, pin, val) \
0206     snd_hda_codec_write_cache(codec, pin, 0, \
0207                    AC_VERB_SET_PIN_WIDGET_CONTROL, val)
0208 
0209 /* restore the pinctl based on the cached value */
0210 static inline void restore_pin_ctl(struct hda_codec *codec, hda_nid_t pin)
0211 {
0212     update_pin_ctl(codec, pin, snd_hda_codec_get_pin_target(codec, pin));
0213 }
0214 
0215 /* set the pinctl target value and write it if requested */
0216 static void set_pin_target(struct hda_codec *codec, hda_nid_t pin,
0217                unsigned int val, bool do_write)
0218 {
0219     if (!pin)
0220         return;
0221     val = snd_hda_correct_pin_ctl(codec, pin, val);
0222     snd_hda_codec_set_pin_target(codec, pin, val);
0223     if (do_write)
0224         update_pin_ctl(codec, pin, val);
0225 }
0226 
0227 /* set pinctl target values for all given pins */
0228 static void set_pin_targets(struct hda_codec *codec, int num_pins,
0229                 hda_nid_t *pins, unsigned int val)
0230 {
0231     int i;
0232     for (i = 0; i < num_pins; i++)
0233         set_pin_target(codec, pins[i], val, false);
0234 }
0235 
0236 /*
0237  * parsing paths
0238  */
0239 
0240 /* return the position of NID in the list, or -1 if not found */
0241 static int find_idx_in_nid_list(hda_nid_t nid, const hda_nid_t *list, int nums)
0242 {
0243     int i;
0244     for (i = 0; i < nums; i++)
0245         if (list[i] == nid)
0246             return i;
0247     return -1;
0248 }
0249 
0250 /* return true if the given NID is contained in the path */
0251 static bool is_nid_contained(struct nid_path *path, hda_nid_t nid)
0252 {
0253     return find_idx_in_nid_list(nid, path->path, path->depth) >= 0;
0254 }
0255 
0256 static struct nid_path *get_nid_path(struct hda_codec *codec,
0257                      hda_nid_t from_nid, hda_nid_t to_nid,
0258                      int anchor_nid)
0259 {
0260     struct hda_gen_spec *spec = codec->spec;
0261     struct nid_path *path;
0262     int i;
0263 
0264     snd_array_for_each(&spec->paths, i, path) {
0265         if (path->depth <= 0)
0266             continue;
0267         if ((!from_nid || path->path[0] == from_nid) &&
0268             (!to_nid || path->path[path->depth - 1] == to_nid)) {
0269             if (!anchor_nid ||
0270                 (anchor_nid > 0 && is_nid_contained(path, anchor_nid)) ||
0271                 (anchor_nid < 0 && !is_nid_contained(path, anchor_nid)))
0272                 return path;
0273         }
0274     }
0275     return NULL;
0276 }
0277 
0278 /**
0279  * snd_hda_get_path_idx - get the index number corresponding to the path
0280  * instance
0281  * @codec: the HDA codec
0282  * @path: nid_path object
0283  *
0284  * The returned index starts from 1, i.e. the actual array index with offset 1,
0285  * and zero is handled as an invalid path
0286  */
0287 int snd_hda_get_path_idx(struct hda_codec *codec, struct nid_path *path)
0288 {
0289     struct hda_gen_spec *spec = codec->spec;
0290     struct nid_path *array = spec->paths.list;
0291     ssize_t idx;
0292 
0293     if (!spec->paths.used)
0294         return 0;
0295     idx = path - array;
0296     if (idx < 0 || idx >= spec->paths.used)
0297         return 0;
0298     return idx + 1;
0299 }
0300 EXPORT_SYMBOL_GPL(snd_hda_get_path_idx);
0301 
0302 /**
0303  * snd_hda_get_path_from_idx - get the path instance corresponding to the
0304  * given index number
0305  * @codec: the HDA codec
0306  * @idx: the path index
0307  */
0308 struct nid_path *snd_hda_get_path_from_idx(struct hda_codec *codec, int idx)
0309 {
0310     struct hda_gen_spec *spec = codec->spec;
0311 
0312     if (idx <= 0 || idx > spec->paths.used)
0313         return NULL;
0314     return snd_array_elem(&spec->paths, idx - 1);
0315 }
0316 EXPORT_SYMBOL_GPL(snd_hda_get_path_from_idx);
0317 
0318 /* check whether the given DAC is already found in any existing paths */
0319 static bool is_dac_already_used(struct hda_codec *codec, hda_nid_t nid)
0320 {
0321     struct hda_gen_spec *spec = codec->spec;
0322     const struct nid_path *path;
0323     int i;
0324 
0325     snd_array_for_each(&spec->paths, i, path) {
0326         if (path->path[0] == nid)
0327             return true;
0328     }
0329     return false;
0330 }
0331 
0332 /* check whether the given two widgets can be connected */
0333 static bool is_reachable_path(struct hda_codec *codec,
0334                   hda_nid_t from_nid, hda_nid_t to_nid)
0335 {
0336     if (!from_nid || !to_nid)
0337         return false;
0338     return snd_hda_get_conn_index(codec, to_nid, from_nid, true) >= 0;
0339 }
0340 
0341 /* nid, dir and idx */
0342 #define AMP_VAL_COMPARE_MASK    (0xffff | (1U << 18) | (0x0f << 19))
0343 
0344 /* check whether the given ctl is already assigned in any path elements */
0345 static bool is_ctl_used(struct hda_codec *codec, unsigned int val, int type)
0346 {
0347     struct hda_gen_spec *spec = codec->spec;
0348     const struct nid_path *path;
0349     int i;
0350 
0351     val &= AMP_VAL_COMPARE_MASK;
0352     snd_array_for_each(&spec->paths, i, path) {
0353         if ((path->ctls[type] & AMP_VAL_COMPARE_MASK) == val)
0354             return true;
0355     }
0356     return false;
0357 }
0358 
0359 /* check whether a control with the given (nid, dir, idx) was assigned */
0360 static bool is_ctl_associated(struct hda_codec *codec, hda_nid_t nid,
0361                   int dir, int idx, int type)
0362 {
0363     unsigned int val = HDA_COMPOSE_AMP_VAL(nid, 3, idx, dir);
0364     return is_ctl_used(codec, val, type);
0365 }
0366 
0367 static void print_nid_path(struct hda_codec *codec,
0368                const char *pfx, struct nid_path *path)
0369 {
0370     char buf[40];
0371     char *pos = buf;
0372     int i;
0373 
0374     *pos = 0;
0375     for (i = 0; i < path->depth; i++)
0376         pos += scnprintf(pos, sizeof(buf) - (pos - buf), "%s%02x",
0377                  pos != buf ? ":" : "",
0378                  path->path[i]);
0379 
0380     codec_dbg(codec, "%s path: depth=%d '%s'\n", pfx, path->depth, buf);
0381 }
0382 
0383 /* called recursively */
0384 static bool __parse_nid_path(struct hda_codec *codec,
0385                  hda_nid_t from_nid, hda_nid_t to_nid,
0386                  int anchor_nid, struct nid_path *path,
0387                  int depth)
0388 {
0389     const hda_nid_t *conn;
0390     int i, nums;
0391 
0392     if (to_nid == anchor_nid)
0393         anchor_nid = 0; /* anchor passed */
0394     else if (to_nid == (hda_nid_t)(-anchor_nid))
0395         return false; /* hit the exclusive nid */
0396 
0397     nums = snd_hda_get_conn_list(codec, to_nid, &conn);
0398     for (i = 0; i < nums; i++) {
0399         if (conn[i] != from_nid) {
0400             /* special case: when from_nid is 0,
0401              * try to find an empty DAC
0402              */
0403             if (from_nid ||
0404                 get_wcaps_type(get_wcaps(codec, conn[i])) != AC_WID_AUD_OUT ||
0405                 is_dac_already_used(codec, conn[i]))
0406                 continue;
0407         }
0408         /* anchor is not requested or already passed? */
0409         if (anchor_nid <= 0)
0410             goto found;
0411     }
0412     if (depth >= MAX_NID_PATH_DEPTH)
0413         return false;
0414     for (i = 0; i < nums; i++) {
0415         unsigned int type;
0416         type = get_wcaps_type(get_wcaps(codec, conn[i]));
0417         if (type == AC_WID_AUD_OUT || type == AC_WID_AUD_IN ||
0418             type == AC_WID_PIN)
0419             continue;
0420         if (__parse_nid_path(codec, from_nid, conn[i],
0421                      anchor_nid, path, depth + 1))
0422             goto found;
0423     }
0424     return false;
0425 
0426  found:
0427     path->path[path->depth] = conn[i];
0428     path->idx[path->depth + 1] = i;
0429     if (nums > 1 && get_wcaps_type(get_wcaps(codec, to_nid)) != AC_WID_AUD_MIX)
0430         path->multi[path->depth + 1] = 1;
0431     path->depth++;
0432     return true;
0433 }
0434 
0435 /*
0436  * snd_hda_parse_nid_path - parse the widget path from the given nid to
0437  * the target nid
0438  * @codec: the HDA codec
0439  * @from_nid: the NID where the path start from
0440  * @to_nid: the NID where the path ends at
0441  * @anchor_nid: the anchor indication
0442  * @path: the path object to store the result
0443  *
0444  * Returns true if a matching path is found.
0445  *
0446  * The parsing behavior depends on parameters:
0447  * when @from_nid is 0, try to find an empty DAC;
0448  * when @anchor_nid is set to a positive value, only paths through the widget
0449  * with the given value are evaluated.
0450  * when @anchor_nid is set to a negative value, paths through the widget
0451  * with the negative of given value are excluded, only other paths are chosen.
0452  * when @anchor_nid is zero, no special handling about path selection.
0453  */
0454 static bool snd_hda_parse_nid_path(struct hda_codec *codec, hda_nid_t from_nid,
0455                 hda_nid_t to_nid, int anchor_nid,
0456                 struct nid_path *path)
0457 {
0458     if (__parse_nid_path(codec, from_nid, to_nid, anchor_nid, path, 1)) {
0459         path->path[path->depth] = to_nid;
0460         path->depth++;
0461         return true;
0462     }
0463     return false;
0464 }
0465 
0466 /**
0467  * snd_hda_add_new_path - parse the path between the given NIDs and
0468  * add to the path list
0469  * @codec: the HDA codec
0470  * @from_nid: the NID where the path start from
0471  * @to_nid: the NID where the path ends at
0472  * @anchor_nid: the anchor indication, see snd_hda_parse_nid_path()
0473  *
0474  * If no valid path is found, returns NULL.
0475  */
0476 struct nid_path *
0477 snd_hda_add_new_path(struct hda_codec *codec, hda_nid_t from_nid,
0478              hda_nid_t to_nid, int anchor_nid)
0479 {
0480     struct hda_gen_spec *spec = codec->spec;
0481     struct nid_path *path;
0482 
0483     if (from_nid && to_nid && !is_reachable_path(codec, from_nid, to_nid))
0484         return NULL;
0485 
0486     /* check whether the path has been already added */
0487     path = get_nid_path(codec, from_nid, to_nid, anchor_nid);
0488     if (path)
0489         return path;
0490 
0491     path = snd_array_new(&spec->paths);
0492     if (!path)
0493         return NULL;
0494     memset(path, 0, sizeof(*path));
0495     if (snd_hda_parse_nid_path(codec, from_nid, to_nid, anchor_nid, path))
0496         return path;
0497     /* push back */
0498     spec->paths.used--;
0499     return NULL;
0500 }
0501 EXPORT_SYMBOL_GPL(snd_hda_add_new_path);
0502 
0503 /* clear the given path as invalid so that it won't be picked up later */
0504 static void invalidate_nid_path(struct hda_codec *codec, int idx)
0505 {
0506     struct nid_path *path = snd_hda_get_path_from_idx(codec, idx);
0507     if (!path)
0508         return;
0509     memset(path, 0, sizeof(*path));
0510 }
0511 
0512 /* return a DAC if paired to the given pin by codec driver */
0513 static hda_nid_t get_preferred_dac(struct hda_codec *codec, hda_nid_t pin)
0514 {
0515     struct hda_gen_spec *spec = codec->spec;
0516     const hda_nid_t *list = spec->preferred_dacs;
0517 
0518     if (!list)
0519         return 0;
0520     for (; *list; list += 2)
0521         if (*list == pin)
0522             return list[1];
0523     return 0;
0524 }
0525 
0526 /* look for an empty DAC slot */
0527 static hda_nid_t look_for_dac(struct hda_codec *codec, hda_nid_t pin,
0528                   bool is_digital)
0529 {
0530     struct hda_gen_spec *spec = codec->spec;
0531     bool cap_digital;
0532     int i;
0533 
0534     for (i = 0; i < spec->num_all_dacs; i++) {
0535         hda_nid_t nid = spec->all_dacs[i];
0536         if (!nid || is_dac_already_used(codec, nid))
0537             continue;
0538         cap_digital = !!(get_wcaps(codec, nid) & AC_WCAP_DIGITAL);
0539         if (is_digital != cap_digital)
0540             continue;
0541         if (is_reachable_path(codec, nid, pin))
0542             return nid;
0543     }
0544     return 0;
0545 }
0546 
0547 /* replace the channels in the composed amp value with the given number */
0548 static unsigned int amp_val_replace_channels(unsigned int val, unsigned int chs)
0549 {
0550     val &= ~(0x3U << 16);
0551     val |= chs << 16;
0552     return val;
0553 }
0554 
0555 static bool same_amp_caps(struct hda_codec *codec, hda_nid_t nid1,
0556               hda_nid_t nid2, int dir)
0557 {
0558     if (!(get_wcaps(codec, nid1) & (1 << (dir + 1))))
0559         return !(get_wcaps(codec, nid2) & (1 << (dir + 1)));
0560     return (query_amp_caps(codec, nid1, dir) ==
0561         query_amp_caps(codec, nid2, dir));
0562 }
0563 
0564 /* look for a widget suitable for assigning a mute switch in the path */
0565 static hda_nid_t look_for_out_mute_nid(struct hda_codec *codec,
0566                        struct nid_path *path)
0567 {
0568     int i;
0569 
0570     for (i = path->depth - 1; i >= 0; i--) {
0571         if (nid_has_mute(codec, path->path[i], HDA_OUTPUT))
0572             return path->path[i];
0573         if (i != path->depth - 1 && i != 0 &&
0574             nid_has_mute(codec, path->path[i], HDA_INPUT))
0575             return path->path[i];
0576     }
0577     return 0;
0578 }
0579 
0580 /* look for a widget suitable for assigning a volume ctl in the path */
0581 static hda_nid_t look_for_out_vol_nid(struct hda_codec *codec,
0582                       struct nid_path *path)
0583 {
0584     struct hda_gen_spec *spec = codec->spec;
0585     int i;
0586 
0587     for (i = path->depth - 1; i >= 0; i--) {
0588         hda_nid_t nid = path->path[i];
0589         if ((spec->out_vol_mask >> nid) & 1)
0590             continue;
0591         if (nid_has_volume(codec, nid, HDA_OUTPUT))
0592             return nid;
0593     }
0594     return 0;
0595 }
0596 
0597 /*
0598  * path activation / deactivation
0599  */
0600 
0601 /* can have the amp-in capability? */
0602 static bool has_amp_in(struct hda_codec *codec, struct nid_path *path, int idx)
0603 {
0604     hda_nid_t nid = path->path[idx];
0605     unsigned int caps = get_wcaps(codec, nid);
0606     unsigned int type = get_wcaps_type(caps);
0607 
0608     if (!(caps & AC_WCAP_IN_AMP))
0609         return false;
0610     if (type == AC_WID_PIN && idx > 0) /* only for input pins */
0611         return false;
0612     return true;
0613 }
0614 
0615 /* can have the amp-out capability? */
0616 static bool has_amp_out(struct hda_codec *codec, struct nid_path *path, int idx)
0617 {
0618     hda_nid_t nid = path->path[idx];
0619     unsigned int caps = get_wcaps(codec, nid);
0620     unsigned int type = get_wcaps_type(caps);
0621 
0622     if (!(caps & AC_WCAP_OUT_AMP))
0623         return false;
0624     if (type == AC_WID_PIN && !idx) /* only for output pins */
0625         return false;
0626     return true;
0627 }
0628 
0629 /* check whether the given (nid,dir,idx) is active */
0630 static bool is_active_nid(struct hda_codec *codec, hda_nid_t nid,
0631               unsigned int dir, unsigned int idx)
0632 {
0633     struct hda_gen_spec *spec = codec->spec;
0634     int type = get_wcaps_type(get_wcaps(codec, nid));
0635     const struct nid_path *path;
0636     int i, n;
0637 
0638     if (nid == codec->core.afg)
0639         return true;
0640 
0641     snd_array_for_each(&spec->paths, n, path) {
0642         if (!path->active)
0643             continue;
0644         if (codec->power_save_node) {
0645             if (!path->stream_enabled)
0646                 continue;
0647             /* ignore unplugged paths except for DAC/ADC */
0648             if (!(path->pin_enabled || path->pin_fixed) &&
0649                 type != AC_WID_AUD_OUT && type != AC_WID_AUD_IN)
0650                 continue;
0651         }
0652         for (i = 0; i < path->depth; i++) {
0653             if (path->path[i] == nid) {
0654                 if (dir == HDA_OUTPUT || idx == -1 ||
0655                     path->idx[i] == idx)
0656                     return true;
0657                 break;
0658             }
0659         }
0660     }
0661     return false;
0662 }
0663 
0664 /* check whether the NID is referred by any active paths */
0665 #define is_active_nid_for_any(codec, nid) \
0666     is_active_nid(codec, nid, HDA_OUTPUT, -1)
0667 
0668 /* get the default amp value for the target state */
0669 static int get_amp_val_to_activate(struct hda_codec *codec, hda_nid_t nid,
0670                    int dir, unsigned int caps, bool enable)
0671 {
0672     unsigned int val = 0;
0673 
0674     if (caps & AC_AMPCAP_NUM_STEPS) {
0675         /* set to 0dB */
0676         if (enable)
0677             val = (caps & AC_AMPCAP_OFFSET) >> AC_AMPCAP_OFFSET_SHIFT;
0678     }
0679     if (caps & (AC_AMPCAP_MUTE | AC_AMPCAP_MIN_MUTE)) {
0680         if (!enable)
0681             val |= HDA_AMP_MUTE;
0682     }
0683     return val;
0684 }
0685 
0686 /* is this a stereo widget or a stereo-to-mono mix? */
0687 static bool is_stereo_amps(struct hda_codec *codec, hda_nid_t nid, int dir)
0688 {
0689     unsigned int wcaps = get_wcaps(codec, nid);
0690     hda_nid_t conn;
0691 
0692     if (wcaps & AC_WCAP_STEREO)
0693         return true;
0694     if (dir != HDA_INPUT || get_wcaps_type(wcaps) != AC_WID_AUD_MIX)
0695         return false;
0696     if (snd_hda_get_num_conns(codec, nid) != 1)
0697         return false;
0698     if (snd_hda_get_connections(codec, nid, &conn, 1) < 0)
0699         return false;
0700     return !!(get_wcaps(codec, conn) & AC_WCAP_STEREO);
0701 }
0702 
0703 /* initialize the amp value (only at the first time) */
0704 static void init_amp(struct hda_codec *codec, hda_nid_t nid, int dir, int idx)
0705 {
0706     unsigned int caps = query_amp_caps(codec, nid, dir);
0707     int val = get_amp_val_to_activate(codec, nid, dir, caps, false);
0708 
0709     if (is_stereo_amps(codec, nid, dir))
0710         snd_hda_codec_amp_init_stereo(codec, nid, dir, idx, 0xff, val);
0711     else
0712         snd_hda_codec_amp_init(codec, nid, 0, dir, idx, 0xff, val);
0713 }
0714 
0715 /* update the amp, doing in stereo or mono depending on NID */
0716 static int update_amp(struct hda_codec *codec, hda_nid_t nid, int dir, int idx,
0717               unsigned int mask, unsigned int val)
0718 {
0719     if (is_stereo_amps(codec, nid, dir))
0720         return snd_hda_codec_amp_stereo(codec, nid, dir, idx,
0721                         mask, val);
0722     else
0723         return snd_hda_codec_amp_update(codec, nid, 0, dir, idx,
0724                         mask, val);
0725 }
0726 
0727 /* calculate amp value mask we can modify;
0728  * if the given amp is controlled by mixers, don't touch it
0729  */
0730 static unsigned int get_amp_mask_to_modify(struct hda_codec *codec,
0731                        hda_nid_t nid, int dir, int idx,
0732                        unsigned int caps)
0733 {
0734     unsigned int mask = 0xff;
0735 
0736     if (caps & (AC_AMPCAP_MUTE | AC_AMPCAP_MIN_MUTE)) {
0737         if (is_ctl_associated(codec, nid, dir, idx, NID_PATH_MUTE_CTL))
0738             mask &= ~0x80;
0739     }
0740     if (caps & AC_AMPCAP_NUM_STEPS) {
0741         if (is_ctl_associated(codec, nid, dir, idx, NID_PATH_VOL_CTL) ||
0742             is_ctl_associated(codec, nid, dir, idx, NID_PATH_BOOST_CTL))
0743             mask &= ~0x7f;
0744     }
0745     return mask;
0746 }
0747 
0748 static void activate_amp(struct hda_codec *codec, hda_nid_t nid, int dir,
0749              int idx, int idx_to_check, bool enable)
0750 {
0751     unsigned int caps;
0752     unsigned int mask, val;
0753 
0754     caps = query_amp_caps(codec, nid, dir);
0755     val = get_amp_val_to_activate(codec, nid, dir, caps, enable);
0756     mask = get_amp_mask_to_modify(codec, nid, dir, idx_to_check, caps);
0757     if (!mask)
0758         return;
0759 
0760     val &= mask;
0761     update_amp(codec, nid, dir, idx, mask, val);
0762 }
0763 
0764 static void check_and_activate_amp(struct hda_codec *codec, hda_nid_t nid,
0765                    int dir, int idx, int idx_to_check,
0766                    bool enable)
0767 {
0768     /* check whether the given amp is still used by others */
0769     if (!enable && is_active_nid(codec, nid, dir, idx_to_check))
0770         return;
0771     activate_amp(codec, nid, dir, idx, idx_to_check, enable);
0772 }
0773 
0774 static void activate_amp_out(struct hda_codec *codec, struct nid_path *path,
0775                  int i, bool enable)
0776 {
0777     hda_nid_t nid = path->path[i];
0778     init_amp(codec, nid, HDA_OUTPUT, 0);
0779     check_and_activate_amp(codec, nid, HDA_OUTPUT, 0, 0, enable);
0780 }
0781 
0782 static void activate_amp_in(struct hda_codec *codec, struct nid_path *path,
0783                 int i, bool enable, bool add_aamix)
0784 {
0785     struct hda_gen_spec *spec = codec->spec;
0786     const hda_nid_t *conn;
0787     int n, nums, idx;
0788     int type;
0789     hda_nid_t nid = path->path[i];
0790 
0791     nums = snd_hda_get_conn_list(codec, nid, &conn);
0792     if (nums < 0)
0793         return;
0794     type = get_wcaps_type(get_wcaps(codec, nid));
0795     if (type == AC_WID_PIN ||
0796         (type == AC_WID_AUD_IN && codec->single_adc_amp)) {
0797         nums = 1;
0798         idx = 0;
0799     } else
0800         idx = path->idx[i];
0801 
0802     for (n = 0; n < nums; n++)
0803         init_amp(codec, nid, HDA_INPUT, n);
0804 
0805     /* here is a little bit tricky in comparison with activate_amp_out();
0806      * when aa-mixer is available, we need to enable the path as well
0807      */
0808     for (n = 0; n < nums; n++) {
0809         if (n != idx) {
0810             if (conn[n] != spec->mixer_merge_nid)
0811                 continue;
0812             /* when aamix is disabled, force to off */
0813             if (!add_aamix) {
0814                 activate_amp(codec, nid, HDA_INPUT, n, n, false);
0815                 continue;
0816             }
0817         }
0818         check_and_activate_amp(codec, nid, HDA_INPUT, n, idx, enable);
0819     }
0820 }
0821 
0822 /* sync power of each widget in the given path */
0823 static hda_nid_t path_power_update(struct hda_codec *codec,
0824                    struct nid_path *path,
0825                    bool allow_powerdown)
0826 {
0827     hda_nid_t nid, changed = 0;
0828     int i, state, power;
0829 
0830     for (i = 0; i < path->depth; i++) {
0831         nid = path->path[i];
0832         if (!(get_wcaps(codec, nid) & AC_WCAP_POWER))
0833             continue;
0834         if (nid == codec->core.afg)
0835             continue;
0836         if (!allow_powerdown || is_active_nid_for_any(codec, nid))
0837             state = AC_PWRST_D0;
0838         else
0839             state = AC_PWRST_D3;
0840         power = snd_hda_codec_read(codec, nid, 0,
0841                        AC_VERB_GET_POWER_STATE, 0);
0842         if (power != (state | (state << 4))) {
0843             snd_hda_codec_write(codec, nid, 0,
0844                         AC_VERB_SET_POWER_STATE, state);
0845             changed = nid;
0846             /* all known codecs seem to be capable to handl
0847              * widgets state even in D3, so far.
0848              * if any new codecs need to restore the widget
0849              * states after D0 transition, call the function
0850              * below.
0851              */
0852 #if 0 /* disabled */
0853             if (state == AC_PWRST_D0)
0854                 snd_hdac_regmap_sync_node(&codec->core, nid);
0855 #endif
0856         }
0857     }
0858     return changed;
0859 }
0860 
0861 /* do sync with the last power state change */
0862 static void sync_power_state_change(struct hda_codec *codec, hda_nid_t nid)
0863 {
0864     if (nid) {
0865         msleep(10);
0866         snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_POWER_STATE, 0);
0867     }
0868 }
0869 
0870 /**
0871  * snd_hda_activate_path - activate or deactivate the given path
0872  * @codec: the HDA codec
0873  * @path: the path to activate/deactivate
0874  * @enable: flag to activate or not
0875  * @add_aamix: enable the input from aamix NID
0876  *
0877  * If @add_aamix is set, enable the input from aa-mix NID as well (if any).
0878  */
0879 void snd_hda_activate_path(struct hda_codec *codec, struct nid_path *path,
0880                bool enable, bool add_aamix)
0881 {
0882     struct hda_gen_spec *spec = codec->spec;
0883     int i;
0884 
0885     path->active = enable;
0886 
0887     /* make sure the widget is powered up */
0888     if (enable && (spec->power_down_unused || codec->power_save_node))
0889         path_power_update(codec, path, codec->power_save_node);
0890 
0891     for (i = path->depth - 1; i >= 0; i--) {
0892         hda_nid_t nid = path->path[i];
0893 
0894         if (enable && path->multi[i])
0895             snd_hda_codec_write_cache(codec, nid, 0,
0896                         AC_VERB_SET_CONNECT_SEL,
0897                         path->idx[i]);
0898         if (has_amp_in(codec, path, i))
0899             activate_amp_in(codec, path, i, enable, add_aamix);
0900         if (has_amp_out(codec, path, i))
0901             activate_amp_out(codec, path, i, enable);
0902     }
0903 }
0904 EXPORT_SYMBOL_GPL(snd_hda_activate_path);
0905 
0906 /* if the given path is inactive, put widgets into D3 (only if suitable) */
0907 static void path_power_down_sync(struct hda_codec *codec, struct nid_path *path)
0908 {
0909     struct hda_gen_spec *spec = codec->spec;
0910 
0911     if (!(spec->power_down_unused || codec->power_save_node) || path->active)
0912         return;
0913     sync_power_state_change(codec, path_power_update(codec, path, true));
0914 }
0915 
0916 /* turn on/off EAPD on the given pin */
0917 static void set_pin_eapd(struct hda_codec *codec, hda_nid_t pin, bool enable)
0918 {
0919     struct hda_gen_spec *spec = codec->spec;
0920     if (spec->own_eapd_ctl ||
0921         !(snd_hda_query_pin_caps(codec, pin) & AC_PINCAP_EAPD))
0922         return;
0923     if (spec->keep_eapd_on && !enable)
0924         return;
0925     if (codec->inv_eapd)
0926         enable = !enable;
0927     snd_hda_codec_write_cache(codec, pin, 0,
0928                    AC_VERB_SET_EAPD_BTLENABLE,
0929                    enable ? 0x02 : 0x00);
0930 }
0931 
0932 /* re-initialize the path specified by the given path index */
0933 static void resume_path_from_idx(struct hda_codec *codec, int path_idx)
0934 {
0935     struct nid_path *path = snd_hda_get_path_from_idx(codec, path_idx);
0936     if (path)
0937         snd_hda_activate_path(codec, path, path->active, false);
0938 }
0939 
0940 
0941 /*
0942  * Helper functions for creating mixer ctl elements
0943  */
0944 
0945 static int hda_gen_mixer_mute_put(struct snd_kcontrol *kcontrol,
0946                   struct snd_ctl_elem_value *ucontrol);
0947 static int hda_gen_bind_mute_get(struct snd_kcontrol *kcontrol,
0948                  struct snd_ctl_elem_value *ucontrol);
0949 static int hda_gen_bind_mute_put(struct snd_kcontrol *kcontrol,
0950                  struct snd_ctl_elem_value *ucontrol);
0951 
0952 enum {
0953     HDA_CTL_WIDGET_VOL,
0954     HDA_CTL_WIDGET_MUTE,
0955     HDA_CTL_BIND_MUTE,
0956 };
0957 static const struct snd_kcontrol_new control_templates[] = {
0958     HDA_CODEC_VOLUME(NULL, 0, 0, 0),
0959     /* only the put callback is replaced for handling the special mute */
0960     {
0961         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
0962         .subdevice = HDA_SUBDEV_AMP_FLAG,
0963         .info = snd_hda_mixer_amp_switch_info,
0964         .get = snd_hda_mixer_amp_switch_get,
0965         .put = hda_gen_mixer_mute_put, /* replaced */
0966         .private_value = HDA_COMPOSE_AMP_VAL(0, 3, 0, 0),
0967     },
0968     {
0969         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
0970         .info = snd_hda_mixer_amp_switch_info,
0971         .get = hda_gen_bind_mute_get,
0972         .put = hda_gen_bind_mute_put, /* replaced */
0973         .private_value = HDA_COMPOSE_AMP_VAL(0, 3, 0, 0),
0974     },
0975 };
0976 
0977 /* add dynamic controls from template */
0978 static struct snd_kcontrol_new *
0979 add_control(struct hda_gen_spec *spec, int type, const char *name,
0980                int cidx, unsigned long val)
0981 {
0982     struct snd_kcontrol_new *knew;
0983 
0984     knew = snd_hda_gen_add_kctl(spec, name, &control_templates[type]);
0985     if (!knew)
0986         return NULL;
0987     knew->index = cidx;
0988     if (get_amp_nid_(val))
0989         knew->subdevice = HDA_SUBDEV_AMP_FLAG;
0990     if (knew->access == 0)
0991         knew->access = SNDRV_CTL_ELEM_ACCESS_READWRITE;
0992     knew->private_value = val;
0993     return knew;
0994 }
0995 
0996 static int add_control_with_pfx(struct hda_gen_spec *spec, int type,
0997                 const char *pfx, const char *dir,
0998                 const char *sfx, int cidx, unsigned long val)
0999 {
1000     char name[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];
1001     snprintf(name, sizeof(name), "%s %s %s", pfx, dir, sfx);
1002     if (!add_control(spec, type, name, cidx, val))
1003         return -ENOMEM;
1004     return 0;
1005 }
1006 
1007 #define add_pb_vol_ctrl(spec, type, pfx, val)           \
1008     add_control_with_pfx(spec, type, pfx, "Playback", "Volume", 0, val)
1009 #define add_pb_sw_ctrl(spec, type, pfx, val)            \
1010     add_control_with_pfx(spec, type, pfx, "Playback", "Switch", 0, val)
1011 #define __add_pb_vol_ctrl(spec, type, pfx, cidx, val)           \
1012     add_control_with_pfx(spec, type, pfx, "Playback", "Volume", cidx, val)
1013 #define __add_pb_sw_ctrl(spec, type, pfx, cidx, val)            \
1014     add_control_with_pfx(spec, type, pfx, "Playback", "Switch", cidx, val)
1015 
1016 static int add_vol_ctl(struct hda_codec *codec, const char *pfx, int cidx,
1017                unsigned int chs, struct nid_path *path)
1018 {
1019     unsigned int val;
1020     if (!path)
1021         return 0;
1022     val = path->ctls[NID_PATH_VOL_CTL];
1023     if (!val)
1024         return 0;
1025     val = amp_val_replace_channels(val, chs);
1026     return __add_pb_vol_ctrl(codec->spec, HDA_CTL_WIDGET_VOL, pfx, cidx, val);
1027 }
1028 
1029 /* return the channel bits suitable for the given path->ctls[] */
1030 static int get_default_ch_nums(struct hda_codec *codec, struct nid_path *path,
1031                    int type)
1032 {
1033     int chs = 1; /* mono (left only) */
1034     if (path) {
1035         hda_nid_t nid = get_amp_nid_(path->ctls[type]);
1036         if (nid && (get_wcaps(codec, nid) & AC_WCAP_STEREO))
1037             chs = 3; /* stereo */
1038     }
1039     return chs;
1040 }
1041 
1042 static int add_stereo_vol(struct hda_codec *codec, const char *pfx, int cidx,
1043               struct nid_path *path)
1044 {
1045     int chs = get_default_ch_nums(codec, path, NID_PATH_VOL_CTL);
1046     return add_vol_ctl(codec, pfx, cidx, chs, path);
1047 }
1048 
1049 /* create a mute-switch for the given mixer widget;
1050  * if it has multiple sources (e.g. DAC and loopback), create a bind-mute
1051  */
1052 static int add_sw_ctl(struct hda_codec *codec, const char *pfx, int cidx,
1053               unsigned int chs, struct nid_path *path)
1054 {
1055     unsigned int val;
1056     int type = HDA_CTL_WIDGET_MUTE;
1057 
1058     if (!path)
1059         return 0;
1060     val = path->ctls[NID_PATH_MUTE_CTL];
1061     if (!val)
1062         return 0;
1063     val = amp_val_replace_channels(val, chs);
1064     if (get_amp_direction_(val) == HDA_INPUT) {
1065         hda_nid_t nid = get_amp_nid_(val);
1066         int nums = snd_hda_get_num_conns(codec, nid);
1067         if (nums > 1) {
1068             type = HDA_CTL_BIND_MUTE;
1069             val |= nums << 19;
1070         }
1071     }
1072     return __add_pb_sw_ctrl(codec->spec, type, pfx, cidx, val);
1073 }
1074 
1075 static int add_stereo_sw(struct hda_codec *codec, const char *pfx,
1076                   int cidx, struct nid_path *path)
1077 {
1078     int chs = get_default_ch_nums(codec, path, NID_PATH_MUTE_CTL);
1079     return add_sw_ctl(codec, pfx, cidx, chs, path);
1080 }
1081 
1082 /* playback mute control with the software mute bit check */
1083 static void sync_auto_mute_bits(struct snd_kcontrol *kcontrol,
1084                 struct snd_ctl_elem_value *ucontrol)
1085 {
1086     struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1087     struct hda_gen_spec *spec = codec->spec;
1088 
1089     if (spec->auto_mute_via_amp) {
1090         hda_nid_t nid = get_amp_nid(kcontrol);
1091         bool enabled = !((spec->mute_bits >> nid) & 1);
1092         ucontrol->value.integer.value[0] &= enabled;
1093         ucontrol->value.integer.value[1] &= enabled;
1094     }
1095 }
1096 
1097 static int hda_gen_mixer_mute_put(struct snd_kcontrol *kcontrol,
1098                   struct snd_ctl_elem_value *ucontrol)
1099 {
1100     sync_auto_mute_bits(kcontrol, ucontrol);
1101     return snd_hda_mixer_amp_switch_put(kcontrol, ucontrol);
1102 }
1103 
1104 /*
1105  * Bound mute controls
1106  */
1107 #define AMP_VAL_IDX_SHIFT   19
1108 #define AMP_VAL_IDX_MASK    (0x0f<<19)
1109 
1110 static int hda_gen_bind_mute_get(struct snd_kcontrol *kcontrol,
1111                  struct snd_ctl_elem_value *ucontrol)
1112 {
1113     struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1114     unsigned long pval;
1115     int err;
1116 
1117     mutex_lock(&codec->control_mutex);
1118     pval = kcontrol->private_value;
1119     kcontrol->private_value = pval & ~AMP_VAL_IDX_MASK; /* index 0 */
1120     err = snd_hda_mixer_amp_switch_get(kcontrol, ucontrol);
1121     kcontrol->private_value = pval;
1122     mutex_unlock(&codec->control_mutex);
1123     return err;
1124 }
1125 
1126 static int hda_gen_bind_mute_put(struct snd_kcontrol *kcontrol,
1127                  struct snd_ctl_elem_value *ucontrol)
1128 {
1129     struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1130     unsigned long pval;
1131     int i, indices, err = 0, change = 0;
1132 
1133     sync_auto_mute_bits(kcontrol, ucontrol);
1134 
1135     mutex_lock(&codec->control_mutex);
1136     pval = kcontrol->private_value;
1137     indices = (pval & AMP_VAL_IDX_MASK) >> AMP_VAL_IDX_SHIFT;
1138     for (i = 0; i < indices; i++) {
1139         kcontrol->private_value = (pval & ~AMP_VAL_IDX_MASK) |
1140             (i << AMP_VAL_IDX_SHIFT);
1141         err = snd_hda_mixer_amp_switch_put(kcontrol, ucontrol);
1142         if (err < 0)
1143             break;
1144         change |= err;
1145     }
1146     kcontrol->private_value = pval;
1147     mutex_unlock(&codec->control_mutex);
1148     return err < 0 ? err : change;
1149 }
1150 
1151 /* any ctl assigned to the path with the given index? */
1152 static bool path_has_mixer(struct hda_codec *codec, int path_idx, int ctl_type)
1153 {
1154     struct nid_path *path = snd_hda_get_path_from_idx(codec, path_idx);
1155     return path && path->ctls[ctl_type];
1156 }
1157 
1158 static const char * const channel_name[4] = {
1159     "Front", "Surround", "CLFE", "Side"
1160 };
1161 
1162 /* give some appropriate ctl name prefix for the given line out channel */
1163 static const char *get_line_out_pfx(struct hda_codec *codec, int ch,
1164                     int *index, int ctl_type)
1165 {
1166     struct hda_gen_spec *spec = codec->spec;
1167     struct auto_pin_cfg *cfg = &spec->autocfg;
1168 
1169     *index = 0;
1170     if (cfg->line_outs == 1 && !spec->multi_ios &&
1171         !codec->force_pin_prefix &&
1172         !cfg->hp_outs && !cfg->speaker_outs)
1173         return spec->vmaster_mute.hook ? "PCM" : "Master";
1174 
1175     /* if there is really a single DAC used in the whole output paths,
1176      * use it master (or "PCM" if a vmaster hook is present)
1177      */
1178     if (spec->multiout.num_dacs == 1 && !spec->mixer_nid &&
1179         !codec->force_pin_prefix &&
1180         !spec->multiout.hp_out_nid[0] && !spec->multiout.extra_out_nid[0])
1181         return spec->vmaster_mute.hook ? "PCM" : "Master";
1182 
1183     /* multi-io channels */
1184     if (ch >= cfg->line_outs)
1185         return channel_name[ch];
1186 
1187     switch (cfg->line_out_type) {
1188     case AUTO_PIN_SPEAKER_OUT:
1189         /* if the primary channel vol/mute is shared with HP volume,
1190          * don't name it as Speaker
1191          */
1192         if (!ch && cfg->hp_outs &&
1193             !path_has_mixer(codec, spec->hp_paths[0], ctl_type))
1194             break;
1195         if (cfg->line_outs == 1)
1196             return "Speaker";
1197         if (cfg->line_outs == 2)
1198             return ch ? "Bass Speaker" : "Speaker";
1199         break;
1200     case AUTO_PIN_HP_OUT:
1201         /* if the primary channel vol/mute is shared with spk volume,
1202          * don't name it as Headphone
1203          */
1204         if (!ch && cfg->speaker_outs &&
1205             !path_has_mixer(codec, spec->speaker_paths[0], ctl_type))
1206             break;
1207         /* for multi-io case, only the primary out */
1208         if (ch && spec->multi_ios)
1209             break;
1210         *index = ch;
1211         return "Headphone";
1212     case AUTO_PIN_LINE_OUT:
1213         /* This deals with the case where one HP or one Speaker or
1214          * one HP + one Speaker need to share the DAC with LO
1215          */
1216         if (!ch) {
1217             bool hp_lo_shared = false, spk_lo_shared = false;
1218 
1219             if (cfg->speaker_outs)
1220                 spk_lo_shared = !path_has_mixer(codec,
1221                                 spec->speaker_paths[0], ctl_type);
1222             if (cfg->hp_outs)
1223                 hp_lo_shared = !path_has_mixer(codec, spec->hp_paths[0], ctl_type);
1224             if (hp_lo_shared && spk_lo_shared)
1225                 return spec->vmaster_mute.hook ? "PCM" : "Master";
1226             if (hp_lo_shared)
1227                 return "Headphone+LO";
1228             if (spk_lo_shared)
1229                 return "Speaker+LO";
1230         }
1231     }
1232 
1233     /* for a single channel output, we don't have to name the channel */
1234     if (cfg->line_outs == 1 && !spec->multi_ios)
1235         return "Line Out";
1236 
1237     if (ch >= ARRAY_SIZE(channel_name)) {
1238         snd_BUG();
1239         return "PCM";
1240     }
1241 
1242     return channel_name[ch];
1243 }
1244 
1245 /*
1246  * Parse output paths
1247  */
1248 
1249 /* badness definition */
1250 enum {
1251     /* No primary DAC is found for the main output */
1252     BAD_NO_PRIMARY_DAC = 0x10000,
1253     /* No DAC is found for the extra output */
1254     BAD_NO_DAC = 0x4000,
1255     /* No possible multi-ios */
1256     BAD_MULTI_IO = 0x120,
1257     /* No individual DAC for extra output */
1258     BAD_NO_EXTRA_DAC = 0x102,
1259     /* No individual DAC for extra surrounds */
1260     BAD_NO_EXTRA_SURR_DAC = 0x101,
1261     /* Primary DAC shared with main surrounds */
1262     BAD_SHARED_SURROUND = 0x100,
1263     /* No independent HP possible */
1264     BAD_NO_INDEP_HP = 0x10,
1265     /* Primary DAC shared with main CLFE */
1266     BAD_SHARED_CLFE = 0x10,
1267     /* Primary DAC shared with extra surrounds */
1268     BAD_SHARED_EXTRA_SURROUND = 0x10,
1269     /* Volume widget is shared */
1270     BAD_SHARED_VOL = 0x10,
1271 };
1272 
1273 /* look for widgets in the given path which are appropriate for
1274  * volume and mute controls, and assign the values to ctls[].
1275  *
1276  * When no appropriate widget is found in the path, the badness value
1277  * is incremented depending on the situation.  The function returns the
1278  * total badness for both volume and mute controls.
1279  */
1280 static int assign_out_path_ctls(struct hda_codec *codec, struct nid_path *path)
1281 {
1282     struct hda_gen_spec *spec = codec->spec;
1283     hda_nid_t nid;
1284     unsigned int val;
1285     int badness = 0;
1286 
1287     if (!path)
1288         return BAD_SHARED_VOL * 2;
1289 
1290     if (path->ctls[NID_PATH_VOL_CTL] ||
1291         path->ctls[NID_PATH_MUTE_CTL])
1292         return 0; /* already evaluated */
1293 
1294     nid = look_for_out_vol_nid(codec, path);
1295     if (nid) {
1296         val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
1297         if (spec->dac_min_mute)
1298             val |= HDA_AMP_VAL_MIN_MUTE;
1299         if (is_ctl_used(codec, val, NID_PATH_VOL_CTL))
1300             badness += BAD_SHARED_VOL;
1301         else
1302             path->ctls[NID_PATH_VOL_CTL] = val;
1303     } else
1304         badness += BAD_SHARED_VOL;
1305     nid = look_for_out_mute_nid(codec, path);
1306     if (nid) {
1307         unsigned int wid_type = get_wcaps_type(get_wcaps(codec, nid));
1308         if (wid_type == AC_WID_PIN || wid_type == AC_WID_AUD_OUT ||
1309             nid_has_mute(codec, nid, HDA_OUTPUT))
1310             val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
1311         else
1312             val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT);
1313         if (is_ctl_used(codec, val, NID_PATH_MUTE_CTL))
1314             badness += BAD_SHARED_VOL;
1315         else
1316             path->ctls[NID_PATH_MUTE_CTL] = val;
1317     } else
1318         badness += BAD_SHARED_VOL;
1319     return badness;
1320 }
1321 
1322 const struct badness_table hda_main_out_badness = {
1323     .no_primary_dac = BAD_NO_PRIMARY_DAC,
1324     .no_dac = BAD_NO_DAC,
1325     .shared_primary = BAD_NO_PRIMARY_DAC,
1326     .shared_surr = BAD_SHARED_SURROUND,
1327     .shared_clfe = BAD_SHARED_CLFE,
1328     .shared_surr_main = BAD_SHARED_SURROUND,
1329 };
1330 EXPORT_SYMBOL_GPL(hda_main_out_badness);
1331 
1332 const struct badness_table hda_extra_out_badness = {
1333     .no_primary_dac = BAD_NO_DAC,
1334     .no_dac = BAD_NO_DAC,
1335     .shared_primary = BAD_NO_EXTRA_DAC,
1336     .shared_surr = BAD_SHARED_EXTRA_SURROUND,
1337     .shared_clfe = BAD_SHARED_EXTRA_SURROUND,
1338     .shared_surr_main = BAD_NO_EXTRA_SURR_DAC,
1339 };
1340 EXPORT_SYMBOL_GPL(hda_extra_out_badness);
1341 
1342 /* get the DAC of the primary output corresponding to the given array index */
1343 static hda_nid_t get_primary_out(struct hda_codec *codec, int idx)
1344 {
1345     struct hda_gen_spec *spec = codec->spec;
1346     struct auto_pin_cfg *cfg = &spec->autocfg;
1347 
1348     if (cfg->line_outs > idx)
1349         return spec->private_dac_nids[idx];
1350     idx -= cfg->line_outs;
1351     if (spec->multi_ios > idx)
1352         return spec->multi_io[idx].dac;
1353     return 0;
1354 }
1355 
1356 /* return the DAC if it's reachable, otherwise zero */
1357 static inline hda_nid_t try_dac(struct hda_codec *codec,
1358                 hda_nid_t dac, hda_nid_t pin)
1359 {
1360     return is_reachable_path(codec, dac, pin) ? dac : 0;
1361 }
1362 
1363 /* try to assign DACs to pins and return the resultant badness */
1364 static int try_assign_dacs(struct hda_codec *codec, int num_outs,
1365                const hda_nid_t *pins, hda_nid_t *dacs,
1366                int *path_idx,
1367                const struct badness_table *bad)
1368 {
1369     struct hda_gen_spec *spec = codec->spec;
1370     int i, j;
1371     int badness = 0;
1372     hda_nid_t dac;
1373 
1374     if (!num_outs)
1375         return 0;
1376 
1377     for (i = 0; i < num_outs; i++) {
1378         struct nid_path *path;
1379         hda_nid_t pin = pins[i];
1380 
1381         if (!spec->obey_preferred_dacs) {
1382             path = snd_hda_get_path_from_idx(codec, path_idx[i]);
1383             if (path) {
1384                 badness += assign_out_path_ctls(codec, path);
1385                 continue;
1386             }
1387         }
1388 
1389         dacs[i] = get_preferred_dac(codec, pin);
1390         if (dacs[i]) {
1391             if (is_dac_already_used(codec, dacs[i]))
1392                 badness += bad->shared_primary;
1393         } else if (spec->obey_preferred_dacs) {
1394             badness += BAD_NO_PRIMARY_DAC;
1395         }
1396 
1397         if (!dacs[i])
1398             dacs[i] = look_for_dac(codec, pin, false);
1399         if (!dacs[i] && !i) {
1400             /* try to steal the DAC of surrounds for the front */
1401             for (j = 1; j < num_outs; j++) {
1402                 if (is_reachable_path(codec, dacs[j], pin)) {
1403                     dacs[0] = dacs[j];
1404                     dacs[j] = 0;
1405                     invalidate_nid_path(codec, path_idx[j]);
1406                     path_idx[j] = 0;
1407                     break;
1408                 }
1409             }
1410         }
1411         dac = dacs[i];
1412         if (!dac) {
1413             if (num_outs > 2)
1414                 dac = try_dac(codec, get_primary_out(codec, i), pin);
1415             if (!dac)
1416                 dac = try_dac(codec, dacs[0], pin);
1417             if (!dac)
1418                 dac = try_dac(codec, get_primary_out(codec, i), pin);
1419             if (dac) {
1420                 if (!i)
1421                     badness += bad->shared_primary;
1422                 else if (i == 1)
1423                     badness += bad->shared_surr;
1424                 else
1425                     badness += bad->shared_clfe;
1426             } else if (is_reachable_path(codec, spec->private_dac_nids[0], pin)) {
1427                 dac = spec->private_dac_nids[0];
1428                 badness += bad->shared_surr_main;
1429             } else if (!i)
1430                 badness += bad->no_primary_dac;
1431             else
1432                 badness += bad->no_dac;
1433         }
1434         if (!dac)
1435             continue;
1436         path = snd_hda_add_new_path(codec, dac, pin, -spec->mixer_nid);
1437         if (!path && !i && spec->mixer_nid) {
1438             /* try with aamix */
1439             path = snd_hda_add_new_path(codec, dac, pin, 0);
1440         }
1441         if (!path) {
1442             dacs[i] = 0;
1443             badness += bad->no_dac;
1444         } else {
1445             /* print_nid_path(codec, "output", path); */
1446             path->active = true;
1447             path_idx[i] = snd_hda_get_path_idx(codec, path);
1448             badness += assign_out_path_ctls(codec, path);
1449         }
1450     }
1451 
1452     return badness;
1453 }
1454 
1455 /* return NID if the given pin has only a single connection to a certain DAC */
1456 static hda_nid_t get_dac_if_single(struct hda_codec *codec, hda_nid_t pin)
1457 {
1458     struct hda_gen_spec *spec = codec->spec;
1459     int i;
1460     hda_nid_t nid_found = 0;
1461 
1462     for (i = 0; i < spec->num_all_dacs; i++) {
1463         hda_nid_t nid = spec->all_dacs[i];
1464         if (!nid || is_dac_already_used(codec, nid))
1465             continue;
1466         if (is_reachable_path(codec, nid, pin)) {
1467             if (nid_found)
1468                 return 0;
1469             nid_found = nid;
1470         }
1471     }
1472     return nid_found;
1473 }
1474 
1475 /* check whether the given pin can be a multi-io pin */
1476 static bool can_be_multiio_pin(struct hda_codec *codec,
1477                    unsigned int location, hda_nid_t nid)
1478 {
1479     unsigned int defcfg, caps;
1480 
1481     defcfg = snd_hda_codec_get_pincfg(codec, nid);
1482     if (get_defcfg_connect(defcfg) != AC_JACK_PORT_COMPLEX)
1483         return false;
1484     if (location && get_defcfg_location(defcfg) != location)
1485         return false;
1486     caps = snd_hda_query_pin_caps(codec, nid);
1487     if (!(caps & AC_PINCAP_OUT))
1488         return false;
1489     return true;
1490 }
1491 
1492 /* count the number of input pins that are capable to be multi-io */
1493 static int count_multiio_pins(struct hda_codec *codec, hda_nid_t reference_pin)
1494 {
1495     struct hda_gen_spec *spec = codec->spec;
1496     struct auto_pin_cfg *cfg = &spec->autocfg;
1497     unsigned int defcfg = snd_hda_codec_get_pincfg(codec, reference_pin);
1498     unsigned int location = get_defcfg_location(defcfg);
1499     int type, i;
1500     int num_pins = 0;
1501 
1502     for (type = AUTO_PIN_LINE_IN; type >= AUTO_PIN_MIC; type--) {
1503         for (i = 0; i < cfg->num_inputs; i++) {
1504             if (cfg->inputs[i].type != type)
1505                 continue;
1506             if (can_be_multiio_pin(codec, location,
1507                            cfg->inputs[i].pin))
1508                 num_pins++;
1509         }
1510     }
1511     return num_pins;
1512 }
1513 
1514 /*
1515  * multi-io helper
1516  *
1517  * When hardwired is set, try to fill ony hardwired pins, and returns
1518  * zero if any pins are filled, non-zero if nothing found.
1519  * When hardwired is off, try to fill possible input pins, and returns
1520  * the badness value.
1521  */
1522 static int fill_multi_ios(struct hda_codec *codec,
1523               hda_nid_t reference_pin,
1524               bool hardwired)
1525 {
1526     struct hda_gen_spec *spec = codec->spec;
1527     struct auto_pin_cfg *cfg = &spec->autocfg;
1528     int type, i, j, num_pins, old_pins;
1529     unsigned int defcfg = snd_hda_codec_get_pincfg(codec, reference_pin);
1530     unsigned int location = get_defcfg_location(defcfg);
1531     int badness = 0;
1532     struct nid_path *path;
1533 
1534     old_pins = spec->multi_ios;
1535     if (old_pins >= 2)
1536         goto end_fill;
1537 
1538     num_pins = count_multiio_pins(codec, reference_pin);
1539     if (num_pins < 2)
1540         goto end_fill;
1541 
1542     for (type = AUTO_PIN_LINE_IN; type >= AUTO_PIN_MIC; type--) {
1543         for (i = 0; i < cfg->num_inputs; i++) {
1544             hda_nid_t nid = cfg->inputs[i].pin;
1545             hda_nid_t dac = 0;
1546 
1547             if (cfg->inputs[i].type != type)
1548                 continue;
1549             if (!can_be_multiio_pin(codec, location, nid))
1550                 continue;
1551             for (j = 0; j < spec->multi_ios; j++) {
1552                 if (nid == spec->multi_io[j].pin)
1553                     break;
1554             }
1555             if (j < spec->multi_ios)
1556                 continue;
1557 
1558             if (hardwired)
1559                 dac = get_dac_if_single(codec, nid);
1560             else if (!dac)
1561                 dac = look_for_dac(codec, nid, false);
1562             if (!dac) {
1563                 badness++;
1564                 continue;
1565             }
1566             path = snd_hda_add_new_path(codec, dac, nid,
1567                             -spec->mixer_nid);
1568             if (!path) {
1569                 badness++;
1570                 continue;
1571             }
1572             /* print_nid_path(codec, "multiio", path); */
1573             spec->multi_io[spec->multi_ios].pin = nid;
1574             spec->multi_io[spec->multi_ios].dac = dac;
1575             spec->out_paths[cfg->line_outs + spec->multi_ios] =
1576                 snd_hda_get_path_idx(codec, path);
1577             spec->multi_ios++;
1578             if (spec->multi_ios >= 2)
1579                 break;
1580         }
1581     }
1582  end_fill:
1583     if (badness)
1584         badness = BAD_MULTI_IO;
1585     if (old_pins == spec->multi_ios) {
1586         if (hardwired)
1587             return 1; /* nothing found */
1588         else
1589             return badness; /* no badness if nothing found */
1590     }
1591     if (!hardwired && spec->multi_ios < 2) {
1592         /* cancel newly assigned paths */
1593         spec->paths.used -= spec->multi_ios - old_pins;
1594         spec->multi_ios = old_pins;
1595         return badness;
1596     }
1597 
1598     /* assign volume and mute controls */
1599     for (i = old_pins; i < spec->multi_ios; i++) {
1600         path = snd_hda_get_path_from_idx(codec, spec->out_paths[cfg->line_outs + i]);
1601         badness += assign_out_path_ctls(codec, path);
1602     }
1603 
1604     return badness;
1605 }
1606 
1607 /* map DACs for all pins in the list if they are single connections */
1608 static bool map_singles(struct hda_codec *codec, int outs,
1609             const hda_nid_t *pins, hda_nid_t *dacs, int *path_idx)
1610 {
1611     struct hda_gen_spec *spec = codec->spec;
1612     int i;
1613     bool found = false;
1614     for (i = 0; i < outs; i++) {
1615         struct nid_path *path;
1616         hda_nid_t dac;
1617         if (dacs[i])
1618             continue;
1619         dac = get_dac_if_single(codec, pins[i]);
1620         if (!dac)
1621             continue;
1622         path = snd_hda_add_new_path(codec, dac, pins[i],
1623                         -spec->mixer_nid);
1624         if (!path && !i && spec->mixer_nid)
1625             path = snd_hda_add_new_path(codec, dac, pins[i], 0);
1626         if (path) {
1627             dacs[i] = dac;
1628             found = true;
1629             /* print_nid_path(codec, "output", path); */
1630             path->active = true;
1631             path_idx[i] = snd_hda_get_path_idx(codec, path);
1632         }
1633     }
1634     return found;
1635 }
1636 
1637 static inline bool has_aamix_out_paths(struct hda_gen_spec *spec)
1638 {
1639     return spec->aamix_out_paths[0] || spec->aamix_out_paths[1] ||
1640         spec->aamix_out_paths[2];
1641 }
1642 
1643 /* create a new path including aamix if available, and return its index */
1644 static int check_aamix_out_path(struct hda_codec *codec, int path_idx)
1645 {
1646     struct hda_gen_spec *spec = codec->spec;
1647     struct nid_path *path;
1648     hda_nid_t path_dac, dac, pin;
1649 
1650     path = snd_hda_get_path_from_idx(codec, path_idx);
1651     if (!path || !path->depth ||
1652         is_nid_contained(path, spec->mixer_nid))
1653         return 0;
1654     path_dac = path->path[0];
1655     dac = spec->private_dac_nids[0];
1656     pin = path->path[path->depth - 1];
1657     path = snd_hda_add_new_path(codec, dac, pin, spec->mixer_nid);
1658     if (!path) {
1659         if (dac != path_dac)
1660             dac = path_dac;
1661         else if (spec->multiout.hp_out_nid[0])
1662             dac = spec->multiout.hp_out_nid[0];
1663         else if (spec->multiout.extra_out_nid[0])
1664             dac = spec->multiout.extra_out_nid[0];
1665         else
1666             dac = 0;
1667         if (dac)
1668             path = snd_hda_add_new_path(codec, dac, pin,
1669                             spec->mixer_nid);
1670     }
1671     if (!path)
1672         return 0;
1673     /* print_nid_path(codec, "output-aamix", path); */
1674     path->active = false; /* unused as default */
1675     path->pin_fixed = true; /* static route */
1676     return snd_hda_get_path_idx(codec, path);
1677 }
1678 
1679 /* check whether the independent HP is available with the current config */
1680 static bool indep_hp_possible(struct hda_codec *codec)
1681 {
1682     struct hda_gen_spec *spec = codec->spec;
1683     struct auto_pin_cfg *cfg = &spec->autocfg;
1684     struct nid_path *path;
1685     int i, idx;
1686 
1687     if (cfg->line_out_type == AUTO_PIN_HP_OUT)
1688         idx = spec->out_paths[0];
1689     else
1690         idx = spec->hp_paths[0];
1691     path = snd_hda_get_path_from_idx(codec, idx);
1692     if (!path)
1693         return false;
1694 
1695     /* assume no path conflicts unless aamix is involved */
1696     if (!spec->mixer_nid || !is_nid_contained(path, spec->mixer_nid))
1697         return true;
1698 
1699     /* check whether output paths contain aamix */
1700     for (i = 0; i < cfg->line_outs; i++) {
1701         if (spec->out_paths[i] == idx)
1702             break;
1703         path = snd_hda_get_path_from_idx(codec, spec->out_paths[i]);
1704         if (path && is_nid_contained(path, spec->mixer_nid))
1705             return false;
1706     }
1707     for (i = 0; i < cfg->speaker_outs; i++) {
1708         path = snd_hda_get_path_from_idx(codec, spec->speaker_paths[i]);
1709         if (path && is_nid_contained(path, spec->mixer_nid))
1710             return false;
1711     }
1712 
1713     return true;
1714 }
1715 
1716 /* fill the empty entries in the dac array for speaker/hp with the
1717  * shared dac pointed by the paths
1718  */
1719 static void refill_shared_dacs(struct hda_codec *codec, int num_outs,
1720                    hda_nid_t *dacs, int *path_idx)
1721 {
1722     struct nid_path *path;
1723     int i;
1724 
1725     for (i = 0; i < num_outs; i++) {
1726         if (dacs[i])
1727             continue;
1728         path = snd_hda_get_path_from_idx(codec, path_idx[i]);
1729         if (!path)
1730             continue;
1731         dacs[i] = path->path[0];
1732     }
1733 }
1734 
1735 /* fill in the dac_nids table from the parsed pin configuration */
1736 static int fill_and_eval_dacs(struct hda_codec *codec,
1737                   bool fill_hardwired,
1738                   bool fill_mio_first)
1739 {
1740     struct hda_gen_spec *spec = codec->spec;
1741     struct auto_pin_cfg *cfg = &spec->autocfg;
1742     int i, err, badness;
1743 
1744     /* set num_dacs once to full for look_for_dac() */
1745     spec->multiout.num_dacs = cfg->line_outs;
1746     spec->multiout.dac_nids = spec->private_dac_nids;
1747     memset(spec->private_dac_nids, 0, sizeof(spec->private_dac_nids));
1748     memset(spec->multiout.hp_out_nid, 0, sizeof(spec->multiout.hp_out_nid));
1749     memset(spec->multiout.extra_out_nid, 0, sizeof(spec->multiout.extra_out_nid));
1750     spec->multi_ios = 0;
1751     snd_array_free(&spec->paths);
1752 
1753     /* clear path indices */
1754     memset(spec->out_paths, 0, sizeof(spec->out_paths));
1755     memset(spec->hp_paths, 0, sizeof(spec->hp_paths));
1756     memset(spec->speaker_paths, 0, sizeof(spec->speaker_paths));
1757     memset(spec->aamix_out_paths, 0, sizeof(spec->aamix_out_paths));
1758     memset(spec->digout_paths, 0, sizeof(spec->digout_paths));
1759     memset(spec->input_paths, 0, sizeof(spec->input_paths));
1760     memset(spec->loopback_paths, 0, sizeof(spec->loopback_paths));
1761     memset(&spec->digin_path, 0, sizeof(spec->digin_path));
1762 
1763     badness = 0;
1764 
1765     /* fill hard-wired DACs first */
1766     if (fill_hardwired) {
1767         bool mapped;
1768         do {
1769             mapped = map_singles(codec, cfg->line_outs,
1770                          cfg->line_out_pins,
1771                          spec->private_dac_nids,
1772                          spec->out_paths);
1773             mapped |= map_singles(codec, cfg->hp_outs,
1774                           cfg->hp_pins,
1775                           spec->multiout.hp_out_nid,
1776                           spec->hp_paths);
1777             mapped |= map_singles(codec, cfg->speaker_outs,
1778                           cfg->speaker_pins,
1779                           spec->multiout.extra_out_nid,
1780                           spec->speaker_paths);
1781             if (!spec->no_multi_io &&
1782                 fill_mio_first && cfg->line_outs == 1 &&
1783                 cfg->line_out_type != AUTO_PIN_SPEAKER_OUT) {
1784                 err = fill_multi_ios(codec, cfg->line_out_pins[0], true);
1785                 if (!err)
1786                     mapped = true;
1787             }
1788         } while (mapped);
1789     }
1790 
1791     badness += try_assign_dacs(codec, cfg->line_outs, cfg->line_out_pins,
1792                    spec->private_dac_nids, spec->out_paths,
1793                    spec->main_out_badness);
1794 
1795     if (!spec->no_multi_io && fill_mio_first &&
1796         cfg->line_outs == 1 && cfg->line_out_type != AUTO_PIN_SPEAKER_OUT) {
1797         /* try to fill multi-io first */
1798         err = fill_multi_ios(codec, cfg->line_out_pins[0], false);
1799         if (err < 0)
1800             return err;
1801         /* we don't count badness at this stage yet */
1802     }
1803 
1804     if (cfg->line_out_type != AUTO_PIN_HP_OUT) {
1805         err = try_assign_dacs(codec, cfg->hp_outs, cfg->hp_pins,
1806                       spec->multiout.hp_out_nid,
1807                       spec->hp_paths,
1808                       spec->extra_out_badness);
1809         if (err < 0)
1810             return err;
1811         badness += err;
1812     }
1813     if (cfg->line_out_type != AUTO_PIN_SPEAKER_OUT) {
1814         err = try_assign_dacs(codec, cfg->speaker_outs,
1815                       cfg->speaker_pins,
1816                       spec->multiout.extra_out_nid,
1817                       spec->speaker_paths,
1818                       spec->extra_out_badness);
1819         if (err < 0)
1820             return err;
1821         badness += err;
1822     }
1823     if (!spec->no_multi_io &&
1824         cfg->line_outs == 1 && cfg->line_out_type != AUTO_PIN_SPEAKER_OUT) {
1825         err = fill_multi_ios(codec, cfg->line_out_pins[0], false);
1826         if (err < 0)
1827             return err;
1828         badness += err;
1829     }
1830 
1831     if (spec->mixer_nid) {
1832         spec->aamix_out_paths[0] =
1833             check_aamix_out_path(codec, spec->out_paths[0]);
1834         if (cfg->line_out_type != AUTO_PIN_HP_OUT)
1835             spec->aamix_out_paths[1] =
1836                 check_aamix_out_path(codec, spec->hp_paths[0]);
1837         if (cfg->line_out_type != AUTO_PIN_SPEAKER_OUT)
1838             spec->aamix_out_paths[2] =
1839                 check_aamix_out_path(codec, spec->speaker_paths[0]);
1840     }
1841 
1842     if (!spec->no_multi_io &&
1843         cfg->hp_outs && cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
1844         if (count_multiio_pins(codec, cfg->hp_pins[0]) >= 2)
1845             spec->multi_ios = 1; /* give badness */
1846 
1847     /* re-count num_dacs and squash invalid entries */
1848     spec->multiout.num_dacs = 0;
1849     for (i = 0; i < cfg->line_outs; i++) {
1850         if (spec->private_dac_nids[i])
1851             spec->multiout.num_dacs++;
1852         else {
1853             memmove(spec->private_dac_nids + i,
1854                 spec->private_dac_nids + i + 1,
1855                 sizeof(hda_nid_t) * (cfg->line_outs - i - 1));
1856             spec->private_dac_nids[cfg->line_outs - 1] = 0;
1857         }
1858     }
1859 
1860     spec->ext_channel_count = spec->min_channel_count =
1861         spec->multiout.num_dacs * 2;
1862 
1863     if (spec->multi_ios == 2) {
1864         for (i = 0; i < 2; i++)
1865             spec->private_dac_nids[spec->multiout.num_dacs++] =
1866                 spec->multi_io[i].dac;
1867     } else if (spec->multi_ios) {
1868         spec->multi_ios = 0;
1869         badness += BAD_MULTI_IO;
1870     }
1871 
1872     if (spec->indep_hp && !indep_hp_possible(codec))
1873         badness += BAD_NO_INDEP_HP;
1874 
1875     /* re-fill the shared DAC for speaker / headphone */
1876     if (cfg->line_out_type != AUTO_PIN_HP_OUT)
1877         refill_shared_dacs(codec, cfg->hp_outs,
1878                    spec->multiout.hp_out_nid,
1879                    spec->hp_paths);
1880     if (cfg->line_out_type != AUTO_PIN_SPEAKER_OUT)
1881         refill_shared_dacs(codec, cfg->speaker_outs,
1882                    spec->multiout.extra_out_nid,
1883                    spec->speaker_paths);
1884 
1885     return badness;
1886 }
1887 
1888 #define DEBUG_BADNESS
1889 
1890 #ifdef DEBUG_BADNESS
1891 #define debug_badness(fmt, ...)                     \
1892     codec_dbg(codec, fmt, ##__VA_ARGS__)
1893 #else
1894 #define debug_badness(fmt, ...)                     \
1895     do { if (0) codec_dbg(codec, fmt, ##__VA_ARGS__); } while (0)
1896 #endif
1897 
1898 #ifdef DEBUG_BADNESS
1899 static inline void print_nid_path_idx(struct hda_codec *codec,
1900                       const char *pfx, int idx)
1901 {
1902     struct nid_path *path;
1903 
1904     path = snd_hda_get_path_from_idx(codec, idx);
1905     if (path)
1906         print_nid_path(codec, pfx, path);
1907 }
1908 
1909 static void debug_show_configs(struct hda_codec *codec,
1910                    struct auto_pin_cfg *cfg)
1911 {
1912     struct hda_gen_spec *spec = codec->spec;
1913     static const char * const lo_type[3] = { "LO", "SP", "HP" };
1914     int i;
1915 
1916     debug_badness("multi_outs = %x/%x/%x/%x : %x/%x/%x/%x (type %s)\n",
1917               cfg->line_out_pins[0], cfg->line_out_pins[1],
1918               cfg->line_out_pins[2], cfg->line_out_pins[3],
1919               spec->multiout.dac_nids[0],
1920               spec->multiout.dac_nids[1],
1921               spec->multiout.dac_nids[2],
1922               spec->multiout.dac_nids[3],
1923               lo_type[cfg->line_out_type]);
1924     for (i = 0; i < cfg->line_outs; i++)
1925         print_nid_path_idx(codec, "  out", spec->out_paths[i]);
1926     if (spec->multi_ios > 0)
1927         debug_badness("multi_ios(%d) = %x/%x : %x/%x\n",
1928                   spec->multi_ios,
1929                   spec->multi_io[0].pin, spec->multi_io[1].pin,
1930                   spec->multi_io[0].dac, spec->multi_io[1].dac);
1931     for (i = 0; i < spec->multi_ios; i++)
1932         print_nid_path_idx(codec, "  mio",
1933                    spec->out_paths[cfg->line_outs + i]);
1934     if (cfg->hp_outs)
1935         debug_badness("hp_outs = %x/%x/%x/%x : %x/%x/%x/%x\n",
1936               cfg->hp_pins[0], cfg->hp_pins[1],
1937               cfg->hp_pins[2], cfg->hp_pins[3],
1938               spec->multiout.hp_out_nid[0],
1939               spec->multiout.hp_out_nid[1],
1940               spec->multiout.hp_out_nid[2],
1941               spec->multiout.hp_out_nid[3]);
1942     for (i = 0; i < cfg->hp_outs; i++)
1943         print_nid_path_idx(codec, "  hp ", spec->hp_paths[i]);
1944     if (cfg->speaker_outs)
1945         debug_badness("spk_outs = %x/%x/%x/%x : %x/%x/%x/%x\n",
1946               cfg->speaker_pins[0], cfg->speaker_pins[1],
1947               cfg->speaker_pins[2], cfg->speaker_pins[3],
1948               spec->multiout.extra_out_nid[0],
1949               spec->multiout.extra_out_nid[1],
1950               spec->multiout.extra_out_nid[2],
1951               spec->multiout.extra_out_nid[3]);
1952     for (i = 0; i < cfg->speaker_outs; i++)
1953         print_nid_path_idx(codec, "  spk", spec->speaker_paths[i]);
1954     for (i = 0; i < 3; i++)
1955         print_nid_path_idx(codec, "  mix", spec->aamix_out_paths[i]);
1956 }
1957 #else
1958 #define debug_show_configs(codec, cfg) /* NOP */
1959 #endif
1960 
1961 /* find all available DACs of the codec */
1962 static void fill_all_dac_nids(struct hda_codec *codec)
1963 {
1964     struct hda_gen_spec *spec = codec->spec;
1965     hda_nid_t nid;
1966 
1967     spec->num_all_dacs = 0;
1968     memset(spec->all_dacs, 0, sizeof(spec->all_dacs));
1969     for_each_hda_codec_node(nid, codec) {
1970         if (get_wcaps_type(get_wcaps(codec, nid)) != AC_WID_AUD_OUT)
1971             continue;
1972         if (spec->num_all_dacs >= ARRAY_SIZE(spec->all_dacs)) {
1973             codec_err(codec, "Too many DACs!\n");
1974             break;
1975         }
1976         spec->all_dacs[spec->num_all_dacs++] = nid;
1977     }
1978 }
1979 
1980 static int parse_output_paths(struct hda_codec *codec)
1981 {
1982     struct hda_gen_spec *spec = codec->spec;
1983     struct auto_pin_cfg *cfg = &spec->autocfg;
1984     struct auto_pin_cfg *best_cfg;
1985     unsigned int val;
1986     int best_badness = INT_MAX;
1987     int badness;
1988     bool fill_hardwired = true, fill_mio_first = true;
1989     bool best_wired = true, best_mio = true;
1990     bool hp_spk_swapped = false;
1991 
1992     best_cfg = kmalloc(sizeof(*best_cfg), GFP_KERNEL);
1993     if (!best_cfg)
1994         return -ENOMEM;
1995     *best_cfg = *cfg;
1996 
1997     for (;;) {
1998         badness = fill_and_eval_dacs(codec, fill_hardwired,
1999                          fill_mio_first);
2000         if (badness < 0) {
2001             kfree(best_cfg);
2002             return badness;
2003         }
2004         debug_badness("==> lo_type=%d, wired=%d, mio=%d, badness=0x%x\n",
2005                   cfg->line_out_type, fill_hardwired, fill_mio_first,
2006                   badness);
2007         debug_show_configs(codec, cfg);
2008         if (badness < best_badness) {
2009             best_badness = badness;
2010             *best_cfg = *cfg;
2011             best_wired = fill_hardwired;
2012             best_mio = fill_mio_first;
2013         }
2014         if (!badness)
2015             break;
2016         fill_mio_first = !fill_mio_first;
2017         if (!fill_mio_first)
2018             continue;
2019         fill_hardwired = !fill_hardwired;
2020         if (!fill_hardwired)
2021             continue;
2022         if (hp_spk_swapped)
2023             break;
2024         hp_spk_swapped = true;
2025         if (cfg->speaker_outs > 0 &&
2026             cfg->line_out_type == AUTO_PIN_HP_OUT) {
2027             cfg->hp_outs = cfg->line_outs;
2028             memcpy(cfg->hp_pins, cfg->line_out_pins,
2029                    sizeof(cfg->hp_pins));
2030             cfg->line_outs = cfg->speaker_outs;
2031             memcpy(cfg->line_out_pins, cfg->speaker_pins,
2032                    sizeof(cfg->speaker_pins));
2033             cfg->speaker_outs = 0;
2034             memset(cfg->speaker_pins, 0, sizeof(cfg->speaker_pins));
2035             cfg->line_out_type = AUTO_PIN_SPEAKER_OUT;
2036             fill_hardwired = true;
2037             continue;
2038         }
2039         if (cfg->hp_outs > 0 &&
2040             cfg->line_out_type == AUTO_PIN_SPEAKER_OUT) {
2041             cfg->speaker_outs = cfg->line_outs;
2042             memcpy(cfg->speaker_pins, cfg->line_out_pins,
2043                    sizeof(cfg->speaker_pins));
2044             cfg->line_outs = cfg->hp_outs;
2045             memcpy(cfg->line_out_pins, cfg->hp_pins,
2046                    sizeof(cfg->hp_pins));
2047             cfg->hp_outs = 0;
2048             memset(cfg->hp_pins, 0, sizeof(cfg->hp_pins));
2049             cfg->line_out_type = AUTO_PIN_HP_OUT;
2050             fill_hardwired = true;
2051             continue;
2052         }
2053         break;
2054     }
2055 
2056     if (badness) {
2057         debug_badness("==> restoring best_cfg\n");
2058         *cfg = *best_cfg;
2059         fill_and_eval_dacs(codec, best_wired, best_mio);
2060     }
2061     debug_badness("==> Best config: lo_type=%d, wired=%d, mio=%d\n",
2062               cfg->line_out_type, best_wired, best_mio);
2063     debug_show_configs(codec, cfg);
2064 
2065     if (cfg->line_out_pins[0]) {
2066         struct nid_path *path;
2067         path = snd_hda_get_path_from_idx(codec, spec->out_paths[0]);
2068         if (path)
2069             spec->vmaster_nid = look_for_out_vol_nid(codec, path);
2070         if (spec->vmaster_nid) {
2071             snd_hda_set_vmaster_tlv(codec, spec->vmaster_nid,
2072                         HDA_OUTPUT, spec->vmaster_tlv);
2073             if (spec->dac_min_mute)
2074                 spec->vmaster_tlv[SNDRV_CTL_TLVO_DB_SCALE_MUTE_AND_STEP] |= TLV_DB_SCALE_MUTE;
2075         }
2076     }
2077 
2078     /* set initial pinctl targets */
2079     if (spec->prefer_hp_amp || cfg->line_out_type == AUTO_PIN_HP_OUT)
2080         val = PIN_HP;
2081     else
2082         val = PIN_OUT;
2083     set_pin_targets(codec, cfg->line_outs, cfg->line_out_pins, val);
2084     if (cfg->line_out_type != AUTO_PIN_HP_OUT)
2085         set_pin_targets(codec, cfg->hp_outs, cfg->hp_pins, PIN_HP);
2086     if (cfg->line_out_type != AUTO_PIN_SPEAKER_OUT) {
2087         val = spec->prefer_hp_amp ? PIN_HP : PIN_OUT;
2088         set_pin_targets(codec, cfg->speaker_outs,
2089                 cfg->speaker_pins, val);
2090     }
2091 
2092     /* clear indep_hp flag if not available */
2093     if (spec->indep_hp && !indep_hp_possible(codec))
2094         spec->indep_hp = 0;
2095 
2096     kfree(best_cfg);
2097     return 0;
2098 }
2099 
2100 /* add playback controls from the parsed DAC table */
2101 static int create_multi_out_ctls(struct hda_codec *codec,
2102                  const struct auto_pin_cfg *cfg)
2103 {
2104     struct hda_gen_spec *spec = codec->spec;
2105     int i, err, noutputs;
2106 
2107     noutputs = cfg->line_outs;
2108     if (spec->multi_ios > 0 && cfg->line_outs < 3)
2109         noutputs += spec->multi_ios;
2110 
2111     for (i = 0; i < noutputs; i++) {
2112         const char *name;
2113         int index;
2114         struct nid_path *path;
2115 
2116         path = snd_hda_get_path_from_idx(codec, spec->out_paths[i]);
2117         if (!path)
2118             continue;
2119 
2120         name = get_line_out_pfx(codec, i, &index, NID_PATH_VOL_CTL);
2121         if (!name || !strcmp(name, "CLFE")) {
2122             /* Center/LFE */
2123             err = add_vol_ctl(codec, "Center", 0, 1, path);
2124             if (err < 0)
2125                 return err;
2126             err = add_vol_ctl(codec, "LFE", 0, 2, path);
2127             if (err < 0)
2128                 return err;
2129         } else {
2130             err = add_stereo_vol(codec, name, index, path);
2131             if (err < 0)
2132                 return err;
2133         }
2134 
2135         name = get_line_out_pfx(codec, i, &index, NID_PATH_MUTE_CTL);
2136         if (!name || !strcmp(name, "CLFE")) {
2137             err = add_sw_ctl(codec, "Center", 0, 1, path);
2138             if (err < 0)
2139                 return err;
2140             err = add_sw_ctl(codec, "LFE", 0, 2, path);
2141             if (err < 0)
2142                 return err;
2143         } else {
2144             err = add_stereo_sw(codec, name, index, path);
2145             if (err < 0)
2146                 return err;
2147         }
2148     }
2149     return 0;
2150 }
2151 
2152 static int create_extra_out(struct hda_codec *codec, int path_idx,
2153                 const char *pfx, int cidx)
2154 {
2155     struct nid_path *path;
2156     int err;
2157 
2158     path = snd_hda_get_path_from_idx(codec, path_idx);
2159     if (!path)
2160         return 0;
2161     err = add_stereo_vol(codec, pfx, cidx, path);
2162     if (err < 0)
2163         return err;
2164     err = add_stereo_sw(codec, pfx, cidx, path);
2165     if (err < 0)
2166         return err;
2167     return 0;
2168 }
2169 
2170 /* add playback controls for speaker and HP outputs */
2171 static int create_extra_outs(struct hda_codec *codec, int num_pins,
2172                  const int *paths, const char *pfx)
2173 {
2174     int i;
2175 
2176     for (i = 0; i < num_pins; i++) {
2177         const char *name;
2178         char tmp[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];
2179         int err, idx = 0;
2180 
2181         if (num_pins == 2 && i == 1 && !strcmp(pfx, "Speaker"))
2182             name = "Bass Speaker";
2183         else if (num_pins >= 3) {
2184             snprintf(tmp, sizeof(tmp), "%s %s",
2185                  pfx, channel_name[i]);
2186             name = tmp;
2187         } else {
2188             name = pfx;
2189             idx = i;
2190         }
2191         err = create_extra_out(codec, paths[i], name, idx);
2192         if (err < 0)
2193             return err;
2194     }
2195     return 0;
2196 }
2197 
2198 static int create_hp_out_ctls(struct hda_codec *codec)
2199 {
2200     struct hda_gen_spec *spec = codec->spec;
2201     return create_extra_outs(codec, spec->autocfg.hp_outs,
2202                  spec->hp_paths,
2203                  "Headphone");
2204 }
2205 
2206 static int create_speaker_out_ctls(struct hda_codec *codec)
2207 {
2208     struct hda_gen_spec *spec = codec->spec;
2209     return create_extra_outs(codec, spec->autocfg.speaker_outs,
2210                  spec->speaker_paths,
2211                  "Speaker");
2212 }
2213 
2214 /*
2215  * independent HP controls
2216  */
2217 
2218 static void call_hp_automute(struct hda_codec *codec,
2219                  struct hda_jack_callback *jack);
2220 static int indep_hp_info(struct snd_kcontrol *kcontrol,
2221              struct snd_ctl_elem_info *uinfo)
2222 {
2223     return snd_hda_enum_bool_helper_info(kcontrol, uinfo);
2224 }
2225 
2226 static int indep_hp_get(struct snd_kcontrol *kcontrol,
2227             struct snd_ctl_elem_value *ucontrol)
2228 {
2229     struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2230     struct hda_gen_spec *spec = codec->spec;
2231     ucontrol->value.enumerated.item[0] = spec->indep_hp_enabled;
2232     return 0;
2233 }
2234 
2235 static void update_aamix_paths(struct hda_codec *codec, bool do_mix,
2236                    int nomix_path_idx, int mix_path_idx,
2237                    int out_type);
2238 
2239 static int indep_hp_put(struct snd_kcontrol *kcontrol,
2240             struct snd_ctl_elem_value *ucontrol)
2241 {
2242     struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2243     struct hda_gen_spec *spec = codec->spec;
2244     unsigned int select = ucontrol->value.enumerated.item[0];
2245     int ret = 0;
2246 
2247     mutex_lock(&spec->pcm_mutex);
2248     if (spec->active_streams) {
2249         ret = -EBUSY;
2250         goto unlock;
2251     }
2252 
2253     if (spec->indep_hp_enabled != select) {
2254         hda_nid_t *dacp;
2255         if (spec->autocfg.line_out_type == AUTO_PIN_HP_OUT)
2256             dacp = &spec->private_dac_nids[0];
2257         else
2258             dacp = &spec->multiout.hp_out_nid[0];
2259 
2260         /* update HP aamix paths in case it conflicts with indep HP */
2261         if (spec->have_aamix_ctl) {
2262             if (spec->autocfg.line_out_type == AUTO_PIN_HP_OUT)
2263                 update_aamix_paths(codec, spec->aamix_mode,
2264                            spec->out_paths[0],
2265                            spec->aamix_out_paths[0],
2266                            spec->autocfg.line_out_type);
2267             else
2268                 update_aamix_paths(codec, spec->aamix_mode,
2269                            spec->hp_paths[0],
2270                            spec->aamix_out_paths[1],
2271                            AUTO_PIN_HP_OUT);
2272         }
2273 
2274         spec->indep_hp_enabled = select;
2275         if (spec->indep_hp_enabled)
2276             *dacp = 0;
2277         else
2278             *dacp = spec->alt_dac_nid;
2279 
2280         call_hp_automute(codec, NULL);
2281         ret = 1;
2282     }
2283  unlock:
2284     mutex_unlock(&spec->pcm_mutex);
2285     return ret;
2286 }
2287 
2288 static const struct snd_kcontrol_new indep_hp_ctl = {
2289     .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2290     .name = "Independent HP",
2291     .info = indep_hp_info,
2292     .get = indep_hp_get,
2293     .put = indep_hp_put,
2294 };
2295 
2296 
2297 static int create_indep_hp_ctls(struct hda_codec *codec)
2298 {
2299     struct hda_gen_spec *spec = codec->spec;
2300     hda_nid_t dac;
2301 
2302     if (!spec->indep_hp)
2303         return 0;
2304     if (spec->autocfg.line_out_type == AUTO_PIN_HP_OUT)
2305         dac = spec->multiout.dac_nids[0];
2306     else
2307         dac = spec->multiout.hp_out_nid[0];
2308     if (!dac) {
2309         spec->indep_hp = 0;
2310         return 0;
2311     }
2312 
2313     spec->indep_hp_enabled = false;
2314     spec->alt_dac_nid = dac;
2315     if (!snd_hda_gen_add_kctl(spec, NULL, &indep_hp_ctl))
2316         return -ENOMEM;
2317     return 0;
2318 }
2319 
2320 /*
2321  * channel mode enum control
2322  */
2323 
2324 static int ch_mode_info(struct snd_kcontrol *kcontrol,
2325             struct snd_ctl_elem_info *uinfo)
2326 {
2327     struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2328     struct hda_gen_spec *spec = codec->spec;
2329     int chs;
2330 
2331     uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
2332     uinfo->count = 1;
2333     uinfo->value.enumerated.items = spec->multi_ios + 1;
2334     if (uinfo->value.enumerated.item > spec->multi_ios)
2335         uinfo->value.enumerated.item = spec->multi_ios;
2336     chs = uinfo->value.enumerated.item * 2 + spec->min_channel_count;
2337     sprintf(uinfo->value.enumerated.name, "%dch", chs);
2338     return 0;
2339 }
2340 
2341 static int ch_mode_get(struct snd_kcontrol *kcontrol,
2342                struct snd_ctl_elem_value *ucontrol)
2343 {
2344     struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2345     struct hda_gen_spec *spec = codec->spec;
2346     ucontrol->value.enumerated.item[0] =
2347         (spec->ext_channel_count - spec->min_channel_count) / 2;
2348     return 0;
2349 }
2350 
2351 static inline struct nid_path *
2352 get_multiio_path(struct hda_codec *codec, int idx)
2353 {
2354     struct hda_gen_spec *spec = codec->spec;
2355     return snd_hda_get_path_from_idx(codec,
2356         spec->out_paths[spec->autocfg.line_outs + idx]);
2357 }
2358 
2359 static void update_automute_all(struct hda_codec *codec);
2360 
2361 /* Default value to be passed as aamix argument for snd_hda_activate_path();
2362  * used for output paths
2363  */
2364 static bool aamix_default(struct hda_gen_spec *spec)
2365 {
2366     return !spec->have_aamix_ctl || spec->aamix_mode;
2367 }
2368 
2369 static int set_multi_io(struct hda_codec *codec, int idx, bool output)
2370 {
2371     struct hda_gen_spec *spec = codec->spec;
2372     hda_nid_t nid = spec->multi_io[idx].pin;
2373     struct nid_path *path;
2374 
2375     path = get_multiio_path(codec, idx);
2376     if (!path)
2377         return -EINVAL;
2378 
2379     if (path->active == output)
2380         return 0;
2381 
2382     if (output) {
2383         set_pin_target(codec, nid, PIN_OUT, true);
2384         snd_hda_activate_path(codec, path, true, aamix_default(spec));
2385         set_pin_eapd(codec, nid, true);
2386     } else {
2387         set_pin_eapd(codec, nid, false);
2388         snd_hda_activate_path(codec, path, false, aamix_default(spec));
2389         set_pin_target(codec, nid, spec->multi_io[idx].ctl_in, true);
2390         path_power_down_sync(codec, path);
2391     }
2392 
2393     /* update jack retasking in case it modifies any of them */
2394     update_automute_all(codec);
2395 
2396     return 0;
2397 }
2398 
2399 static int ch_mode_put(struct snd_kcontrol *kcontrol,
2400                struct snd_ctl_elem_value *ucontrol)
2401 {
2402     struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2403     struct hda_gen_spec *spec = codec->spec;
2404     int i, ch;
2405 
2406     ch = ucontrol->value.enumerated.item[0];
2407     if (ch < 0 || ch > spec->multi_ios)
2408         return -EINVAL;
2409     if (ch == (spec->ext_channel_count - spec->min_channel_count) / 2)
2410         return 0;
2411     spec->ext_channel_count = ch * 2 + spec->min_channel_count;
2412     for (i = 0; i < spec->multi_ios; i++)
2413         set_multi_io(codec, i, i < ch);
2414     spec->multiout.max_channels = max(spec->ext_channel_count,
2415                       spec->const_channel_count);
2416     if (spec->need_dac_fix)
2417         spec->multiout.num_dacs = spec->multiout.max_channels / 2;
2418     return 1;
2419 }
2420 
2421 static const struct snd_kcontrol_new channel_mode_enum = {
2422     .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2423     .name = "Channel Mode",
2424     .info = ch_mode_info,
2425     .get = ch_mode_get,
2426     .put = ch_mode_put,
2427 };
2428 
2429 static int create_multi_channel_mode(struct hda_codec *codec)
2430 {
2431     struct hda_gen_spec *spec = codec->spec;
2432 
2433     if (spec->multi_ios > 0) {
2434         if (!snd_hda_gen_add_kctl(spec, NULL, &channel_mode_enum))
2435             return -ENOMEM;
2436     }
2437     return 0;
2438 }
2439 
2440 /*
2441  * aamix loopback enable/disable switch
2442  */
2443 
2444 #define loopback_mixing_info    indep_hp_info
2445 
2446 static int loopback_mixing_get(struct snd_kcontrol *kcontrol,
2447                    struct snd_ctl_elem_value *ucontrol)
2448 {
2449     struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2450     struct hda_gen_spec *spec = codec->spec;
2451     ucontrol->value.enumerated.item[0] = spec->aamix_mode;
2452     return 0;
2453 }
2454 
2455 static void update_aamix_paths(struct hda_codec *codec, bool do_mix,
2456                    int nomix_path_idx, int mix_path_idx,
2457                    int out_type)
2458 {
2459     struct hda_gen_spec *spec = codec->spec;
2460     struct nid_path *nomix_path, *mix_path;
2461 
2462     nomix_path = snd_hda_get_path_from_idx(codec, nomix_path_idx);
2463     mix_path = snd_hda_get_path_from_idx(codec, mix_path_idx);
2464     if (!nomix_path || !mix_path)
2465         return;
2466 
2467     /* if HP aamix path is driven from a different DAC and the
2468      * independent HP mode is ON, can't turn on aamix path
2469      */
2470     if (out_type == AUTO_PIN_HP_OUT && spec->indep_hp_enabled &&
2471         mix_path->path[0] != spec->alt_dac_nid)
2472         do_mix = false;
2473 
2474     if (do_mix) {
2475         snd_hda_activate_path(codec, nomix_path, false, true);
2476         snd_hda_activate_path(codec, mix_path, true, true);
2477         path_power_down_sync(codec, nomix_path);
2478     } else {
2479         snd_hda_activate_path(codec, mix_path, false, false);
2480         snd_hda_activate_path(codec, nomix_path, true, false);
2481         path_power_down_sync(codec, mix_path);
2482     }
2483 }
2484 
2485 /* re-initialize the output paths; only called from loopback_mixing_put() */
2486 static void update_output_paths(struct hda_codec *codec, int num_outs,
2487                 const int *paths)
2488 {
2489     struct hda_gen_spec *spec = codec->spec;
2490     struct nid_path *path;
2491     int i;
2492 
2493     for (i = 0; i < num_outs; i++) {
2494         path = snd_hda_get_path_from_idx(codec, paths[i]);
2495         if (path)
2496             snd_hda_activate_path(codec, path, path->active,
2497                           spec->aamix_mode);
2498     }
2499 }
2500 
2501 static int loopback_mixing_put(struct snd_kcontrol *kcontrol,
2502                    struct snd_ctl_elem_value *ucontrol)
2503 {
2504     struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2505     struct hda_gen_spec *spec = codec->spec;
2506     const struct auto_pin_cfg *cfg = &spec->autocfg;
2507     unsigned int val = ucontrol->value.enumerated.item[0];
2508 
2509     if (val == spec->aamix_mode)
2510         return 0;
2511     spec->aamix_mode = val;
2512     if (has_aamix_out_paths(spec)) {
2513         update_aamix_paths(codec, val, spec->out_paths[0],
2514                    spec->aamix_out_paths[0],
2515                    cfg->line_out_type);
2516         update_aamix_paths(codec, val, spec->hp_paths[0],
2517                    spec->aamix_out_paths[1],
2518                    AUTO_PIN_HP_OUT);
2519         update_aamix_paths(codec, val, spec->speaker_paths[0],
2520                    spec->aamix_out_paths[2],
2521                    AUTO_PIN_SPEAKER_OUT);
2522     } else {
2523         update_output_paths(codec, cfg->line_outs, spec->out_paths);
2524         if (cfg->line_out_type != AUTO_PIN_HP_OUT)
2525             update_output_paths(codec, cfg->hp_outs, spec->hp_paths);
2526         if (cfg->line_out_type != AUTO_PIN_SPEAKER_OUT)
2527             update_output_paths(codec, cfg->speaker_outs,
2528                         spec->speaker_paths);
2529     }
2530     return 1;
2531 }
2532 
2533 static const struct snd_kcontrol_new loopback_mixing_enum = {
2534     .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2535     .name = "Loopback Mixing",
2536     .info = loopback_mixing_info,
2537     .get = loopback_mixing_get,
2538     .put = loopback_mixing_put,
2539 };
2540 
2541 static int create_loopback_mixing_ctl(struct hda_codec *codec)
2542 {
2543     struct hda_gen_spec *spec = codec->spec;
2544 
2545     if (!spec->mixer_nid)
2546         return 0;
2547     if (!snd_hda_gen_add_kctl(spec, NULL, &loopback_mixing_enum))
2548         return -ENOMEM;
2549     spec->have_aamix_ctl = 1;
2550     return 0;
2551 }
2552 
2553 /*
2554  * shared headphone/mic handling
2555  */
2556 
2557 static void call_update_outputs(struct hda_codec *codec);
2558 
2559 /* for shared I/O, change the pin-control accordingly */
2560 static void update_hp_mic(struct hda_codec *codec, int adc_mux, bool force)
2561 {
2562     struct hda_gen_spec *spec = codec->spec;
2563     bool as_mic;
2564     unsigned int val;
2565     hda_nid_t pin;
2566 
2567     pin = spec->hp_mic_pin;
2568     as_mic = spec->cur_mux[adc_mux] == spec->hp_mic_mux_idx;
2569 
2570     if (!force) {
2571         val = snd_hda_codec_get_pin_target(codec, pin);
2572         if (as_mic) {
2573             if (val & PIN_IN)
2574                 return;
2575         } else {
2576             if (val & PIN_OUT)
2577                 return;
2578         }
2579     }
2580 
2581     val = snd_hda_get_default_vref(codec, pin);
2582     /* if the HP pin doesn't support VREF and the codec driver gives an
2583      * alternative pin, set up the VREF on that pin instead
2584      */
2585     if (val == AC_PINCTL_VREF_HIZ && spec->shared_mic_vref_pin) {
2586         const hda_nid_t vref_pin = spec->shared_mic_vref_pin;
2587         unsigned int vref_val = snd_hda_get_default_vref(codec, vref_pin);
2588         if (vref_val != AC_PINCTL_VREF_HIZ)
2589             snd_hda_set_pin_ctl_cache(codec, vref_pin,
2590                           PIN_IN | (as_mic ? vref_val : 0));
2591     }
2592 
2593     if (!spec->hp_mic_jack_modes) {
2594         if (as_mic)
2595             val |= PIN_IN;
2596         else
2597             val = PIN_HP;
2598         set_pin_target(codec, pin, val, true);
2599         call_hp_automute(codec, NULL);
2600     }
2601 }
2602 
2603 /* create a shared input with the headphone out */
2604 static int create_hp_mic(struct hda_codec *codec)
2605 {
2606     struct hda_gen_spec *spec = codec->spec;
2607     struct auto_pin_cfg *cfg = &spec->autocfg;
2608     unsigned int defcfg;
2609     hda_nid_t nid;
2610 
2611     if (!spec->hp_mic) {
2612         if (spec->suppress_hp_mic_detect)
2613             return 0;
2614         /* automatic detection: only if no input or a single internal
2615          * input pin is found, try to detect the shared hp/mic
2616          */
2617         if (cfg->num_inputs > 1)
2618             return 0;
2619         else if (cfg->num_inputs == 1) {
2620             defcfg = snd_hda_codec_get_pincfg(codec, cfg->inputs[0].pin);
2621             if (snd_hda_get_input_pin_attr(defcfg) != INPUT_PIN_ATTR_INT)
2622                 return 0;
2623         }
2624     }
2625 
2626     spec->hp_mic = 0; /* clear once */
2627     if (cfg->num_inputs >= AUTO_CFG_MAX_INS)
2628         return 0;
2629 
2630     nid = 0;
2631     if (cfg->line_out_type == AUTO_PIN_HP_OUT && cfg->line_outs > 0)
2632         nid = cfg->line_out_pins[0];
2633     else if (cfg->hp_outs > 0)
2634         nid = cfg->hp_pins[0];
2635     if (!nid)
2636         return 0;
2637 
2638     if (!(snd_hda_query_pin_caps(codec, nid) & AC_PINCAP_IN))
2639         return 0; /* no input */
2640 
2641     cfg->inputs[cfg->num_inputs].pin = nid;
2642     cfg->inputs[cfg->num_inputs].type = AUTO_PIN_MIC;
2643     cfg->inputs[cfg->num_inputs].is_headphone_mic = 1;
2644     cfg->num_inputs++;
2645     spec->hp_mic = 1;
2646     spec->hp_mic_pin = nid;
2647     /* we can't handle auto-mic together with HP-mic */
2648     spec->suppress_auto_mic = 1;
2649     codec_dbg(codec, "Enable shared I/O jack on NID 0x%x\n", nid);
2650     return 0;
2651 }
2652 
2653 /*
2654  * output jack mode
2655  */
2656 
2657 static int create_hp_mic_jack_mode(struct hda_codec *codec, hda_nid_t pin);
2658 
2659 static const char * const out_jack_texts[] = {
2660     "Line Out", "Headphone Out",
2661 };
2662 
2663 static int out_jack_mode_info(struct snd_kcontrol *kcontrol,
2664                   struct snd_ctl_elem_info *uinfo)
2665 {
2666     return snd_hda_enum_helper_info(kcontrol, uinfo, 2, out_jack_texts);
2667 }
2668 
2669 static int out_jack_mode_get(struct snd_kcontrol *kcontrol,
2670                  struct snd_ctl_elem_value *ucontrol)
2671 {
2672     struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2673     hda_nid_t nid = kcontrol->private_value;
2674     if (snd_hda_codec_get_pin_target(codec, nid) == PIN_HP)
2675         ucontrol->value.enumerated.item[0] = 1;
2676     else
2677         ucontrol->value.enumerated.item[0] = 0;
2678     return 0;
2679 }
2680 
2681 static int out_jack_mode_put(struct snd_kcontrol *kcontrol,
2682                  struct snd_ctl_elem_value *ucontrol)
2683 {
2684     struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2685     hda_nid_t nid = kcontrol->private_value;
2686     unsigned int val;
2687 
2688     val = ucontrol->value.enumerated.item[0] ? PIN_HP : PIN_OUT;
2689     if (snd_hda_codec_get_pin_target(codec, nid) == val)
2690         return 0;
2691     snd_hda_set_pin_ctl_cache(codec, nid, val);
2692     return 1;
2693 }
2694 
2695 static const struct snd_kcontrol_new out_jack_mode_enum = {
2696     .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2697     .info = out_jack_mode_info,
2698     .get = out_jack_mode_get,
2699     .put = out_jack_mode_put,
2700 };
2701 
2702 static bool find_kctl_name(struct hda_codec *codec, const char *name, int idx)
2703 {
2704     struct hda_gen_spec *spec = codec->spec;
2705     const struct snd_kcontrol_new *kctl;
2706     int i;
2707 
2708     snd_array_for_each(&spec->kctls, i, kctl) {
2709         if (!strcmp(kctl->name, name) && kctl->index == idx)
2710             return true;
2711     }
2712     return false;
2713 }
2714 
2715 static void get_jack_mode_name(struct hda_codec *codec, hda_nid_t pin,
2716                    char *name, size_t name_len)
2717 {
2718     struct hda_gen_spec *spec = codec->spec;
2719     int idx = 0;
2720 
2721     snd_hda_get_pin_label(codec, pin, &spec->autocfg, name, name_len, &idx);
2722     strlcat(name, " Jack Mode", name_len);
2723 
2724     for (; find_kctl_name(codec, name, idx); idx++)
2725         ;
2726 }
2727 
2728 static int get_out_jack_num_items(struct hda_codec *codec, hda_nid_t pin)
2729 {
2730     struct hda_gen_spec *spec = codec->spec;
2731     if (spec->add_jack_modes) {
2732         unsigned int pincap = snd_hda_query_pin_caps(codec, pin);
2733         if ((pincap & AC_PINCAP_OUT) && (pincap & AC_PINCAP_HP_DRV))
2734             return 2;
2735     }
2736     return 1;
2737 }
2738 
2739 static int create_out_jack_modes(struct hda_codec *codec, int num_pins,
2740                  hda_nid_t *pins)
2741 {
2742     struct hda_gen_spec *spec = codec->spec;
2743     int i;
2744 
2745     for (i = 0; i < num_pins; i++) {
2746         hda_nid_t pin = pins[i];
2747         if (pin == spec->hp_mic_pin)
2748             continue;
2749         if (get_out_jack_num_items(codec, pin) > 1) {
2750             struct snd_kcontrol_new *knew;
2751             char name[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];
2752             get_jack_mode_name(codec, pin, name, sizeof(name));
2753             knew = snd_hda_gen_add_kctl(spec, name,
2754                             &out_jack_mode_enum);
2755             if (!knew)
2756                 return -ENOMEM;
2757             knew->private_value = pin;
2758         }
2759     }
2760 
2761     return 0;
2762 }
2763 
2764 /*
2765  * input jack mode
2766  */
2767 
2768 /* from AC_PINCTL_VREF_HIZ to AC_PINCTL_VREF_100 */
2769 #define NUM_VREFS   6
2770 
2771 static const char * const vref_texts[NUM_VREFS] = {
2772     "Line In", "Mic 50pc Bias", "Mic 0V Bias",
2773     "", "Mic 80pc Bias", "Mic 100pc Bias"
2774 };
2775 
2776 static unsigned int get_vref_caps(struct hda_codec *codec, hda_nid_t pin)
2777 {
2778     unsigned int pincap;
2779 
2780     pincap = snd_hda_query_pin_caps(codec, pin);
2781     pincap = (pincap & AC_PINCAP_VREF) >> AC_PINCAP_VREF_SHIFT;
2782     /* filter out unusual vrefs */
2783     pincap &= ~(AC_PINCAP_VREF_GRD | AC_PINCAP_VREF_100);
2784     return pincap;
2785 }
2786 
2787 /* convert from the enum item index to the vref ctl index (0=HIZ, 1=50%...) */
2788 static int get_vref_idx(unsigned int vref_caps, unsigned int item_idx)
2789 {
2790     unsigned int i, n = 0;
2791 
2792     for (i = 0; i < NUM_VREFS; i++) {
2793         if (vref_caps & (1 << i)) {
2794             if (n == item_idx)
2795                 return i;
2796             n++;
2797         }
2798     }
2799     return 0;
2800 }
2801 
2802 /* convert back from the vref ctl index to the enum item index */
2803 static int cvt_from_vref_idx(unsigned int vref_caps, unsigned int idx)
2804 {
2805     unsigned int i, n = 0;
2806 
2807     for (i = 0; i < NUM_VREFS; i++) {
2808         if (i == idx)
2809             return n;
2810         if (vref_caps & (1 << i))
2811             n++;
2812     }
2813     return 0;
2814 }
2815 
2816 static int in_jack_mode_info(struct snd_kcontrol *kcontrol,
2817                  struct snd_ctl_elem_info *uinfo)
2818 {
2819     struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2820     hda_nid_t nid = kcontrol->private_value;
2821     unsigned int vref_caps = get_vref_caps(codec, nid);
2822 
2823     snd_hda_enum_helper_info(kcontrol, uinfo, hweight32(vref_caps),
2824                  vref_texts);
2825     /* set the right text */
2826     strcpy(uinfo->value.enumerated.name,
2827            vref_texts[get_vref_idx(vref_caps, uinfo->value.enumerated.item)]);
2828     return 0;
2829 }
2830 
2831 static int in_jack_mode_get(struct snd_kcontrol *kcontrol,
2832                 struct snd_ctl_elem_value *ucontrol)
2833 {
2834     struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2835     hda_nid_t nid = kcontrol->private_value;
2836     unsigned int vref_caps = get_vref_caps(codec, nid);
2837     unsigned int idx;
2838 
2839     idx = snd_hda_codec_get_pin_target(codec, nid) & AC_PINCTL_VREFEN;
2840     ucontrol->value.enumerated.item[0] = cvt_from_vref_idx(vref_caps, idx);
2841     return 0;
2842 }
2843 
2844 static int in_jack_mode_put(struct snd_kcontrol *kcontrol,
2845                 struct snd_ctl_elem_value *ucontrol)
2846 {
2847     struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2848     hda_nid_t nid = kcontrol->private_value;
2849     unsigned int vref_caps = get_vref_caps(codec, nid);
2850     unsigned int val, idx;
2851 
2852     val = snd_hda_codec_get_pin_target(codec, nid);
2853     idx = cvt_from_vref_idx(vref_caps, val & AC_PINCTL_VREFEN);
2854     if (idx == ucontrol->value.enumerated.item[0])
2855         return 0;
2856 
2857     val &= ~AC_PINCTL_VREFEN;
2858     val |= get_vref_idx(vref_caps, ucontrol->value.enumerated.item[0]);
2859     snd_hda_set_pin_ctl_cache(codec, nid, val);
2860     return 1;
2861 }
2862 
2863 static const struct snd_kcontrol_new in_jack_mode_enum = {
2864     .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2865     .info = in_jack_mode_info,
2866     .get = in_jack_mode_get,
2867     .put = in_jack_mode_put,
2868 };
2869 
2870 static int get_in_jack_num_items(struct hda_codec *codec, hda_nid_t pin)
2871 {
2872     struct hda_gen_spec *spec = codec->spec;
2873     int nitems = 0;
2874     if (spec->add_jack_modes)
2875         nitems = hweight32(get_vref_caps(codec, pin));
2876     return nitems ? nitems : 1;
2877 }
2878 
2879 static int create_in_jack_mode(struct hda_codec *codec, hda_nid_t pin)
2880 {
2881     struct hda_gen_spec *spec = codec->spec;
2882     struct snd_kcontrol_new *knew;
2883     char name[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];
2884     unsigned int defcfg;
2885 
2886     if (pin == spec->hp_mic_pin)
2887         return 0; /* already done in create_out_jack_mode() */
2888 
2889     /* no jack mode for fixed pins */
2890     defcfg = snd_hda_codec_get_pincfg(codec, pin);
2891     if (snd_hda_get_input_pin_attr(defcfg) == INPUT_PIN_ATTR_INT)
2892         return 0;
2893 
2894     /* no multiple vref caps? */
2895     if (get_in_jack_num_items(codec, pin) <= 1)
2896         return 0;
2897 
2898     get_jack_mode_name(codec, pin, name, sizeof(name));
2899     knew = snd_hda_gen_add_kctl(spec, name, &in_jack_mode_enum);
2900     if (!knew)
2901         return -ENOMEM;
2902     knew->private_value = pin;
2903     return 0;
2904 }
2905 
2906 /*
2907  * HP/mic shared jack mode
2908  */
2909 static int hp_mic_jack_mode_info(struct snd_kcontrol *kcontrol,
2910                  struct snd_ctl_elem_info *uinfo)
2911 {
2912     struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2913     hda_nid_t nid = kcontrol->private_value;
2914     int out_jacks = get_out_jack_num_items(codec, nid);
2915     int in_jacks = get_in_jack_num_items(codec, nid);
2916     const char *text = NULL;
2917     int idx;
2918 
2919     uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
2920     uinfo->count = 1;
2921     uinfo->value.enumerated.items = out_jacks + in_jacks;
2922     if (uinfo->value.enumerated.item >= uinfo->value.enumerated.items)
2923         uinfo->value.enumerated.item = uinfo->value.enumerated.items - 1;
2924     idx = uinfo->value.enumerated.item;
2925     if (idx < out_jacks) {
2926         if (out_jacks > 1)
2927             text = out_jack_texts[idx];
2928         else
2929             text = "Headphone Out";
2930     } else {
2931         idx -= out_jacks;
2932         if (in_jacks > 1) {
2933             unsigned int vref_caps = get_vref_caps(codec, nid);
2934             text = vref_texts[get_vref_idx(vref_caps, idx)];
2935         } else
2936             text = "Mic In";
2937     }
2938 
2939     strcpy(uinfo->value.enumerated.name, text);
2940     return 0;
2941 }
2942 
2943 static int get_cur_hp_mic_jack_mode(struct hda_codec *codec, hda_nid_t nid)
2944 {
2945     int out_jacks = get_out_jack_num_items(codec, nid);
2946     int in_jacks = get_in_jack_num_items(codec, nid);
2947     unsigned int val = snd_hda_codec_get_pin_target(codec, nid);
2948     int idx = 0;
2949 
2950     if (val & PIN_OUT) {
2951         if (out_jacks > 1 && val == PIN_HP)
2952             idx = 1;
2953     } else if (val & PIN_IN) {
2954         idx = out_jacks;
2955         if (in_jacks > 1) {
2956             unsigned int vref_caps = get_vref_caps(codec, nid);
2957             val &= AC_PINCTL_VREFEN;
2958             idx += cvt_from_vref_idx(vref_caps, val);
2959         }
2960     }
2961     return idx;
2962 }
2963 
2964 static int hp_mic_jack_mode_get(struct snd_kcontrol *kcontrol,
2965                 struct snd_ctl_elem_value *ucontrol)
2966 {
2967     struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2968     hda_nid_t nid = kcontrol->private_value;
2969     ucontrol->value.enumerated.item[0] =
2970         get_cur_hp_mic_jack_mode(codec, nid);
2971     return 0;
2972 }
2973 
2974 static int hp_mic_jack_mode_put(struct snd_kcontrol *kcontrol,
2975                 struct snd_ctl_elem_value *ucontrol)
2976 {
2977     struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2978     hda_nid_t nid = kcontrol->private_value;
2979     int out_jacks = get_out_jack_num_items(codec, nid);
2980     int in_jacks = get_in_jack_num_items(codec, nid);
2981     unsigned int val, oldval, idx;
2982 
2983     oldval = get_cur_hp_mic_jack_mode(codec, nid);
2984     idx = ucontrol->value.enumerated.item[0];
2985     if (oldval == idx)
2986         return 0;
2987 
2988     if (idx < out_jacks) {
2989         if (out_jacks > 1)
2990             val = idx ? PIN_HP : PIN_OUT;
2991         else
2992             val = PIN_HP;
2993     } else {
2994         idx -= out_jacks;
2995         if (in_jacks > 1) {
2996             unsigned int vref_caps = get_vref_caps(codec, nid);
2997             val = snd_hda_codec_get_pin_target(codec, nid);
2998             val &= ~(AC_PINCTL_VREFEN | PIN_HP);
2999             val |= get_vref_idx(vref_caps, idx) | PIN_IN;
3000         } else
3001             val = snd_hda_get_default_vref(codec, nid) | PIN_IN;
3002     }
3003     snd_hda_set_pin_ctl_cache(codec, nid, val);
3004     call_hp_automute(codec, NULL);
3005 
3006     return 1;
3007 }
3008 
3009 static const struct snd_kcontrol_new hp_mic_jack_mode_enum = {
3010     .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3011     .info = hp_mic_jack_mode_info,
3012     .get = hp_mic_jack_mode_get,
3013     .put = hp_mic_jack_mode_put,
3014 };
3015 
3016 static int create_hp_mic_jack_mode(struct hda_codec *codec, hda_nid_t pin)
3017 {
3018     struct hda_gen_spec *spec = codec->spec;
3019     struct snd_kcontrol_new *knew;
3020 
3021     knew = snd_hda_gen_add_kctl(spec, "Headphone Mic Jack Mode",
3022                     &hp_mic_jack_mode_enum);
3023     if (!knew)
3024         return -ENOMEM;
3025     knew->private_value = pin;
3026     spec->hp_mic_jack_modes = 1;
3027     return 0;
3028 }
3029 
3030 /*
3031  * Parse input paths
3032  */
3033 
3034 /* add the powersave loopback-list entry */
3035 static int add_loopback_list(struct hda_gen_spec *spec, hda_nid_t mix, int idx)
3036 {
3037     struct hda_amp_list *list;
3038 
3039     list = snd_array_new(&spec->loopback_list);
3040     if (!list)
3041         return -ENOMEM;
3042     list->nid = mix;
3043     list->dir = HDA_INPUT;
3044     list->idx = idx;
3045     spec->loopback.amplist = spec->loopback_list.list;
3046     return 0;
3047 }
3048 
3049 /* return true if either a volume or a mute amp is found for the given
3050  * aamix path; the amp has to be either in the mixer node or its direct leaf
3051  */
3052 static bool look_for_mix_leaf_ctls(struct hda_codec *codec, hda_nid_t mix_nid,
3053                    hda_nid_t pin, unsigned int *mix_val,
3054                    unsigned int *mute_val)
3055 {
3056     int idx, num_conns;
3057     const hda_nid_t *list;
3058     hda_nid_t nid;
3059 
3060     idx = snd_hda_get_conn_index(codec, mix_nid, pin, true);
3061     if (idx < 0)
3062         return false;
3063 
3064     *mix_val = *mute_val = 0;
3065     if (nid_has_volume(codec, mix_nid, HDA_INPUT))
3066         *mix_val = HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT);
3067     if (nid_has_mute(codec, mix_nid, HDA_INPUT))
3068         *mute_val = HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT);
3069     if (*mix_val && *mute_val)
3070         return true;
3071 
3072     /* check leaf node */
3073     num_conns = snd_hda_get_conn_list(codec, mix_nid, &list);
3074     if (num_conns < idx)
3075         return false;
3076     nid = list[idx];
3077     if (!*mix_val && nid_has_volume(codec, nid, HDA_OUTPUT) &&
3078         !is_ctl_associated(codec, nid, HDA_OUTPUT, 0, NID_PATH_VOL_CTL))
3079         *mix_val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
3080     if (!*mute_val && nid_has_mute(codec, nid, HDA_OUTPUT) &&
3081         !is_ctl_associated(codec, nid, HDA_OUTPUT, 0, NID_PATH_MUTE_CTL))
3082         *mute_val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
3083 
3084     return *mix_val || *mute_val;
3085 }
3086 
3087 /* create input playback/capture controls for the given pin */
3088 static int new_analog_input(struct hda_codec *codec, int input_idx,
3089                 hda_nid_t pin, const char *ctlname, int ctlidx,
3090                 hda_nid_t mix_nid)
3091 {
3092     struct hda_gen_spec *spec = codec->spec;
3093     struct nid_path *path;
3094     unsigned int mix_val, mute_val;
3095     int err, idx;
3096 
3097     if (!look_for_mix_leaf_ctls(codec, mix_nid, pin, &mix_val, &mute_val))
3098         return 0;
3099 
3100     path = snd_hda_add_new_path(codec, pin, mix_nid, 0);
3101     if (!path)
3102         return -EINVAL;
3103     print_nid_path(codec, "loopback", path);
3104     spec->loopback_paths[input_idx] = snd_hda_get_path_idx(codec, path);
3105 
3106     idx = path->idx[path->depth - 1];
3107     if (mix_val) {
3108         err = __add_pb_vol_ctrl(spec, HDA_CTL_WIDGET_VOL, ctlname, ctlidx, mix_val);
3109         if (err < 0)
3110             return err;
3111         path->ctls[NID_PATH_VOL_CTL] = mix_val;
3112     }
3113 
3114     if (mute_val) {
3115         err = __add_pb_sw_ctrl(spec, HDA_CTL_WIDGET_MUTE, ctlname, ctlidx, mute_val);
3116         if (err < 0)
3117             return err;
3118         path->ctls[NID_PATH_MUTE_CTL] = mute_val;
3119     }
3120 
3121     path->active = true;
3122     path->stream_enabled = true; /* no DAC/ADC involved */
3123     err = add_loopback_list(spec, mix_nid, idx);
3124     if (err < 0)
3125         return err;
3126 
3127     if (spec->mixer_nid != spec->mixer_merge_nid &&
3128         !spec->loopback_merge_path) {
3129         path = snd_hda_add_new_path(codec, spec->mixer_nid,
3130                         spec->mixer_merge_nid, 0);
3131         if (path) {
3132             print_nid_path(codec, "loopback-merge", path);
3133             path->active = true;
3134             path->pin_fixed = true; /* static route */
3135             path->stream_enabled = true; /* no DAC/ADC involved */
3136             spec->loopback_merge_path =
3137                 snd_hda_get_path_idx(codec, path);
3138         }
3139     }
3140 
3141     return 0;
3142 }
3143 
3144 static int is_input_pin(struct hda_codec *codec, hda_nid_t nid)
3145 {
3146     unsigned int pincap = snd_hda_query_pin_caps(codec, nid);
3147     return (pincap & AC_PINCAP_IN) != 0;
3148 }
3149 
3150 /* Parse the codec tree and retrieve ADCs */
3151 static int fill_adc_nids(struct hda_codec *codec)
3152 {
3153     struct hda_gen_spec *spec = codec->spec;
3154     hda_nid_t nid;
3155     hda_nid_t *adc_nids = spec->adc_nids;
3156     int max_nums = ARRAY_SIZE(spec->adc_nids);
3157     int nums = 0;
3158 
3159     for_each_hda_codec_node(nid, codec) {
3160         unsigned int caps = get_wcaps(codec, nid);
3161         int type = get_wcaps_type(caps);
3162 
3163         if (type != AC_WID_AUD_IN || (caps & AC_WCAP_DIGITAL))
3164             continue;
3165         adc_nids[nums] = nid;
3166         if (++nums >= max_nums)
3167             break;
3168     }
3169     spec->num_adc_nids = nums;
3170 
3171     /* copy the detected ADCs to all_adcs[] */
3172     spec->num_all_adcs = nums;
3173     memcpy(spec->all_adcs, spec->adc_nids, nums * sizeof(hda_nid_t));
3174 
3175     return nums;
3176 }
3177 
3178 /* filter out invalid adc_nids that don't give all active input pins;
3179  * if needed, check whether dynamic ADC-switching is available
3180  */
3181 static int check_dyn_adc_switch(struct hda_codec *codec)
3182 {
3183     struct hda_gen_spec *spec = codec->spec;
3184     struct hda_input_mux *imux = &spec->input_mux;
3185     unsigned int ok_bits;
3186     int i, n, nums;
3187 
3188     nums = 0;
3189     ok_bits = 0;
3190     for (n = 0; n < spec->num_adc_nids; n++) {
3191         for (i = 0; i < imux->num_items; i++) {
3192             if (!spec->input_paths[i][n])
3193                 break;
3194         }
3195         if (i >= imux->num_items) {
3196             ok_bits |= (1 << n);
3197             nums++;
3198         }
3199     }
3200 
3201     if (!ok_bits) {
3202         /* check whether ADC-switch is possible */
3203         for (i = 0; i < imux->num_items; i++) {
3204             for (n = 0; n < spec->num_adc_nids; n++) {
3205                 if (spec->input_paths[i][n]) {
3206                     spec->dyn_adc_idx[i] = n;
3207                     break;
3208                 }
3209             }
3210         }
3211 
3212         codec_dbg(codec, "enabling ADC switching\n");
3213         spec->dyn_adc_switch = 1;
3214     } else if (nums != spec->num_adc_nids) {
3215         /* shrink the invalid adcs and input paths */
3216         nums = 0;
3217         for (n = 0; n < spec->num_adc_nids; n++) {
3218             if (!(ok_bits & (1 << n)))
3219                 continue;
3220             if (n != nums) {
3221                 spec->adc_nids[nums] = spec->adc_nids[n];
3222                 for (i = 0; i < imux->num_items; i++) {
3223                     invalidate_nid_path(codec,
3224                         spec->input_paths[i][nums]);
3225                     spec->input_paths[i][nums] =
3226                         spec->input_paths[i][n];
3227                     spec->input_paths[i][n] = 0;
3228                 }
3229             }
3230             nums++;
3231         }
3232         spec->num_adc_nids = nums;
3233     }
3234 
3235     if (imux->num_items == 1 ||
3236         (imux->num_items == 2 && spec->hp_mic)) {
3237         codec_dbg(codec, "reducing to a single ADC\n");
3238         spec->num_adc_nids = 1; /* reduce to a single ADC */
3239     }
3240 
3241     /* single index for individual volumes ctls */
3242     if (!spec->dyn_adc_switch && spec->multi_cap_vol)
3243         spec->num_adc_nids = 1;
3244 
3245     return 0;
3246 }
3247 
3248 /* parse capture source paths from the given pin and create imux items */
3249 static int parse_capture_source(struct hda_codec *codec, hda_nid_t pin,
3250                 int cfg_idx, int num_adcs,
3251                 const char *label, int anchor)
3252 {
3253     struct hda_gen_spec *spec = codec->spec;
3254     struct hda_input_mux *imux = &spec->input_mux;
3255     int imux_idx = imux->num_items;
3256     bool imux_added = false;
3257     int c;
3258 
3259     for (c = 0; c < num_adcs; c++) {
3260         struct nid_path *path;
3261         hda_nid_t adc = spec->adc_nids[c];
3262 
3263         if (!is_reachable_path(codec, pin, adc))
3264             continue;
3265         path = snd_hda_add_new_path(codec, pin, adc, anchor);
3266         if (!path)
3267             continue;
3268         print_nid_path(codec, "input", path);
3269         spec->input_paths[imux_idx][c] =
3270             snd_hda_get_path_idx(codec, path);
3271 
3272         if (!imux_added) {
3273             if (spec->hp_mic_pin == pin)
3274                 spec->hp_mic_mux_idx = imux->num_items;
3275             spec->imux_pins[imux->num_items] = pin;
3276             snd_hda_add_imux_item(codec, imux, label, cfg_idx, NULL);
3277             imux_added = true;
3278             if (spec->dyn_adc_switch)
3279                 spec->dyn_adc_idx[imux_idx] = c;
3280         }
3281     }
3282 
3283     return 0;
3284 }
3285 
3286 /*
3287  * create playback/capture controls for input pins
3288  */
3289 
3290 /* fill the label for each input at first */
3291 static int fill_input_pin_labels(struct hda_codec *codec)
3292 {
3293     struct hda_gen_spec *spec = codec->spec;
3294     const struct auto_pin_cfg *cfg = &spec->autocfg;
3295     int i;
3296 
3297     for (i = 0; i < cfg->num_inputs; i++) {
3298         hda_nid_t pin = cfg->inputs[i].pin;
3299         const char *label;
3300         int j, idx;
3301 
3302         if (!is_input_pin(codec, pin))
3303             continue;
3304 
3305         label = hda_get_autocfg_input_label(codec, cfg, i);
3306         idx = 0;
3307         for (j = i - 1; j >= 0; j--) {
3308             if (spec->input_labels[j] &&
3309                 !strcmp(spec->input_labels[j], label)) {
3310                 idx = spec->input_label_idxs[j] + 1;
3311                 break;
3312             }
3313         }
3314 
3315         spec->input_labels[i] = label;
3316         spec->input_label_idxs[i] = idx;
3317     }
3318 
3319     return 0;
3320 }
3321 
3322 #define CFG_IDX_MIX 99  /* a dummy cfg->input idx for stereo mix */
3323 
3324 static int create_input_ctls(struct hda_codec *codec)
3325 {
3326     struct hda_gen_spec *spec = codec->spec;
3327     const struct auto_pin_cfg *cfg = &spec->autocfg;
3328     hda_nid_t mixer = spec->mixer_nid;
3329     int num_adcs;
3330     int i, err;
3331     unsigned int val;
3332 
3333     num_adcs = fill_adc_nids(codec);
3334     if (num_adcs < 0)
3335         return 0;
3336 
3337     err = fill_input_pin_labels(codec);
3338     if (err < 0)
3339         return err;
3340 
3341     for (i = 0; i < cfg->num_inputs; i++) {
3342         hda_nid_t pin;
3343 
3344         pin = cfg->inputs[i].pin;
3345         if (!is_input_pin(codec, pin))
3346             continue;
3347 
3348         val = PIN_IN;
3349         if (cfg->inputs[i].type == AUTO_PIN_MIC)
3350             val |= snd_hda_get_default_vref(codec, pin);
3351         if (pin != spec->hp_mic_pin &&
3352             !snd_hda_codec_get_pin_target(codec, pin))
3353             set_pin_target(codec, pin, val, false);
3354 
3355         if (mixer) {
3356             if (is_reachable_path(codec, pin, mixer)) {
3357                 err = new_analog_input(codec, i, pin,
3358                                spec->input_labels[i],
3359                                spec->input_label_idxs[i],
3360                                mixer);
3361                 if (err < 0)
3362                     return err;
3363             }
3364         }
3365 
3366         err = parse_capture_source(codec, pin, i, num_adcs,
3367                        spec->input_labels[i], -mixer);
3368         if (err < 0)
3369             return err;
3370 
3371         if (spec->add_jack_modes) {
3372             err = create_in_jack_mode(codec, pin);
3373             if (err < 0)
3374                 return err;
3375         }
3376     }
3377 
3378     /* add stereo mix when explicitly enabled via hint */
3379     if (mixer && spec->add_stereo_mix_input == HDA_HINT_STEREO_MIX_ENABLE) {
3380         err = parse_capture_source(codec, mixer, CFG_IDX_MIX, num_adcs,
3381                        "Stereo Mix", 0);
3382         if (err < 0)
3383             return err;
3384         else
3385             spec->suppress_auto_mic = 1;
3386     }
3387 
3388     return 0;
3389 }
3390 
3391 
3392 /*
3393  * input source mux
3394  */
3395 
3396 /* get the input path specified by the given adc and imux indices */
3397 static struct nid_path *get_input_path(struct hda_codec *codec, int adc_idx, int imux_idx)
3398 {
3399     struct hda_gen_spec *spec = codec->spec;
3400     if (imux_idx < 0 || imux_idx >= HDA_MAX_NUM_INPUTS) {
3401         snd_BUG();
3402         return NULL;
3403     }
3404     if (spec->dyn_adc_switch)
3405         adc_idx = spec->dyn_adc_idx[imux_idx];
3406     if (adc_idx < 0 || adc_idx >= AUTO_CFG_MAX_INS) {
3407         snd_BUG();
3408         return NULL;
3409     }
3410     return snd_hda_get_path_from_idx(codec, spec->input_paths[imux_idx][adc_idx]);
3411 }
3412 
3413 static int mux_select(struct hda_codec *codec, unsigned int adc_idx,
3414               unsigned int idx);
3415 
3416 static int mux_enum_info(struct snd_kcontrol *kcontrol,
3417              struct snd_ctl_elem_info *uinfo)
3418 {
3419     struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3420     struct hda_gen_spec *spec = codec->spec;
3421     return snd_hda_input_mux_info(&spec->input_mux, uinfo);
3422 }
3423 
3424 static int mux_enum_get(struct snd_kcontrol *kcontrol,
3425             struct snd_ctl_elem_value *ucontrol)
3426 {
3427     struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3428     struct hda_gen_spec *spec = codec->spec;
3429     /* the ctls are created at once with multiple counts */
3430     unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
3431 
3432     ucontrol->value.enumerated.item[0] = spec->cur_mux[adc_idx];
3433     return 0;
3434 }
3435 
3436 static int mux_enum_put(struct snd_kcontrol *kcontrol,
3437                 struct snd_ctl_elem_value *ucontrol)
3438 {
3439     struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3440     unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
3441     return mux_select(codec, adc_idx,
3442               ucontrol->value.enumerated.item[0]);
3443 }
3444 
3445 static const struct snd_kcontrol_new cap_src_temp = {
3446     .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3447     .name = "Input Source",
3448     .info = mux_enum_info,
3449     .get = mux_enum_get,
3450     .put = mux_enum_put,
3451 };
3452 
3453 /*
3454  * capture volume and capture switch ctls
3455  */
3456 
3457 typedef int (*put_call_t)(struct snd_kcontrol *kcontrol,
3458               struct snd_ctl_elem_value *ucontrol);
3459 
3460 /* call the given amp update function for all amps in the imux list at once */
3461 static int cap_put_caller(struct snd_kcontrol *kcontrol,
3462               struct snd_ctl_elem_value *ucontrol,
3463               put_call_t func, int type)
3464 {
3465     struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3466     struct hda_gen_spec *spec = codec->spec;
3467     const struct hda_input_mux *imux;
3468     struct nid_path *path;
3469     int i, adc_idx, ret, err = 0;
3470 
3471     imux = &spec->input_mux;
3472     adc_idx = kcontrol->id.index;
3473     mutex_lock(&codec->control_mutex);
3474     for (i = 0; i < imux->num_items; i++) {
3475         path = get_input_path(codec, adc_idx, i);
3476         if (!path || !path->ctls[type])
3477             continue;
3478         kcontrol->private_value = path->ctls[type];
3479         ret = func(kcontrol, ucontrol);
3480         if (ret < 0) {
3481             err = ret;
3482             break;
3483         }
3484         if (ret > 0)
3485             err = 1;
3486     }
3487     mutex_unlock(&codec->control_mutex);
3488     if (err >= 0 && spec->cap_sync_hook)
3489         spec->cap_sync_hook(codec, kcontrol, ucontrol);
3490     return err;
3491 }
3492 
3493 /* capture volume ctl callbacks */
3494 #define cap_vol_info        snd_hda_mixer_amp_volume_info
3495 #define cap_vol_get     snd_hda_mixer_amp_volume_get
3496 #define cap_vol_tlv     snd_hda_mixer_amp_tlv
3497 
3498 static int cap_vol_put(struct snd_kcontrol *kcontrol,
3499                struct snd_ctl_elem_value *ucontrol)
3500 {
3501     return cap_put_caller(kcontrol, ucontrol,
3502                   snd_hda_mixer_amp_volume_put,
3503                   NID_PATH_VOL_CTL);
3504 }
3505 
3506 static const struct snd_kcontrol_new cap_vol_temp = {
3507     .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3508     .name = "Capture Volume",
3509     .access = (SNDRV_CTL_ELEM_ACCESS_READWRITE |
3510            SNDRV_CTL_ELEM_ACCESS_TLV_READ |
3511            SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK),
3512     .info = cap_vol_info,
3513     .get = cap_vol_get,
3514     .put = cap_vol_put,
3515     .tlv = { .c = cap_vol_tlv },
3516 };
3517 
3518 /* capture switch ctl callbacks */
3519 #define cap_sw_info     snd_ctl_boolean_stereo_info
3520 #define cap_sw_get      snd_hda_mixer_amp_switch_get
3521 
3522 static int cap_sw_put(struct snd_kcontrol *kcontrol,
3523               struct snd_ctl_elem_value *ucontrol)
3524 {
3525     return cap_put_caller(kcontrol, ucontrol,
3526                   snd_hda_mixer_amp_switch_put,
3527                   NID_PATH_MUTE_CTL);
3528 }
3529 
3530 static const struct snd_kcontrol_new cap_sw_temp = {
3531     .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3532     .name = "Capture Switch",
3533     .access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
3534     .info = cap_sw_info,
3535     .get = cap_sw_get,
3536     .put = cap_sw_put,
3537 };
3538 
3539 static int parse_capvol_in_path(struct hda_codec *codec, struct nid_path *path)
3540 {
3541     hda_nid_t nid;
3542     int i, depth;
3543 
3544     path->ctls[NID_PATH_VOL_CTL] = path->ctls[NID_PATH_MUTE_CTL] = 0;
3545     for (depth = 0; depth < 3; depth++) {
3546         if (depth >= path->depth)
3547             return -EINVAL;
3548         i = path->depth - depth - 1;
3549         nid = path->path[i];
3550         if (!path->ctls[NID_PATH_VOL_CTL]) {
3551             if (nid_has_volume(codec, nid, HDA_OUTPUT))
3552                 path->ctls[NID_PATH_VOL_CTL] =
3553                     HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
3554             else if (nid_has_volume(codec, nid, HDA_INPUT)) {
3555                 int idx = path->idx[i];
3556                 if (!depth && codec->single_adc_amp)
3557                     idx = 0;
3558                 path->ctls[NID_PATH_VOL_CTL] =
3559                     HDA_COMPOSE_AMP_VAL(nid, 3, idx, HDA_INPUT);
3560             }
3561         }
3562         if (!path->ctls[NID_PATH_MUTE_CTL]) {
3563             if (nid_has_mute(codec, nid, HDA_OUTPUT))
3564                 path->ctls[NID_PATH_MUTE_CTL] =
3565                     HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
3566             else if (nid_has_mute(codec, nid, HDA_INPUT)) {
3567                 int idx = path->idx[i];
3568                 if (!depth && codec->single_adc_amp)
3569                     idx = 0;
3570                 path->ctls[NID_PATH_MUTE_CTL] =
3571                     HDA_COMPOSE_AMP_VAL(nid, 3, idx, HDA_INPUT);
3572             }
3573         }
3574     }
3575     return 0;
3576 }
3577 
3578 static bool is_inv_dmic_pin(struct hda_codec *codec, hda_nid_t nid)
3579 {
3580     struct hda_gen_spec *spec = codec->spec;
3581     struct auto_pin_cfg *cfg = &spec->autocfg;
3582     unsigned int val;
3583     int i;
3584 
3585     if (!spec->inv_dmic_split)
3586         return false;
3587     for (i = 0; i < cfg->num_inputs; i++) {
3588         if (cfg->inputs[i].pin != nid)
3589             continue;
3590         if (cfg->inputs[i].type != AUTO_PIN_MIC)
3591             return false;
3592         val = snd_hda_codec_get_pincfg(codec, nid);
3593         return snd_hda_get_input_pin_attr(val) == INPUT_PIN_ATTR_INT;
3594     }
3595     return false;
3596 }
3597 
3598 /* capture switch put callback for a single control with hook call */
3599 static int cap_single_sw_put(struct snd_kcontrol *kcontrol,
3600                  struct snd_ctl_elem_value *ucontrol)
3601 {
3602     struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3603     struct hda_gen_spec *spec = codec->spec;
3604     int ret;
3605 
3606     ret = snd_hda_mixer_amp_switch_put(kcontrol, ucontrol);
3607     if (ret < 0)
3608         return ret;
3609 
3610     if (spec->cap_sync_hook)
3611         spec->cap_sync_hook(codec, kcontrol, ucontrol);
3612 
3613     return ret;
3614 }
3615 
3616 static int add_single_cap_ctl(struct hda_codec *codec, const char *label,
3617                   int idx, bool is_switch, unsigned int ctl,
3618                   bool inv_dmic)
3619 {
3620     struct hda_gen_spec *spec = codec->spec;
3621     char tmpname[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];
3622     int type = is_switch ? HDA_CTL_WIDGET_MUTE : HDA_CTL_WIDGET_VOL;
3623     const char *sfx = is_switch ? "Switch" : "Volume";
3624     unsigned int chs = inv_dmic ? 1 : 3;
3625     struct snd_kcontrol_new *knew;
3626 
3627     if (!ctl)
3628         return 0;
3629 
3630     if (label)
3631         snprintf(tmpname, sizeof(tmpname),
3632              "%s Capture %s", label, sfx);
3633     else
3634         snprintf(tmpname, sizeof(tmpname),
3635              "Capture %s", sfx);
3636     knew = add_control(spec, type, tmpname, idx,
3637                amp_val_replace_channels(ctl, chs));
3638     if (!knew)
3639         return -ENOMEM;
3640     if (is_switch) {
3641         knew->put = cap_single_sw_put;
3642         if (spec->mic_mute_led)
3643             knew->access |= SNDRV_CTL_ELEM_ACCESS_MIC_LED;
3644     }
3645     if (!inv_dmic)
3646         return 0;
3647 
3648     /* Make independent right kcontrol */
3649     if (label)
3650         snprintf(tmpname, sizeof(tmpname),
3651              "Inverted %s Capture %s", label, sfx);
3652     else
3653         snprintf(tmpname, sizeof(tmpname),
3654              "Inverted Capture %s", sfx);
3655     knew = add_control(spec, type, tmpname, idx,
3656                amp_val_replace_channels(ctl, 2));
3657     if (!knew)
3658         return -ENOMEM;
3659     if (is_switch) {
3660         knew->put = cap_single_sw_put;
3661         if (spec->mic_mute_led)
3662             knew->access |= SNDRV_CTL_ELEM_ACCESS_MIC_LED;
3663     }
3664     return 0;
3665 }
3666 
3667 /* create single (and simple) capture volume and switch controls */
3668 static int create_single_cap_vol_ctl(struct hda_codec *codec, int idx,
3669                      unsigned int vol_ctl, unsigned int sw_ctl,
3670                      bool inv_dmic)
3671 {
3672     int err;
3673     err = add_single_cap_ctl(codec, NULL, idx, false, vol_ctl, inv_dmic);
3674     if (err < 0)
3675         return err;
3676     err = add_single_cap_ctl(codec, NULL, idx, true, sw_ctl, inv_dmic);
3677     if (err < 0)
3678         return err;
3679     return 0;
3680 }
3681 
3682 /* create bound capture volume and switch controls */
3683 static int create_bind_cap_vol_ctl(struct hda_codec *codec, int idx,
3684                    unsigned int vol_ctl, unsigned int sw_ctl)
3685 {
3686     struct hda_gen_spec *spec = codec->spec;
3687     struct snd_kcontrol_new *knew;
3688 
3689     if (vol_ctl) {
3690         knew = snd_hda_gen_add_kctl(spec, NULL, &cap_vol_temp);
3691         if (!knew)
3692             return -ENOMEM;
3693         knew->index = idx;
3694         knew->private_value = vol_ctl;
3695         knew->subdevice = HDA_SUBDEV_AMP_FLAG;
3696     }
3697     if (sw_ctl) {
3698         knew = snd_hda_gen_add_kctl(spec, NULL, &cap_sw_temp);
3699         if (!knew)
3700             return -ENOMEM;
3701         knew->index = idx;
3702         knew->private_value = sw_ctl;
3703         knew->subdevice = HDA_SUBDEV_AMP_FLAG;
3704         if (spec->mic_mute_led)
3705             knew->access |= SNDRV_CTL_ELEM_ACCESS_MIC_LED;
3706     }
3707     return 0;
3708 }
3709 
3710 /* return the vol ctl when used first in the imux list */
3711 static unsigned int get_first_cap_ctl(struct hda_codec *codec, int idx, int type)
3712 {
3713     struct nid_path *path;
3714     unsigned int ctl;
3715     int i;
3716 
3717     path = get_input_path(codec, 0, idx);
3718     if (!path)
3719         return 0;
3720     ctl = path->ctls[type];
3721     if (!ctl)
3722         return 0;
3723     for (i = 0; i < idx - 1; i++) {
3724         path = get_input_path(codec, 0, i);
3725         if (path && path->ctls[type] == ctl)
3726             return 0;
3727     }
3728     return ctl;
3729 }
3730 
3731 /* create individual capture volume and switch controls per input */
3732 static int create_multi_cap_vol_ctl(struct hda_codec *codec)
3733 {
3734     struct hda_gen_spec *spec = codec->spec;
3735     struct hda_input_mux *imux = &spec->input_mux;
3736     int i, err, type;
3737 
3738     for (i = 0; i < imux->num_items; i++) {
3739         bool inv_dmic;
3740         int idx;
3741 
3742         idx = imux->items[i].index;
3743         if (idx >= spec->autocfg.num_inputs)
3744             continue;
3745         inv_dmic = is_inv_dmic_pin(codec, spec->imux_pins[i]);
3746 
3747         for (type = 0; type < 2; type++) {
3748             err = add_single_cap_ctl(codec,
3749                          spec->input_labels[idx],
3750                          spec->input_label_idxs[idx],
3751                          type,
3752                          get_first_cap_ctl(codec, i, type),
3753                          inv_dmic);
3754             if (err < 0)
3755                 return err;
3756         }
3757     }
3758     return 0;
3759 }
3760 
3761 static int create_capture_mixers(struct hda_codec *codec)
3762 {
3763     struct hda_gen_spec *spec = codec->spec;
3764     struct hda_input_mux *imux = &spec->input_mux;
3765     int i, n, nums, err;
3766 
3767     if (spec->dyn_adc_switch)
3768         nums = 1;
3769     else
3770         nums = spec->num_adc_nids;
3771 
3772     if (!spec->auto_mic && imux->num_items > 1) {
3773         struct snd_kcontrol_new *knew;
3774         const char *name;
3775         name = nums > 1 ? "Input Source" : "Capture Source";
3776         knew = snd_hda_gen_add_kctl(spec, name, &cap_src_temp);
3777         if (!knew)
3778             return -ENOMEM;
3779         knew->count = nums;
3780     }
3781 
3782     for (n = 0; n < nums; n++) {
3783         bool multi = false;
3784         bool multi_cap_vol = spec->multi_cap_vol;
3785         bool inv_dmic = false;
3786         int vol, sw;
3787 
3788         vol = sw = 0;
3789         for (i = 0; i < imux->num_items; i++) {
3790             struct nid_path *path;
3791             path = get_input_path(codec, n, i);
3792             if (!path)
3793                 continue;
3794             parse_capvol_in_path(codec, path);
3795             if (!vol)
3796                 vol = path->ctls[NID_PATH_VOL_CTL];
3797             else if (vol != path->ctls[NID_PATH_VOL_CTL]) {
3798                 multi = true;
3799                 if (!same_amp_caps(codec, vol,
3800                     path->ctls[NID_PATH_VOL_CTL], HDA_INPUT))
3801                     multi_cap_vol = true;
3802             }
3803             if (!sw)
3804                 sw = path->ctls[NID_PATH_MUTE_CTL];
3805             else if (sw != path->ctls[NID_PATH_MUTE_CTL]) {
3806                 multi = true;
3807                 if (!same_amp_caps(codec, sw,
3808                     path->ctls[NID_PATH_MUTE_CTL], HDA_INPUT))
3809                     multi_cap_vol = true;
3810             }
3811             if (is_inv_dmic_pin(codec, spec->imux_pins[i]))
3812                 inv_dmic = true;
3813         }
3814 
3815         if (!multi)
3816             err = create_single_cap_vol_ctl(codec, n, vol, sw,
3817                             inv_dmic);
3818         else if (!multi_cap_vol && !inv_dmic)
3819             err = create_bind_cap_vol_ctl(codec, n, vol, sw);
3820         else
3821             err = create_multi_cap_vol_ctl(codec);
3822         if (err < 0)
3823             return err;
3824     }
3825 
3826     return 0;
3827 }
3828 
3829 /*
3830  * add mic boosts if needed
3831  */
3832 
3833 /* check whether the given amp is feasible as a boost volume */
3834 static bool check_boost_vol(struct hda_codec *codec, hda_nid_t nid,
3835                 int dir, int idx)
3836 {
3837     unsigned int step;
3838 
3839     if (!nid_has_volume(codec, nid, dir) ||
3840         is_ctl_associated(codec, nid, dir, idx, NID_PATH_VOL_CTL) ||
3841         is_ctl_associated(codec, nid, dir, idx, NID_PATH_BOOST_CTL))
3842         return false;
3843 
3844     step = (query_amp_caps(codec, nid, dir) & AC_AMPCAP_STEP_SIZE)
3845         >> AC_AMPCAP_STEP_SIZE_SHIFT;
3846     if (step < 0x20)
3847         return false;
3848     return true;
3849 }
3850 
3851 /* look for a boost amp in a widget close to the pin */
3852 static unsigned int look_for_boost_amp(struct hda_codec *codec,
3853                        struct nid_path *path)
3854 {
3855     unsigned int val = 0;
3856     hda_nid_t nid;
3857     int depth;
3858 
3859     for (depth = 0; depth < 3; depth++) {
3860         if (depth >= path->depth - 1)
3861             break;
3862         nid = path->path[depth];
3863         if (depth && check_boost_vol(codec, nid, HDA_OUTPUT, 0)) {
3864             val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
3865             break;
3866         } else if (check_boost_vol(codec, nid, HDA_INPUT,
3867                        path->idx[depth])) {
3868             val = HDA_COMPOSE_AMP_VAL(nid, 3, path->idx[depth],
3869                           HDA_INPUT);
3870             break;
3871         }
3872     }
3873 
3874     return val;
3875 }
3876 
3877 static int parse_mic_boost(struct hda_codec *codec)
3878 {
3879     struct hda_gen_spec *spec = codec->spec;
3880     struct auto_pin_cfg *cfg = &spec->autocfg;
3881     struct hda_input_mux *imux = &spec->input_mux;
3882     int i;
3883 
3884     if (!spec->num_adc_nids)
3885         return 0;
3886 
3887     for (i = 0; i < imux->num_items; i++) {
3888         struct nid_path *path;
3889         unsigned int val;
3890         int idx;
3891         char boost_label[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];
3892 
3893         idx = imux->items[i].index;
3894         if (idx >= imux->num_items)
3895             continue;
3896 
3897         /* check only line-in and mic pins */
3898         if (cfg->inputs[idx].type > AUTO_PIN_LINE_IN)
3899             continue;
3900 
3901         path = get_input_path(codec, 0, i);
3902         if (!path)
3903             continue;
3904 
3905         val = look_for_boost_amp(codec, path);
3906         if (!val)
3907             continue;
3908 
3909         /* create a boost control */
3910         snprintf(boost_label, sizeof(boost_label),
3911              "%s Boost Volume", spec->input_labels[idx]);
3912         if (!add_control(spec, HDA_CTL_WIDGET_VOL, boost_label,
3913                  spec->input_label_idxs[idx], val))
3914             return -ENOMEM;
3915 
3916         path->ctls[NID_PATH_BOOST_CTL] = val;
3917     }
3918     return 0;
3919 }
3920 
3921 #ifdef CONFIG_SND_HDA_GENERIC_LEDS
3922 /*
3923  * vmaster mute LED hook helpers
3924  */
3925 
3926 static int create_mute_led_cdev(struct hda_codec *codec,
3927                 int (*callback)(struct led_classdev *,
3928                         enum led_brightness),
3929                 bool micmute)
3930 {
3931     struct hda_gen_spec *spec = codec->spec;
3932     struct led_classdev *cdev;
3933     int idx = micmute ? LED_AUDIO_MICMUTE : LED_AUDIO_MUTE;
3934     int err;
3935 
3936     cdev = devm_kzalloc(&codec->core.dev, sizeof(*cdev), GFP_KERNEL);
3937     if (!cdev)
3938         return -ENOMEM;
3939 
3940     cdev->name = micmute ? "hda::micmute" : "hda::mute";
3941     cdev->max_brightness = 1;
3942     cdev->default_trigger = micmute ? "audio-micmute" : "audio-mute";
3943     cdev->brightness_set_blocking = callback;
3944     cdev->brightness = ledtrig_audio_get(idx);
3945     cdev->flags = LED_CORE_SUSPENDRESUME;
3946 
3947     err = led_classdev_register(&codec->core.dev, cdev);
3948     if (err < 0)
3949         return err;
3950     spec->led_cdevs[idx] = cdev;
3951     return 0;
3952 }
3953 
3954 /**
3955  * snd_hda_gen_add_mute_led_cdev - Create a LED classdev and enable as vmaster mute LED
3956  * @codec: the HDA codec
3957  * @callback: the callback for LED classdev brightness_set_blocking
3958  */
3959 int snd_hda_gen_add_mute_led_cdev(struct hda_codec *codec,
3960                   int (*callback)(struct led_classdev *,
3961                           enum led_brightness))
3962 {
3963     struct hda_gen_spec *spec = codec->spec;
3964     int err;
3965 
3966     if (callback) {
3967         err = create_mute_led_cdev(codec, callback, false);
3968         if (err) {
3969             codec_warn(codec, "failed to create a mute LED cdev\n");
3970             return err;
3971         }
3972     }
3973 
3974     if (spec->vmaster_mute.hook)
3975         codec_err(codec, "vmaster hook already present before cdev!\n");
3976 
3977     spec->vmaster_mute_led = 1;
3978     return 0;
3979 }
3980 EXPORT_SYMBOL_GPL(snd_hda_gen_add_mute_led_cdev);
3981 
3982 /**
3983  * snd_hda_gen_add_micmute_led_cdev - Create a LED classdev and enable as mic-mute LED
3984  * @codec: the HDA codec
3985  * @callback: the callback for LED classdev brightness_set_blocking
3986  *
3987  * Called from the codec drivers for offering the mic mute LED controls.
3988  * This creates a LED classdev and sets up the cap_sync_hook that is called at
3989  * each time when the capture mixer switch changes.
3990  *
3991  * When NULL is passed to @callback, no classdev is created but only the
3992  * LED-trigger is set up.
3993  *
3994  * Returns 0 or a negative error.
3995  */
3996 int snd_hda_gen_add_micmute_led_cdev(struct hda_codec *codec,
3997                      int (*callback)(struct led_classdev *,
3998                              enum led_brightness))
3999 {
4000     struct hda_gen_spec *spec = codec->spec;
4001     int err;
4002 
4003     if (callback) {
4004         err = create_mute_led_cdev(codec, callback, true);
4005         if (err) {
4006             codec_warn(codec, "failed to create a mic-mute LED cdev\n");
4007             return err;
4008         }
4009     }
4010 
4011     spec->mic_mute_led = 1;
4012     return 0;
4013 }
4014 EXPORT_SYMBOL_GPL(snd_hda_gen_add_micmute_led_cdev);
4015 #endif /* CONFIG_SND_HDA_GENERIC_LEDS */
4016 
4017 /*
4018  * parse digital I/Os and set up NIDs in BIOS auto-parse mode
4019  */
4020 static void parse_digital(struct hda_codec *codec)
4021 {
4022     struct hda_gen_spec *spec = codec->spec;
4023     struct nid_path *path;
4024     int i, nums;
4025     hda_nid_t dig_nid, pin;
4026 
4027     /* support multiple SPDIFs; the secondary is set up as a follower */
4028     nums = 0;
4029     for (i = 0; i < spec->autocfg.dig_outs; i++) {
4030         pin = spec->autocfg.dig_out_pins[i];
4031         dig_nid = look_for_dac(codec, pin, true);
4032         if (!dig_nid)
4033             continue;
4034         path = snd_hda_add_new_path(codec, dig_nid, pin, 0);
4035         if (!path)
4036             continue;
4037         print_nid_path(codec, "digout", path);
4038         path->active = true;
4039         path->pin_fixed = true; /* no jack detection */
4040         spec->digout_paths[i] = snd_hda_get_path_idx(codec, path);
4041         set_pin_target(codec, pin, PIN_OUT, false);
4042         if (!nums) {
4043             spec->multiout.dig_out_nid = dig_nid;
4044             spec->dig_out_type = spec->autocfg.dig_out_type[0];
4045         } else {
4046             spec->multiout.follower_dig_outs = spec->follower_dig_outs;
4047             if (nums >= ARRAY_SIZE(spec->follower_dig_outs) - 1)
4048                 break;
4049             spec->follower_dig_outs[nums - 1] = dig_nid;
4050         }
4051         nums++;
4052     }
4053 
4054     if (spec->autocfg.dig_in_pin) {
4055         pin = spec->autocfg.dig_in_pin;
4056         for_each_hda_codec_node(dig_nid, codec) {
4057             unsigned int wcaps = get_wcaps(codec, dig_nid);
4058             if (get_wcaps_type(wcaps) != AC_WID_AUD_IN)
4059                 continue;
4060             if (!(wcaps & AC_WCAP_DIGITAL))
4061                 continue;
4062             path = snd_hda_add_new_path(codec, pin, dig_nid, 0);
4063             if (path) {
4064                 print_nid_path(codec, "digin", path);
4065                 path->active = true;
4066                 path->pin_fixed = true; /* no jack */
4067                 spec->dig_in_nid = dig_nid;
4068                 spec->digin_path = snd_hda_get_path_idx(codec, path);
4069                 set_pin_target(codec, pin, PIN_IN, false);
4070                 break;
4071             }
4072         }
4073     }
4074 }
4075 
4076 
4077 /*
4078  * input MUX handling
4079  */
4080 
4081 static bool dyn_adc_pcm_resetup(struct hda_codec *codec, int cur);
4082 
4083 /* select the given imux item; either unmute exclusively or select the route */
4084 static int mux_select(struct hda_codec *codec, unsigned int adc_idx,
4085               unsigned int idx)
4086 {
4087     struct hda_gen_spec *spec = codec->spec;
4088     const struct hda_input_mux *imux;
4089     struct nid_path *old_path, *path;
4090 
4091     imux = &spec->input_mux;
4092     if (!imux->num_items)
4093         return 0;
4094 
4095     if (idx >= imux->num_items)
4096         idx = imux->num_items - 1;
4097     if (spec->cur_mux[adc_idx] == idx)
4098         return 0;
4099 
4100     old_path = get_input_path(codec, adc_idx, spec->cur_mux[adc_idx]);
4101     if (!old_path)
4102         return 0;
4103     if (old_path->active)
4104         snd_hda_activate_path(codec, old_path, false, false);
4105 
4106     spec->cur_mux[adc_idx] = idx;
4107 
4108     if (spec->hp_mic)
4109         update_hp_mic(codec, adc_idx, false);
4110 
4111     if (spec->dyn_adc_switch)
4112         dyn_adc_pcm_resetup(codec, idx);
4113 
4114     path = get_input_path(codec, adc_idx, idx);
4115     if (!path)
4116         return 0;
4117     if (path->active)
4118         return 0;
4119     snd_hda_activate_path(codec, path, true, false);
4120     if (spec->cap_sync_hook)
4121         spec->cap_sync_hook(codec, NULL, NULL);
4122     path_power_down_sync(codec, old_path);
4123     return 1;
4124 }
4125 
4126 /* power up/down widgets in the all paths that match with the given NID
4127  * as terminals (either start- or endpoint)
4128  *
4129  * returns the last changed NID, or zero if unchanged.
4130  */
4131 static hda_nid_t set_path_power(struct hda_codec *codec, hda_nid_t nid,
4132                 int pin_state, int stream_state)
4133 {
4134     struct hda_gen_spec *spec = codec->spec;
4135     hda_nid_t last, changed = 0;
4136     struct nid_path *path;
4137     int n;
4138 
4139     snd_array_for_each(&spec->paths, n, path) {
4140         if (!path->depth)
4141             continue;
4142         if (path->path[0] == nid ||
4143             path->path[path->depth - 1] == nid) {
4144             bool pin_old = path->pin_enabled;
4145             bool stream_old = path->stream_enabled;
4146 
4147             if (pin_state >= 0)
4148                 path->pin_enabled = pin_state;
4149             if (stream_state >= 0)
4150                 path->stream_enabled = stream_state;
4151             if ((!path->pin_fixed && path->pin_enabled != pin_old)
4152                 || path->stream_enabled != stream_old) {
4153                 last = path_power_update(codec, path, true);
4154                 if (last)
4155                     changed = last;
4156             }
4157         }
4158     }
4159     return changed;
4160 }
4161 
4162 /* check the jack status for power control */
4163 static bool detect_pin_state(struct hda_codec *codec, hda_nid_t pin)
4164 {
4165     if (!is_jack_detectable(codec, pin))
4166         return true;
4167     return snd_hda_jack_detect_state(codec, pin) != HDA_JACK_NOT_PRESENT;
4168 }
4169 
4170 /* power up/down the paths of the given pin according to the jack state;
4171  * power = 0/1 : only power up/down if it matches with the jack state,
4172  *       < 0   : force power up/down to follow the jack sate
4173  *
4174  * returns the last changed NID, or zero if unchanged.
4175  */
4176 static hda_nid_t set_pin_power_jack(struct hda_codec *codec, hda_nid_t pin,
4177                     int power)
4178 {
4179     bool on;
4180 
4181     if (!codec->power_save_node)
4182         return 0;
4183 
4184     on = detect_pin_state(codec, pin);
4185 
4186     if (power >= 0 && on != power)
4187         return 0;
4188     return set_path_power(codec, pin, on, -1);
4189 }
4190 
4191 static void pin_power_callback(struct hda_codec *codec,
4192                    struct hda_jack_callback *jack,
4193                    bool on)
4194 {
4195     if (jack && jack->nid)
4196         sync_power_state_change(codec,
4197                     set_pin_power_jack(codec, jack->nid, on));
4198 }
4199 
4200 /* callback only doing power up -- called at first */
4201 static void pin_power_up_callback(struct hda_codec *codec,
4202                   struct hda_jack_callback *jack)
4203 {
4204     pin_power_callback(codec, jack, true);
4205 }
4206 
4207 /* callback only doing power down -- called at last */
4208 static void pin_power_down_callback(struct hda_codec *codec,
4209                     struct hda_jack_callback *jack)
4210 {
4211     pin_power_callback(codec, jack, false);
4212 }
4213 
4214 /* set up the power up/down callbacks */
4215 static void add_pin_power_ctls(struct hda_codec *codec, int num_pins,
4216                    const hda_nid_t *pins, bool on)
4217 {
4218     int i;
4219     hda_jack_callback_fn cb =
4220         on ? pin_power_up_callback : pin_power_down_callback;
4221 
4222     for (i = 0; i < num_pins && pins[i]; i++) {
4223         if (is_jack_detectable(codec, pins[i]))
4224             snd_hda_jack_detect_enable_callback(codec, pins[i], cb);
4225         else
4226             set_path_power(codec, pins[i], true, -1);
4227     }
4228 }
4229 
4230 /* enabled power callback to each available I/O pin with jack detections;
4231  * the digital I/O pins are excluded because of the unreliable detectsion
4232  */
4233 static void add_all_pin_power_ctls(struct hda_codec *codec, bool on)
4234 {
4235     struct hda_gen_spec *spec = codec->spec;
4236     struct auto_pin_cfg *cfg = &spec->autocfg;
4237     int i;
4238 
4239     if (!codec->power_save_node)
4240         return;
4241     add_pin_power_ctls(codec, cfg->line_outs, cfg->line_out_pins, on);
4242     if (cfg->line_out_type != AUTO_PIN_HP_OUT)
4243         add_pin_power_ctls(codec, cfg->hp_outs, cfg->hp_pins, on);
4244     if (cfg->line_out_type != AUTO_PIN_SPEAKER_OUT)
4245         add_pin_power_ctls(codec, cfg->speaker_outs, cfg->speaker_pins, on);
4246     for (i = 0; i < cfg->num_inputs; i++)
4247         add_pin_power_ctls(codec, 1, &cfg->inputs[i].pin, on);
4248 }
4249 
4250 /* sync path power up/down with the jack states of given pins */
4251 static void sync_pin_power_ctls(struct hda_codec *codec, int num_pins,
4252                 const hda_nid_t *pins)
4253 {
4254     int i;
4255 
4256     for (i = 0; i < num_pins && pins[i]; i++)
4257         if (is_jack_detectable(codec, pins[i]))
4258             set_pin_power_jack(codec, pins[i], -1);
4259 }
4260 
4261 /* sync path power up/down with pins; called at init and resume */
4262 static void sync_all_pin_power_ctls(struct hda_codec *codec)
4263 {
4264     struct hda_gen_spec *spec = codec->spec;
4265     struct auto_pin_cfg *cfg = &spec->autocfg;
4266     int i;
4267 
4268     if (!codec->power_save_node)
4269         return;
4270     sync_pin_power_ctls(codec, cfg->line_outs, cfg->line_out_pins);
4271     if (cfg->line_out_type != AUTO_PIN_HP_OUT)
4272         sync_pin_power_ctls(codec, cfg->hp_outs, cfg->hp_pins);
4273     if (cfg->line_out_type != AUTO_PIN_SPEAKER_OUT)
4274         sync_pin_power_ctls(codec, cfg->speaker_outs, cfg->speaker_pins);
4275     for (i = 0; i < cfg->num_inputs; i++)
4276         sync_pin_power_ctls(codec, 1, &cfg->inputs[i].pin);
4277 }
4278 
4279 /* add fake paths if not present yet */
4280 static int add_fake_paths(struct hda_codec *codec, hda_nid_t nid,
4281                int num_pins, const hda_nid_t *pins)
4282 {
4283     struct hda_gen_spec *spec = codec->spec;
4284     struct nid_path *path;
4285     int i;
4286 
4287     for (i = 0; i < num_pins; i++) {
4288         if (!pins[i])
4289             break;
4290         if (get_nid_path(codec, nid, pins[i], 0))
4291             continue;
4292         path = snd_array_new(&spec->paths);
4293         if (!path)
4294             return -ENOMEM;
4295         memset(path, 0, sizeof(*path));
4296         path->depth = 2;
4297         path->path[0] = nid;
4298         path->path[1] = pins[i];
4299         path->active = true;
4300     }
4301     return 0;
4302 }
4303 
4304 /* create fake paths to all outputs from beep */
4305 static int add_fake_beep_paths(struct hda_codec *codec)
4306 {
4307     struct hda_gen_spec *spec = codec->spec;
4308     struct auto_pin_cfg *cfg = &spec->autocfg;
4309     hda_nid_t nid = spec->beep_nid;
4310     int err;
4311 
4312     if (!codec->power_save_node || !nid)
4313         return 0;
4314     err = add_fake_paths(codec, nid, cfg->line_outs, cfg->line_out_pins);
4315     if (err < 0)
4316         return err;
4317     if (cfg->line_out_type != AUTO_PIN_HP_OUT) {
4318         err = add_fake_paths(codec, nid, cfg->hp_outs, cfg->hp_pins);
4319         if (err < 0)
4320             return err;
4321     }
4322     if (cfg->line_out_type != AUTO_PIN_SPEAKER_OUT) {
4323         err = add_fake_paths(codec, nid, cfg->speaker_outs,
4324                      cfg->speaker_pins);
4325         if (err < 0)
4326             return err;
4327     }
4328     return 0;
4329 }
4330 
4331 /* power up/down beep widget and its output paths */
4332 static void beep_power_hook(struct hda_beep *beep, bool on)
4333 {
4334     set_path_power(beep->codec, beep->nid, -1, on);
4335 }
4336 
4337 /**
4338  * snd_hda_gen_fix_pin_power - Fix the power of the given pin widget to D0
4339  * @codec: the HDA codec
4340  * @pin: NID of pin to fix
4341  */
4342 int snd_hda_gen_fix_pin_power(struct hda_codec *codec, hda_nid_t pin)
4343 {
4344     struct hda_gen_spec *spec = codec->spec;
4345     struct nid_path *path;
4346 
4347     path = snd_array_new(&spec->paths);
4348     if (!path)
4349         return -ENOMEM;
4350     memset(path, 0, sizeof(*path));
4351     path->depth = 1;
4352     path->path[0] = pin;
4353     path->active = true;
4354     path->pin_fixed = true;
4355     path->stream_enabled = true;
4356     return 0;
4357 }
4358 EXPORT_SYMBOL_GPL(snd_hda_gen_fix_pin_power);
4359 
4360 /*
4361  * Jack detections for HP auto-mute and mic-switch
4362  */
4363 
4364 /* check each pin in the given array; returns true if any of them is plugged */
4365 static bool detect_jacks(struct hda_codec *codec, int num_pins, const hda_nid_t *pins)
4366 {
4367     int i;
4368     bool present = false;
4369 
4370     for (i = 0; i < num_pins; i++) {
4371         hda_nid_t nid = pins[i];
4372         if (!nid)
4373             break;
4374         /* don't detect pins retasked as inputs */
4375         if (snd_hda_codec_get_pin_target(codec, nid) & AC_PINCTL_IN_EN)
4376             continue;
4377         if (snd_hda_jack_detect_state(codec, nid) == HDA_JACK_PRESENT)
4378             present = true;
4379     }
4380     return present;
4381 }
4382 
4383 /* standard HP/line-out auto-mute helper */
4384 static void do_automute(struct hda_codec *codec, int num_pins, const hda_nid_t *pins,
4385             int *paths, bool mute)
4386 {
4387     struct hda_gen_spec *spec = codec->spec;
4388     int i;
4389 
4390     for (i = 0; i < num_pins; i++) {
4391         hda_nid_t nid = pins[i];
4392         unsigned int val, oldval;
4393         if (!nid)
4394             break;
4395 
4396         oldval = snd_hda_codec_get_pin_target(codec, nid);
4397         if (oldval & PIN_IN)
4398             continue; /* no mute for inputs */
4399 
4400         if (spec->auto_mute_via_amp) {
4401             struct nid_path *path;
4402             hda_nid_t mute_nid;
4403 
4404             path = snd_hda_get_path_from_idx(codec, paths[i]);
4405             if (!path)
4406                 continue;
4407             mute_nid = get_amp_nid_(path->ctls[NID_PATH_MUTE_CTL]);
4408             if (!mute_nid)
4409                 continue;
4410             if (mute)
4411                 spec->mute_bits |= (1ULL << mute_nid);
4412             else
4413                 spec->mute_bits &= ~(1ULL << mute_nid);
4414             continue;
4415         } else {
4416             /* don't reset VREF value in case it's controlling
4417              * the amp (see alc861_fixup_asus_amp_vref_0f())
4418              */
4419             if (spec->keep_vref_in_automute)
4420                 val = oldval & ~PIN_HP;
4421             else
4422                 val = 0;
4423             if (!mute)
4424                 val |= oldval;
4425             /* here we call update_pin_ctl() so that the pinctl is
4426              * changed without changing the pinctl target value;
4427              * the original target value will be still referred at
4428              * the init / resume again
4429              */
4430             update_pin_ctl(codec, nid, val);
4431         }
4432 
4433         set_pin_eapd(codec, nid, !mute);
4434         if (codec->power_save_node) {
4435             bool on = !mute;
4436             if (on)
4437                 on = detect_pin_state(codec, nid);
4438             set_path_power(codec, nid, on, -1);
4439         }
4440     }
4441 }
4442 
4443 /**
4444  * snd_hda_gen_update_outputs - Toggle outputs muting
4445  * @codec: the HDA codec
4446  *
4447  * Update the mute status of all outputs based on the current jack states.
4448  */
4449 void snd_hda_gen_update_outputs(struct hda_codec *codec)
4450 {
4451     struct hda_gen_spec *spec = codec->spec;
4452     int *paths;
4453     int on;
4454 
4455     /* Control HP pins/amps depending on master_mute state;
4456      * in general, HP pins/amps control should be enabled in all cases,
4457      * but currently set only for master_mute, just to be safe
4458      */
4459     if (spec->autocfg.line_out_type == AUTO_PIN_HP_OUT)
4460         paths = spec->out_paths;
4461     else
4462         paths = spec->hp_paths;
4463     do_automute(codec, ARRAY_SIZE(spec->autocfg.hp_pins),
4464             spec->autocfg.hp_pins, paths, spec->master_mute);
4465 
4466     if (!spec->automute_speaker)
4467         on = 0;
4468     else
4469         on = spec->hp_jack_present | spec->line_jack_present;
4470     on |= spec->master_mute;
4471     spec->speaker_muted = on;
4472     if (spec->autocfg.line_out_type == AUTO_PIN_SPEAKER_OUT)
4473         paths = spec->out_paths;
4474     else
4475         paths = spec->speaker_paths;
4476     do_automute(codec, ARRAY_SIZE(spec->autocfg.speaker_pins),
4477             spec->autocfg.speaker_pins, paths, on);
4478 
4479     /* toggle line-out mutes if needed, too */
4480     /* if LO is a copy of either HP or Speaker, don't need to handle it */
4481     if (spec->autocfg.line_out_pins[0] == spec->autocfg.hp_pins[0] ||
4482         spec->autocfg.line_out_pins[0] == spec->autocfg.speaker_pins[0])
4483         return;
4484     if (!spec->automute_lo)
4485         on = 0;
4486     else
4487         on = spec->hp_jack_present;
4488     on |= spec->master_mute;
4489     spec->line_out_muted = on;
4490     paths = spec->out_paths;
4491     do_automute(codec, ARRAY_SIZE(spec->autocfg.line_out_pins),
4492             spec->autocfg.line_out_pins, paths, on);
4493 }
4494 EXPORT_SYMBOL_GPL(snd_hda_gen_update_outputs);
4495 
4496 static void call_update_outputs(struct hda_codec *codec)
4497 {
4498     struct hda_gen_spec *spec = codec->spec;
4499     if (spec->automute_hook)
4500         spec->automute_hook(codec);
4501     else
4502         snd_hda_gen_update_outputs(codec);
4503 
4504     /* sync the whole vmaster followers to reflect the new auto-mute status */
4505     if (spec->auto_mute_via_amp && !codec->bus->shutdown)
4506         snd_ctl_sync_vmaster(spec->vmaster_mute.sw_kctl, false);
4507 }
4508 
4509 /**
4510  * snd_hda_gen_hp_automute - standard HP-automute helper
4511  * @codec: the HDA codec
4512  * @jack: jack object, NULL for the whole
4513  */
4514 void snd_hda_gen_hp_automute(struct hda_codec *codec,
4515                  struct hda_jack_callback *jack)
4516 {
4517     struct hda_gen_spec *spec = codec->spec;
4518     hda_nid_t *pins = spec->autocfg.hp_pins;
4519     int num_pins = ARRAY_SIZE(spec->autocfg.hp_pins);
4520 
4521     /* No detection for the first HP jack during indep-HP mode */
4522     if (spec->indep_hp_enabled) {
4523         pins++;
4524         num_pins--;
4525     }
4526 
4527     spec->hp_jack_present = detect_jacks(codec, num_pins, pins);
4528     if (!spec->detect_hp || (!spec->automute_speaker && !spec->automute_lo))
4529         return;
4530     call_update_outputs(codec);
4531 }
4532 EXPORT_SYMBOL_GPL(snd_hda_gen_hp_automute);
4533 
4534 /**
4535  * snd_hda_gen_line_automute - standard line-out-automute helper
4536  * @codec: the HDA codec
4537  * @jack: jack object, NULL for the whole
4538  */
4539 void snd_hda_gen_line_automute(struct hda_codec *codec,
4540                    struct hda_jack_callback *jack)
4541 {
4542     struct hda_gen_spec *spec = codec->spec;
4543 
4544     if (spec->autocfg.line_out_type == AUTO_PIN_SPEAKER_OUT)
4545         return;
4546     /* check LO jack only when it's different from HP */
4547     if (spec->autocfg.line_out_pins[0] == spec->autocfg.hp_pins[0])
4548         return;
4549 
4550     spec->line_jack_present =
4551         detect_jacks(codec, ARRAY_SIZE(spec->autocfg.line_out_pins),
4552                  spec->autocfg.line_out_pins);
4553     if (!spec->automute_speaker || !spec->detect_lo)
4554         return;
4555     call_update_outputs(codec);
4556 }
4557 EXPORT_SYMBOL_GPL(snd_hda_gen_line_automute);
4558 
4559 /**
4560  * snd_hda_gen_mic_autoswitch - standard mic auto-switch helper
4561  * @codec: the HDA codec
4562  * @jack: jack object, NULL for the whole
4563  */
4564 void snd_hda_gen_mic_autoswitch(struct hda_codec *codec,
4565                 struct hda_jack_callback *jack)
4566 {
4567     struct hda_gen_spec *spec = codec->spec;
4568     int i;
4569 
4570     if (!spec->auto_mic)
4571         return;
4572 
4573     for (i = spec->am_num_entries - 1; i > 0; i--) {
4574         hda_nid_t pin = spec->am_entry[i].pin;
4575         /* don't detect pins retasked as outputs */
4576         if (snd_hda_codec_get_pin_target(codec, pin) & AC_PINCTL_OUT_EN)
4577             continue;
4578         if (snd_hda_jack_detect_state(codec, pin) == HDA_JACK_PRESENT) {
4579             mux_select(codec, 0, spec->am_entry[i].idx);
4580             return;
4581         }
4582     }
4583     mux_select(codec, 0, spec->am_entry[0].idx);
4584 }
4585 EXPORT_SYMBOL_GPL(snd_hda_gen_mic_autoswitch);
4586 
4587 /* call appropriate hooks */
4588 static void call_hp_automute(struct hda_codec *codec,
4589                  struct hda_jack_callback *jack)
4590 {
4591     struct hda_gen_spec *spec = codec->spec;
4592     if (spec->hp_automute_hook)
4593         spec->hp_automute_hook(codec, jack);
4594     else
4595         snd_hda_gen_hp_automute(codec, jack);
4596 }
4597 
4598 static void call_line_automute(struct hda_codec *codec,
4599                    struct hda_jack_callback *jack)
4600 {
4601     struct hda_gen_spec *spec = codec->spec;
4602     if (spec->line_automute_hook)
4603         spec->line_automute_hook(codec, jack);
4604     else
4605         snd_hda_gen_line_automute(codec, jack);
4606 }
4607 
4608 static void call_mic_autoswitch(struct hda_codec *codec,
4609                 struct hda_jack_callback *jack)
4610 {
4611     struct hda_gen_spec *spec = codec->spec;
4612     if (spec->mic_autoswitch_hook)
4613         spec->mic_autoswitch_hook(codec, jack);
4614     else
4615         snd_hda_gen_mic_autoswitch(codec, jack);
4616 }
4617 
4618 /* update jack retasking */
4619 static void update_automute_all(struct hda_codec *codec)
4620 {
4621     call_hp_automute(codec, NULL);
4622     call_line_automute(codec, NULL);
4623     call_mic_autoswitch(codec, NULL);
4624 }
4625 
4626 /*
4627  * Auto-Mute mode mixer enum support
4628  */
4629 static int automute_mode_info(struct snd_kcontrol *kcontrol,
4630                   struct snd_ctl_elem_info *uinfo)
4631 {
4632     struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
4633     struct hda_gen_spec *spec = codec->spec;
4634     static const char * const texts3[] = {
4635         "Disabled", "Speaker Only", "Line Out+Speaker"
4636     };
4637 
4638     if (spec->automute_speaker_possible && spec->automute_lo_possible)
4639         return snd_hda_enum_helper_info(kcontrol, uinfo, 3, texts3);
4640     return snd_hda_enum_bool_helper_info(kcontrol, uinfo);
4641 }
4642 
4643 static int automute_mode_get(struct snd_kcontrol *kcontrol,
4644                  struct snd_ctl_elem_value *ucontrol)
4645 {
4646     struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
4647     struct hda_gen_spec *spec = codec->spec;
4648     unsigned int val = 0;
4649     if (spec->automute_speaker)
4650         val++;
4651     if (spec->automute_lo)
4652         val++;
4653 
4654     ucontrol->value.enumerated.item[0] = val;
4655     return 0;
4656 }
4657 
4658 static int automute_mode_put(struct snd_kcontrol *kcontrol,
4659                  struct snd_ctl_elem_value *ucontrol)
4660 {
4661     struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
4662     struct hda_gen_spec *spec = codec->spec;
4663 
4664     switch (ucontrol->value.enumerated.item[0]) {
4665     case 0:
4666         if (!spec->automute_speaker && !spec->automute_lo)
4667             return 0;
4668         spec->automute_speaker = 0;
4669         spec->automute_lo = 0;
4670         break;
4671     case 1:
4672         if (spec->automute_speaker_possible) {
4673             if (!spec->automute_lo && spec->automute_speaker)
4674                 return 0;
4675             spec->automute_speaker = 1;
4676             spec->automute_lo = 0;
4677         } else if (spec->automute_lo_possible) {
4678             if (spec->automute_lo)
4679                 return 0;
4680             spec->automute_lo = 1;
4681         } else
4682             return -EINVAL;
4683         break;
4684     case 2:
4685         if (!spec->automute_lo_possible || !spec->automute_speaker_possible)
4686             return -EINVAL;
4687         if (spec->automute_speaker && spec->automute_lo)
4688             return 0;
4689         spec->automute_speaker = 1;
4690         spec->automute_lo = 1;
4691         break;
4692     default:
4693         return -EINVAL;
4694     }
4695     call_update_outputs(codec);
4696     return 1;
4697 }
4698 
4699 static const struct snd_kcontrol_new automute_mode_enum = {
4700     .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
4701     .name = "Auto-Mute Mode",
4702     .info = automute_mode_info,
4703     .get = automute_mode_get,
4704     .put = automute_mode_put,
4705 };
4706 
4707 static int add_automute_mode_enum(struct hda_codec *codec)
4708 {
4709     struct hda_gen_spec *spec = codec->spec;
4710 
4711     if (!snd_hda_gen_add_kctl(spec, NULL, &automute_mode_enum))
4712         return -ENOMEM;
4713     return 0;
4714 }
4715 
4716 /*
4717  * Check the availability of HP/line-out auto-mute;
4718  * Set up appropriately if really supported
4719  */
4720 static int check_auto_mute_availability(struct hda_codec *codec)
4721 {
4722     struct hda_gen_spec *spec = codec->spec;
4723     struct auto_pin_cfg *cfg = &spec->autocfg;
4724     int present = 0;
4725     int i, err;
4726 
4727     if (spec->suppress_auto_mute)
4728         return 0;
4729 
4730     if (cfg->hp_pins[0])
4731         present++;
4732     if (cfg->line_out_pins[0])
4733         present++;
4734     if (cfg->speaker_pins[0])
4735         present++;
4736     if (present < 2) /* need two different output types */
4737         return 0;
4738 
4739     if (!cfg->speaker_pins[0] &&
4740         cfg->line_out_type == AUTO_PIN_SPEAKER_OUT) {
4741         memcpy(cfg->speaker_pins, cfg->line_out_pins,
4742                sizeof(cfg->speaker_pins));
4743         cfg->speaker_outs = cfg->line_outs;
4744     }
4745 
4746     if (!cfg->hp_pins[0] &&
4747         cfg->line_out_type == AUTO_PIN_HP_OUT) {
4748         memcpy(cfg->hp_pins, cfg->line_out_pins,
4749                sizeof(cfg->hp_pins));
4750         cfg->hp_outs = cfg->line_outs;
4751     }
4752 
4753     for (i = 0; i < cfg->hp_outs; i++) {
4754         hda_nid_t nid = cfg->hp_pins[i];
4755         if (!is_jack_detectable(codec, nid))
4756             continue;
4757         codec_dbg(codec, "Enable HP auto-muting on NID 0x%x\n", nid);
4758         snd_hda_jack_detect_enable_callback(codec, nid,
4759                             call_hp_automute);
4760         spec->detect_hp = 1;
4761     }
4762 
4763     if (cfg->line_out_type == AUTO_PIN_LINE_OUT && cfg->line_outs) {
4764         if (cfg->speaker_outs)
4765             for (i = 0; i < cfg->line_outs; i++) {
4766                 hda_nid_t nid = cfg->line_out_pins[i];
4767                 if (!is_jack_detectable(codec, nid))
4768                     continue;
4769                 codec_dbg(codec, "Enable Line-Out auto-muting on NID 0x%x\n", nid);
4770                 snd_hda_jack_detect_enable_callback(codec, nid,
4771                                     call_line_automute);
4772                 spec->detect_lo = 1;
4773             }
4774         spec->automute_lo_possible = spec->detect_hp;
4775     }
4776 
4777     spec->automute_speaker_possible = cfg->speaker_outs &&
4778         (spec->detect_hp || spec->detect_lo);
4779 
4780     spec->automute_lo = spec->automute_lo_possible;
4781     spec->automute_speaker = spec->automute_speaker_possible;
4782 
4783     if (spec->automute_speaker_possible || spec->automute_lo_possible) {
4784         /* create a control for automute mode */
4785         err = add_automute_mode_enum(codec);
4786         if (err < 0)
4787             return err;
4788     }
4789     return 0;
4790 }
4791 
4792 /* check whether all auto-mic pins are valid; setup indices if OK */
4793 static bool auto_mic_check_imux(struct hda_codec *codec)
4794 {
4795     struct hda_gen_spec *spec = codec->spec;
4796     const struct hda_input_mux *imux;
4797     int i;
4798 
4799     imux = &spec->input_mux;
4800     for (i = 0; i < spec->am_num_entries; i++) {
4801         spec->am_entry[i].idx =
4802             find_idx_in_nid_list(spec->am_entry[i].pin,
4803                          spec->imux_pins, imux->num_items);
4804         if (spec->am_entry[i].idx < 0)
4805             return false; /* no corresponding imux */
4806     }
4807 
4808     /* we don't need the jack detection for the first pin */
4809     for (i = 1; i < spec->am_num_entries; i++)
4810         snd_hda_jack_detect_enable_callback(codec,
4811                             spec->am_entry[i].pin,
4812                             call_mic_autoswitch);
4813     return true;
4814 }
4815 
4816 static int compare_attr(const void *ap, const void *bp)
4817 {
4818     const struct automic_entry *a = ap;
4819     const struct automic_entry *b = bp;
4820     return (int)(a->attr - b->attr);
4821 }
4822 
4823 /*
4824  * Check the availability of auto-mic switch;
4825  * Set up if really supported
4826  */
4827 static int check_auto_mic_availability(struct hda_codec *codec)
4828 {
4829     struct hda_gen_spec *spec = codec->spec;
4830     struct auto_pin_cfg *cfg = &spec->autocfg;
4831     unsigned int types;
4832     int i, num_pins;
4833 
4834     if (spec->suppress_auto_mic)
4835         return 0;
4836 
4837     types = 0;
4838     num_pins = 0;
4839     for (i = 0; i < cfg->num_inputs; i++) {
4840         hda_nid_t nid = cfg->inputs[i].pin;
4841         unsigned int attr;
4842         attr = snd_hda_codec_get_pincfg(codec, nid);
4843         attr = snd_hda_get_input_pin_attr(attr);
4844         if (types & (1 << attr))
4845             return 0; /* already occupied */
4846         switch (attr) {
4847         case INPUT_PIN_ATTR_INT:
4848             if (cfg->inputs[i].type != AUTO_PIN_MIC)
4849                 return 0; /* invalid type */
4850             break;
4851         case INPUT_PIN_ATTR_UNUSED:
4852             return 0; /* invalid entry */
4853         default:
4854             if (cfg->inputs[i].type > AUTO_PIN_LINE_IN)
4855                 return 0; /* invalid type */
4856             if (!spec->line_in_auto_switch &&
4857                 cfg->inputs[i].type != AUTO_PIN_MIC)
4858                 return 0; /* only mic is allowed */
4859             if (!is_jack_detectable(codec, nid))
4860                 return 0; /* no unsol support */
4861             break;
4862         }
4863         if (num_pins >= MAX_AUTO_MIC_PINS)
4864             return 0;
4865         types |= (1 << attr);
4866         spec->am_entry[num_pins].pin = nid;
4867         spec->am_entry[num_pins].attr = attr;
4868         num_pins++;
4869     }
4870 
4871     if (num_pins < 2)
4872         return 0;
4873 
4874     spec->am_num_entries = num_pins;
4875     /* sort the am_entry in the order of attr so that the pin with a
4876      * higher attr will be selected when the jack is plugged.
4877      */
4878     sort(spec->am_entry, num_pins, sizeof(spec->am_entry[0]),
4879          compare_attr, NULL);
4880 
4881     if (!auto_mic_check_imux(codec))
4882         return 0;
4883 
4884     spec->auto_mic = 1;
4885     spec->num_adc_nids = 1;
4886     spec->cur_mux[0] = spec->am_entry[0].idx;
4887     codec_dbg(codec, "Enable auto-mic switch on NID 0x%x/0x%x/0x%x\n",
4888             spec->am_entry[0].pin,
4889             spec->am_entry[1].pin,
4890             spec->am_entry[2].pin);
4891 
4892     return 0;
4893 }
4894 
4895 /**
4896  * snd_hda_gen_path_power_filter - power_filter hook to make inactive widgets
4897  * into power down
4898  * @codec: the HDA codec
4899  * @nid: NID to evalute
4900  * @power_state: target power state
4901  */
4902 unsigned int snd_hda_gen_path_power_filter(struct hda_codec *codec,
4903                           hda_nid_t nid,
4904                           unsigned int power_state)
4905 {
4906     struct hda_gen_spec *spec = codec->spec;
4907 
4908     if (!spec->power_down_unused && !codec->power_save_node)
4909         return power_state;
4910     if (power_state != AC_PWRST_D0 || nid == codec->core.afg)
4911         return power_state;
4912     if (get_wcaps_type(get_wcaps(codec, nid)) >= AC_WID_POWER)
4913         return power_state;
4914     if (is_active_nid_for_any(codec, nid))
4915         return power_state;
4916     return AC_PWRST_D3;
4917 }
4918 EXPORT_SYMBOL_GPL(snd_hda_gen_path_power_filter);
4919 
4920 /* mute all aamix inputs initially; parse up to the first leaves */
4921 static void mute_all_mixer_nid(struct hda_codec *codec, hda_nid_t mix)
4922 {
4923     int i, nums;
4924     const hda_nid_t *conn;
4925     bool has_amp;
4926 
4927     nums = snd_hda_get_conn_list(codec, mix, &conn);
4928     has_amp = nid_has_mute(codec, mix, HDA_INPUT);
4929     for (i = 0; i < nums; i++) {
4930         if (has_amp)
4931             update_amp(codec, mix, HDA_INPUT, i,
4932                    0xff, HDA_AMP_MUTE);
4933         else if (nid_has_volume(codec, conn[i], HDA_OUTPUT))
4934             update_amp(codec, conn[i], HDA_OUTPUT, 0,
4935                    0xff, HDA_AMP_MUTE);
4936     }
4937 }
4938 
4939 /**
4940  * snd_hda_gen_stream_pm - Stream power management callback
4941  * @codec: the HDA codec
4942  * @nid: audio widget
4943  * @on: power on/off flag
4944  *
4945  * Set this in patch_ops.stream_pm.  Only valid with power_save_node flag.
4946  */
4947 void snd_hda_gen_stream_pm(struct hda_codec *codec, hda_nid_t nid, bool on)
4948 {
4949     if (codec->power_save_node)
4950         set_path_power(codec, nid, -1, on);
4951 }
4952 EXPORT_SYMBOL_GPL(snd_hda_gen_stream_pm);
4953 
4954 /**
4955  * snd_hda_gen_parse_auto_config - Parse the given BIOS configuration and
4956  * set up the hda_gen_spec
4957  * @codec: the HDA codec
4958  * @cfg: Parsed pin configuration
4959  *
4960  * return 1 if successful, 0 if the proper config is not found,
4961  * or a negative error code
4962  */
4963 int snd_hda_gen_parse_auto_config(struct hda_codec *codec,
4964                   struct auto_pin_cfg *cfg)
4965 {
4966     struct hda_gen_spec *spec = codec->spec;
4967     int err;
4968 
4969     parse_user_hints(codec);
4970 
4971     if (spec->vmaster_mute_led || spec->mic_mute_led)
4972         snd_ctl_led_request();
4973 
4974     if (spec->mixer_nid && !spec->mixer_merge_nid)
4975         spec->mixer_merge_nid = spec->mixer_nid;
4976 
4977     if (cfg != &spec->autocfg) {
4978         spec->autocfg = *cfg;
4979         cfg = &spec->autocfg;
4980     }
4981 
4982     if (!spec->main_out_badness)
4983         spec->main_out_badness = &hda_main_out_badness;
4984     if (!spec->extra_out_badness)
4985         spec->extra_out_badness = &hda_extra_out_badness;
4986 
4987     fill_all_dac_nids(codec);
4988 
4989     if (!cfg->line_outs) {
4990         if (cfg->dig_outs || cfg->dig_in_pin) {
4991             spec->multiout.max_channels = 2;
4992             spec->no_analog = 1;
4993             goto dig_only;
4994         }
4995         if (!cfg->num_inputs && !cfg->dig_in_pin)
4996             return 0; /* can't find valid BIOS pin config */
4997     }
4998 
4999     if (!spec->no_primary_hp &&
5000         cfg->line_out_type == AUTO_PIN_SPEAKER_OUT &&
5001         cfg->line_outs <= cfg->hp_outs) {
5002         /* use HP as primary out */
5003         cfg->speaker_outs = cfg->line_outs;
5004         memcpy(cfg->speaker_pins, cfg->line_out_pins,
5005                sizeof(cfg->speaker_pins));
5006         cfg->line_outs = cfg->hp_outs;
5007         memcpy(cfg->line_out_pins, cfg->hp_pins, sizeof(cfg->hp_pins));
5008         cfg->hp_outs = 0;
5009         memset(cfg->hp_pins, 0, sizeof(cfg->hp_pins));
5010         cfg->line_out_type = AUTO_PIN_HP_OUT;
5011     }
5012 
5013     err = parse_output_paths(codec);
5014     if (err < 0)
5015         return err;
5016     err = create_multi_channel_mode(codec);
5017     if (err < 0)
5018         return err;
5019     err = create_multi_out_ctls(codec, cfg);
5020     if (err < 0)
5021         return err;
5022     err = create_hp_out_ctls(codec);
5023     if (err < 0)
5024         return err;
5025     err = create_speaker_out_ctls(codec);
5026     if (err < 0)
5027         return err;
5028     err = create_indep_hp_ctls(codec);
5029     if (err < 0)
5030         return err;
5031     err = create_loopback_mixing_ctl(codec);
5032     if (err < 0)
5033         return err;
5034     err = create_hp_mic(codec);
5035     if (err < 0)
5036         return err;
5037     err = create_input_ctls(codec);
5038     if (err < 0)
5039         return err;
5040 
5041     /* add power-down pin callbacks at first */
5042     add_all_pin_power_ctls(codec, false);
5043 
5044     spec->const_channel_count = spec->ext_channel_count;
5045     /* check the multiple speaker and headphone pins */
5046     if (cfg->line_out_type != AUTO_PIN_SPEAKER_OUT)
5047         spec->const_channel_count = max(spec->const_channel_count,
5048                         cfg->speaker_outs * 2);
5049     if (cfg->line_out_type != AUTO_PIN_HP_OUT)
5050         spec->const_channel_count = max(spec->const_channel_count,
5051                         cfg->hp_outs * 2);
5052     spec->multiout.max_channels = max(spec->ext_channel_count,
5053                       spec->const_channel_count);
5054 
5055     err = check_auto_mute_availability(codec);
5056     if (err < 0)
5057         return err;
5058 
5059     err = check_dyn_adc_switch(codec);
5060     if (err < 0)
5061         return err;
5062 
5063     err = check_auto_mic_availability(codec);
5064     if (err < 0)
5065         return err;
5066 
5067     /* add stereo mix if available and not enabled yet */
5068     if (!spec->auto_mic && spec->mixer_nid &&
5069         spec->add_stereo_mix_input == HDA_HINT_STEREO_MIX_AUTO &&
5070         spec->input_mux.num_items > 1) {
5071         err = parse_capture_source(codec, spec->mixer_nid,
5072                        CFG_IDX_MIX, spec->num_all_adcs,
5073                        "Stereo Mix", 0);
5074         if (err < 0)
5075             return err;
5076     }
5077 
5078 
5079     err = create_capture_mixers(codec);
5080     if (err < 0)
5081         return err;
5082 
5083     err = parse_mic_boost(codec);
5084     if (err < 0)
5085         return err;
5086 
5087     /* create "Headphone Mic Jack Mode" if no input selection is
5088      * available (or user specifies add_jack_modes hint)
5089      */
5090     if (spec->hp_mic_pin &&
5091         (spec->auto_mic || spec->input_mux.num_items == 1 ||
5092          spec->add_jack_modes)) {
5093         err = create_hp_mic_jack_mode(codec, spec->hp_mic_pin);
5094         if (err < 0)
5095             return err;
5096     }
5097 
5098     if (spec->add_jack_modes) {
5099         if (cfg->line_out_type != AUTO_PIN_SPEAKER_OUT) {
5100             err = create_out_jack_modes(codec, cfg->line_outs,
5101                             cfg->line_out_pins);
5102             if (err < 0)
5103                 return err;
5104         }
5105         if (cfg->line_out_type != AUTO_PIN_HP_OUT) {
5106             err = create_out_jack_modes(codec, cfg->hp_outs,
5107                             cfg->hp_pins);
5108             if (err < 0)
5109                 return err;
5110         }
5111     }
5112 
5113     /* add power-up pin callbacks at last */
5114     add_all_pin_power_ctls(codec, true);
5115 
5116     /* mute all aamix input initially */
5117     if (spec->mixer_nid)
5118         mute_all_mixer_nid(codec, spec->mixer_nid);
5119 
5120  dig_only:
5121     parse_digital(codec);
5122 
5123     if (spec->power_down_unused || codec->power_save_node) {
5124         if (!codec->power_filter)
5125             codec->power_filter = snd_hda_gen_path_power_filter;
5126         if (!codec->patch_ops.stream_pm)
5127             codec->patch_ops.stream_pm = snd_hda_gen_stream_pm;
5128     }
5129 
5130     if (!spec->no_analog && spec->beep_nid) {
5131         err = snd_hda_attach_beep_device(codec, spec->beep_nid);
5132         if (err < 0)
5133             return err;
5134         if (codec->beep && codec->power_save_node) {
5135             err = add_fake_beep_paths(codec);
5136             if (err < 0)
5137                 return err;
5138             codec->beep->power_hook = beep_power_hook;
5139         }
5140     }
5141 
5142     return 1;
5143 }
5144 EXPORT_SYMBOL_GPL(snd_hda_gen_parse_auto_config);
5145 
5146 
5147 /*
5148  * Build control elements
5149  */
5150 
5151 /* follower controls for virtual master */
5152 static const char * const follower_pfxs[] = {
5153     "Front", "Surround", "Center", "LFE", "Side",
5154     "Headphone", "Speaker", "Mono", "Line Out",
5155     "CLFE", "Bass Speaker", "PCM",
5156     "Speaker Front", "Speaker Surround", "Speaker CLFE", "Speaker Side",
5157     "Headphone Front", "Headphone Surround", "Headphone CLFE",
5158     "Headphone Side", "Headphone+LO", "Speaker+LO",
5159     NULL,
5160 };
5161 
5162 /**
5163  * snd_hda_gen_build_controls - Build controls from the parsed results
5164  * @codec: the HDA codec
5165  *
5166  * Pass this to build_controls patch_ops.
5167  */
5168 int snd_hda_gen_build_controls(struct hda_codec *codec)
5169 {
5170     struct hda_gen_spec *spec = codec->spec;
5171     int err;
5172 
5173     if (spec->kctls.used) {
5174         err = snd_hda_add_new_ctls(codec, spec->kctls.list);
5175         if (err < 0)
5176             return err;
5177     }
5178 
5179     if (spec->multiout.dig_out_nid) {
5180         err = snd_hda_create_dig_out_ctls(codec,
5181                           spec->multiout.dig_out_nid,
5182                           spec->multiout.dig_out_nid,
5183                           spec->pcm_rec[1]->pcm_type);
5184         if (err < 0)
5185             return err;
5186         if (!spec->no_analog) {
5187             err = snd_hda_create_spdif_share_sw(codec,
5188                                 &spec->multiout);
5189             if (err < 0)
5190                 return err;
5191             spec->multiout.share_spdif = 1;
5192         }
5193     }
5194     if (spec->dig_in_nid) {
5195         err = snd_hda_create_spdif_in_ctls(codec, spec->dig_in_nid);
5196         if (err < 0)
5197             return err;
5198     }
5199 
5200     /* if we have no master control, let's create it */
5201     if (!spec->no_analog && !spec->suppress_vmaster &&
5202         !snd_hda_find_mixer_ctl(codec, "Master Playback Volume")) {
5203         err = snd_hda_add_vmaster(codec, "Master Playback Volume",
5204                       spec->vmaster_tlv, follower_pfxs,
5205                       "Playback Volume", 0);
5206         if (err < 0)
5207             return err;
5208     }
5209     if (!spec->no_analog && !spec->suppress_vmaster &&
5210         !snd_hda_find_mixer_ctl(codec, "Master Playback Switch")) {
5211         err = __snd_hda_add_vmaster(codec, "Master Playback Switch",
5212                         NULL, follower_pfxs,
5213                         "Playback Switch", true,
5214                         spec->vmaster_mute_led ?
5215                         SNDRV_CTL_ELEM_ACCESS_SPK_LED : 0,
5216                         &spec->vmaster_mute.sw_kctl);
5217         if (err < 0)
5218             return err;
5219         if (spec->vmaster_mute.hook) {
5220             snd_hda_add_vmaster_hook(codec, &spec->vmaster_mute);
5221             snd_hda_sync_vmaster_hook(&spec->vmaster_mute);
5222         }
5223     }
5224 
5225     free_kctls(spec); /* no longer needed */
5226 
5227     err = snd_hda_jack_add_kctls(codec, &spec->autocfg);
5228     if (err < 0)
5229         return err;
5230 
5231     return 0;
5232 }
5233 EXPORT_SYMBOL_GPL(snd_hda_gen_build_controls);
5234 
5235 
5236 /*
5237  * PCM definitions
5238  */
5239 
5240 static void call_pcm_playback_hook(struct hda_pcm_stream *hinfo,
5241                    struct hda_codec *codec,
5242                    struct snd_pcm_substream *substream,
5243                    int action)
5244 {
5245     struct hda_gen_spec *spec = codec->spec;
5246     if (spec->pcm_playback_hook)
5247         spec->pcm_playback_hook(hinfo, codec, substream, action);
5248 }
5249 
5250 static void call_pcm_capture_hook(struct hda_pcm_stream *hinfo,
5251                   struct hda_codec *codec,
5252                   struct snd_pcm_substream *substream,
5253                   int action)
5254 {
5255     struct hda_gen_spec *spec = codec->spec;
5256     if (spec->pcm_capture_hook)
5257         spec->pcm_capture_hook(hinfo, codec, substream, action);
5258 }
5259 
5260 /*
5261  * Analog playback callbacks
5262  */
5263 static int playback_pcm_open(struct hda_pcm_stream *hinfo,
5264                  struct hda_codec *codec,
5265                  struct snd_pcm_substream *substream)
5266 {
5267     struct hda_gen_spec *spec = codec->spec;
5268     int err;
5269 
5270     mutex_lock(&spec->pcm_mutex);
5271     err = snd_hda_multi_out_analog_open(codec,
5272                         &spec->multiout, substream,
5273                          hinfo);
5274     if (!err) {
5275         spec->active_streams |= 1 << STREAM_MULTI_OUT;
5276         call_pcm_playback_hook(hinfo, codec, substream,
5277                        HDA_GEN_PCM_ACT_OPEN);
5278     }
5279     mutex_unlock(&spec->pcm_mutex);
5280     return err;
5281 }
5282 
5283 static int playback_pcm_prepare(struct hda_pcm_stream *hinfo,
5284                 struct hda_codec *codec,
5285                 unsigned int stream_tag,
5286                 unsigned int format,
5287                 struct snd_pcm_substream *substream)
5288 {
5289     struct hda_gen_spec *spec = codec->spec;
5290     int err;
5291 
5292     err = snd_hda_multi_out_analog_prepare(codec, &spec->multiout,
5293                            stream_tag, format, substream);
5294     if (!err)
5295         call_pcm_playback_hook(hinfo, codec, substream,
5296                        HDA_GEN_PCM_ACT_PREPARE);
5297     return err;
5298 }
5299 
5300 static int playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
5301                 struct hda_codec *codec,
5302                 struct snd_pcm_substream *substream)
5303 {
5304     struct hda_gen_spec *spec = codec->spec;
5305     int err;
5306 
5307     err = snd_hda_multi_out_analog_cleanup(codec, &spec->multiout);
5308     if (!err)
5309         call_pcm_playback_hook(hinfo, codec, substream,
5310                        HDA_GEN_PCM_ACT_CLEANUP);
5311     return err;
5312 }
5313 
5314 static int playback_pcm_close(struct hda_pcm_stream *hinfo,
5315                   struct hda_codec *codec,
5316                   struct snd_pcm_substream *substream)
5317 {
5318     struct hda_gen_spec *spec = codec->spec;
5319     mutex_lock(&spec->pcm_mutex);
5320     spec->active_streams &= ~(1 << STREAM_MULTI_OUT);
5321     call_pcm_playback_hook(hinfo, codec, substream,
5322                    HDA_GEN_PCM_ACT_CLOSE);
5323     mutex_unlock(&spec->pcm_mutex);
5324     return 0;
5325 }
5326 
5327 static int capture_pcm_open(struct hda_pcm_stream *hinfo,
5328                 struct hda_codec *codec,
5329                 struct snd_pcm_substream *substream)
5330 {
5331     call_pcm_capture_hook(hinfo, codec, substream, HDA_GEN_PCM_ACT_OPEN);
5332     return 0;
5333 }
5334 
5335 static int capture_pcm_prepare(struct hda_pcm_stream *hinfo,
5336                    struct hda_codec *codec,
5337                    unsigned int stream_tag,
5338                    unsigned int format,
5339                    struct snd_pcm_substream *substream)
5340 {
5341     snd_hda_codec_setup_stream(codec, hinfo->nid, stream_tag, 0, format);
5342     call_pcm_capture_hook(hinfo, codec, substream,
5343                   HDA_GEN_PCM_ACT_PREPARE);
5344     return 0;
5345 }
5346 
5347 static int capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
5348                    struct hda_codec *codec,
5349                    struct snd_pcm_substream *substream)
5350 {
5351     snd_hda_codec_cleanup_stream(codec, hinfo->nid);
5352     call_pcm_capture_hook(hinfo, codec, substream,
5353                   HDA_GEN_PCM_ACT_CLEANUP);
5354     return 0;
5355 }
5356 
5357 static int capture_pcm_close(struct hda_pcm_stream *hinfo,
5358                  struct hda_codec *codec,
5359                  struct snd_pcm_substream *substream)
5360 {
5361     call_pcm_capture_hook(hinfo, codec, substream, HDA_GEN_PCM_ACT_CLOSE);
5362     return 0;
5363 }
5364 
5365 static int alt_playback_pcm_open(struct hda_pcm_stream *hinfo,
5366                  struct hda_codec *codec,
5367                  struct snd_pcm_substream *substream)
5368 {
5369     struct hda_gen_spec *spec = codec->spec;
5370     int err = 0;
5371 
5372     mutex_lock(&spec->pcm_mutex);
5373     if (spec->indep_hp && !spec->indep_hp_enabled)
5374         err = -EBUSY;
5375     else
5376         spec->active_streams |= 1 << STREAM_INDEP_HP;
5377     call_pcm_playback_hook(hinfo, codec, substream,
5378                    HDA_GEN_PCM_ACT_OPEN);
5379     mutex_unlock(&spec->pcm_mutex);
5380     return err;
5381 }
5382 
5383 static int alt_playback_pcm_close(struct hda_pcm_stream *hinfo,
5384                   struct hda_codec *codec,
5385                   struct snd_pcm_substream *substream)
5386 {
5387     struct hda_gen_spec *spec = codec->spec;
5388     mutex_lock(&spec->pcm_mutex);
5389     spec->active_streams &= ~(1 << STREAM_INDEP_HP);
5390     call_pcm_playback_hook(hinfo, codec, substream,
5391                    HDA_GEN_PCM_ACT_CLOSE);
5392     mutex_unlock(&spec->pcm_mutex);
5393     return 0;
5394 }
5395 
5396 static int alt_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
5397                     struct hda_codec *codec,
5398                     unsigned int stream_tag,
5399                     unsigned int format,
5400                     struct snd_pcm_substream *substream)
5401 {
5402     snd_hda_codec_setup_stream(codec, hinfo->nid, stream_tag, 0, format);
5403     call_pcm_playback_hook(hinfo, codec, substream,
5404                    HDA_GEN_PCM_ACT_PREPARE);
5405     return 0;
5406 }
5407 
5408 static int alt_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
5409                     struct hda_codec *codec,
5410                     struct snd_pcm_substream *substream)
5411 {
5412     snd_hda_codec_cleanup_stream(codec, hinfo->nid);
5413     call_pcm_playback_hook(hinfo, codec, substream,
5414                    HDA_GEN_PCM_ACT_CLEANUP);
5415     return 0;
5416 }
5417 
5418 /*
5419  * Digital out
5420  */
5421 static int dig_playback_pcm_open(struct hda_pcm_stream *hinfo,
5422                  struct hda_codec *codec,
5423                  struct snd_pcm_substream *substream)
5424 {
5425     struct hda_gen_spec *spec = codec->spec;
5426     return snd_hda_multi_out_dig_open(codec, &spec->multiout);
5427 }
5428 
5429 static int dig_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
5430                     struct hda_codec *codec,
5431                     unsigned int stream_tag,
5432                     unsigned int format,
5433                     struct snd_pcm_substream *substream)
5434 {
5435     struct hda_gen_spec *spec = codec->spec;
5436     return snd_hda_multi_out_dig_prepare(codec, &spec->multiout,
5437                          stream_tag, format, substream);
5438 }
5439 
5440 static int dig_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
5441                     struct hda_codec *codec,
5442                     struct snd_pcm_substream *substream)
5443 {
5444     struct hda_gen_spec *spec = codec->spec;
5445     return snd_hda_multi_out_dig_cleanup(codec, &spec->multiout);
5446 }
5447 
5448 static int dig_playback_pcm_close(struct hda_pcm_stream *hinfo,
5449                   struct hda_codec *codec,
5450                   struct snd_pcm_substream *substream)
5451 {
5452     struct hda_gen_spec *spec = codec->spec;
5453     return snd_hda_multi_out_dig_close(codec, &spec->multiout);
5454 }
5455 
5456 /*
5457  * Analog capture
5458  */
5459 #define alt_capture_pcm_open    capture_pcm_open
5460 #define alt_capture_pcm_close   capture_pcm_close
5461 
5462 static int alt_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
5463                    struct hda_codec *codec,
5464                    unsigned int stream_tag,
5465                    unsigned int format,
5466                    struct snd_pcm_substream *substream)
5467 {
5468     struct hda_gen_spec *spec = codec->spec;
5469 
5470     snd_hda_codec_setup_stream(codec, spec->adc_nids[substream->number + 1],
5471                    stream_tag, 0, format);
5472     call_pcm_capture_hook(hinfo, codec, substream,
5473                   HDA_GEN_PCM_ACT_PREPARE);
5474     return 0;
5475 }
5476 
5477 static int alt_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
5478                    struct hda_codec *codec,
5479                    struct snd_pcm_substream *substream)
5480 {
5481     struct hda_gen_spec *spec = codec->spec;
5482 
5483     snd_hda_codec_cleanup_stream(codec,
5484                      spec->adc_nids[substream->number + 1]);
5485     call_pcm_capture_hook(hinfo, codec, substream,
5486                   HDA_GEN_PCM_ACT_CLEANUP);
5487     return 0;
5488 }
5489 
5490 /*
5491  */
5492 static const struct hda_pcm_stream pcm_analog_playback = {
5493     .substreams = 1,
5494     .channels_min = 2,
5495     .channels_max = 8,
5496     /* NID is set in build_pcms */
5497     .ops = {
5498         .open = playback_pcm_open,
5499         .close = playback_pcm_close,
5500         .prepare = playback_pcm_prepare,
5501         .cleanup = playback_pcm_cleanup
5502     },
5503 };
5504 
5505 static const struct hda_pcm_stream pcm_analog_capture = {
5506     .substreams = 1,
5507     .channels_min = 2,
5508     .channels_max = 2,
5509     /* NID is set in build_pcms */
5510     .ops = {
5511         .open = capture_pcm_open,
5512         .close = capture_pcm_close,
5513         .prepare = capture_pcm_prepare,
5514         .cleanup = capture_pcm_cleanup
5515     },
5516 };
5517 
5518 static const struct hda_pcm_stream pcm_analog_alt_playback = {
5519     .substreams = 1,
5520     .channels_min = 2,
5521     .channels_max = 2,
5522     /* NID is set in build_pcms */
5523     .ops = {
5524         .open = alt_playback_pcm_open,
5525         .close = alt_playback_pcm_close,
5526         .prepare = alt_playback_pcm_prepare,
5527         .cleanup = alt_playback_pcm_cleanup
5528     },
5529 };
5530 
5531 static const struct hda_pcm_stream pcm_analog_alt_capture = {
5532     .substreams = 2, /* can be overridden */
5533     .channels_min = 2,
5534     .channels_max = 2,
5535     /* NID is set in build_pcms */
5536     .ops = {
5537         .open = alt_capture_pcm_open,
5538         .close = alt_capture_pcm_close,
5539         .prepare = alt_capture_pcm_prepare,
5540         .cleanup = alt_capture_pcm_cleanup
5541     },
5542 };
5543 
5544 static const struct hda_pcm_stream pcm_digital_playback = {
5545     .substreams = 1,
5546     .channels_min = 2,
5547     .channels_max = 2,
5548     /* NID is set in build_pcms */
5549     .ops = {
5550         .open = dig_playback_pcm_open,
5551         .close = dig_playback_pcm_close,
5552         .prepare = dig_playback_pcm_prepare,
5553         .cleanup = dig_playback_pcm_cleanup
5554     },
5555 };
5556 
5557 static const struct hda_pcm_stream pcm_digital_capture = {
5558     .substreams = 1,
5559     .channels_min = 2,
5560     .channels_max = 2,
5561     /* NID is set in build_pcms */
5562 };
5563 
5564 /* Used by build_pcms to flag that a PCM has no playback stream */
5565 static const struct hda_pcm_stream pcm_null_stream = {
5566     .substreams = 0,
5567     .channels_min = 0,
5568     .channels_max = 0,
5569 };
5570 
5571 /*
5572  * dynamic changing ADC PCM streams
5573  */
5574 static bool dyn_adc_pcm_resetup(struct hda_codec *codec, int cur)
5575 {
5576     struct hda_gen_spec *spec = codec->spec;
5577     hda_nid_t new_adc = spec->adc_nids[spec->dyn_adc_idx[cur]];
5578 
5579     if (spec->cur_adc && spec->cur_adc != new_adc) {
5580         /* stream is running, let's swap the current ADC */
5581         __snd_hda_codec_cleanup_stream(codec, spec->cur_adc, 1);
5582         spec->cur_adc = new_adc;
5583         snd_hda_codec_setup_stream(codec, new_adc,
5584                        spec->cur_adc_stream_tag, 0,
5585                        spec->cur_adc_format);
5586         return true;
5587     }
5588     return false;
5589 }
5590 
5591 /* analog capture with dynamic dual-adc changes */
5592 static int dyn_adc_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
5593                        struct hda_codec *codec,
5594                        unsigned int stream_tag,
5595                        unsigned int format,
5596                        struct snd_pcm_substream *substream)
5597 {
5598     struct hda_gen_spec *spec = codec->spec;
5599     spec->cur_adc = spec->adc_nids[spec->dyn_adc_idx[spec->cur_mux[0]]];
5600     spec->cur_adc_stream_tag = stream_tag;
5601     spec->cur_adc_format = format;
5602     snd_hda_codec_setup_stream(codec, spec->cur_adc, stream_tag, 0, format);
5603     call_pcm_capture_hook(hinfo, codec, substream, HDA_GEN_PCM_ACT_PREPARE);
5604     return 0;
5605 }
5606 
5607 static int dyn_adc_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
5608                        struct hda_codec *codec,
5609                        struct snd_pcm_substream *substream)
5610 {
5611     struct hda_gen_spec *spec = codec->spec;
5612     snd_hda_codec_cleanup_stream(codec, spec->cur_adc);
5613     spec->cur_adc = 0;
5614     call_pcm_capture_hook(hinfo, codec, substream, HDA_GEN_PCM_ACT_CLEANUP);
5615     return 0;
5616 }
5617 
5618 static const struct hda_pcm_stream dyn_adc_pcm_analog_capture = {
5619     .substreams = 1,
5620     .channels_min = 2,
5621     .channels_max = 2,
5622     .nid = 0, /* fill later */
5623     .ops = {
5624         .prepare = dyn_adc_capture_pcm_prepare,
5625         .cleanup = dyn_adc_capture_pcm_cleanup
5626     },
5627 };
5628 
5629 static void fill_pcm_stream_name(char *str, size_t len, const char *sfx,
5630                  const char *chip_name)
5631 {
5632     char *p;
5633 
5634     if (*str)
5635         return;
5636     strscpy(str, chip_name, len);
5637 
5638     /* drop non-alnum chars after a space */
5639     for (p = strchr(str, ' '); p; p = strchr(p + 1, ' ')) {
5640         if (!isalnum(p[1])) {
5641             *p = 0;
5642             break;
5643         }
5644     }
5645     strlcat(str, sfx, len);
5646 }
5647 
5648 /* copy PCM stream info from @default_str, and override non-NULL entries
5649  * from @spec_str and @nid
5650  */
5651 static void setup_pcm_stream(struct hda_pcm_stream *str,
5652                  const struct hda_pcm_stream *default_str,
5653                  const struct hda_pcm_stream *spec_str,
5654                  hda_nid_t nid)
5655 {
5656     *str = *default_str;
5657     if (nid)
5658         str->nid = nid;
5659     if (spec_str) {
5660         if (spec_str->substreams)
5661             str->substreams = spec_str->substreams;
5662         if (spec_str->channels_min)
5663             str->channels_min = spec_str->channels_min;
5664         if (spec_str->channels_max)
5665             str->channels_max = spec_str->channels_max;
5666         if (spec_str->rates)
5667             str->rates = spec_str->rates;
5668         if (spec_str->formats)
5669             str->formats = spec_str->formats;
5670         if (spec_str->maxbps)
5671             str->maxbps = spec_str->maxbps;
5672     }
5673 }
5674 
5675 /**
5676  * snd_hda_gen_build_pcms - build PCM streams based on the parsed results
5677  * @codec: the HDA codec
5678  *
5679  * Pass this to build_pcms patch_ops.
5680  */
5681 int snd_hda_gen_build_pcms(struct hda_codec *codec)
5682 {
5683     struct hda_gen_spec *spec = codec->spec;
5684     struct hda_pcm *info;
5685     bool have_multi_adcs;
5686 
5687     if (spec->no_analog)
5688         goto skip_analog;
5689 
5690     fill_pcm_stream_name(spec->stream_name_analog,
5691                  sizeof(spec->stream_name_analog),
5692                  " Analog", codec->core.chip_name);
5693     info = snd_hda_codec_pcm_new(codec, "%s", spec->stream_name_analog);
5694     if (!info)
5695         return -ENOMEM;
5696     spec->pcm_rec[0] = info;
5697 
5698     if (spec->multiout.num_dacs > 0) {
5699         setup_pcm_stream(&info->stream[SNDRV_PCM_STREAM_PLAYBACK],
5700                  &pcm_analog_playback,
5701                  spec->stream_analog_playback,
5702                  spec->multiout.dac_nids[0]);
5703         info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max =
5704             spec->multiout.max_channels;
5705         if (spec->autocfg.line_out_type == AUTO_PIN_SPEAKER_OUT &&
5706             spec->autocfg.line_outs == 2)
5707             info->stream[SNDRV_PCM_STREAM_PLAYBACK].chmap =
5708                 snd_pcm_2_1_chmaps;
5709     }
5710     if (spec->num_adc_nids) {
5711         setup_pcm_stream(&info->stream[SNDRV_PCM_STREAM_CAPTURE],
5712                  (spec->dyn_adc_switch ?
5713                   &dyn_adc_pcm_analog_capture : &pcm_analog_capture),
5714                  spec->stream_analog_capture,
5715                  spec->adc_nids[0]);
5716     }
5717 
5718  skip_analog:
5719     /* SPDIF for stream index #1 */
5720     if (spec->multiout.dig_out_nid || spec->dig_in_nid) {
5721         fill_pcm_stream_name(spec->stream_name_digital,
5722                      sizeof(spec->stream_name_digital),
5723                      " Digital", codec->core.chip_name);
5724         info = snd_hda_codec_pcm_new(codec, "%s",
5725                          spec->stream_name_digital);
5726         if (!info)
5727             return -ENOMEM;
5728         codec->follower_dig_outs = spec->multiout.follower_dig_outs;
5729         spec->pcm_rec[1] = info;
5730         if (spec->dig_out_type)
5731             info->pcm_type = spec->dig_out_type;
5732         else
5733             info->pcm_type = HDA_PCM_TYPE_SPDIF;
5734         if (spec->multiout.dig_out_nid)
5735             setup_pcm_stream(&info->stream[SNDRV_PCM_STREAM_PLAYBACK],
5736                      &pcm_digital_playback,
5737                      spec->stream_digital_playback,
5738                      spec->multiout.dig_out_nid);
5739         if (spec->dig_in_nid)
5740             setup_pcm_stream(&info->stream[SNDRV_PCM_STREAM_CAPTURE],
5741                      &pcm_digital_capture,
5742                      spec->stream_digital_capture,
5743                      spec->dig_in_nid);
5744     }
5745 
5746     if (spec->no_analog)
5747         return 0;
5748 
5749     /* If the use of more than one ADC is requested for the current
5750      * model, configure a second analog capture-only PCM.
5751      */
5752     have_multi_adcs = (spec->num_adc_nids > 1) &&
5753         !spec->dyn_adc_switch && !spec->auto_mic;
5754     /* Additional Analaog capture for index #2 */
5755     if (spec->alt_dac_nid || have_multi_adcs) {
5756         fill_pcm_stream_name(spec->stream_name_alt_analog,
5757                      sizeof(spec->stream_name_alt_analog),
5758                  " Alt Analog", codec->core.chip_name);
5759         info = snd_hda_codec_pcm_new(codec, "%s",
5760                          spec->stream_name_alt_analog);
5761         if (!info)
5762             return -ENOMEM;
5763         spec->pcm_rec[2] = info;
5764         if (spec->alt_dac_nid)
5765             setup_pcm_stream(&info->stream[SNDRV_PCM_STREAM_PLAYBACK],
5766                      &pcm_analog_alt_playback,
5767                      spec->stream_analog_alt_playback,
5768                      spec->alt_dac_nid);
5769         else
5770             setup_pcm_stream(&info->stream[SNDRV_PCM_STREAM_PLAYBACK],
5771                      &pcm_null_stream, NULL, 0);
5772         if (have_multi_adcs) {
5773             setup_pcm_stream(&info->stream[SNDRV_PCM_STREAM_CAPTURE],
5774                      &pcm_analog_alt_capture,
5775                      spec->stream_analog_alt_capture,
5776                      spec->adc_nids[1]);
5777             info->stream[SNDRV_PCM_STREAM_CAPTURE].substreams =
5778                 spec->num_adc_nids - 1;
5779         } else {
5780             setup_pcm_stream(&info->stream[SNDRV_PCM_STREAM_CAPTURE],
5781                      &pcm_null_stream, NULL, 0);
5782         }
5783     }
5784 
5785     return 0;
5786 }
5787 EXPORT_SYMBOL_GPL(snd_hda_gen_build_pcms);
5788 
5789 
5790 /*
5791  * Standard auto-parser initializations
5792  */
5793 
5794 /* configure the given path as a proper output */
5795 static void set_output_and_unmute(struct hda_codec *codec, int path_idx)
5796 {
5797     struct nid_path *path;
5798     hda_nid_t pin;
5799 
5800     path = snd_hda_get_path_from_idx(codec, path_idx);
5801     if (!path || !path->depth)
5802         return;
5803     pin = path->path[path->depth - 1];
5804     restore_pin_ctl(codec, pin);
5805     snd_hda_activate_path(codec, path, path->active,
5806                   aamix_default(codec->spec));
5807     set_pin_eapd(codec, pin, path->active);
5808 }
5809 
5810 /* initialize primary output paths */
5811 static void init_multi_out(struct hda_codec *codec)
5812 {
5813     struct hda_gen_spec *spec = codec->spec;
5814     int i;
5815 
5816     for (i = 0; i < spec->autocfg.line_outs; i++)
5817         set_output_and_unmute(codec, spec->out_paths[i]);
5818 }
5819 
5820 
5821 static void __init_extra_out(struct hda_codec *codec, int num_outs, int *paths)
5822 {
5823     int i;
5824 
5825     for (i = 0; i < num_outs; i++)
5826         set_output_and_unmute(codec, paths[i]);
5827 }
5828 
5829 /* initialize hp and speaker paths */
5830 static void init_extra_out(struct hda_codec *codec)
5831 {
5832     struct hda_gen_spec *spec = codec->spec;
5833 
5834     if (spec->autocfg.line_out_type != AUTO_PIN_HP_OUT)
5835         __init_extra_out(codec, spec->autocfg.hp_outs, spec->hp_paths);
5836     if (spec->autocfg.line_out_type != AUTO_PIN_SPEAKER_OUT)
5837         __init_extra_out(codec, spec->autocfg.speaker_outs,
5838                  spec->speaker_paths);
5839 }
5840 
5841 /* initialize multi-io paths */
5842 static void init_multi_io(struct hda_codec *codec)
5843 {
5844     struct hda_gen_spec *spec = codec->spec;
5845     int i;
5846 
5847     for (i = 0; i < spec->multi_ios; i++) {
5848         hda_nid_t pin = spec->multi_io[i].pin;
5849         struct nid_path *path;
5850         path = get_multiio_path(codec, i);
5851         if (!path)
5852             continue;
5853         if (!spec->multi_io[i].ctl_in)
5854             spec->multi_io[i].ctl_in =
5855                 snd_hda_codec_get_pin_target(codec, pin);
5856         snd_hda_activate_path(codec, path, path->active,
5857                       aamix_default(spec));
5858     }
5859 }
5860 
5861 static void init_aamix_paths(struct hda_codec *codec)
5862 {
5863     struct hda_gen_spec *spec = codec->spec;
5864 
5865     if (!spec->have_aamix_ctl)
5866         return;
5867     if (!has_aamix_out_paths(spec))
5868         return;
5869     update_aamix_paths(codec, spec->aamix_mode, spec->out_paths[0],
5870                spec->aamix_out_paths[0],
5871                spec->autocfg.line_out_type);
5872     update_aamix_paths(codec, spec->aamix_mode, spec->hp_paths[0],
5873                spec->aamix_out_paths[1],
5874                AUTO_PIN_HP_OUT);
5875     update_aamix_paths(codec, spec->aamix_mode, spec->speaker_paths[0],
5876                spec->aamix_out_paths[2],
5877                AUTO_PIN_SPEAKER_OUT);
5878 }
5879 
5880 /* set up input pins and loopback paths */
5881 static void init_analog_input(struct hda_codec *codec)
5882 {
5883     struct hda_gen_spec *spec = codec->spec;
5884     struct auto_pin_cfg *cfg = &spec->autocfg;
5885     int i;
5886 
5887     for (i = 0; i < cfg->num_inputs; i++) {
5888         hda_nid_t nid = cfg->inputs[i].pin;
5889         if (is_input_pin(codec, nid))
5890             restore_pin_ctl(codec, nid);
5891 
5892         /* init loopback inputs */
5893         if (spec->mixer_nid) {
5894             resume_path_from_idx(codec, spec->loopback_paths[i]);
5895             resume_path_from_idx(codec, spec->loopback_merge_path);
5896         }
5897     }
5898 }
5899 
5900 /* initialize ADC paths */
5901 static void init_input_src(struct hda_codec *codec)
5902 {
5903     struct hda_gen_spec *spec = codec->spec;
5904     struct hda_input_mux *imux = &spec->input_mux;
5905     struct nid_path *path;
5906     int i, c, nums;
5907 
5908     if (spec->dyn_adc_switch)
5909         nums = 1;
5910     else
5911         nums = spec->num_adc_nids;
5912 
5913     for (c = 0; c < nums; c++) {
5914         for (i = 0; i < imux->num_items; i++) {
5915             path = get_input_path(codec, c, i);
5916             if (path) {
5917                 bool active = path->active;
5918                 if (i == spec->cur_mux[c])
5919                     active = true;
5920                 snd_hda_activate_path(codec, path, active, false);
5921             }
5922         }
5923         if (spec->hp_mic)
5924             update_hp_mic(codec, c, true);
5925     }
5926 
5927     if (spec->cap_sync_hook)
5928         spec->cap_sync_hook(codec, NULL, NULL);
5929 }
5930 
5931 /* set right pin controls for digital I/O */
5932 static void init_digital(struct hda_codec *codec)
5933 {
5934     struct hda_gen_spec *spec = codec->spec;
5935     int i;
5936     hda_nid_t pin;
5937 
5938     for (i = 0; i < spec->autocfg.dig_outs; i++)
5939         set_output_and_unmute(codec, spec->digout_paths[i]);
5940     pin = spec->autocfg.dig_in_pin;
5941     if (pin) {
5942         restore_pin_ctl(codec, pin);
5943         resume_path_from_idx(codec, spec->digin_path);
5944     }
5945 }
5946 
5947 /* clear unsol-event tags on unused pins; Conexant codecs seem to leave
5948  * invalid unsol tags by some reason
5949  */
5950 static void clear_unsol_on_unused_pins(struct hda_codec *codec)
5951 {
5952     const struct hda_pincfg *pin;
5953     int i;
5954 
5955     snd_array_for_each(&codec->init_pins, i, pin) {
5956         hda_nid_t nid = pin->nid;
5957         if (is_jack_detectable(codec, nid) &&
5958             !snd_hda_jack_tbl_get(codec, nid))
5959             snd_hda_codec_write_cache(codec, nid, 0,
5960                     AC_VERB_SET_UNSOLICITED_ENABLE, 0);
5961     }
5962 }
5963 
5964 /**
5965  * snd_hda_gen_init - initialize the generic spec
5966  * @codec: the HDA codec
5967  *
5968  * This can be put as patch_ops init function.
5969  */
5970 int snd_hda_gen_init(struct hda_codec *codec)
5971 {
5972     struct hda_gen_spec *spec = codec->spec;
5973 
5974     if (spec->init_hook)
5975         spec->init_hook(codec);
5976 
5977     if (!spec->skip_verbs)
5978         snd_hda_apply_verbs(codec);
5979 
5980     init_multi_out(codec);
5981     init_extra_out(codec);
5982     init_multi_io(codec);
5983     init_aamix_paths(codec);
5984     init_analog_input(codec);
5985     init_input_src(codec);
5986     init_digital(codec);
5987 
5988     clear_unsol_on_unused_pins(codec);
5989 
5990     sync_all_pin_power_ctls(codec);
5991 
5992     /* call init functions of standard auto-mute helpers */
5993     update_automute_all(codec);
5994 
5995     snd_hda_regmap_sync(codec);
5996 
5997     if (spec->vmaster_mute.sw_kctl && spec->vmaster_mute.hook)
5998         snd_hda_sync_vmaster_hook(&spec->vmaster_mute);
5999 
6000     hda_call_check_power_status(codec, 0x01);
6001     return 0;
6002 }
6003 EXPORT_SYMBOL_GPL(snd_hda_gen_init);
6004 
6005 /**
6006  * snd_hda_gen_free - free the generic spec
6007  * @codec: the HDA codec
6008  *
6009  * This can be put as patch_ops free function.
6010  */
6011 void snd_hda_gen_free(struct hda_codec *codec)
6012 {
6013     snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_FREE);
6014     snd_hda_gen_spec_free(codec->spec);
6015     kfree(codec->spec);
6016     codec->spec = NULL;
6017 }
6018 EXPORT_SYMBOL_GPL(snd_hda_gen_free);
6019 
6020 #ifdef CONFIG_PM
6021 /**
6022  * snd_hda_gen_check_power_status - check the loopback power save state
6023  * @codec: the HDA codec
6024  * @nid: NID to inspect
6025  *
6026  * This can be put as patch_ops check_power_status function.
6027  */
6028 int snd_hda_gen_check_power_status(struct hda_codec *codec, hda_nid_t nid)
6029 {
6030     struct hda_gen_spec *spec = codec->spec;
6031     return snd_hda_check_amp_list_power(codec, &spec->loopback, nid);
6032 }
6033 EXPORT_SYMBOL_GPL(snd_hda_gen_check_power_status);
6034 #endif
6035 
6036 
6037 /*
6038  * the generic codec support
6039  */
6040 
6041 static const struct hda_codec_ops generic_patch_ops = {
6042     .build_controls = snd_hda_gen_build_controls,
6043     .build_pcms = snd_hda_gen_build_pcms,
6044     .init = snd_hda_gen_init,
6045     .free = snd_hda_gen_free,
6046     .unsol_event = snd_hda_jack_unsol_event,
6047 #ifdef CONFIG_PM
6048     .check_power_status = snd_hda_gen_check_power_status,
6049 #endif
6050 };
6051 
6052 /*
6053  * snd_hda_parse_generic_codec - Generic codec parser
6054  * @codec: the HDA codec
6055  */
6056 static int snd_hda_parse_generic_codec(struct hda_codec *codec)
6057 {
6058     struct hda_gen_spec *spec;
6059     int err;
6060 
6061     spec = kzalloc(sizeof(*spec), GFP_KERNEL);
6062     if (!spec)
6063         return -ENOMEM;
6064     snd_hda_gen_spec_init(spec);
6065     codec->spec = spec;
6066 
6067     err = snd_hda_parse_pin_defcfg(codec, &spec->autocfg, NULL, 0);
6068     if (err < 0)
6069         goto error;
6070 
6071     err = snd_hda_gen_parse_auto_config(codec, &spec->autocfg);
6072     if (err < 0)
6073         goto error;
6074 
6075     codec->patch_ops = generic_patch_ops;
6076     return 0;
6077 
6078 error:
6079     snd_hda_gen_free(codec);
6080     return err;
6081 }
6082 
6083 static const struct hda_device_id snd_hda_id_generic[] = {
6084     HDA_CODEC_ENTRY(HDA_CODEC_ID_GENERIC, "Generic", snd_hda_parse_generic_codec),
6085     {} /* terminator */
6086 };
6087 MODULE_DEVICE_TABLE(hdaudio, snd_hda_id_generic);
6088 
6089 static struct hda_codec_driver generic_driver = {
6090     .id = snd_hda_id_generic,
6091 };
6092 
6093 module_hda_codec_driver(generic_driver);
6094 
6095 MODULE_LICENSE("GPL");
6096 MODULE_DESCRIPTION("Generic HD-audio codec parser");
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!