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