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         .access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
3524         .info = cap_sw_info,
3525         .get = cap_sw_get,
3526         .put = cap_sw_put,
3527 };
3528
3529 static int parse_capvol_in_path(struct hda_codec *codec, struct nid_path *path)
3530 {
3531         hda_nid_t nid;
3532         int i, depth;
3533
3534         path->ctls[NID_PATH_VOL_CTL] = path->ctls[NID_PATH_MUTE_CTL] = 0;
3535         for (depth = 0; depth < 3; depth++) {
3536                 if (depth >= path->depth)
3537                         return -EINVAL;
3538                 i = path->depth - depth - 1;
3539                 nid = path->path[i];
3540                 if (!path->ctls[NID_PATH_VOL_CTL]) {
3541                         if (nid_has_volume(codec, nid, HDA_OUTPUT))
3542                                 path->ctls[NID_PATH_VOL_CTL] =
3543                                         HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
3544                         else if (nid_has_volume(codec, nid, HDA_INPUT)) {
3545                                 int idx = path->idx[i];
3546                                 if (!depth && codec->single_adc_amp)
3547                                         idx = 0;
3548                                 path->ctls[NID_PATH_VOL_CTL] =
3549                                         HDA_COMPOSE_AMP_VAL(nid, 3, idx, HDA_INPUT);
3550                         }
3551                 }
3552                 if (!path->ctls[NID_PATH_MUTE_CTL]) {
3553                         if (nid_has_mute(codec, nid, HDA_OUTPUT))
3554                                 path->ctls[NID_PATH_MUTE_CTL] =
3555                                         HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
3556                         else if (nid_has_mute(codec, nid, HDA_INPUT)) {
3557                                 int idx = path->idx[i];
3558                                 if (!depth && codec->single_adc_amp)
3559                                         idx = 0;
3560                                 path->ctls[NID_PATH_MUTE_CTL] =
3561                                         HDA_COMPOSE_AMP_VAL(nid, 3, idx, HDA_INPUT);
3562                         }
3563                 }
3564         }
3565         return 0;
3566 }
3567
3568 static bool is_inv_dmic_pin(struct hda_codec *codec, hda_nid_t nid)
3569 {
3570         struct hda_gen_spec *spec = codec->spec;
3571         struct auto_pin_cfg *cfg = &spec->autocfg;
3572         unsigned int val;
3573         int i;
3574
3575         if (!spec->inv_dmic_split)
3576                 return false;
3577         for (i = 0; i < cfg->num_inputs; i++) {
3578                 if (cfg->inputs[i].pin != nid)
3579                         continue;
3580                 if (cfg->inputs[i].type != AUTO_PIN_MIC)
3581                         return false;
3582                 val = snd_hda_codec_get_pincfg(codec, nid);
3583                 return snd_hda_get_input_pin_attr(val) == INPUT_PIN_ATTR_INT;
3584         }
3585         return false;
3586 }
3587
3588 /* capture switch put callback for a single control with hook call */
3589 static int cap_single_sw_put(struct snd_kcontrol *kcontrol,
3590                              struct snd_ctl_elem_value *ucontrol)
3591 {
3592         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3593         struct hda_gen_spec *spec = codec->spec;
3594         int ret;
3595
3596         ret = snd_hda_mixer_amp_switch_put(kcontrol, ucontrol);
3597         if (ret < 0)
3598                 return ret;
3599
3600         if (spec->cap_sync_hook)
3601                 spec->cap_sync_hook(codec, kcontrol, ucontrol);
3602
3603         return ret;
3604 }
3605
3606 static int add_single_cap_ctl(struct hda_codec *codec, const char *label,
3607                               int idx, bool is_switch, unsigned int ctl,
3608                               bool inv_dmic)
3609 {
3610         struct hda_gen_spec *spec = codec->spec;
3611         char tmpname[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];
3612         int type = is_switch ? HDA_CTL_WIDGET_MUTE : HDA_CTL_WIDGET_VOL;
3613         const char *sfx = is_switch ? "Switch" : "Volume";
3614         unsigned int chs = inv_dmic ? 1 : 3;
3615         struct snd_kcontrol_new *knew;
3616
3617         if (!ctl)
3618                 return 0;
3619
3620         if (label)
3621                 snprintf(tmpname, sizeof(tmpname),
3622                          "%s Capture %s", label, sfx);
3623         else
3624                 snprintf(tmpname, sizeof(tmpname),
3625                          "Capture %s", sfx);
3626         knew = add_control(spec, type, tmpname, idx,
3627                            amp_val_replace_channels(ctl, chs));
3628         if (!knew)
3629                 return -ENOMEM;
3630         if (is_switch) {
3631                 knew->put = cap_single_sw_put;
3632                 if (spec->mic_mute_led)
3633                         knew->access |= SNDRV_CTL_ELEM_ACCESS_MIC_LED;
3634         }
3635         if (!inv_dmic)
3636                 return 0;
3637
3638         /* Make independent right kcontrol */
3639         if (label)
3640                 snprintf(tmpname, sizeof(tmpname),
3641                          "Inverted %s Capture %s", label, sfx);
3642         else
3643                 snprintf(tmpname, sizeof(tmpname),
3644                          "Inverted Capture %s", sfx);
3645         knew = add_control(spec, type, tmpname, idx,
3646                            amp_val_replace_channels(ctl, 2));
3647         if (!knew)
3648                 return -ENOMEM;
3649         if (is_switch) {
3650                 knew->put = cap_single_sw_put;
3651                 if (spec->mic_mute_led)
3652                         knew->access |= SNDRV_CTL_ELEM_ACCESS_MIC_LED;
3653         }
3654         return 0;
3655 }
3656
3657 /* create single (and simple) capture volume and switch controls */
3658 static int create_single_cap_vol_ctl(struct hda_codec *codec, int idx,
3659                                      unsigned int vol_ctl, unsigned int sw_ctl,
3660                                      bool inv_dmic)
3661 {
3662         int err;
3663         err = add_single_cap_ctl(codec, NULL, idx, false, vol_ctl, inv_dmic);
3664         if (err < 0)
3665                 return err;
3666         err = add_single_cap_ctl(codec, NULL, idx, true, sw_ctl, inv_dmic);
3667         if (err < 0)
3668                 return err;
3669         return 0;
3670 }
3671
3672 /* create bound capture volume and switch controls */
3673 static int create_bind_cap_vol_ctl(struct hda_codec *codec, int idx,
3674                                    unsigned int vol_ctl, unsigned int sw_ctl)
3675 {
3676         struct hda_gen_spec *spec = codec->spec;
3677         struct snd_kcontrol_new *knew;
3678
3679         if (vol_ctl) {
3680                 knew = snd_hda_gen_add_kctl(spec, NULL, &cap_vol_temp);
3681                 if (!knew)
3682                         return -ENOMEM;
3683                 knew->index = idx;
3684                 knew->private_value = vol_ctl;
3685                 knew->subdevice = HDA_SUBDEV_AMP_FLAG;
3686         }
3687         if (sw_ctl) {
3688                 knew = snd_hda_gen_add_kctl(spec, NULL, &cap_sw_temp);
3689                 if (!knew)
3690                         return -ENOMEM;
3691                 knew->index = idx;
3692                 knew->private_value = sw_ctl;
3693                 knew->subdevice = HDA_SUBDEV_AMP_FLAG;
3694                 if (spec->mic_mute_led)
3695                         knew->access |= SNDRV_CTL_ELEM_ACCESS_MIC_LED;
3696         }
3697         return 0;
3698 }
3699
3700 /* return the vol ctl when used first in the imux list */
3701 static unsigned int get_first_cap_ctl(struct hda_codec *codec, int idx, int type)
3702 {
3703         struct nid_path *path;
3704         unsigned int ctl;
3705         int i;
3706
3707         path = get_input_path(codec, 0, idx);
3708         if (!path)
3709                 return 0;
3710         ctl = path->ctls[type];
3711         if (!ctl)
3712                 return 0;
3713         for (i = 0; i < idx - 1; i++) {
3714                 path = get_input_path(codec, 0, i);
3715                 if (path && path->ctls[type] == ctl)
3716                         return 0;
3717         }
3718         return ctl;
3719 }
3720
3721 /* create individual capture volume and switch controls per input */
3722 static int create_multi_cap_vol_ctl(struct hda_codec *codec)
3723 {
3724         struct hda_gen_spec *spec = codec->spec;
3725         struct hda_input_mux *imux = &spec->input_mux;
3726         int i, err, type;
3727
3728         for (i = 0; i < imux->num_items; i++) {
3729                 bool inv_dmic;
3730                 int idx;
3731
3732                 idx = imux->items[i].index;
3733                 if (idx >= spec->autocfg.num_inputs)
3734                         continue;
3735                 inv_dmic = is_inv_dmic_pin(codec, spec->imux_pins[i]);
3736
3737                 for (type = 0; type < 2; type++) {
3738                         err = add_single_cap_ctl(codec,
3739                                                  spec->input_labels[idx],
3740                                                  spec->input_label_idxs[idx],
3741                                                  type,
3742                                                  get_first_cap_ctl(codec, i, type),
3743                                                  inv_dmic);
3744                         if (err < 0)
3745                                 return err;
3746                 }
3747         }
3748         return 0;
3749 }
3750
3751 static int create_capture_mixers(struct hda_codec *codec)
3752 {
3753         struct hda_gen_spec *spec = codec->spec;
3754         struct hda_input_mux *imux = &spec->input_mux;
3755         int i, n, nums, err;
3756
3757         if (spec->dyn_adc_switch)
3758                 nums = 1;
3759         else
3760                 nums = spec->num_adc_nids;
3761
3762         if (!spec->auto_mic && imux->num_items > 1) {
3763                 struct snd_kcontrol_new *knew;
3764                 const char *name;
3765                 name = nums > 1 ? "Input Source" : "Capture Source";
3766                 knew = snd_hda_gen_add_kctl(spec, name, &cap_src_temp);
3767                 if (!knew)
3768                         return -ENOMEM;
3769                 knew->count = nums;
3770         }
3771
3772         for (n = 0; n < nums; n++) {
3773                 bool multi = false;
3774                 bool multi_cap_vol = spec->multi_cap_vol;
3775                 bool inv_dmic = false;
3776                 int vol, sw;
3777
3778                 vol = sw = 0;
3779                 for (i = 0; i < imux->num_items; i++) {
3780                         struct nid_path *path;
3781                         path = get_input_path(codec, n, i);
3782                         if (!path)
3783                                 continue;
3784                         parse_capvol_in_path(codec, path);
3785                         if (!vol)
3786                                 vol = path->ctls[NID_PATH_VOL_CTL];
3787                         else if (vol != path->ctls[NID_PATH_VOL_CTL]) {
3788                                 multi = true;
3789                                 if (!same_amp_caps(codec, vol,
3790                                     path->ctls[NID_PATH_VOL_CTL], HDA_INPUT))
3791                                         multi_cap_vol = true;
3792                         }
3793                         if (!sw)
3794                                 sw = path->ctls[NID_PATH_MUTE_CTL];
3795                         else if (sw != path->ctls[NID_PATH_MUTE_CTL]) {
3796                                 multi = true;
3797                                 if (!same_amp_caps(codec, sw,
3798                                     path->ctls[NID_PATH_MUTE_CTL], HDA_INPUT))
3799                                         multi_cap_vol = true;
3800                         }
3801                         if (is_inv_dmic_pin(codec, spec->imux_pins[i]))
3802                                 inv_dmic = true;
3803                 }
3804
3805                 if (!multi)
3806                         err = create_single_cap_vol_ctl(codec, n, vol, sw,
3807                                                         inv_dmic);
3808                 else if (!multi_cap_vol && !inv_dmic)
3809                         err = create_bind_cap_vol_ctl(codec, n, vol, sw);
3810                 else
3811                         err = create_multi_cap_vol_ctl(codec);
3812                 if (err < 0)
3813                         return err;
3814         }
3815
3816         return 0;
3817 }
3818
3819 /*
3820  * add mic boosts if needed
3821  */
3822
3823 /* check whether the given amp is feasible as a boost volume */
3824 static bool check_boost_vol(struct hda_codec *codec, hda_nid_t nid,
3825                             int dir, int idx)
3826 {
3827         unsigned int step;
3828
3829         if (!nid_has_volume(codec, nid, dir) ||
3830             is_ctl_associated(codec, nid, dir, idx, NID_PATH_VOL_CTL) ||
3831             is_ctl_associated(codec, nid, dir, idx, NID_PATH_BOOST_CTL))
3832                 return false;
3833
3834         step = (query_amp_caps(codec, nid, dir) & AC_AMPCAP_STEP_SIZE)
3835                 >> AC_AMPCAP_STEP_SIZE_SHIFT;
3836         if (step < 0x20)
3837                 return false;
3838         return true;
3839 }
3840
3841 /* look for a boost amp in a widget close to the pin */
3842 static unsigned int look_for_boost_amp(struct hda_codec *codec,
3843                                        struct nid_path *path)
3844 {
3845         unsigned int val = 0;
3846         hda_nid_t nid;
3847         int depth;
3848
3849         for (depth = 0; depth < 3; depth++) {
3850                 if (depth >= path->depth - 1)
3851                         break;
3852                 nid = path->path[depth];
3853                 if (depth && check_boost_vol(codec, nid, HDA_OUTPUT, 0)) {
3854                         val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
3855                         break;
3856                 } else if (check_boost_vol(codec, nid, HDA_INPUT,
3857                                            path->idx[depth])) {
3858                         val = HDA_COMPOSE_AMP_VAL(nid, 3, path->idx[depth],
3859                                                   HDA_INPUT);
3860                         break;
3861                 }
3862         }
3863
3864         return val;
3865 }
3866
3867 static int parse_mic_boost(struct hda_codec *codec)
3868 {
3869         struct hda_gen_spec *spec = codec->spec;
3870         struct auto_pin_cfg *cfg = &spec->autocfg;
3871         struct hda_input_mux *imux = &spec->input_mux;
3872         int i;
3873
3874         if (!spec->num_adc_nids)
3875                 return 0;
3876
3877         for (i = 0; i < imux->num_items; i++) {
3878                 struct nid_path *path;
3879                 unsigned int val;
3880                 int idx;
3881                 char boost_label[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];
3882
3883                 idx = imux->items[i].index;
3884                 if (idx >= imux->num_items)
3885                         continue;
3886
3887                 /* check only line-in and mic pins */
3888                 if (cfg->inputs[idx].type > AUTO_PIN_LINE_IN)
3889                         continue;
3890
3891                 path = get_input_path(codec, 0, i);
3892                 if (!path)
3893                         continue;
3894
3895                 val = look_for_boost_amp(codec, path);
3896                 if (!val)
3897                         continue;
3898
3899                 /* create a boost control */
3900                 snprintf(boost_label, sizeof(boost_label),
3901                          "%s Boost Volume", spec->input_labels[idx]);
3902                 if (!add_control(spec, HDA_CTL_WIDGET_VOL, boost_label,
3903                                  spec->input_label_idxs[idx], val))
3904                         return -ENOMEM;
3905
3906                 path->ctls[NID_PATH_BOOST_CTL] = val;
3907         }
3908         return 0;
3909 }
3910
3911 #ifdef CONFIG_SND_HDA_GENERIC_LEDS
3912 /*
3913  * vmaster mute LED hook helpers
3914  */
3915
3916 static int create_mute_led_cdev(struct hda_codec *codec,
3917                                 int (*callback)(struct led_classdev *,
3918                                                 enum led_brightness),
3919                                 bool micmute)
3920 {
3921         struct led_classdev *cdev;
3922
3923         cdev = devm_kzalloc(&codec->core.dev, sizeof(*cdev), GFP_KERNEL);
3924         if (!cdev)
3925                 return -ENOMEM;
3926
3927         cdev->name = micmute ? "hda::micmute" : "hda::mute";
3928         cdev->max_brightness = 1;
3929         cdev->default_trigger = micmute ? "audio-micmute" : "audio-mute";
3930         cdev->brightness_set_blocking = callback;
3931         cdev->brightness = ledtrig_audio_get(micmute ? LED_AUDIO_MICMUTE : LED_AUDIO_MUTE);
3932         cdev->flags = LED_CORE_SUSPENDRESUME;
3933
3934         return devm_led_classdev_register(&codec->core.dev, cdev);
3935 }
3936
3937 /**
3938  * snd_hda_gen_add_mute_led_cdev - Create a LED classdev and enable as vmaster mute LED
3939  * @codec: the HDA codec
3940  * @callback: the callback for LED classdev brightness_set_blocking
3941  */
3942 int snd_hda_gen_add_mute_led_cdev(struct hda_codec *codec,
3943                                   int (*callback)(struct led_classdev *,
3944                                                   enum led_brightness))
3945 {
3946         struct hda_gen_spec *spec = codec->spec;
3947         int err;
3948
3949         if (callback) {
3950                 err = create_mute_led_cdev(codec, callback, false);
3951                 if (err) {
3952                         codec_warn(codec, "failed to create a mute LED cdev\n");
3953                         return err;
3954                 }
3955         }
3956
3957         if (spec->vmaster_mute.hook)
3958                 codec_err(codec, "vmaster hook already present before cdev!\n");
3959
3960         spec->vmaster_mute_led = 1;
3961         return 0;
3962 }
3963 EXPORT_SYMBOL_GPL(snd_hda_gen_add_mute_led_cdev);
3964
3965 /**
3966  * snd_hda_gen_add_micmute_led_cdev - Create a LED classdev and enable as mic-mute LED
3967  * @codec: the HDA codec
3968  * @callback: the callback for LED classdev brightness_set_blocking
3969  *
3970  * Called from the codec drivers for offering the mic mute LED controls.
3971  * This creates a LED classdev and sets up the cap_sync_hook that is called at
3972  * each time when the capture mixer switch changes.
3973  *
3974  * When NULL is passed to @callback, no classdev is created but only the
3975  * LED-trigger is set up.
3976  *
3977  * Returns 0 or a negative error.
3978  */
3979 int snd_hda_gen_add_micmute_led_cdev(struct hda_codec *codec,
3980                                      int (*callback)(struct led_classdev *,
3981                                                      enum led_brightness))
3982 {
3983         struct hda_gen_spec *spec = codec->spec;
3984         int err;
3985
3986         if (callback) {
3987                 err = create_mute_led_cdev(codec, callback, true);
3988                 if (err) {
3989                         codec_warn(codec, "failed to create a mic-mute LED cdev\n");
3990                         return err;
3991                 }
3992         }
3993
3994         spec->mic_mute_led = 1;
3995         return 0;
3996 }
3997 EXPORT_SYMBOL_GPL(snd_hda_gen_add_micmute_led_cdev);
3998 #endif /* CONFIG_SND_HDA_GENERIC_LEDS */
3999
4000 /*
4001  * parse digital I/Os and set up NIDs in BIOS auto-parse mode
4002  */
4003 static void parse_digital(struct hda_codec *codec)
4004 {
4005         struct hda_gen_spec *spec = codec->spec;
4006         struct nid_path *path;
4007         int i, nums;
4008         hda_nid_t dig_nid, pin;
4009
4010         /* support multiple SPDIFs; the secondary is set up as a follower */
4011         nums = 0;
4012         for (i = 0; i < spec->autocfg.dig_outs; i++) {
4013                 pin = spec->autocfg.dig_out_pins[i];
4014                 dig_nid = look_for_dac(codec, pin, true);
4015                 if (!dig_nid)
4016                         continue;
4017                 path = snd_hda_add_new_path(codec, dig_nid, pin, 0);
4018                 if (!path)
4019                         continue;
4020                 print_nid_path(codec, "digout", path);
4021                 path->active = true;
4022                 path->pin_fixed = true; /* no jack detection */
4023                 spec->digout_paths[i] = snd_hda_get_path_idx(codec, path);
4024                 set_pin_target(codec, pin, PIN_OUT, false);
4025                 if (!nums) {
4026                         spec->multiout.dig_out_nid = dig_nid;
4027                         spec->dig_out_type = spec->autocfg.dig_out_type[0];
4028                 } else {
4029                         spec->multiout.follower_dig_outs = spec->follower_dig_outs;
4030                         if (nums >= ARRAY_SIZE(spec->follower_dig_outs) - 1)
4031                                 break;
4032                         spec->follower_dig_outs[nums - 1] = dig_nid;
4033                 }
4034                 nums++;
4035         }
4036
4037         if (spec->autocfg.dig_in_pin) {
4038                 pin = spec->autocfg.dig_in_pin;
4039                 for_each_hda_codec_node(dig_nid, codec) {
4040                         unsigned int wcaps = get_wcaps(codec, dig_nid);
4041                         if (get_wcaps_type(wcaps) != AC_WID_AUD_IN)
4042                                 continue;
4043                         if (!(wcaps & AC_WCAP_DIGITAL))
4044                                 continue;
4045                         path = snd_hda_add_new_path(codec, pin, dig_nid, 0);
4046                         if (path) {
4047                                 print_nid_path(codec, "digin", path);
4048                                 path->active = true;
4049                                 path->pin_fixed = true; /* no jack */
4050                                 spec->dig_in_nid = dig_nid;
4051                                 spec->digin_path = snd_hda_get_path_idx(codec, path);
4052                                 set_pin_target(codec, pin, PIN_IN, false);
4053                                 break;
4054                         }
4055                 }
4056         }
4057 }
4058
4059
4060 /*
4061  * input MUX handling
4062  */
4063
4064 static bool dyn_adc_pcm_resetup(struct hda_codec *codec, int cur);
4065
4066 /* select the given imux item; either unmute exclusively or select the route */
4067 static int mux_select(struct hda_codec *codec, unsigned int adc_idx,
4068                       unsigned int idx)
4069 {
4070         struct hda_gen_spec *spec = codec->spec;
4071         const struct hda_input_mux *imux;
4072         struct nid_path *old_path, *path;
4073
4074         imux = &spec->input_mux;
4075         if (!imux->num_items)
4076                 return 0;
4077
4078         if (idx >= imux->num_items)
4079                 idx = imux->num_items - 1;
4080         if (spec->cur_mux[adc_idx] == idx)
4081                 return 0;
4082
4083         old_path = get_input_path(codec, adc_idx, spec->cur_mux[adc_idx]);
4084         if (!old_path)
4085                 return 0;
4086         if (old_path->active)
4087                 snd_hda_activate_path(codec, old_path, false, false);
4088
4089         spec->cur_mux[adc_idx] = idx;
4090
4091         if (spec->hp_mic)
4092                 update_hp_mic(codec, adc_idx, false);
4093
4094         if (spec->dyn_adc_switch)
4095                 dyn_adc_pcm_resetup(codec, idx);
4096
4097         path = get_input_path(codec, adc_idx, idx);
4098         if (!path)
4099                 return 0;
4100         if (path->active)
4101                 return 0;
4102         snd_hda_activate_path(codec, path, true, false);
4103         if (spec->cap_sync_hook)
4104                 spec->cap_sync_hook(codec, NULL, NULL);
4105         path_power_down_sync(codec, old_path);
4106         return 1;
4107 }
4108
4109 /* power up/down widgets in the all paths that match with the given NID
4110  * as terminals (either start- or endpoint)
4111  *
4112  * returns the last changed NID, or zero if unchanged.
4113  */
4114 static hda_nid_t set_path_power(struct hda_codec *codec, hda_nid_t nid,
4115                                 int pin_state, int stream_state)
4116 {
4117         struct hda_gen_spec *spec = codec->spec;
4118         hda_nid_t last, changed = 0;
4119         struct nid_path *path;
4120         int n;
4121
4122         snd_array_for_each(&spec->paths, n, path) {
4123                 if (!path->depth)
4124                         continue;
4125                 if (path->path[0] == nid ||
4126                     path->path[path->depth - 1] == nid) {
4127                         bool pin_old = path->pin_enabled;
4128                         bool stream_old = path->stream_enabled;
4129
4130                         if (pin_state >= 0)
4131                                 path->pin_enabled = pin_state;
4132                         if (stream_state >= 0)
4133                                 path->stream_enabled = stream_state;
4134                         if ((!path->pin_fixed && path->pin_enabled != pin_old)
4135                             || path->stream_enabled != stream_old) {
4136                                 last = path_power_update(codec, path, true);
4137                                 if (last)
4138                                         changed = last;
4139                         }
4140                 }
4141         }
4142         return changed;
4143 }
4144
4145 /* check the jack status for power control */
4146 static bool detect_pin_state(struct hda_codec *codec, hda_nid_t pin)
4147 {
4148         if (!is_jack_detectable(codec, pin))
4149                 return true;
4150         return snd_hda_jack_detect_state(codec, pin) != HDA_JACK_NOT_PRESENT;
4151 }
4152
4153 /* power up/down the paths of the given pin according to the jack state;
4154  * power = 0/1 : only power up/down if it matches with the jack state,
4155  *       < 0   : force power up/down to follow the jack sate
4156  *
4157  * returns the last changed NID, or zero if unchanged.
4158  */
4159 static hda_nid_t set_pin_power_jack(struct hda_codec *codec, hda_nid_t pin,
4160                                     int power)
4161 {
4162         bool on;
4163
4164         if (!codec->power_save_node)
4165                 return 0;
4166
4167         on = detect_pin_state(codec, pin);
4168
4169         if (power >= 0 && on != power)
4170                 return 0;
4171         return set_path_power(codec, pin, on, -1);
4172 }
4173
4174 static void pin_power_callback(struct hda_codec *codec,
4175                                struct hda_jack_callback *jack,
4176                                bool on)
4177 {
4178         if (jack && jack->nid)
4179                 sync_power_state_change(codec,
4180                                         set_pin_power_jack(codec, jack->nid, on));
4181 }
4182
4183 /* callback only doing power up -- called at first */
4184 static void pin_power_up_callback(struct hda_codec *codec,
4185                                   struct hda_jack_callback *jack)
4186 {
4187         pin_power_callback(codec, jack, true);
4188 }
4189
4190 /* callback only doing power down -- called at last */
4191 static void pin_power_down_callback(struct hda_codec *codec,
4192                                     struct hda_jack_callback *jack)
4193 {
4194         pin_power_callback(codec, jack, false);
4195 }
4196
4197 /* set up the power up/down callbacks */
4198 static void add_pin_power_ctls(struct hda_codec *codec, int num_pins,
4199                                const hda_nid_t *pins, bool on)
4200 {
4201         int i;
4202         hda_jack_callback_fn cb =
4203                 on ? pin_power_up_callback : pin_power_down_callback;
4204
4205         for (i = 0; i < num_pins && pins[i]; i++) {
4206                 if (is_jack_detectable(codec, pins[i]))
4207                         snd_hda_jack_detect_enable_callback(codec, pins[i], cb);
4208                 else
4209                         set_path_power(codec, pins[i], true, -1);
4210         }
4211 }
4212
4213 /* enabled power callback to each available I/O pin with jack detections;
4214  * the digital I/O pins are excluded because of the unreliable detectsion
4215  */
4216 static void add_all_pin_power_ctls(struct hda_codec *codec, bool on)
4217 {
4218         struct hda_gen_spec *spec = codec->spec;
4219         struct auto_pin_cfg *cfg = &spec->autocfg;
4220         int i;
4221
4222         if (!codec->power_save_node)
4223                 return;
4224         add_pin_power_ctls(codec, cfg->line_outs, cfg->line_out_pins, on);
4225         if (cfg->line_out_type != AUTO_PIN_HP_OUT)
4226                 add_pin_power_ctls(codec, cfg->hp_outs, cfg->hp_pins, on);
4227         if (cfg->line_out_type != AUTO_PIN_SPEAKER_OUT)
4228                 add_pin_power_ctls(codec, cfg->speaker_outs, cfg->speaker_pins, on);
4229         for (i = 0; i < cfg->num_inputs; i++)
4230                 add_pin_power_ctls(codec, 1, &cfg->inputs[i].pin, on);
4231 }
4232
4233 /* sync path power up/down with the jack states of given pins */
4234 static void sync_pin_power_ctls(struct hda_codec *codec, int num_pins,
4235                                 const hda_nid_t *pins)
4236 {
4237         int i;
4238
4239         for (i = 0; i < num_pins && pins[i]; i++)
4240                 if (is_jack_detectable(codec, pins[i]))
4241                         set_pin_power_jack(codec, pins[i], -1);
4242 }
4243
4244 /* sync path power up/down with pins; called at init and resume */
4245 static void sync_all_pin_power_ctls(struct hda_codec *codec)
4246 {
4247         struct hda_gen_spec *spec = codec->spec;
4248         struct auto_pin_cfg *cfg = &spec->autocfg;
4249         int i;
4250
4251         if (!codec->power_save_node)
4252                 return;
4253         sync_pin_power_ctls(codec, cfg->line_outs, cfg->line_out_pins);
4254         if (cfg->line_out_type != AUTO_PIN_HP_OUT)
4255                 sync_pin_power_ctls(codec, cfg->hp_outs, cfg->hp_pins);
4256         if (cfg->line_out_type != AUTO_PIN_SPEAKER_OUT)
4257                 sync_pin_power_ctls(codec, cfg->speaker_outs, cfg->speaker_pins);
4258         for (i = 0; i < cfg->num_inputs; i++)
4259                 sync_pin_power_ctls(codec, 1, &cfg->inputs[i].pin);
4260 }
4261
4262 /* add fake paths if not present yet */
4263 static int add_fake_paths(struct hda_codec *codec, hda_nid_t nid,
4264                            int num_pins, const hda_nid_t *pins)
4265 {
4266         struct hda_gen_spec *spec = codec->spec;
4267         struct nid_path *path;
4268         int i;
4269
4270         for (i = 0; i < num_pins; i++) {
4271                 if (!pins[i])
4272                         break;
4273                 if (get_nid_path(codec, nid, pins[i], 0))
4274                         continue;
4275                 path = snd_array_new(&spec->paths);
4276                 if (!path)
4277                         return -ENOMEM;
4278                 memset(path, 0, sizeof(*path));
4279                 path->depth = 2;
4280                 path->path[0] = nid;
4281                 path->path[1] = pins[i];
4282                 path->active = true;
4283         }
4284         return 0;
4285 }
4286
4287 /* create fake paths to all outputs from beep */
4288 static int add_fake_beep_paths(struct hda_codec *codec)
4289 {
4290         struct hda_gen_spec *spec = codec->spec;
4291         struct auto_pin_cfg *cfg = &spec->autocfg;
4292         hda_nid_t nid = spec->beep_nid;
4293         int err;
4294
4295         if (!codec->power_save_node || !nid)
4296                 return 0;
4297         err = add_fake_paths(codec, nid, cfg->line_outs, cfg->line_out_pins);
4298         if (err < 0)
4299                 return err;
4300         if (cfg->line_out_type != AUTO_PIN_HP_OUT) {
4301                 err = add_fake_paths(codec, nid, cfg->hp_outs, cfg->hp_pins);
4302                 if (err < 0)
4303                         return err;
4304         }
4305         if (cfg->line_out_type != AUTO_PIN_SPEAKER_OUT) {
4306                 err = add_fake_paths(codec, nid, cfg->speaker_outs,
4307                                      cfg->speaker_pins);
4308                 if (err < 0)
4309                         return err;
4310         }
4311         return 0;
4312 }
4313
4314 /* power up/down beep widget and its output paths */
4315 static void beep_power_hook(struct hda_beep *beep, bool on)
4316 {
4317         set_path_power(beep->codec, beep->nid, -1, on);
4318 }
4319
4320 /**
4321  * snd_hda_gen_fix_pin_power - Fix the power of the given pin widget to D0
4322  * @codec: the HDA codec
4323  * @pin: NID of pin to fix
4324  */
4325 int snd_hda_gen_fix_pin_power(struct hda_codec *codec, hda_nid_t pin)
4326 {
4327         struct hda_gen_spec *spec = codec->spec;
4328         struct nid_path *path;
4329
4330         path = snd_array_new(&spec->paths);
4331         if (!path)
4332                 return -ENOMEM;
4333         memset(path, 0, sizeof(*path));
4334         path->depth = 1;
4335         path->path[0] = pin;
4336         path->active = true;
4337         path->pin_fixed = true;
4338         path->stream_enabled = true;
4339         return 0;
4340 }
4341 EXPORT_SYMBOL_GPL(snd_hda_gen_fix_pin_power);
4342
4343 /*
4344  * Jack detections for HP auto-mute and mic-switch
4345  */
4346
4347 /* check each pin in the given array; returns true if any of them is plugged */
4348 static bool detect_jacks(struct hda_codec *codec, int num_pins, const hda_nid_t *pins)
4349 {
4350         int i;
4351         bool present = false;
4352
4353         for (i = 0; i < num_pins; i++) {
4354                 hda_nid_t nid = pins[i];
4355                 if (!nid)
4356                         break;
4357                 /* don't detect pins retasked as inputs */
4358                 if (snd_hda_codec_get_pin_target(codec, nid) & AC_PINCTL_IN_EN)
4359                         continue;
4360                 if (snd_hda_jack_detect_state(codec, nid) == HDA_JACK_PRESENT)
4361                         present = true;
4362         }
4363         return present;
4364 }
4365
4366 /* standard HP/line-out auto-mute helper */
4367 static void do_automute(struct hda_codec *codec, int num_pins, const hda_nid_t *pins,
4368                         int *paths, bool mute)
4369 {
4370         struct hda_gen_spec *spec = codec->spec;
4371         int i;
4372
4373         for (i = 0; i < num_pins; i++) {
4374                 hda_nid_t nid = pins[i];
4375                 unsigned int val, oldval;
4376                 if (!nid)
4377                         break;
4378
4379                 oldval = snd_hda_codec_get_pin_target(codec, nid);
4380                 if (oldval & PIN_IN)
4381                         continue; /* no mute for inputs */
4382
4383                 if (spec->auto_mute_via_amp) {
4384                         struct nid_path *path;
4385                         hda_nid_t mute_nid;
4386
4387                         path = snd_hda_get_path_from_idx(codec, paths[i]);
4388                         if (!path)
4389                                 continue;
4390                         mute_nid = get_amp_nid_(path->ctls[NID_PATH_MUTE_CTL]);
4391                         if (!mute_nid)
4392                                 continue;
4393                         if (mute)
4394                                 spec->mute_bits |= (1ULL << mute_nid);
4395                         else
4396                                 spec->mute_bits &= ~(1ULL << mute_nid);
4397                         continue;
4398                 } else {
4399                         /* don't reset VREF value in case it's controlling
4400                          * the amp (see alc861_fixup_asus_amp_vref_0f())
4401                          */
4402                         if (spec->keep_vref_in_automute)
4403                                 val = oldval & ~PIN_HP;
4404                         else
4405                                 val = 0;
4406                         if (!mute)
4407                                 val |= oldval;
4408                         /* here we call update_pin_ctl() so that the pinctl is
4409                          * changed without changing the pinctl target value;
4410                          * the original target value will be still referred at
4411                          * the init / resume again
4412                          */
4413                         update_pin_ctl(codec, nid, val);
4414                 }
4415
4416                 set_pin_eapd(codec, nid, !mute);
4417                 if (codec->power_save_node) {
4418                         bool on = !mute;
4419                         if (on)
4420                                 on = detect_pin_state(codec, nid);
4421                         set_path_power(codec, nid, on, -1);
4422                 }
4423         }
4424 }
4425
4426 /**
4427  * snd_hda_gen_update_outputs - Toggle outputs muting
4428  * @codec: the HDA codec
4429  *
4430  * Update the mute status of all outputs based on the current jack states.
4431  */
4432 void snd_hda_gen_update_outputs(struct hda_codec *codec)
4433 {
4434         struct hda_gen_spec *spec = codec->spec;
4435         int *paths;
4436         int on;
4437
4438         /* Control HP pins/amps depending on master_mute state;
4439          * in general, HP pins/amps control should be enabled in all cases,
4440          * but currently set only for master_mute, just to be safe
4441          */
4442         if (spec->autocfg.line_out_type == AUTO_PIN_HP_OUT)
4443                 paths = spec->out_paths;
4444         else
4445                 paths = spec->hp_paths;
4446         do_automute(codec, ARRAY_SIZE(spec->autocfg.hp_pins),
4447                     spec->autocfg.hp_pins, paths, spec->master_mute);
4448
4449         if (!spec->automute_speaker)
4450                 on = 0;
4451         else
4452                 on = spec->hp_jack_present | spec->line_jack_present;
4453         on |= spec->master_mute;
4454         spec->speaker_muted = on;
4455         if (spec->autocfg.line_out_type == AUTO_PIN_SPEAKER_OUT)
4456                 paths = spec->out_paths;
4457         else
4458                 paths = spec->speaker_paths;
4459         do_automute(codec, ARRAY_SIZE(spec->autocfg.speaker_pins),
4460                     spec->autocfg.speaker_pins, paths, on);
4461
4462         /* toggle line-out mutes if needed, too */
4463         /* if LO is a copy of either HP or Speaker, don't need to handle it */
4464         if (spec->autocfg.line_out_pins[0] == spec->autocfg.hp_pins[0] ||
4465             spec->autocfg.line_out_pins[0] == spec->autocfg.speaker_pins[0])
4466                 return;
4467         if (!spec->automute_lo)
4468                 on = 0;
4469         else
4470                 on = spec->hp_jack_present;
4471         on |= spec->master_mute;
4472         spec->line_out_muted = on;
4473         paths = spec->out_paths;
4474         do_automute(codec, ARRAY_SIZE(spec->autocfg.line_out_pins),
4475                     spec->autocfg.line_out_pins, paths, on);
4476 }
4477 EXPORT_SYMBOL_GPL(snd_hda_gen_update_outputs);
4478
4479 static void call_update_outputs(struct hda_codec *codec)
4480 {
4481         struct hda_gen_spec *spec = codec->spec;
4482         if (spec->automute_hook)
4483                 spec->automute_hook(codec);
4484         else
4485                 snd_hda_gen_update_outputs(codec);
4486
4487         /* sync the whole vmaster followers to reflect the new auto-mute status */
4488         if (spec->auto_mute_via_amp && !codec->bus->shutdown)
4489                 snd_ctl_sync_vmaster(spec->vmaster_mute.sw_kctl, false);
4490 }
4491
4492 /**
4493  * snd_hda_gen_hp_automute - standard HP-automute helper
4494  * @codec: the HDA codec
4495  * @jack: jack object, NULL for the whole
4496  */
4497 void snd_hda_gen_hp_automute(struct hda_codec *codec,
4498                              struct hda_jack_callback *jack)
4499 {
4500         struct hda_gen_spec *spec = codec->spec;
4501         hda_nid_t *pins = spec->autocfg.hp_pins;
4502         int num_pins = ARRAY_SIZE(spec->autocfg.hp_pins);
4503
4504         /* No detection for the first HP jack during indep-HP mode */
4505         if (spec->indep_hp_enabled) {
4506                 pins++;
4507                 num_pins--;
4508         }
4509
4510         spec->hp_jack_present = detect_jacks(codec, num_pins, pins);
4511         if (!spec->detect_hp || (!spec->automute_speaker && !spec->automute_lo))
4512                 return;
4513         call_update_outputs(codec);
4514 }
4515 EXPORT_SYMBOL_GPL(snd_hda_gen_hp_automute);
4516
4517 /**
4518  * snd_hda_gen_line_automute - standard line-out-automute helper
4519  * @codec: the HDA codec
4520  * @jack: jack object, NULL for the whole
4521  */
4522 void snd_hda_gen_line_automute(struct hda_codec *codec,
4523                                struct hda_jack_callback *jack)
4524 {
4525         struct hda_gen_spec *spec = codec->spec;
4526
4527         if (spec->autocfg.line_out_type == AUTO_PIN_SPEAKER_OUT)
4528                 return;
4529         /* check LO jack only when it's different from HP */
4530         if (spec->autocfg.line_out_pins[0] == spec->autocfg.hp_pins[0])
4531                 return;
4532
4533         spec->line_jack_present =
4534                 detect_jacks(codec, ARRAY_SIZE(spec->autocfg.line_out_pins),
4535                              spec->autocfg.line_out_pins);
4536         if (!spec->automute_speaker || !spec->detect_lo)
4537                 return;
4538         call_update_outputs(codec);
4539 }
4540 EXPORT_SYMBOL_GPL(snd_hda_gen_line_automute);
4541
4542 /**
4543  * snd_hda_gen_mic_autoswitch - standard mic auto-switch helper
4544  * @codec: the HDA codec
4545  * @jack: jack object, NULL for the whole
4546  */
4547 void snd_hda_gen_mic_autoswitch(struct hda_codec *codec,
4548                                 struct hda_jack_callback *jack)
4549 {
4550         struct hda_gen_spec *spec = codec->spec;
4551         int i;
4552
4553         if (!spec->auto_mic)
4554                 return;
4555
4556         for (i = spec->am_num_entries - 1; i > 0; i--) {
4557                 hda_nid_t pin = spec->am_entry[i].pin;
4558                 /* don't detect pins retasked as outputs */
4559                 if (snd_hda_codec_get_pin_target(codec, pin) & AC_PINCTL_OUT_EN)
4560                         continue;
4561                 if (snd_hda_jack_detect_state(codec, pin) == HDA_JACK_PRESENT) {
4562                         mux_select(codec, 0, spec->am_entry[i].idx);
4563                         return;
4564                 }
4565         }
4566         mux_select(codec, 0, spec->am_entry[0].idx);
4567 }
4568 EXPORT_SYMBOL_GPL(snd_hda_gen_mic_autoswitch);
4569
4570 /* call appropriate hooks */
4571 static void call_hp_automute(struct hda_codec *codec,
4572                              struct hda_jack_callback *jack)
4573 {
4574         struct hda_gen_spec *spec = codec->spec;
4575         if (spec->hp_automute_hook)
4576                 spec->hp_automute_hook(codec, jack);
4577         else
4578                 snd_hda_gen_hp_automute(codec, jack);
4579 }
4580
4581 static void call_line_automute(struct hda_codec *codec,
4582                                struct hda_jack_callback *jack)
4583 {
4584         struct hda_gen_spec *spec = codec->spec;
4585         if (spec->line_automute_hook)
4586                 spec->line_automute_hook(codec, jack);
4587         else
4588                 snd_hda_gen_line_automute(codec, jack);
4589 }
4590
4591 static void call_mic_autoswitch(struct hda_codec *codec,
4592                                 struct hda_jack_callback *jack)
4593 {
4594         struct hda_gen_spec *spec = codec->spec;
4595         if (spec->mic_autoswitch_hook)
4596                 spec->mic_autoswitch_hook(codec, jack);
4597         else
4598                 snd_hda_gen_mic_autoswitch(codec, jack);
4599 }
4600
4601 /* update jack retasking */
4602 static void update_automute_all(struct hda_codec *codec)
4603 {
4604         call_hp_automute(codec, NULL);
4605         call_line_automute(codec, NULL);
4606         call_mic_autoswitch(codec, NULL);
4607 }
4608
4609 /*
4610  * Auto-Mute mode mixer enum support
4611  */
4612 static int automute_mode_info(struct snd_kcontrol *kcontrol,
4613                               struct snd_ctl_elem_info *uinfo)
4614 {
4615         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
4616         struct hda_gen_spec *spec = codec->spec;
4617         static const char * const texts3[] = {
4618                 "Disabled", "Speaker Only", "Line Out+Speaker"
4619         };
4620
4621         if (spec->automute_speaker_possible && spec->automute_lo_possible)
4622                 return snd_hda_enum_helper_info(kcontrol, uinfo, 3, texts3);
4623         return snd_hda_enum_bool_helper_info(kcontrol, uinfo);
4624 }
4625
4626 static int automute_mode_get(struct snd_kcontrol *kcontrol,
4627                              struct snd_ctl_elem_value *ucontrol)
4628 {
4629         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
4630         struct hda_gen_spec *spec = codec->spec;
4631         unsigned int val = 0;
4632         if (spec->automute_speaker)
4633                 val++;
4634         if (spec->automute_lo)
4635                 val++;
4636
4637         ucontrol->value.enumerated.item[0] = val;
4638         return 0;
4639 }
4640
4641 static int automute_mode_put(struct snd_kcontrol *kcontrol,
4642                              struct snd_ctl_elem_value *ucontrol)
4643 {
4644         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
4645         struct hda_gen_spec *spec = codec->spec;
4646
4647         switch (ucontrol->value.enumerated.item[0]) {
4648         case 0:
4649                 if (!spec->automute_speaker && !spec->automute_lo)
4650                         return 0;
4651                 spec->automute_speaker = 0;
4652                 spec->automute_lo = 0;
4653                 break;
4654         case 1:
4655                 if (spec->automute_speaker_possible) {
4656                         if (!spec->automute_lo && spec->automute_speaker)
4657                                 return 0;
4658                         spec->automute_speaker = 1;
4659                         spec->automute_lo = 0;
4660                 } else if (spec->automute_lo_possible) {
4661                         if (spec->automute_lo)
4662                                 return 0;
4663                         spec->automute_lo = 1;
4664                 } else
4665                         return -EINVAL;
4666                 break;
4667         case 2:
4668                 if (!spec->automute_lo_possible || !spec->automute_speaker_possible)
4669                         return -EINVAL;
4670                 if (spec->automute_speaker && spec->automute_lo)
4671                         return 0;
4672                 spec->automute_speaker = 1;
4673                 spec->automute_lo = 1;
4674                 break;
4675         default:
4676                 return -EINVAL;
4677         }
4678         call_update_outputs(codec);
4679         return 1;
4680 }
4681
4682 static const struct snd_kcontrol_new automute_mode_enum = {
4683         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
4684         .name = "Auto-Mute Mode",
4685         .info = automute_mode_info,
4686         .get = automute_mode_get,
4687         .put = automute_mode_put,
4688 };
4689
4690 static int add_automute_mode_enum(struct hda_codec *codec)
4691 {
4692         struct hda_gen_spec *spec = codec->spec;
4693
4694         if (!snd_hda_gen_add_kctl(spec, NULL, &automute_mode_enum))
4695                 return -ENOMEM;
4696         return 0;
4697 }
4698
4699 /*
4700  * Check the availability of HP/line-out auto-mute;
4701  * Set up appropriately if really supported
4702  */
4703 static int check_auto_mute_availability(struct hda_codec *codec)
4704 {
4705         struct hda_gen_spec *spec = codec->spec;
4706         struct auto_pin_cfg *cfg = &spec->autocfg;
4707         int present = 0;
4708         int i, err;
4709
4710         if (spec->suppress_auto_mute)
4711                 return 0;
4712
4713         if (cfg->hp_pins[0])
4714                 present++;
4715         if (cfg->line_out_pins[0])
4716                 present++;
4717         if (cfg->speaker_pins[0])
4718                 present++;
4719         if (present < 2) /* need two different output types */
4720                 return 0;
4721
4722         if (!cfg->speaker_pins[0] &&
4723             cfg->line_out_type == AUTO_PIN_SPEAKER_OUT) {
4724                 memcpy(cfg->speaker_pins, cfg->line_out_pins,
4725                        sizeof(cfg->speaker_pins));
4726                 cfg->speaker_outs = cfg->line_outs;
4727         }
4728
4729         if (!cfg->hp_pins[0] &&
4730             cfg->line_out_type == AUTO_PIN_HP_OUT) {
4731                 memcpy(cfg->hp_pins, cfg->line_out_pins,
4732                        sizeof(cfg->hp_pins));
4733                 cfg->hp_outs = cfg->line_outs;
4734         }
4735
4736         for (i = 0; i < cfg->hp_outs; i++) {
4737                 hda_nid_t nid = cfg->hp_pins[i];
4738                 if (!is_jack_detectable(codec, nid))
4739                         continue;
4740                 codec_dbg(codec, "Enable HP auto-muting on NID 0x%x\n", nid);
4741                 snd_hda_jack_detect_enable_callback(codec, nid,
4742                                                     call_hp_automute);
4743                 spec->detect_hp = 1;
4744         }
4745
4746         if (cfg->line_out_type == AUTO_PIN_LINE_OUT && cfg->line_outs) {
4747                 if (cfg->speaker_outs)
4748                         for (i = 0; i < cfg->line_outs; i++) {
4749                                 hda_nid_t nid = cfg->line_out_pins[i];
4750                                 if (!is_jack_detectable(codec, nid))
4751                                         continue;
4752                                 codec_dbg(codec, "Enable Line-Out auto-muting on NID 0x%x\n", nid);
4753                                 snd_hda_jack_detect_enable_callback(codec, nid,
4754                                                                     call_line_automute);
4755                                 spec->detect_lo = 1;
4756                         }
4757                 spec->automute_lo_possible = spec->detect_hp;
4758         }
4759
4760         spec->automute_speaker_possible = cfg->speaker_outs &&
4761                 (spec->detect_hp || spec->detect_lo);
4762
4763         spec->automute_lo = spec->automute_lo_possible;
4764         spec->automute_speaker = spec->automute_speaker_possible;
4765
4766         if (spec->automute_speaker_possible || spec->automute_lo_possible) {
4767                 /* create a control for automute mode */
4768                 err = add_automute_mode_enum(codec);
4769                 if (err < 0)
4770                         return err;
4771         }
4772         return 0;
4773 }
4774
4775 /* check whether all auto-mic pins are valid; setup indices if OK */
4776 static bool auto_mic_check_imux(struct hda_codec *codec)
4777 {
4778         struct hda_gen_spec *spec = codec->spec;
4779         const struct hda_input_mux *imux;
4780         int i;
4781
4782         imux = &spec->input_mux;
4783         for (i = 0; i < spec->am_num_entries; i++) {
4784                 spec->am_entry[i].idx =
4785                         find_idx_in_nid_list(spec->am_entry[i].pin,
4786                                              spec->imux_pins, imux->num_items);
4787                 if (spec->am_entry[i].idx < 0)
4788                         return false; /* no corresponding imux */
4789         }
4790
4791         /* we don't need the jack detection for the first pin */
4792         for (i = 1; i < spec->am_num_entries; i++)
4793                 snd_hda_jack_detect_enable_callback(codec,
4794                                                     spec->am_entry[i].pin,
4795                                                     call_mic_autoswitch);
4796         return true;
4797 }
4798
4799 static int compare_attr(const void *ap, const void *bp)
4800 {
4801         const struct automic_entry *a = ap;
4802         const struct automic_entry *b = bp;
4803         return (int)(a->attr - b->attr);
4804 }
4805
4806 /*
4807  * Check the availability of auto-mic switch;
4808  * Set up if really supported
4809  */
4810 static int check_auto_mic_availability(struct hda_codec *codec)
4811 {
4812         struct hda_gen_spec *spec = codec->spec;
4813         struct auto_pin_cfg *cfg = &spec->autocfg;
4814         unsigned int types;
4815         int i, num_pins;
4816
4817         if (spec->suppress_auto_mic)
4818                 return 0;
4819
4820         types = 0;
4821         num_pins = 0;
4822         for (i = 0; i < cfg->num_inputs; i++) {
4823                 hda_nid_t nid = cfg->inputs[i].pin;
4824                 unsigned int attr;
4825                 attr = snd_hda_codec_get_pincfg(codec, nid);
4826                 attr = snd_hda_get_input_pin_attr(attr);
4827                 if (types & (1 << attr))
4828                         return 0; /* already occupied */
4829                 switch (attr) {
4830                 case INPUT_PIN_ATTR_INT:
4831                         if (cfg->inputs[i].type != AUTO_PIN_MIC)
4832                                 return 0; /* invalid type */
4833                         break;
4834                 case INPUT_PIN_ATTR_UNUSED:
4835                         return 0; /* invalid entry */
4836                 default:
4837                         if (cfg->inputs[i].type > AUTO_PIN_LINE_IN)
4838                                 return 0; /* invalid type */
4839                         if (!spec->line_in_auto_switch &&
4840                             cfg->inputs[i].type != AUTO_PIN_MIC)
4841                                 return 0; /* only mic is allowed */
4842                         if (!is_jack_detectable(codec, nid))
4843                                 return 0; /* no unsol support */
4844                         break;
4845                 }
4846                 if (num_pins >= MAX_AUTO_MIC_PINS)
4847                         return 0;
4848                 types |= (1 << attr);
4849                 spec->am_entry[num_pins].pin = nid;
4850                 spec->am_entry[num_pins].attr = attr;
4851                 num_pins++;
4852         }
4853
4854         if (num_pins < 2)
4855                 return 0;
4856
4857         spec->am_num_entries = num_pins;
4858         /* sort the am_entry in the order of attr so that the pin with a
4859          * higher attr will be selected when the jack is plugged.
4860          */
4861         sort(spec->am_entry, num_pins, sizeof(spec->am_entry[0]),
4862              compare_attr, NULL);
4863
4864         if (!auto_mic_check_imux(codec))
4865                 return 0;
4866
4867         spec->auto_mic = 1;
4868         spec->num_adc_nids = 1;
4869         spec->cur_mux[0] = spec->am_entry[0].idx;
4870         codec_dbg(codec, "Enable auto-mic switch on NID 0x%x/0x%x/0x%x\n",
4871                     spec->am_entry[0].pin,
4872                     spec->am_entry[1].pin,
4873                     spec->am_entry[2].pin);
4874
4875         return 0;
4876 }
4877
4878 /**
4879  * snd_hda_gen_path_power_filter - power_filter hook to make inactive widgets
4880  * into power down
4881  * @codec: the HDA codec
4882  * @nid: NID to evalute
4883  * @power_state: target power state
4884  */
4885 unsigned int snd_hda_gen_path_power_filter(struct hda_codec *codec,
4886                                                   hda_nid_t nid,
4887                                                   unsigned int power_state)
4888 {
4889         struct hda_gen_spec *spec = codec->spec;
4890
4891         if (!spec->power_down_unused && !codec->power_save_node)
4892                 return power_state;
4893         if (power_state != AC_PWRST_D0 || nid == codec->core.afg)
4894                 return power_state;
4895         if (get_wcaps_type(get_wcaps(codec, nid)) >= AC_WID_POWER)
4896                 return power_state;
4897         if (is_active_nid_for_any(codec, nid))
4898                 return power_state;
4899         return AC_PWRST_D3;
4900 }
4901 EXPORT_SYMBOL_GPL(snd_hda_gen_path_power_filter);
4902
4903 /* mute all aamix inputs initially; parse up to the first leaves */
4904 static void mute_all_mixer_nid(struct hda_codec *codec, hda_nid_t mix)
4905 {
4906         int i, nums;
4907         const hda_nid_t *conn;
4908         bool has_amp;
4909
4910         nums = snd_hda_get_conn_list(codec, mix, &conn);
4911         has_amp = nid_has_mute(codec, mix, HDA_INPUT);
4912         for (i = 0; i < nums; i++) {
4913                 if (has_amp)
4914                         update_amp(codec, mix, HDA_INPUT, i,
4915                                    0xff, HDA_AMP_MUTE);
4916                 else if (nid_has_volume(codec, conn[i], HDA_OUTPUT))
4917                         update_amp(codec, conn[i], HDA_OUTPUT, 0,
4918                                    0xff, HDA_AMP_MUTE);
4919         }
4920 }
4921
4922 /**
4923  * snd_hda_gen_stream_pm - Stream power management callback
4924  * @codec: the HDA codec
4925  * @nid: audio widget
4926  * @on: power on/off flag
4927  *
4928  * Set this in patch_ops.stream_pm.  Only valid with power_save_node flag.
4929  */
4930 void snd_hda_gen_stream_pm(struct hda_codec *codec, hda_nid_t nid, bool on)
4931 {
4932         if (codec->power_save_node)
4933                 set_path_power(codec, nid, -1, on);
4934 }
4935 EXPORT_SYMBOL_GPL(snd_hda_gen_stream_pm);
4936
4937 /**
4938  * snd_hda_gen_parse_auto_config - Parse the given BIOS configuration and
4939  * set up the hda_gen_spec
4940  * @codec: the HDA codec
4941  * @cfg: Parsed pin configuration
4942  *
4943  * return 1 if successful, 0 if the proper config is not found,
4944  * or a negative error code
4945  */
4946 int snd_hda_gen_parse_auto_config(struct hda_codec *codec,
4947                                   struct auto_pin_cfg *cfg)
4948 {
4949         struct hda_gen_spec *spec = codec->spec;
4950         int err;
4951
4952         parse_user_hints(codec);
4953
4954         if (spec->vmaster_mute_led || spec->mic_mute_led)
4955                 snd_ctl_led_request();
4956
4957         if (spec->mixer_nid && !spec->mixer_merge_nid)
4958                 spec->mixer_merge_nid = spec->mixer_nid;
4959
4960         if (cfg != &spec->autocfg) {
4961                 spec->autocfg = *cfg;
4962                 cfg = &spec->autocfg;
4963         }
4964
4965         if (!spec->main_out_badness)
4966                 spec->main_out_badness = &hda_main_out_badness;
4967         if (!spec->extra_out_badness)
4968                 spec->extra_out_badness = &hda_extra_out_badness;
4969
4970         fill_all_dac_nids(codec);
4971
4972         if (!cfg->line_outs) {
4973                 if (cfg->dig_outs || cfg->dig_in_pin) {
4974                         spec->multiout.max_channels = 2;
4975                         spec->no_analog = 1;
4976                         goto dig_only;
4977                 }
4978                 if (!cfg->num_inputs && !cfg->dig_in_pin)
4979                         return 0; /* can't find valid BIOS pin config */
4980         }
4981
4982         if (!spec->no_primary_hp &&
4983             cfg->line_out_type == AUTO_PIN_SPEAKER_OUT &&
4984             cfg->line_outs <= cfg->hp_outs) {
4985                 /* use HP as primary out */
4986                 cfg->speaker_outs = cfg->line_outs;
4987                 memcpy(cfg->speaker_pins, cfg->line_out_pins,
4988                        sizeof(cfg->speaker_pins));
4989                 cfg->line_outs = cfg->hp_outs;
4990                 memcpy(cfg->line_out_pins, cfg->hp_pins, sizeof(cfg->hp_pins));
4991                 cfg->hp_outs = 0;
4992                 memset(cfg->hp_pins, 0, sizeof(cfg->hp_pins));
4993                 cfg->line_out_type = AUTO_PIN_HP_OUT;
4994         }
4995
4996         err = parse_output_paths(codec);
4997         if (err < 0)
4998                 return err;
4999         err = create_multi_channel_mode(codec);
5000         if (err < 0)
5001                 return err;
5002         err = create_multi_out_ctls(codec, cfg);
5003         if (err < 0)
5004                 return err;
5005         err = create_hp_out_ctls(codec);
5006         if (err < 0)
5007                 return err;
5008         err = create_speaker_out_ctls(codec);
5009         if (err < 0)
5010                 return err;
5011         err = create_indep_hp_ctls(codec);
5012         if (err < 0)
5013                 return err;
5014         err = create_loopback_mixing_ctl(codec);
5015         if (err < 0)
5016                 return err;
5017         err = create_hp_mic(codec);
5018         if (err < 0)
5019                 return err;
5020         err = create_input_ctls(codec);
5021         if (err < 0)
5022                 return err;
5023
5024         /* add power-down pin callbacks at first */
5025         add_all_pin_power_ctls(codec, false);
5026
5027         spec->const_channel_count = spec->ext_channel_count;
5028         /* check the multiple speaker and headphone pins */
5029         if (cfg->line_out_type != AUTO_PIN_SPEAKER_OUT)
5030                 spec->const_channel_count = max(spec->const_channel_count,
5031                                                 cfg->speaker_outs * 2);
5032         if (cfg->line_out_type != AUTO_PIN_HP_OUT)
5033                 spec->const_channel_count = max(spec->const_channel_count,
5034                                                 cfg->hp_outs * 2);
5035         spec->multiout.max_channels = max(spec->ext_channel_count,
5036                                           spec->const_channel_count);
5037
5038         err = check_auto_mute_availability(codec);
5039         if (err < 0)
5040                 return err;
5041
5042         err = check_dyn_adc_switch(codec);
5043         if (err < 0)
5044                 return err;
5045
5046         err = check_auto_mic_availability(codec);
5047         if (err < 0)
5048                 return err;
5049
5050         /* add stereo mix if available and not enabled yet */
5051         if (!spec->auto_mic && spec->mixer_nid &&
5052             spec->add_stereo_mix_input == HDA_HINT_STEREO_MIX_AUTO &&
5053             spec->input_mux.num_items > 1) {
5054                 err = parse_capture_source(codec, spec->mixer_nid,
5055                                            CFG_IDX_MIX, spec->num_all_adcs,
5056                                            "Stereo Mix", 0);
5057                 if (err < 0)
5058                         return err;
5059         }
5060
5061
5062         err = create_capture_mixers(codec);
5063         if (err < 0)
5064                 return err;
5065
5066         err = parse_mic_boost(codec);
5067         if (err < 0)
5068                 return err;
5069
5070         /* create "Headphone Mic Jack Mode" if no input selection is
5071          * available (or user specifies add_jack_modes hint)
5072          */
5073         if (spec->hp_mic_pin &&
5074             (spec->auto_mic || spec->input_mux.num_items == 1 ||
5075              spec->add_jack_modes)) {
5076                 err = create_hp_mic_jack_mode(codec, spec->hp_mic_pin);
5077                 if (err < 0)
5078                         return err;
5079         }
5080
5081         if (spec->add_jack_modes) {
5082                 if (cfg->line_out_type != AUTO_PIN_SPEAKER_OUT) {
5083                         err = create_out_jack_modes(codec, cfg->line_outs,
5084                                                     cfg->line_out_pins);
5085                         if (err < 0)
5086                                 return err;
5087                 }
5088                 if (cfg->line_out_type != AUTO_PIN_HP_OUT) {
5089                         err = create_out_jack_modes(codec, cfg->hp_outs,
5090                                                     cfg->hp_pins);
5091                         if (err < 0)
5092                                 return err;
5093                 }
5094         }
5095
5096         /* add power-up pin callbacks at last */
5097         add_all_pin_power_ctls(codec, true);
5098
5099         /* mute all aamix input initially */
5100         if (spec->mixer_nid)
5101                 mute_all_mixer_nid(codec, spec->mixer_nid);
5102
5103  dig_only:
5104         parse_digital(codec);
5105
5106         if (spec->power_down_unused || codec->power_save_node) {
5107                 if (!codec->power_filter)
5108                         codec->power_filter = snd_hda_gen_path_power_filter;
5109                 if (!codec->patch_ops.stream_pm)
5110                         codec->patch_ops.stream_pm = snd_hda_gen_stream_pm;
5111         }
5112
5113         if (!spec->no_analog && spec->beep_nid) {
5114                 err = snd_hda_attach_beep_device(codec, spec->beep_nid);
5115                 if (err < 0)
5116                         return err;
5117                 if (codec->beep && codec->power_save_node) {
5118                         err = add_fake_beep_paths(codec);
5119                         if (err < 0)
5120                                 return err;
5121                         codec->beep->power_hook = beep_power_hook;
5122                 }
5123         }
5124
5125         return 1;
5126 }
5127 EXPORT_SYMBOL_GPL(snd_hda_gen_parse_auto_config);
5128
5129
5130 /*
5131  * Build control elements
5132  */
5133
5134 /* follower controls for virtual master */
5135 static const char * const follower_pfxs[] = {
5136         "Front", "Surround", "Center", "LFE", "Side",
5137         "Headphone", "Speaker", "Mono", "Line Out",
5138         "CLFE", "Bass Speaker", "PCM",
5139         "Speaker Front", "Speaker Surround", "Speaker CLFE", "Speaker Side",
5140         "Headphone Front", "Headphone Surround", "Headphone CLFE",
5141         "Headphone Side", "Headphone+LO", "Speaker+LO",
5142         NULL,
5143 };
5144
5145 /**
5146  * snd_hda_gen_build_controls - Build controls from the parsed results
5147  * @codec: the HDA codec
5148  *
5149  * Pass this to build_controls patch_ops.
5150  */
5151 int snd_hda_gen_build_controls(struct hda_codec *codec)
5152 {
5153         struct hda_gen_spec *spec = codec->spec;
5154         int err;
5155
5156         if (spec->kctls.used) {
5157                 err = snd_hda_add_new_ctls(codec, spec->kctls.list);
5158                 if (err < 0)
5159                         return err;
5160         }
5161
5162         if (spec->multiout.dig_out_nid) {
5163                 err = snd_hda_create_dig_out_ctls(codec,
5164                                                   spec->multiout.dig_out_nid,
5165                                                   spec->multiout.dig_out_nid,
5166                                                   spec->pcm_rec[1]->pcm_type);
5167                 if (err < 0)
5168                         return err;
5169                 if (!spec->no_analog) {
5170                         err = snd_hda_create_spdif_share_sw(codec,
5171                                                             &spec->multiout);
5172                         if (err < 0)
5173                                 return err;
5174                         spec->multiout.share_spdif = 1;
5175                 }
5176         }
5177         if (spec->dig_in_nid) {
5178                 err = snd_hda_create_spdif_in_ctls(codec, spec->dig_in_nid);
5179                 if (err < 0)
5180                         return err;
5181         }
5182
5183         /* if we have no master control, let's create it */
5184         if (!spec->no_analog && !spec->suppress_vmaster &&
5185             !snd_hda_find_mixer_ctl(codec, "Master Playback Volume")) {
5186                 err = snd_hda_add_vmaster(codec, "Master Playback Volume",
5187                                           spec->vmaster_tlv, follower_pfxs,
5188                                           "Playback Volume", 0);
5189                 if (err < 0)
5190                         return err;
5191         }
5192         if (!spec->no_analog && !spec->suppress_vmaster &&
5193             !snd_hda_find_mixer_ctl(codec, "Master Playback Switch")) {
5194                 err = __snd_hda_add_vmaster(codec, "Master Playback Switch",
5195                                             NULL, follower_pfxs,
5196                                             "Playback Switch", true,
5197                                             spec->vmaster_mute_led ?
5198                                                 SNDRV_CTL_ELEM_ACCESS_SPK_LED : 0,
5199                                             &spec->vmaster_mute.sw_kctl);
5200                 if (err < 0)
5201                         return err;
5202                 if (spec->vmaster_mute.hook) {
5203                         snd_hda_add_vmaster_hook(codec, &spec->vmaster_mute);
5204                         snd_hda_sync_vmaster_hook(&spec->vmaster_mute);
5205                 }
5206         }
5207
5208         free_kctls(spec); /* no longer needed */
5209
5210         err = snd_hda_jack_add_kctls(codec, &spec->autocfg);
5211         if (err < 0)
5212                 return err;
5213
5214         return 0;
5215 }
5216 EXPORT_SYMBOL_GPL(snd_hda_gen_build_controls);
5217
5218
5219 /*
5220  * PCM definitions
5221  */
5222
5223 static void call_pcm_playback_hook(struct hda_pcm_stream *hinfo,
5224                                    struct hda_codec *codec,
5225                                    struct snd_pcm_substream *substream,
5226                                    int action)
5227 {
5228         struct hda_gen_spec *spec = codec->spec;
5229         if (spec->pcm_playback_hook)
5230                 spec->pcm_playback_hook(hinfo, codec, substream, action);
5231 }
5232
5233 static void call_pcm_capture_hook(struct hda_pcm_stream *hinfo,
5234                                   struct hda_codec *codec,
5235                                   struct snd_pcm_substream *substream,
5236                                   int action)
5237 {
5238         struct hda_gen_spec *spec = codec->spec;
5239         if (spec->pcm_capture_hook)
5240                 spec->pcm_capture_hook(hinfo, codec, substream, action);
5241 }
5242
5243 /*
5244  * Analog playback callbacks
5245  */
5246 static int playback_pcm_open(struct hda_pcm_stream *hinfo,
5247                              struct hda_codec *codec,
5248                              struct snd_pcm_substream *substream)
5249 {
5250         struct hda_gen_spec *spec = codec->spec;
5251         int err;
5252
5253         mutex_lock(&spec->pcm_mutex);
5254         err = snd_hda_multi_out_analog_open(codec,
5255                                             &spec->multiout, substream,
5256                                              hinfo);
5257         if (!err) {
5258                 spec->active_streams |= 1 << STREAM_MULTI_OUT;
5259                 call_pcm_playback_hook(hinfo, codec, substream,
5260                                        HDA_GEN_PCM_ACT_OPEN);
5261         }
5262         mutex_unlock(&spec->pcm_mutex);
5263         return err;
5264 }
5265
5266 static int playback_pcm_prepare(struct hda_pcm_stream *hinfo,
5267                                 struct hda_codec *codec,
5268                                 unsigned int stream_tag,
5269                                 unsigned int format,
5270                                 struct snd_pcm_substream *substream)
5271 {
5272         struct hda_gen_spec *spec = codec->spec;
5273         int err;
5274
5275         err = snd_hda_multi_out_analog_prepare(codec, &spec->multiout,
5276                                                stream_tag, format, substream);
5277         if (!err)
5278                 call_pcm_playback_hook(hinfo, codec, substream,
5279                                        HDA_GEN_PCM_ACT_PREPARE);
5280         return err;
5281 }
5282
5283 static int playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
5284                                 struct hda_codec *codec,
5285                                 struct snd_pcm_substream *substream)
5286 {
5287         struct hda_gen_spec *spec = codec->spec;
5288         int err;
5289
5290         err = snd_hda_multi_out_analog_cleanup(codec, &spec->multiout);
5291         if (!err)
5292                 call_pcm_playback_hook(hinfo, codec, substream,
5293                                        HDA_GEN_PCM_ACT_CLEANUP);
5294         return err;
5295 }
5296
5297 static int playback_pcm_close(struct hda_pcm_stream *hinfo,
5298                               struct hda_codec *codec,
5299                               struct snd_pcm_substream *substream)
5300 {
5301         struct hda_gen_spec *spec = codec->spec;
5302         mutex_lock(&spec->pcm_mutex);
5303         spec->active_streams &= ~(1 << STREAM_MULTI_OUT);
5304         call_pcm_playback_hook(hinfo, codec, substream,
5305                                HDA_GEN_PCM_ACT_CLOSE);
5306         mutex_unlock(&spec->pcm_mutex);
5307         return 0;
5308 }
5309
5310 static int capture_pcm_open(struct hda_pcm_stream *hinfo,
5311                             struct hda_codec *codec,
5312                             struct snd_pcm_substream *substream)
5313 {
5314         call_pcm_capture_hook(hinfo, codec, substream, HDA_GEN_PCM_ACT_OPEN);
5315         return 0;
5316 }
5317
5318 static int capture_pcm_prepare(struct hda_pcm_stream *hinfo,
5319                                struct hda_codec *codec,
5320                                unsigned int stream_tag,
5321                                unsigned int format,
5322                                struct snd_pcm_substream *substream)
5323 {
5324         snd_hda_codec_setup_stream(codec, hinfo->nid, stream_tag, 0, format);
5325         call_pcm_capture_hook(hinfo, codec, substream,
5326                               HDA_GEN_PCM_ACT_PREPARE);
5327         return 0;
5328 }
5329
5330 static int capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
5331                                struct hda_codec *codec,
5332                                struct snd_pcm_substream *substream)
5333 {
5334         snd_hda_codec_cleanup_stream(codec, hinfo->nid);
5335         call_pcm_capture_hook(hinfo, codec, substream,
5336                               HDA_GEN_PCM_ACT_CLEANUP);
5337         return 0;
5338 }
5339
5340 static int capture_pcm_close(struct hda_pcm_stream *hinfo,
5341                              struct hda_codec *codec,
5342                              struct snd_pcm_substream *substream)
5343 {
5344         call_pcm_capture_hook(hinfo, codec, substream, HDA_GEN_PCM_ACT_CLOSE);
5345         return 0;
5346 }
5347
5348 static int alt_playback_pcm_open(struct hda_pcm_stream *hinfo,
5349                                  struct hda_codec *codec,
5350                                  struct snd_pcm_substream *substream)
5351 {
5352         struct hda_gen_spec *spec = codec->spec;
5353         int err = 0;
5354
5355         mutex_lock(&spec->pcm_mutex);
5356         if (spec->indep_hp && !spec->indep_hp_enabled)
5357                 err = -EBUSY;
5358         else
5359                 spec->active_streams |= 1 << STREAM_INDEP_HP;
5360         call_pcm_playback_hook(hinfo, codec, substream,
5361                                HDA_GEN_PCM_ACT_OPEN);
5362         mutex_unlock(&spec->pcm_mutex);
5363         return err;
5364 }
5365
5366 static int alt_playback_pcm_close(struct hda_pcm_stream *hinfo,
5367                                   struct hda_codec *codec,
5368                                   struct snd_pcm_substream *substream)
5369 {
5370         struct hda_gen_spec *spec = codec->spec;
5371         mutex_lock(&spec->pcm_mutex);
5372         spec->active_streams &= ~(1 << STREAM_INDEP_HP);
5373         call_pcm_playback_hook(hinfo, codec, substream,
5374                                HDA_GEN_PCM_ACT_CLOSE);
5375         mutex_unlock(&spec->pcm_mutex);
5376         return 0;
5377 }
5378
5379 static int alt_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
5380                                     struct hda_codec *codec,
5381                                     unsigned int stream_tag,
5382                                     unsigned int format,
5383                                     struct snd_pcm_substream *substream)
5384 {
5385         snd_hda_codec_setup_stream(codec, hinfo->nid, stream_tag, 0, format);
5386         call_pcm_playback_hook(hinfo, codec, substream,
5387                                HDA_GEN_PCM_ACT_PREPARE);
5388         return 0;
5389 }
5390
5391 static int alt_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
5392                                     struct hda_codec *codec,
5393                                     struct snd_pcm_substream *substream)
5394 {
5395         snd_hda_codec_cleanup_stream(codec, hinfo->nid);
5396         call_pcm_playback_hook(hinfo, codec, substream,
5397                                HDA_GEN_PCM_ACT_CLEANUP);
5398         return 0;
5399 }
5400
5401 /*
5402  * Digital out
5403  */
5404 static int dig_playback_pcm_open(struct hda_pcm_stream *hinfo,
5405                                  struct hda_codec *codec,
5406                                  struct snd_pcm_substream *substream)
5407 {
5408         struct hda_gen_spec *spec = codec->spec;
5409         return snd_hda_multi_out_dig_open(codec, &spec->multiout);
5410 }
5411
5412 static int dig_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
5413                                     struct hda_codec *codec,
5414                                     unsigned int stream_tag,
5415                                     unsigned int format,
5416                                     struct snd_pcm_substream *substream)
5417 {
5418         struct hda_gen_spec *spec = codec->spec;
5419         return snd_hda_multi_out_dig_prepare(codec, &spec->multiout,
5420                                              stream_tag, format, substream);
5421 }
5422
5423 static int dig_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
5424                                     struct hda_codec *codec,
5425                                     struct snd_pcm_substream *substream)
5426 {
5427         struct hda_gen_spec *spec = codec->spec;
5428         return snd_hda_multi_out_dig_cleanup(codec, &spec->multiout);
5429 }
5430
5431 static int dig_playback_pcm_close(struct hda_pcm_stream *hinfo,
5432                                   struct hda_codec *codec,
5433                                   struct snd_pcm_substream *substream)
5434 {
5435         struct hda_gen_spec *spec = codec->spec;
5436         return snd_hda_multi_out_dig_close(codec, &spec->multiout);
5437 }
5438
5439 /*
5440  * Analog capture
5441  */
5442 #define alt_capture_pcm_open    capture_pcm_open
5443 #define alt_capture_pcm_close   capture_pcm_close
5444
5445 static int alt_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
5446                                    struct hda_codec *codec,
5447                                    unsigned int stream_tag,
5448                                    unsigned int format,
5449                                    struct snd_pcm_substream *substream)
5450 {
5451         struct hda_gen_spec *spec = codec->spec;
5452
5453         snd_hda_codec_setup_stream(codec, spec->adc_nids[substream->number + 1],
5454                                    stream_tag, 0, format);
5455         call_pcm_capture_hook(hinfo, codec, substream,
5456                               HDA_GEN_PCM_ACT_PREPARE);
5457         return 0;
5458 }
5459
5460 static int alt_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
5461                                    struct hda_codec *codec,
5462                                    struct snd_pcm_substream *substream)
5463 {
5464         struct hda_gen_spec *spec = codec->spec;
5465
5466         snd_hda_codec_cleanup_stream(codec,
5467                                      spec->adc_nids[substream->number + 1]);
5468         call_pcm_capture_hook(hinfo, codec, substream,
5469                               HDA_GEN_PCM_ACT_CLEANUP);
5470         return 0;
5471 }
5472
5473 /*
5474  */
5475 static const struct hda_pcm_stream pcm_analog_playback = {
5476         .substreams = 1,
5477         .channels_min = 2,
5478         .channels_max = 8,
5479         /* NID is set in build_pcms */
5480         .ops = {
5481                 .open = playback_pcm_open,
5482                 .close = playback_pcm_close,
5483                 .prepare = playback_pcm_prepare,
5484                 .cleanup = playback_pcm_cleanup
5485         },
5486 };
5487
5488 static const struct hda_pcm_stream pcm_analog_capture = {
5489         .substreams = 1,
5490         .channels_min = 2,
5491         .channels_max = 2,
5492         /* NID is set in build_pcms */
5493         .ops = {
5494                 .open = capture_pcm_open,
5495                 .close = capture_pcm_close,
5496                 .prepare = capture_pcm_prepare,
5497                 .cleanup = capture_pcm_cleanup
5498         },
5499 };
5500
5501 static const struct hda_pcm_stream pcm_analog_alt_playback = {
5502         .substreams = 1,
5503         .channels_min = 2,
5504         .channels_max = 2,
5505         /* NID is set in build_pcms */
5506         .ops = {
5507                 .open = alt_playback_pcm_open,
5508                 .close = alt_playback_pcm_close,
5509                 .prepare = alt_playback_pcm_prepare,
5510                 .cleanup = alt_playback_pcm_cleanup
5511         },
5512 };
5513
5514 static const struct hda_pcm_stream pcm_analog_alt_capture = {
5515         .substreams = 2, /* can be overridden */
5516         .channels_min = 2,
5517         .channels_max = 2,
5518         /* NID is set in build_pcms */
5519         .ops = {
5520                 .open = alt_capture_pcm_open,
5521                 .close = alt_capture_pcm_close,
5522                 .prepare = alt_capture_pcm_prepare,
5523                 .cleanup = alt_capture_pcm_cleanup
5524         },
5525 };
5526
5527 static const struct hda_pcm_stream pcm_digital_playback = {
5528         .substreams = 1,
5529         .channels_min = 2,
5530         .channels_max = 2,
5531         /* NID is set in build_pcms */
5532         .ops = {
5533                 .open = dig_playback_pcm_open,
5534                 .close = dig_playback_pcm_close,
5535                 .prepare = dig_playback_pcm_prepare,
5536                 .cleanup = dig_playback_pcm_cleanup
5537         },
5538 };
5539
5540 static const struct hda_pcm_stream pcm_digital_capture = {
5541         .substreams = 1,
5542         .channels_min = 2,
5543         .channels_max = 2,
5544         /* NID is set in build_pcms */
5545 };
5546
5547 /* Used by build_pcms to flag that a PCM has no playback stream */
5548 static const struct hda_pcm_stream pcm_null_stream = {
5549         .substreams = 0,
5550         .channels_min = 0,
5551         .channels_max = 0,
5552 };
5553
5554 /*
5555  * dynamic changing ADC PCM streams
5556  */
5557 static bool dyn_adc_pcm_resetup(struct hda_codec *codec, int cur)
5558 {
5559         struct hda_gen_spec *spec = codec->spec;
5560         hda_nid_t new_adc = spec->adc_nids[spec->dyn_adc_idx[cur]];
5561
5562         if (spec->cur_adc && spec->cur_adc != new_adc) {
5563                 /* stream is running, let's swap the current ADC */
5564                 __snd_hda_codec_cleanup_stream(codec, spec->cur_adc, 1);
5565                 spec->cur_adc = new_adc;
5566                 snd_hda_codec_setup_stream(codec, new_adc,
5567                                            spec->cur_adc_stream_tag, 0,
5568                                            spec->cur_adc_format);
5569                 return true;
5570         }
5571         return false;
5572 }
5573
5574 /* analog capture with dynamic dual-adc changes */
5575 static int dyn_adc_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
5576                                        struct hda_codec *codec,
5577                                        unsigned int stream_tag,
5578                                        unsigned int format,
5579                                        struct snd_pcm_substream *substream)
5580 {
5581         struct hda_gen_spec *spec = codec->spec;
5582         spec->cur_adc = spec->adc_nids[spec->dyn_adc_idx[spec->cur_mux[0]]];
5583         spec->cur_adc_stream_tag = stream_tag;
5584         spec->cur_adc_format = format;
5585         snd_hda_codec_setup_stream(codec, spec->cur_adc, stream_tag, 0, format);
5586         call_pcm_capture_hook(hinfo, codec, substream, HDA_GEN_PCM_ACT_PREPARE);
5587         return 0;
5588 }
5589
5590 static int dyn_adc_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
5591                                        struct hda_codec *codec,
5592                                        struct snd_pcm_substream *substream)
5593 {
5594         struct hda_gen_spec *spec = codec->spec;
5595         snd_hda_codec_cleanup_stream(codec, spec->cur_adc);
5596         spec->cur_adc = 0;
5597         call_pcm_capture_hook(hinfo, codec, substream, HDA_GEN_PCM_ACT_CLEANUP);
5598         return 0;
5599 }
5600
5601 static const struct hda_pcm_stream dyn_adc_pcm_analog_capture = {
5602         .substreams = 1,
5603         .channels_min = 2,
5604         .channels_max = 2,
5605         .nid = 0, /* fill later */
5606         .ops = {
5607                 .prepare = dyn_adc_capture_pcm_prepare,
5608                 .cleanup = dyn_adc_capture_pcm_cleanup
5609         },
5610 };
5611
5612 static void fill_pcm_stream_name(char *str, size_t len, const char *sfx,
5613                                  const char *chip_name)
5614 {
5615         char *p;
5616
5617         if (*str)
5618                 return;
5619         strscpy(str, chip_name, len);
5620
5621         /* drop non-alnum chars after a space */
5622         for (p = strchr(str, ' '); p; p = strchr(p + 1, ' ')) {
5623                 if (!isalnum(p[1])) {
5624                         *p = 0;
5625                         break;
5626                 }
5627         }
5628         strlcat(str, sfx, len);
5629 }
5630
5631 /* copy PCM stream info from @default_str, and override non-NULL entries
5632  * from @spec_str and @nid
5633  */
5634 static void setup_pcm_stream(struct hda_pcm_stream *str,
5635                              const struct hda_pcm_stream *default_str,
5636                              const struct hda_pcm_stream *spec_str,
5637                              hda_nid_t nid)
5638 {
5639         *str = *default_str;
5640         if (nid)
5641                 str->nid = nid;
5642         if (spec_str) {
5643                 if (spec_str->substreams)
5644                         str->substreams = spec_str->substreams;
5645                 if (spec_str->channels_min)
5646                         str->channels_min = spec_str->channels_min;
5647                 if (spec_str->channels_max)
5648                         str->channels_max = spec_str->channels_max;
5649                 if (spec_str->rates)
5650                         str->rates = spec_str->rates;
5651                 if (spec_str->formats)
5652                         str->formats = spec_str->formats;
5653                 if (spec_str->maxbps)
5654                         str->maxbps = spec_str->maxbps;
5655         }
5656 }
5657
5658 /**
5659  * snd_hda_gen_build_pcms - build PCM streams based on the parsed results
5660  * @codec: the HDA codec
5661  *
5662  * Pass this to build_pcms patch_ops.
5663  */
5664 int snd_hda_gen_build_pcms(struct hda_codec *codec)
5665 {
5666         struct hda_gen_spec *spec = codec->spec;
5667         struct hda_pcm *info;
5668         bool have_multi_adcs;
5669
5670         if (spec->no_analog)
5671                 goto skip_analog;
5672
5673         fill_pcm_stream_name(spec->stream_name_analog,
5674                              sizeof(spec->stream_name_analog),
5675                              " Analog", codec->core.chip_name);
5676         info = snd_hda_codec_pcm_new(codec, "%s", spec->stream_name_analog);
5677         if (!info)
5678                 return -ENOMEM;
5679         spec->pcm_rec[0] = info;
5680
5681         if (spec->multiout.num_dacs > 0) {
5682                 setup_pcm_stream(&info->stream[SNDRV_PCM_STREAM_PLAYBACK],
5683                                  &pcm_analog_playback,
5684                                  spec->stream_analog_playback,
5685                                  spec->multiout.dac_nids[0]);
5686                 info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max =
5687                         spec->multiout.max_channels;
5688                 if (spec->autocfg.line_out_type == AUTO_PIN_SPEAKER_OUT &&
5689                     spec->autocfg.line_outs == 2)
5690                         info->stream[SNDRV_PCM_STREAM_PLAYBACK].chmap =
5691                                 snd_pcm_2_1_chmaps;
5692         }
5693         if (spec->num_adc_nids) {
5694                 setup_pcm_stream(&info->stream[SNDRV_PCM_STREAM_CAPTURE],
5695                                  (spec->dyn_adc_switch ?
5696                                   &dyn_adc_pcm_analog_capture : &pcm_analog_capture),
5697                                  spec->stream_analog_capture,
5698                                  spec->adc_nids[0]);
5699         }
5700
5701  skip_analog:
5702         /* SPDIF for stream index #1 */
5703         if (spec->multiout.dig_out_nid || spec->dig_in_nid) {
5704                 fill_pcm_stream_name(spec->stream_name_digital,
5705                                      sizeof(spec->stream_name_digital),
5706                                      " Digital", codec->core.chip_name);
5707                 info = snd_hda_codec_pcm_new(codec, "%s",
5708                                              spec->stream_name_digital);
5709                 if (!info)
5710                         return -ENOMEM;
5711                 codec->follower_dig_outs = spec->multiout.follower_dig_outs;
5712                 spec->pcm_rec[1] = info;
5713                 if (spec->dig_out_type)
5714                         info->pcm_type = spec->dig_out_type;
5715                 else
5716                         info->pcm_type = HDA_PCM_TYPE_SPDIF;
5717                 if (spec->multiout.dig_out_nid)
5718                         setup_pcm_stream(&info->stream[SNDRV_PCM_STREAM_PLAYBACK],
5719                                          &pcm_digital_playback,
5720                                          spec->stream_digital_playback,
5721                                          spec->multiout.dig_out_nid);
5722                 if (spec->dig_in_nid)
5723                         setup_pcm_stream(&info->stream[SNDRV_PCM_STREAM_CAPTURE],
5724                                          &pcm_digital_capture,
5725                                          spec->stream_digital_capture,
5726                                          spec->dig_in_nid);
5727         }
5728
5729         if (spec->no_analog)
5730                 return 0;
5731
5732         /* If the use of more than one ADC is requested for the current
5733          * model, configure a second analog capture-only PCM.
5734          */
5735         have_multi_adcs = (spec->num_adc_nids > 1) &&
5736                 !spec->dyn_adc_switch && !spec->auto_mic;
5737         /* Additional Analaog capture for index #2 */
5738         if (spec->alt_dac_nid || have_multi_adcs) {
5739                 fill_pcm_stream_name(spec->stream_name_alt_analog,
5740                                      sizeof(spec->stream_name_alt_analog),
5741                              " Alt Analog", codec->core.chip_name);
5742                 info = snd_hda_codec_pcm_new(codec, "%s",
5743                                              spec->stream_name_alt_analog);
5744                 if (!info)
5745                         return -ENOMEM;
5746                 spec->pcm_rec[2] = info;
5747                 if (spec->alt_dac_nid)
5748                         setup_pcm_stream(&info->stream[SNDRV_PCM_STREAM_PLAYBACK],
5749                                          &pcm_analog_alt_playback,
5750                                          spec->stream_analog_alt_playback,
5751                                          spec->alt_dac_nid);
5752                 else
5753                         setup_pcm_stream(&info->stream[SNDRV_PCM_STREAM_PLAYBACK],
5754                                          &pcm_null_stream, NULL, 0);
5755                 if (have_multi_adcs) {
5756                         setup_pcm_stream(&info->stream[SNDRV_PCM_STREAM_CAPTURE],
5757                                          &pcm_analog_alt_capture,
5758                                          spec->stream_analog_alt_capture,
5759                                          spec->adc_nids[1]);
5760                         info->stream[SNDRV_PCM_STREAM_CAPTURE].substreams =
5761                                 spec->num_adc_nids - 1;
5762                 } else {
5763                         setup_pcm_stream(&info->stream[SNDRV_PCM_STREAM_CAPTURE],
5764                                          &pcm_null_stream, NULL, 0);
5765                 }
5766         }
5767
5768         return 0;
5769 }
5770 EXPORT_SYMBOL_GPL(snd_hda_gen_build_pcms);
5771
5772
5773 /*
5774  * Standard auto-parser initializations
5775  */
5776
5777 /* configure the given path as a proper output */
5778 static void set_output_and_unmute(struct hda_codec *codec, int path_idx)
5779 {
5780         struct nid_path *path;
5781         hda_nid_t pin;
5782
5783         path = snd_hda_get_path_from_idx(codec, path_idx);
5784         if (!path || !path->depth)
5785                 return;
5786         pin = path->path[path->depth - 1];
5787         restore_pin_ctl(codec, pin);
5788         snd_hda_activate_path(codec, path, path->active,
5789                               aamix_default(codec->spec));
5790         set_pin_eapd(codec, pin, path->active);
5791 }
5792
5793 /* initialize primary output paths */
5794 static void init_multi_out(struct hda_codec *codec)
5795 {
5796         struct hda_gen_spec *spec = codec->spec;
5797         int i;
5798
5799         for (i = 0; i < spec->autocfg.line_outs; i++)
5800                 set_output_and_unmute(codec, spec->out_paths[i]);
5801 }
5802
5803
5804 static void __init_extra_out(struct hda_codec *codec, int num_outs, int *paths)
5805 {
5806         int i;
5807
5808         for (i = 0; i < num_outs; i++)
5809                 set_output_and_unmute(codec, paths[i]);
5810 }
5811
5812 /* initialize hp and speaker paths */
5813 static void init_extra_out(struct hda_codec *codec)
5814 {
5815         struct hda_gen_spec *spec = codec->spec;
5816
5817         if (spec->autocfg.line_out_type != AUTO_PIN_HP_OUT)
5818                 __init_extra_out(codec, spec->autocfg.hp_outs, spec->hp_paths);
5819         if (spec->autocfg.line_out_type != AUTO_PIN_SPEAKER_OUT)
5820                 __init_extra_out(codec, spec->autocfg.speaker_outs,
5821                                  spec->speaker_paths);
5822 }
5823
5824 /* initialize multi-io paths */
5825 static void init_multi_io(struct hda_codec *codec)
5826 {
5827         struct hda_gen_spec *spec = codec->spec;
5828         int i;
5829
5830         for (i = 0; i < spec->multi_ios; i++) {
5831                 hda_nid_t pin = spec->multi_io[i].pin;
5832                 struct nid_path *path;
5833                 path = get_multiio_path(codec, i);
5834                 if (!path)
5835                         continue;
5836                 if (!spec->multi_io[i].ctl_in)
5837                         spec->multi_io[i].ctl_in =
5838                                 snd_hda_codec_get_pin_target(codec, pin);
5839                 snd_hda_activate_path(codec, path, path->active,
5840                                       aamix_default(spec));
5841         }
5842 }
5843
5844 static void init_aamix_paths(struct hda_codec *codec)
5845 {
5846         struct hda_gen_spec *spec = codec->spec;
5847
5848         if (!spec->have_aamix_ctl)
5849                 return;
5850         if (!has_aamix_out_paths(spec))
5851                 return;
5852         update_aamix_paths(codec, spec->aamix_mode, spec->out_paths[0],
5853                            spec->aamix_out_paths[0],
5854                            spec->autocfg.line_out_type);
5855         update_aamix_paths(codec, spec->aamix_mode, spec->hp_paths[0],
5856                            spec->aamix_out_paths[1],
5857                            AUTO_PIN_HP_OUT);
5858         update_aamix_paths(codec, spec->aamix_mode, spec->speaker_paths[0],
5859                            spec->aamix_out_paths[2],
5860                            AUTO_PIN_SPEAKER_OUT);
5861 }
5862
5863 /* set up input pins and loopback paths */
5864 static void init_analog_input(struct hda_codec *codec)
5865 {
5866         struct hda_gen_spec *spec = codec->spec;
5867         struct auto_pin_cfg *cfg = &spec->autocfg;
5868         int i;
5869
5870         for (i = 0; i < cfg->num_inputs; i++) {
5871                 hda_nid_t nid = cfg->inputs[i].pin;
5872                 if (is_input_pin(codec, nid))
5873                         restore_pin_ctl(codec, nid);
5874
5875                 /* init loopback inputs */
5876                 if (spec->mixer_nid) {
5877                         resume_path_from_idx(codec, spec->loopback_paths[i]);
5878                         resume_path_from_idx(codec, spec->loopback_merge_path);
5879                 }
5880         }
5881 }
5882
5883 /* initialize ADC paths */
5884 static void init_input_src(struct hda_codec *codec)
5885 {
5886         struct hda_gen_spec *spec = codec->spec;
5887         struct hda_input_mux *imux = &spec->input_mux;
5888         struct nid_path *path;
5889         int i, c, nums;
5890
5891         if (spec->dyn_adc_switch)
5892                 nums = 1;
5893         else
5894                 nums = spec->num_adc_nids;
5895
5896         for (c = 0; c < nums; c++) {
5897                 for (i = 0; i < imux->num_items; i++) {
5898                         path = get_input_path(codec, c, i);
5899                         if (path) {
5900                                 bool active = path->active;
5901                                 if (i == spec->cur_mux[c])
5902                                         active = true;
5903                                 snd_hda_activate_path(codec, path, active, false);
5904                         }
5905                 }
5906                 if (spec->hp_mic)
5907                         update_hp_mic(codec, c, true);
5908         }
5909
5910         if (spec->cap_sync_hook)
5911                 spec->cap_sync_hook(codec, NULL, NULL);
5912 }
5913
5914 /* set right pin controls for digital I/O */
5915 static void init_digital(struct hda_codec *codec)
5916 {
5917         struct hda_gen_spec *spec = codec->spec;
5918         int i;
5919         hda_nid_t pin;
5920
5921         for (i = 0; i < spec->autocfg.dig_outs; i++)
5922                 set_output_and_unmute(codec, spec->digout_paths[i]);
5923         pin = spec->autocfg.dig_in_pin;
5924         if (pin) {
5925                 restore_pin_ctl(codec, pin);
5926                 resume_path_from_idx(codec, spec->digin_path);
5927         }
5928 }
5929
5930 /* clear unsol-event tags on unused pins; Conexant codecs seem to leave
5931  * invalid unsol tags by some reason
5932  */
5933 static void clear_unsol_on_unused_pins(struct hda_codec *codec)
5934 {
5935         const struct hda_pincfg *pin;
5936         int i;
5937
5938         snd_array_for_each(&codec->init_pins, i, pin) {
5939                 hda_nid_t nid = pin->nid;
5940                 if (is_jack_detectable(codec, nid) &&
5941                     !snd_hda_jack_tbl_get(codec, nid))
5942                         snd_hda_codec_write_cache(codec, nid, 0,
5943                                         AC_VERB_SET_UNSOLICITED_ENABLE, 0);
5944         }
5945 }
5946
5947 /**
5948  * snd_hda_gen_init - initialize the generic spec
5949  * @codec: the HDA codec
5950  *
5951  * This can be put as patch_ops init function.
5952  */
5953 int snd_hda_gen_init(struct hda_codec *codec)
5954 {
5955         struct hda_gen_spec *spec = codec->spec;
5956
5957         if (spec->init_hook)
5958                 spec->init_hook(codec);
5959
5960         if (!spec->skip_verbs)
5961                 snd_hda_apply_verbs(codec);
5962
5963         init_multi_out(codec);
5964         init_extra_out(codec);
5965         init_multi_io(codec);
5966         init_aamix_paths(codec);
5967         init_analog_input(codec);
5968         init_input_src(codec);
5969         init_digital(codec);
5970
5971         clear_unsol_on_unused_pins(codec);
5972
5973         sync_all_pin_power_ctls(codec);
5974
5975         /* call init functions of standard auto-mute helpers */
5976         update_automute_all(codec);
5977
5978         snd_hda_regmap_sync(codec);
5979
5980         if (spec->vmaster_mute.sw_kctl && spec->vmaster_mute.hook)
5981                 snd_hda_sync_vmaster_hook(&spec->vmaster_mute);
5982
5983         hda_call_check_power_status(codec, 0x01);
5984         return 0;
5985 }
5986 EXPORT_SYMBOL_GPL(snd_hda_gen_init);
5987
5988 /**
5989  * snd_hda_gen_free - free the generic spec
5990  * @codec: the HDA codec
5991  *
5992  * This can be put as patch_ops free function.
5993  */
5994 void snd_hda_gen_free(struct hda_codec *codec)
5995 {
5996         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_FREE);
5997         snd_hda_gen_spec_free(codec->spec);
5998         kfree(codec->spec);
5999         codec->spec = NULL;
6000 }
6001 EXPORT_SYMBOL_GPL(snd_hda_gen_free);
6002
6003 /**
6004  * snd_hda_gen_reboot_notify - Make codec enter D3 before rebooting
6005  * @codec: the HDA codec
6006  *
6007  * This can be put as patch_ops reboot_notify function.
6008  */
6009 void snd_hda_gen_reboot_notify(struct hda_codec *codec)
6010 {
6011         /* Make the codec enter D3 to avoid spurious noises from the internal
6012          * speaker during (and after) reboot
6013          */
6014         snd_hda_codec_set_power_to_all(codec, codec->core.afg, AC_PWRST_D3);
6015         snd_hda_codec_write(codec, codec->core.afg, 0,
6016                             AC_VERB_SET_POWER_STATE, AC_PWRST_D3);
6017         msleep(10);
6018 }
6019 EXPORT_SYMBOL_GPL(snd_hda_gen_reboot_notify);
6020
6021 #ifdef CONFIG_PM
6022 /**
6023  * snd_hda_gen_check_power_status - check the loopback power save state
6024  * @codec: the HDA codec
6025  * @nid: NID to inspect
6026  *
6027  * This can be put as patch_ops check_power_status function.
6028  */
6029 int snd_hda_gen_check_power_status(struct hda_codec *codec, hda_nid_t nid)
6030 {
6031         struct hda_gen_spec *spec = codec->spec;
6032         return snd_hda_check_amp_list_power(codec, &spec->loopback, nid);
6033 }
6034 EXPORT_SYMBOL_GPL(snd_hda_gen_check_power_status);
6035 #endif
6036
6037
6038 /*
6039  * the generic codec support
6040  */
6041
6042 static const struct hda_codec_ops generic_patch_ops = {
6043         .build_controls = snd_hda_gen_build_controls,
6044         .build_pcms = snd_hda_gen_build_pcms,
6045         .init = snd_hda_gen_init,
6046         .free = snd_hda_gen_free,
6047         .unsol_event = snd_hda_jack_unsol_event,
6048         .reboot_notify = snd_hda_gen_reboot_notify,
6049 #ifdef CONFIG_PM
6050         .check_power_status = snd_hda_gen_check_power_status,
6051 #endif
6052 };
6053
6054 /*
6055  * snd_hda_parse_generic_codec - Generic codec parser
6056  * @codec: the HDA codec
6057  */
6058 static int snd_hda_parse_generic_codec(struct hda_codec *codec)
6059 {
6060         struct hda_gen_spec *spec;
6061         int err;
6062
6063         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
6064         if (!spec)
6065                 return -ENOMEM;
6066         snd_hda_gen_spec_init(spec);
6067         codec->spec = spec;
6068
6069         err = snd_hda_parse_pin_defcfg(codec, &spec->autocfg, NULL, 0);
6070         if (err < 0)
6071                 goto error;
6072
6073         err = snd_hda_gen_parse_auto_config(codec, &spec->autocfg);
6074         if (err < 0)
6075                 goto error;
6076
6077         codec->patch_ops = generic_patch_ops;
6078         return 0;
6079
6080 error:
6081         snd_hda_gen_free(codec);
6082         return err;
6083 }
6084
6085 static const struct hda_device_id snd_hda_id_generic[] = {
6086         HDA_CODEC_ENTRY(HDA_CODEC_ID_GENERIC, "Generic", snd_hda_parse_generic_codec),
6087         {} /* terminator */
6088 };
6089 MODULE_DEVICE_TABLE(hdaudio, snd_hda_id_generic);
6090
6091 static struct hda_codec_driver generic_driver = {
6092         .id = snd_hda_id_generic,
6093 };
6094
6095 module_hda_codec_driver(generic_driver);
6096
6097 MODULE_LICENSE("GPL");
6098 MODULE_DESCRIPTION("Generic HD-audio codec parser");