sound/pci/hda/hda_generic.c

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