sound/pci/hda/hda_generic.c

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