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