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