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