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