sound/pci/hda/hda_generic.c

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