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 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 EXPORT_SYMBOL_GPL(snd_hda_gen_spec_free);
  91
  92 /*
  93  * store user hints
  94  */
  95 static void parse_user_hints(struct hda_codec *codec)
  96 {
  97         struct hda_gen_spec *spec = codec->spec;
  98         int val;
  99
 100         val = snd_hda_get_bool_hint(codec, "jack_detect");
 101         if (val >= 0)
 102                 codec->no_jack_detect = !val;
 103         val = snd_hda_get_bool_hint(codec, "inv_jack_detect");
 104         if (val >= 0)
 105                 codec->inv_jack_detect = !!val;
 106         val = snd_hda_get_bool_hint(codec, "trigger_sense");
 107         if (val >= 0)
 108                 codec->no_trigger_sense = !val;
 109         val = snd_hda_get_bool_hint(codec, "inv_eapd");
 110         if (val >= 0)
 111                 codec->inv_eapd = !!val;
 112         val = snd_hda_get_bool_hint(codec, "pcm_format_first");
 113         if (val >= 0)
 114                 codec->pcm_format_first = !!val;
 115         val = snd_hda_get_bool_hint(codec, "sticky_stream");
 116         if (val >= 0)
 117                 codec->no_sticky_stream = !val;
 118         val = snd_hda_get_bool_hint(codec, "spdif_status_reset");
 119         if (val >= 0)
 120                 codec->spdif_status_reset = !!val;
 121         val = snd_hda_get_bool_hint(codec, "pin_amp_workaround");
 122         if (val >= 0)
 123                 codec->pin_amp_workaround = !!val;
 124         val = snd_hda_get_bool_hint(codec, "single_adc_amp");
 125         if (val >= 0)
 126                 codec->single_adc_amp = !!val;
 127
 128         val = snd_hda_get_bool_hint(codec, "auto_mute");
 129         if (val >= 0)
 130                 spec->suppress_auto_mute = !val;
 131         val = snd_hda_get_bool_hint(codec, "auto_mic");
 132         if (val >= 0)
 133                 spec->suppress_auto_mic = !val;
 134         val = snd_hda_get_bool_hint(codec, "line_in_auto_switch");
 135         if (val >= 0)
 136                 spec->line_in_auto_switch = !!val;
 137         val = snd_hda_get_bool_hint(codec, "auto_mute_via_amp");
 138         if (val >= 0)
 139                 spec->auto_mute_via_amp = !!val;
 140         val = snd_hda_get_bool_hint(codec, "need_dac_fix");
 141         if (val >= 0)
 142                 spec->need_dac_fix = !!val;
 143         val = snd_hda_get_bool_hint(codec, "primary_hp");
 144         if (val >= 0)
 145                 spec->no_primary_hp = !val;
 146         val = snd_hda_get_bool_hint(codec, "multi_io");
 147         if (val >= 0)
 148                 spec->no_multi_io = !val;
 149         val = snd_hda_get_bool_hint(codec, "multi_cap_vol");
 150         if (val >= 0)
 151                 spec->multi_cap_vol = !!val;
 152         val = snd_hda_get_bool_hint(codec, "inv_dmic_split");
 153         if (val >= 0)
 154                 spec->inv_dmic_split = !!val;
 155         val = snd_hda_get_bool_hint(codec, "indep_hp");
 156         if (val >= 0)
 157                 spec->indep_hp = !!val;
 158         val = snd_hda_get_bool_hint(codec, "add_stereo_mix_input");
 159         if (val >= 0)
 160                 spec->add_stereo_mix_input = !!val;
 161         /* the following two are just for compatibility */
 162         val = snd_hda_get_bool_hint(codec, "add_out_jack_modes");
 163         if (val >= 0)
 164                 spec->add_jack_modes = !!val;
 165         val = snd_hda_get_bool_hint(codec, "add_in_jack_modes");
 166         if (val >= 0)
 167                 spec->add_jack_modes = !!val;
 168         val = snd_hda_get_bool_hint(codec, "add_jack_modes");
 169         if (val >= 0)
 170                 spec->add_jack_modes = !!val;
 171         val = snd_hda_get_bool_hint(codec, "power_down_unused");
 172         if (val >= 0)
 173                 spec->power_down_unused = !!val;
 174         val = snd_hda_get_bool_hint(codec, "add_hp_mic");
 175         if (val >= 0)
 176                 spec->hp_mic = !!val;
 177         val = snd_hda_get_bool_hint(codec, "hp_mic_detect");
 178         if (val >= 0)
 179                 spec->suppress_hp_mic_detect = !val;
 180
 181         if (!snd_hda_get_int_hint(codec, "mixer_nid", &val))
 182                 spec->mixer_nid = val;
 183 }
 184
 185 /*
 186  * pin control value accesses
 187  */
 188
 189 #define update_pin_ctl(codec, pin, val) \
 190         snd_hda_codec_update_cache(codec, pin, 0, \
 191                                    AC_VERB_SET_PIN_WIDGET_CONTROL, val)
 192
 193 /* restore the pinctl based on the cached value */
 194 static inline void restore_pin_ctl(struct hda_codec *codec, hda_nid_t pin)
 195 {
 196         update_pin_ctl(codec, pin, snd_hda_codec_get_pin_target(codec, pin));
 197 }
 198
 199 /* set the pinctl target value and write it if requested */
 200 static void set_pin_target(struct hda_codec *codec, hda_nid_t pin,
 201                            unsigned int val, bool do_write)
 202 {
 203         if (!pin)
 204                 return;
 205         val = snd_hda_correct_pin_ctl(codec, pin, val);
 206         snd_hda_codec_set_pin_target(codec, pin, val);
 207         if (do_write)
 208                 update_pin_ctl(codec, pin, val);
 209 }
 210
 211 /* set pinctl target values for all given pins */
 212 static void set_pin_targets(struct hda_codec *codec, int num_pins,
 213                             hda_nid_t *pins, unsigned int val)
 214 {
 215         int i;
 216         for (i = 0; i < num_pins; i++)
 217                 set_pin_target(codec, pins[i], val, false);
 218 }
 219
 220 /*
 221  * parsing paths
 222  */
 223
 224 /* return the position of NID in the list, or -1 if not found */
 225 static int find_idx_in_nid_list(hda_nid_t nid, const hda_nid_t *list, int nums)
 226 {
 227         int i;
 228         for (i = 0; i < nums; i++)
 229                 if (list[i] == nid)
 230                         return i;
 231         return -1;
 232 }
 233
 234 /* return true if the given NID is contained in the path */
 235 static bool is_nid_contained(struct nid_path *path, hda_nid_t nid)
 236 {
 237         return find_idx_in_nid_list(nid, path->path, path->depth) >= 0;
 238 }
 239
 240 static struct nid_path *get_nid_path(struct hda_codec *codec,
 241                                      hda_nid_t from_nid, hda_nid_t to_nid,
 242                                      int anchor_nid)
 243 {
 244         struct hda_gen_spec *spec = codec->spec;
 245         int i;
 246
 247         for (i = 0; i < spec->paths.used; i++) {
 248                 struct nid_path *path = snd_array_elem(&spec->paths, i);
 249                 if (path->depth <= 0)
 250                         continue;
 251                 if ((!from_nid || path->path[0] == from_nid) &&
 252                     (!to_nid || path->path[path->depth - 1] == to_nid)) {
 253                         if (!anchor_nid ||
 254                             (anchor_nid > 0 && is_nid_contained(path, anchor_nid)) ||
 255                             (anchor_nid < 0 && !is_nid_contained(path, anchor_nid)))
 256                                 return path;
 257                 }
 258         }
 259         return NULL;
 260 }
 261
 262 /* get the path between the given NIDs;
 263  * passing 0 to either @pin or @dac behaves as a wildcard
 264  */
 265 struct nid_path *snd_hda_get_nid_path(struct hda_codec *codec,
 266                                       hda_nid_t from_nid, hda_nid_t to_nid)
 267 {
 268         return get_nid_path(codec, from_nid, to_nid, 0);
 269 }
 270 EXPORT_SYMBOL_GPL(snd_hda_get_nid_path);
 271
 272 /* get the index number corresponding to the path instance;
 273  * the index starts from 1, for easier checking the invalid value
 274  */
 275 int snd_hda_get_path_idx(struct hda_codec *codec, struct nid_path *path)
 276 {
 277         struct hda_gen_spec *spec = codec->spec;
 278         struct nid_path *array = spec->paths.list;
 279         ssize_t idx;
 280
 281         if (!spec->paths.used)
 282                 return 0;
 283         idx = path - array;
 284         if (idx < 0 || idx >= spec->paths.used)
 285                 return 0;
 286         return idx + 1;
 287 }
 288 EXPORT_SYMBOL_GPL(snd_hda_get_path_idx);
 289
 290 /* get the path instance corresponding to the given index number */
 291 struct nid_path *snd_hda_get_path_from_idx(struct hda_codec *codec, int idx)
 292 {
 293         struct hda_gen_spec *spec = codec->spec;
 294
 295         if (idx <= 0 || idx > spec->paths.used)
 296                 return NULL;
 297         return snd_array_elem(&spec->paths, idx - 1);
 298 }
 299 EXPORT_SYMBOL_GPL(snd_hda_get_path_from_idx);
 300
 301 /* check whether the given DAC is already found in any existing paths */
 302 static bool is_dac_already_used(struct hda_codec *codec, hda_nid_t nid)
 303 {
 304         struct hda_gen_spec *spec = codec->spec;
 305         int i;
 306
 307         for (i = 0; i < spec->paths.used; i++) {
 308                 struct nid_path *path = snd_array_elem(&spec->paths, i);
 309                 if (path->path[0] == nid)
 310                         return true;
 311         }
 312         return false;
 313 }
 314
 315 /* check whether the given two widgets can be connected */
 316 static bool is_reachable_path(struct hda_codec *codec,
 317                               hda_nid_t from_nid, hda_nid_t to_nid)
 318 {
 319         if (!from_nid || !to_nid)
 320                 return false;
 321         return snd_hda_get_conn_index(codec, to_nid, from_nid, true) >= 0;
 322 }
 323
 324 /* nid, dir and idx */
 325 #define AMP_VAL_COMPARE_MASK    (0xffff | (1U << 18) | (0x0f << 19))
 326
 327 /* check whether the given ctl is already assigned in any path elements */
 328 static bool is_ctl_used(struct hda_codec *codec, unsigned int val, int type)
 329 {
 330         struct hda_gen_spec *spec = codec->spec;
 331         int i;
 332
 333         val &= AMP_VAL_COMPARE_MASK;
 334         for (i = 0; i < spec->paths.used; i++) {
 335                 struct nid_path *path = snd_array_elem(&spec->paths, i);
 336                 if ((path->ctls[type] & AMP_VAL_COMPARE_MASK) == val)
 337                         return true;
 338         }
 339         return false;
 340 }
 341
 342 /* check whether a control with the given (nid, dir, idx) was assigned */
 343 static bool is_ctl_associated(struct hda_codec *codec, hda_nid_t nid,
 344                               int dir, int idx, int type)
 345 {
 346         unsigned int val = HDA_COMPOSE_AMP_VAL(nid, 3, idx, dir);
 347         return is_ctl_used(codec, val, type);
 348 }
 349
 350 static void print_nid_path(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         snd_printdd("%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_write_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("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("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("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("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   snd_printdd
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(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                         snd_printk(KERN_ERR "hda: 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         snd_printdd("hda-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("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("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                 snd_printdd("hda-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                 snd_printdd("hda-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("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("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("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                 snd_printdd("hda-codec: Enable HP auto-muting on NID 0x%x\n",
4174                             nid);
4175                 snd_hda_jack_detect_enable_callback(codec, nid, HDA_GEN_HP_EVENT,
4176                                                     call_hp_automute);
4177                 spec->detect_hp = 1;
4178         }
4179
4180         if (cfg->line_out_type == AUTO_PIN_LINE_OUT && cfg->line_outs) {
4181                 if (cfg->speaker_outs)
4182                         for (i = 0; i < cfg->line_outs; i++) {
4183                                 hda_nid_t nid = cfg->line_out_pins[i];
4184                                 if (!is_jack_detectable(codec, nid))
4185                                         continue;
4186                                 snd_printdd("hda-codec: Enable Line-Out auto-muting on NID 0x%x\n", nid);
4187                                 snd_hda_jack_detect_enable_callback(codec, nid,
4188                                                                     HDA_GEN_FRONT_EVENT,
4189                                                                     call_line_automute);
4190                                 spec->detect_lo = 1;
4191                         }
4192                 spec->automute_lo_possible = spec->detect_hp;
4193         }
4194
4195         spec->automute_speaker_possible = cfg->speaker_outs &&
4196                 (spec->detect_hp || spec->detect_lo);
4197
4198         spec->automute_lo = spec->automute_lo_possible;
4199         spec->automute_speaker = spec->automute_speaker_possible;
4200
4201         if (spec->automute_speaker_possible || spec->automute_lo_possible) {
4202                 /* create a control for automute mode */
4203                 err = add_automute_mode_enum(codec);
4204                 if (err < 0)
4205                         return err;
4206         }
4207         return 0;
4208 }
4209
4210 /* check whether all auto-mic pins are valid; setup indices if OK */
4211 static bool auto_mic_check_imux(struct hda_codec *codec)
4212 {
4213         struct hda_gen_spec *spec = codec->spec;
4214         const struct hda_input_mux *imux;
4215         int i;
4216
4217         imux = &spec->input_mux;
4218         for (i = 0; i < spec->am_num_entries; i++) {
4219                 spec->am_entry[i].idx =
4220                         find_idx_in_nid_list(spec->am_entry[i].pin,
4221                                              spec->imux_pins, imux->num_items);
4222                 if (spec->am_entry[i].idx < 0)
4223                         return false; /* no corresponding imux */
4224         }
4225
4226         /* we don't need the jack detection for the first pin */
4227         for (i = 1; i < spec->am_num_entries; i++)
4228                 snd_hda_jack_detect_enable_callback(codec,
4229                                                     spec->am_entry[i].pin,
4230                                                     HDA_GEN_MIC_EVENT,
4231                                                     call_mic_autoswitch);
4232         return true;
4233 }
4234
4235 static int compare_attr(const void *ap, const void *bp)
4236 {
4237         const struct automic_entry *a = ap;
4238         const struct automic_entry *b = bp;
4239         return (int)(a->attr - b->attr);
4240 }
4241
4242 /*
4243  * Check the availability of auto-mic switch;
4244  * Set up if really supported
4245  */
4246 static int check_auto_mic_availability(struct hda_codec *codec)
4247 {
4248         struct hda_gen_spec *spec = codec->spec;
4249         struct auto_pin_cfg *cfg = &spec->autocfg;
4250         unsigned int types;
4251         int i, num_pins;
4252
4253         if (spec->suppress_auto_mic)
4254                 return 0;
4255
4256         types = 0;
4257         num_pins = 0;
4258         for (i = 0; i < cfg->num_inputs; i++) {
4259                 hda_nid_t nid = cfg->inputs[i].pin;
4260                 unsigned int attr;
4261                 attr = snd_hda_codec_get_pincfg(codec, nid);
4262                 attr = snd_hda_get_input_pin_attr(attr);
4263                 if (types & (1 << attr))
4264                         return 0; /* already occupied */
4265                 switch (attr) {
4266                 case INPUT_PIN_ATTR_INT:
4267                         if (cfg->inputs[i].type != AUTO_PIN_MIC)
4268                                 return 0; /* invalid type */
4269                         break;
4270                 case INPUT_PIN_ATTR_UNUSED:
4271                         return 0; /* invalid entry */
4272                 default:
4273                         if (cfg->inputs[i].type > AUTO_PIN_LINE_IN)
4274                                 return 0; /* invalid type */
4275                         if (!spec->line_in_auto_switch &&
4276                             cfg->inputs[i].type != AUTO_PIN_MIC)
4277                                 return 0; /* only mic is allowed */
4278                         if (!is_jack_detectable(codec, nid))
4279                                 return 0; /* no unsol support */
4280                         break;
4281                 }
4282                 if (num_pins >= MAX_AUTO_MIC_PINS)
4283                         return 0;
4284                 types |= (1 << attr);
4285                 spec->am_entry[num_pins].pin = nid;
4286                 spec->am_entry[num_pins].attr = attr;
4287                 num_pins++;
4288         }
4289
4290         if (num_pins < 2)
4291                 return 0;
4292
4293         spec->am_num_entries = num_pins;
4294         /* sort the am_entry in the order of attr so that the pin with a
4295          * higher attr will be selected when the jack is plugged.
4296          */
4297         sort(spec->am_entry, num_pins, sizeof(spec->am_entry[0]),
4298              compare_attr, NULL);
4299
4300         if (!auto_mic_check_imux(codec))
4301                 return 0;
4302
4303         spec->auto_mic = 1;
4304         spec->num_adc_nids = 1;
4305         spec->cur_mux[0] = spec->am_entry[0].idx;
4306         snd_printdd("hda-codec: Enable auto-mic switch on NID 0x%x/0x%x/0x%x\n",
4307                     spec->am_entry[0].pin,
4308                     spec->am_entry[1].pin,
4309                     spec->am_entry[2].pin);
4310
4311         return 0;
4312 }
4313
4314 /* power_filter hook; make inactive widgets into power down */
4315 unsigned int snd_hda_gen_path_power_filter(struct hda_codec *codec,
4316                                                   hda_nid_t nid,
4317                                                   unsigned int power_state)
4318 {
4319         if (power_state != AC_PWRST_D0 || nid == codec->afg)
4320                 return power_state;
4321         if (get_wcaps_type(get_wcaps(codec, nid)) >= AC_WID_POWER)
4322                 return power_state;
4323         if (is_active_nid_for_any(codec, nid))
4324                 return power_state;
4325         return AC_PWRST_D3;
4326 }
4327 EXPORT_SYMBOL_GPL(snd_hda_gen_path_power_filter);
4328
4329 /* mute all aamix inputs initially; parse up to the first leaves */
4330 static void mute_all_mixer_nid(struct hda_codec *codec, hda_nid_t mix)
4331 {
4332         int i, nums;
4333         const hda_nid_t *conn;
4334         bool has_amp;
4335
4336         nums = snd_hda_get_conn_list(codec, mix, &conn);
4337         has_amp = nid_has_mute(codec, mix, HDA_INPUT);
4338         for (i = 0; i < nums; i++) {
4339                 if (has_amp)
4340                         snd_hda_codec_amp_stereo(codec, mix,
4341                                                  HDA_INPUT, i,
4342                                                  0xff, HDA_AMP_MUTE);
4343                 else if (nid_has_volume(codec, conn[i], HDA_OUTPUT))
4344                         snd_hda_codec_amp_stereo(codec, conn[i],
4345                                                  HDA_OUTPUT, 0,
4346                                                  0xff, HDA_AMP_MUTE);
4347         }
4348 }
4349
4350 /*
4351  * Parse the given BIOS configuration and set up the hda_gen_spec
4352  *
4353  * return 1 if successful, 0 if the proper config is not found,
4354  * or a negative error code
4355  */
4356 int snd_hda_gen_parse_auto_config(struct hda_codec *codec,
4357                                   struct auto_pin_cfg *cfg)
4358 {
4359         struct hda_gen_spec *spec = codec->spec;
4360         int err;
4361
4362         parse_user_hints(codec);
4363
4364         if (spec->mixer_nid && !spec->mixer_merge_nid)
4365                 spec->mixer_merge_nid = spec->mixer_nid;
4366
4367         if (cfg != &spec->autocfg) {
4368                 spec->autocfg = *cfg;
4369                 cfg = &spec->autocfg;
4370         }
4371
4372         if (!spec->main_out_badness)
4373                 spec->main_out_badness = &hda_main_out_badness;
4374         if (!spec->extra_out_badness)
4375                 spec->extra_out_badness = &hda_extra_out_badness;
4376
4377         fill_all_dac_nids(codec);
4378
4379         if (!cfg->line_outs) {
4380                 if (cfg->dig_outs || cfg->dig_in_pin) {
4381                         spec->multiout.max_channels = 2;
4382                         spec->no_analog = 1;
4383                         goto dig_only;
4384                 }
4385                 if (!cfg->num_inputs && !cfg->dig_in_pin)
4386                         return 0; /* can't find valid BIOS pin config */
4387         }
4388
4389         if (!spec->no_primary_hp &&
4390             cfg->line_out_type == AUTO_PIN_SPEAKER_OUT &&
4391             cfg->line_outs <= cfg->hp_outs) {
4392                 /* use HP as primary out */
4393                 cfg->speaker_outs = cfg->line_outs;
4394                 memcpy(cfg->speaker_pins, cfg->line_out_pins,
4395                        sizeof(cfg->speaker_pins));
4396                 cfg->line_outs = cfg->hp_outs;
4397                 memcpy(cfg->line_out_pins, cfg->hp_pins, sizeof(cfg->hp_pins));
4398                 cfg->hp_outs = 0;
4399                 memset(cfg->hp_pins, 0, sizeof(cfg->hp_pins));
4400                 cfg->line_out_type = AUTO_PIN_HP_OUT;
4401         }
4402
4403         err = parse_output_paths(codec);
4404         if (err < 0)
4405                 return err;
4406         err = create_multi_channel_mode(codec);
4407         if (err < 0)
4408                 return err;
4409         err = create_multi_out_ctls(codec, cfg);
4410         if (err < 0)
4411                 return err;
4412         err = create_hp_out_ctls(codec);
4413         if (err < 0)
4414                 return err;
4415         err = create_speaker_out_ctls(codec);
4416         if (err < 0)
4417                 return err;
4418         err = create_indep_hp_ctls(codec);
4419         if (err < 0)
4420                 return err;
4421         err = create_loopback_mixing_ctl(codec);
4422         if (err < 0)
4423                 return err;
4424         err = create_hp_mic(codec);
4425         if (err < 0)
4426                 return err;
4427         err = create_input_ctls(codec);
4428         if (err < 0)
4429                 return err;
4430
4431         spec->const_channel_count = spec->ext_channel_count;
4432         /* check the multiple speaker and headphone pins */
4433         if (cfg->line_out_type != AUTO_PIN_SPEAKER_OUT)
4434                 spec->const_channel_count = max(spec->const_channel_count,
4435                                                 cfg->speaker_outs * 2);
4436         if (cfg->line_out_type != AUTO_PIN_HP_OUT)
4437                 spec->const_channel_count = max(spec->const_channel_count,
4438                                                 cfg->hp_outs * 2);
4439         spec->multiout.max_channels = max(spec->ext_channel_count,
4440                                           spec->const_channel_count);
4441
4442         err = check_auto_mute_availability(codec);
4443         if (err < 0)
4444                 return err;
4445
4446         err = check_dyn_adc_switch(codec);
4447         if (err < 0)
4448                 return err;
4449
4450         err = check_auto_mic_availability(codec);
4451         if (err < 0)
4452                 return err;
4453
4454         /* add stereo mix if available and not enabled yet */
4455         if (!spec->auto_mic && spec->mixer_nid &&
4456             spec->add_stereo_mix_input &&
4457             spec->input_mux.num_items > 1 &&
4458             snd_hda_get_bool_hint(codec, "add_stereo_mix_input") < 0) {
4459                 err = parse_capture_source(codec, spec->mixer_nid,
4460                                            CFG_IDX_MIX, spec->num_all_adcs,
4461                                            "Stereo Mix", 0);
4462                 if (err < 0)
4463                         return err;
4464         }
4465
4466
4467         err = create_capture_mixers(codec);
4468         if (err < 0)
4469                 return err;
4470
4471         err = parse_mic_boost(codec);
4472         if (err < 0)
4473                 return err;
4474
4475         /* create "Headphone Mic Jack Mode" if no input selection is
4476          * available (or user specifies add_jack_modes hint)
4477          */
4478         if (spec->hp_mic_pin &&
4479             (spec->auto_mic || spec->input_mux.num_items == 1 ||
4480              spec->add_jack_modes)) {
4481                 err = create_hp_mic_jack_mode(codec, spec->hp_mic_pin);
4482                 if (err < 0)
4483                         return err;
4484         }
4485
4486         if (spec->add_jack_modes) {
4487                 if (cfg->line_out_type != AUTO_PIN_SPEAKER_OUT) {
4488                         err = create_out_jack_modes(codec, cfg->line_outs,
4489                                                     cfg->line_out_pins);
4490                         if (err < 0)
4491                                 return err;
4492                 }
4493                 if (cfg->line_out_type != AUTO_PIN_HP_OUT) {
4494                         err = create_out_jack_modes(codec, cfg->hp_outs,
4495                                                     cfg->hp_pins);
4496                         if (err < 0)
4497                                 return err;
4498                 }
4499         }
4500
4501         /* mute all aamix input initially */
4502         if (spec->mixer_nid)
4503                 mute_all_mixer_nid(codec, spec->mixer_nid);
4504
4505  dig_only:
4506         parse_digital(codec);
4507
4508         if (spec->power_down_unused)
4509                 codec->power_filter = snd_hda_gen_path_power_filter;
4510
4511         if (!spec->no_analog && spec->beep_nid) {
4512                 err = snd_hda_attach_beep_device(codec, spec->beep_nid);
4513                 if (err < 0)
4514                         return err;
4515         }
4516
4517         return 1;
4518 }
4519 EXPORT_SYMBOL_GPL(snd_hda_gen_parse_auto_config);
4520
4521
4522 /*
4523  * Build control elements
4524  */
4525
4526 /* slave controls for virtual master */
4527 static const char * const slave_pfxs[] = {
4528         "Front", "Surround", "Center", "LFE", "Side",
4529         "Headphone", "Speaker", "Mono", "Line Out",
4530         "CLFE", "Bass Speaker", "PCM",
4531         "Speaker Front", "Speaker Surround", "Speaker CLFE", "Speaker Side",
4532         "Headphone Front", "Headphone Surround", "Headphone CLFE",
4533         "Headphone Side",
4534         NULL,
4535 };
4536
4537 int snd_hda_gen_build_controls(struct hda_codec *codec)
4538 {
4539         struct hda_gen_spec *spec = codec->spec;
4540         int err;
4541
4542         if (spec->kctls.used) {
4543                 err = snd_hda_add_new_ctls(codec, spec->kctls.list);
4544                 if (err < 0)
4545                         return err;
4546         }
4547
4548         if (spec->multiout.dig_out_nid) {
4549                 err = snd_hda_create_dig_out_ctls(codec,
4550                                                   spec->multiout.dig_out_nid,
4551                                                   spec->multiout.dig_out_nid,
4552                                                   spec->pcm_rec[1].pcm_type);
4553                 if (err < 0)
4554                         return err;
4555                 if (!spec->no_analog) {
4556                         err = snd_hda_create_spdif_share_sw(codec,
4557                                                             &spec->multiout);
4558                         if (err < 0)
4559                                 return err;
4560                         spec->multiout.share_spdif = 1;
4561                 }
4562         }
4563         if (spec->dig_in_nid) {
4564                 err = snd_hda_create_spdif_in_ctls(codec, spec->dig_in_nid);
4565                 if (err < 0)
4566                         return err;
4567         }
4568
4569         /* if we have no master control, let's create it */
4570         if (!spec->no_analog &&
4571             !snd_hda_find_mixer_ctl(codec, "Master Playback Volume")) {
4572                 err = snd_hda_add_vmaster(codec, "Master Playback Volume",
4573                                           spec->vmaster_tlv, slave_pfxs,
4574                                           "Playback Volume");
4575                 if (err < 0)
4576                         return err;
4577         }
4578         if (!spec->no_analog &&
4579             !snd_hda_find_mixer_ctl(codec, "Master Playback Switch")) {
4580                 err = __snd_hda_add_vmaster(codec, "Master Playback Switch",
4581                                             NULL, slave_pfxs,
4582                                             "Playback Switch",
4583                                             true, &spec->vmaster_mute.sw_kctl);
4584                 if (err < 0)
4585                         return err;
4586                 if (spec->vmaster_mute.hook) {
4587                         snd_hda_add_vmaster_hook(codec, &spec->vmaster_mute,
4588                                                  spec->vmaster_mute_enum);
4589                         snd_hda_sync_vmaster_hook(&spec->vmaster_mute);
4590                 }
4591         }
4592
4593         free_kctls(spec); /* no longer needed */
4594
4595         err = snd_hda_jack_add_kctls(codec, &spec->autocfg);
4596         if (err < 0)
4597                 return err;
4598
4599         return 0;
4600 }
4601 EXPORT_SYMBOL_GPL(snd_hda_gen_build_controls);
4602
4603
4604 /*
4605  * PCM definitions
4606  */
4607
4608 static void call_pcm_playback_hook(struct hda_pcm_stream *hinfo,
4609                                    struct hda_codec *codec,
4610                                    struct snd_pcm_substream *substream,
4611                                    int action)
4612 {
4613         struct hda_gen_spec *spec = codec->spec;
4614         if (spec->pcm_playback_hook)
4615                 spec->pcm_playback_hook(hinfo, codec, substream, action);
4616 }
4617
4618 static void call_pcm_capture_hook(struct hda_pcm_stream *hinfo,
4619                                   struct hda_codec *codec,
4620                                   struct snd_pcm_substream *substream,
4621                                   int action)
4622 {
4623         struct hda_gen_spec *spec = codec->spec;
4624         if (spec->pcm_capture_hook)
4625                 spec->pcm_capture_hook(hinfo, codec, substream, action);
4626 }
4627
4628 /*
4629  * Analog playback callbacks
4630  */
4631 static int playback_pcm_open(struct hda_pcm_stream *hinfo,
4632                              struct hda_codec *codec,
4633                              struct snd_pcm_substream *substream)
4634 {
4635         struct hda_gen_spec *spec = codec->spec;
4636         int err;
4637
4638         mutex_lock(&spec->pcm_mutex);
4639         err = snd_hda_multi_out_analog_open(codec,
4640                                             &spec->multiout, substream,
4641                                              hinfo);
4642         if (!err) {
4643                 spec->active_streams |= 1 << STREAM_MULTI_OUT;
4644                 call_pcm_playback_hook(hinfo, codec, substream,
4645                                        HDA_GEN_PCM_ACT_OPEN);
4646         }
4647         mutex_unlock(&spec->pcm_mutex);
4648         return err;
4649 }
4650
4651 static int playback_pcm_prepare(struct hda_pcm_stream *hinfo,
4652                                 struct hda_codec *codec,
4653                                 unsigned int stream_tag,
4654                                 unsigned int format,
4655                                 struct snd_pcm_substream *substream)
4656 {
4657         struct hda_gen_spec *spec = codec->spec;
4658         int err;
4659
4660         err = snd_hda_multi_out_analog_prepare(codec, &spec->multiout,
4661                                                stream_tag, format, substream);
4662         if (!err)
4663                 call_pcm_playback_hook(hinfo, codec, substream,
4664                                        HDA_GEN_PCM_ACT_PREPARE);
4665         return err;
4666 }
4667
4668 static int playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
4669                                 struct hda_codec *codec,
4670                                 struct snd_pcm_substream *substream)
4671 {
4672         struct hda_gen_spec *spec = codec->spec;
4673         int err;
4674
4675         err = snd_hda_multi_out_analog_cleanup(codec, &spec->multiout);
4676         if (!err)
4677                 call_pcm_playback_hook(hinfo, codec, substream,
4678                                        HDA_GEN_PCM_ACT_CLEANUP);
4679         return err;
4680 }
4681
4682 static int playback_pcm_close(struct hda_pcm_stream *hinfo,
4683                               struct hda_codec *codec,
4684                               struct snd_pcm_substream *substream)
4685 {
4686         struct hda_gen_spec *spec = codec->spec;
4687         mutex_lock(&spec->pcm_mutex);
4688         spec->active_streams &= ~(1 << STREAM_MULTI_OUT);
4689         call_pcm_playback_hook(hinfo, codec, substream,
4690                                HDA_GEN_PCM_ACT_CLOSE);
4691         mutex_unlock(&spec->pcm_mutex);
4692         return 0;
4693 }
4694
4695 static int capture_pcm_open(struct hda_pcm_stream *hinfo,
4696                             struct hda_codec *codec,
4697                             struct snd_pcm_substream *substream)
4698 {
4699         call_pcm_capture_hook(hinfo, codec, substream, HDA_GEN_PCM_ACT_OPEN);
4700         return 0;
4701 }
4702
4703 static int capture_pcm_prepare(struct hda_pcm_stream *hinfo,
4704                                struct hda_codec *codec,
4705                                unsigned int stream_tag,
4706                                unsigned int format,
4707                                struct snd_pcm_substream *substream)
4708 {
4709         snd_hda_codec_setup_stream(codec, hinfo->nid, stream_tag, 0, format);
4710         call_pcm_capture_hook(hinfo, codec, substream,
4711                               HDA_GEN_PCM_ACT_PREPARE);
4712         return 0;
4713 }
4714
4715 static int capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
4716                                struct hda_codec *codec,
4717                                struct snd_pcm_substream *substream)
4718 {
4719         snd_hda_codec_cleanup_stream(codec, hinfo->nid);
4720         call_pcm_capture_hook(hinfo, codec, substream,
4721                               HDA_GEN_PCM_ACT_CLEANUP);
4722         return 0;
4723 }
4724
4725 static int capture_pcm_close(struct hda_pcm_stream *hinfo,
4726                              struct hda_codec *codec,
4727                              struct snd_pcm_substream *substream)
4728 {
4729         call_pcm_capture_hook(hinfo, codec, substream, HDA_GEN_PCM_ACT_CLOSE);
4730         return 0;
4731 }
4732
4733 static int alt_playback_pcm_open(struct hda_pcm_stream *hinfo,
4734                                  struct hda_codec *codec,
4735                                  struct snd_pcm_substream *substream)
4736 {
4737         struct hda_gen_spec *spec = codec->spec;
4738         int err = 0;
4739
4740         mutex_lock(&spec->pcm_mutex);
4741         if (!spec->indep_hp_enabled)
4742                 err = -EBUSY;
4743         else
4744                 spec->active_streams |= 1 << STREAM_INDEP_HP;
4745         call_pcm_playback_hook(hinfo, codec, substream,
4746                                HDA_GEN_PCM_ACT_OPEN);
4747         mutex_unlock(&spec->pcm_mutex);
4748         return err;
4749 }
4750
4751 static int alt_playback_pcm_close(struct hda_pcm_stream *hinfo,
4752                                   struct hda_codec *codec,
4753                                   struct snd_pcm_substream *substream)
4754 {
4755         struct hda_gen_spec *spec = codec->spec;
4756         mutex_lock(&spec->pcm_mutex);
4757         spec->active_streams &= ~(1 << STREAM_INDEP_HP);
4758         call_pcm_playback_hook(hinfo, codec, substream,
4759                                HDA_GEN_PCM_ACT_CLOSE);
4760         mutex_unlock(&spec->pcm_mutex);
4761         return 0;
4762 }
4763
4764 static int alt_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
4765                                     struct hda_codec *codec,
4766                                     unsigned int stream_tag,
4767                                     unsigned int format,
4768                                     struct snd_pcm_substream *substream)
4769 {
4770         snd_hda_codec_setup_stream(codec, hinfo->nid, stream_tag, 0, format);
4771         call_pcm_playback_hook(hinfo, codec, substream,
4772                                HDA_GEN_PCM_ACT_PREPARE);
4773         return 0;
4774 }
4775
4776 static int alt_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
4777                                     struct hda_codec *codec,
4778                                     struct snd_pcm_substream *substream)
4779 {
4780         snd_hda_codec_cleanup_stream(codec, hinfo->nid);
4781         call_pcm_playback_hook(hinfo, codec, substream,
4782                                HDA_GEN_PCM_ACT_CLEANUP);
4783         return 0;
4784 }
4785
4786 /*
4787  * Digital out
4788  */
4789 static int dig_playback_pcm_open(struct hda_pcm_stream *hinfo,
4790                                  struct hda_codec *codec,
4791                                  struct snd_pcm_substream *substream)
4792 {
4793         struct hda_gen_spec *spec = codec->spec;
4794         return snd_hda_multi_out_dig_open(codec, &spec->multiout);
4795 }
4796
4797 static int dig_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
4798                                     struct hda_codec *codec,
4799                                     unsigned int stream_tag,
4800                                     unsigned int format,
4801                                     struct snd_pcm_substream *substream)
4802 {
4803         struct hda_gen_spec *spec = codec->spec;
4804         return snd_hda_multi_out_dig_prepare(codec, &spec->multiout,
4805                                              stream_tag, format, substream);
4806 }
4807
4808 static int dig_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
4809                                     struct hda_codec *codec,
4810                                     struct snd_pcm_substream *substream)
4811 {
4812         struct hda_gen_spec *spec = codec->spec;
4813         return snd_hda_multi_out_dig_cleanup(codec, &spec->multiout);
4814 }
4815
4816 static int dig_playback_pcm_close(struct hda_pcm_stream *hinfo,
4817                                   struct hda_codec *codec,
4818                                   struct snd_pcm_substream *substream)
4819 {
4820         struct hda_gen_spec *spec = codec->spec;
4821         return snd_hda_multi_out_dig_close(codec, &spec->multiout);
4822 }
4823
4824 /*
4825  * Analog capture
4826  */
4827 #define alt_capture_pcm_open    capture_pcm_open
4828 #define alt_capture_pcm_close   capture_pcm_close
4829
4830 static int alt_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
4831                                    struct hda_codec *codec,
4832                                    unsigned int stream_tag,
4833                                    unsigned int format,
4834                                    struct snd_pcm_substream *substream)
4835 {
4836         struct hda_gen_spec *spec = codec->spec;
4837
4838         snd_hda_codec_setup_stream(codec, spec->adc_nids[substream->number + 1],
4839                                    stream_tag, 0, format);
4840         call_pcm_capture_hook(hinfo, codec, substream,
4841                               HDA_GEN_PCM_ACT_PREPARE);
4842         return 0;
4843 }
4844
4845 static int alt_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
4846                                    struct hda_codec *codec,
4847                                    struct snd_pcm_substream *substream)
4848 {
4849         struct hda_gen_spec *spec = codec->spec;
4850
4851         snd_hda_codec_cleanup_stream(codec,
4852                                      spec->adc_nids[substream->number + 1]);
4853         call_pcm_capture_hook(hinfo, codec, substream,
4854                               HDA_GEN_PCM_ACT_CLEANUP);
4855         return 0;
4856 }
4857
4858 /*
4859  */
4860 static const struct hda_pcm_stream pcm_analog_playback = {
4861         .substreams = 1,
4862         .channels_min = 2,
4863         .channels_max = 8,
4864         /* NID is set in build_pcms */
4865         .ops = {
4866                 .open = playback_pcm_open,
4867                 .close = playback_pcm_close,
4868                 .prepare = playback_pcm_prepare,
4869                 .cleanup = playback_pcm_cleanup
4870         },
4871 };
4872
4873 static const struct hda_pcm_stream pcm_analog_capture = {
4874         .substreams = 1,
4875         .channels_min = 2,
4876         .channels_max = 2,
4877         /* NID is set in build_pcms */
4878         .ops = {
4879                 .open = capture_pcm_open,
4880                 .close = capture_pcm_close,
4881                 .prepare = capture_pcm_prepare,
4882                 .cleanup = capture_pcm_cleanup
4883         },
4884 };
4885
4886 static const struct hda_pcm_stream pcm_analog_alt_playback = {
4887         .substreams = 1,
4888         .channels_min = 2,
4889         .channels_max = 2,
4890         /* NID is set in build_pcms */
4891         .ops = {
4892                 .open = alt_playback_pcm_open,
4893                 .close = alt_playback_pcm_close,
4894                 .prepare = alt_playback_pcm_prepare,
4895                 .cleanup = alt_playback_pcm_cleanup
4896         },
4897 };
4898
4899 static const struct hda_pcm_stream pcm_analog_alt_capture = {
4900         .substreams = 2, /* can be overridden */
4901         .channels_min = 2,
4902         .channels_max = 2,
4903         /* NID is set in build_pcms */
4904         .ops = {
4905                 .open = alt_capture_pcm_open,
4906                 .close = alt_capture_pcm_close,
4907                 .prepare = alt_capture_pcm_prepare,
4908                 .cleanup = alt_capture_pcm_cleanup
4909         },
4910 };
4911
4912 static const struct hda_pcm_stream pcm_digital_playback = {
4913         .substreams = 1,
4914         .channels_min = 2,
4915         .channels_max = 2,
4916         /* NID is set in build_pcms */
4917         .ops = {
4918                 .open = dig_playback_pcm_open,
4919                 .close = dig_playback_pcm_close,
4920                 .prepare = dig_playback_pcm_prepare,
4921                 .cleanup = dig_playback_pcm_cleanup
4922         },
4923 };
4924
4925 static const struct hda_pcm_stream pcm_digital_capture = {
4926         .substreams = 1,
4927         .channels_min = 2,
4928         .channels_max = 2,
4929         /* NID is set in build_pcms */
4930 };
4931
4932 /* Used by build_pcms to flag that a PCM has no playback stream */
4933 static const struct hda_pcm_stream pcm_null_stream = {
4934         .substreams = 0,
4935         .channels_min = 0,
4936         .channels_max = 0,
4937 };
4938
4939 /*
4940  * dynamic changing ADC PCM streams
4941  */
4942 static bool dyn_adc_pcm_resetup(struct hda_codec *codec, int cur)
4943 {
4944         struct hda_gen_spec *spec = codec->spec;
4945         hda_nid_t new_adc = spec->adc_nids[spec->dyn_adc_idx[cur]];
4946
4947         if (spec->cur_adc && spec->cur_adc != new_adc) {
4948                 /* stream is running, let's swap the current ADC */
4949                 __snd_hda_codec_cleanup_stream(codec, spec->cur_adc, 1);
4950                 spec->cur_adc = new_adc;
4951                 snd_hda_codec_setup_stream(codec, new_adc,
4952                                            spec->cur_adc_stream_tag, 0,
4953                                            spec->cur_adc_format);
4954                 return true;
4955         }
4956         return false;
4957 }
4958
4959 /* analog capture with dynamic dual-adc changes */
4960 static int dyn_adc_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
4961                                        struct hda_codec *codec,
4962                                        unsigned int stream_tag,
4963                                        unsigned int format,
4964                                        struct snd_pcm_substream *substream)
4965 {
4966         struct hda_gen_spec *spec = codec->spec;
4967         spec->cur_adc = spec->adc_nids[spec->dyn_adc_idx[spec->cur_mux[0]]];
4968         spec->cur_adc_stream_tag = stream_tag;
4969         spec->cur_adc_format = format;
4970         snd_hda_codec_setup_stream(codec, spec->cur_adc, stream_tag, 0, format);
4971         return 0;
4972 }
4973
4974 static int dyn_adc_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
4975                                        struct hda_codec *codec,
4976                                        struct snd_pcm_substream *substream)
4977 {
4978         struct hda_gen_spec *spec = codec->spec;
4979         snd_hda_codec_cleanup_stream(codec, spec->cur_adc);
4980         spec->cur_adc = 0;
4981         return 0;
4982 }
4983
4984 static const struct hda_pcm_stream dyn_adc_pcm_analog_capture = {
4985         .substreams = 1,
4986         .channels_min = 2,
4987         .channels_max = 2,
4988         .nid = 0, /* fill later */
4989         .ops = {
4990                 .prepare = dyn_adc_capture_pcm_prepare,
4991                 .cleanup = dyn_adc_capture_pcm_cleanup
4992         },
4993 };
4994
4995 static void fill_pcm_stream_name(char *str, size_t len, const char *sfx,
4996                                  const char *chip_name)
4997 {
4998         char *p;
4999
5000         if (*str)
5001                 return;
5002         strlcpy(str, chip_name, len);
5003
5004         /* drop non-alnum chars after a space */
5005         for (p = strchr(str, ' '); p; p = strchr(p + 1, ' ')) {
5006                 if (!isalnum(p[1])) {
5007                         *p = 0;
5008                         break;
5009                 }
5010         }
5011         strlcat(str, sfx, len);
5012 }
5013
5014 /* build PCM streams based on the parsed results */
5015 int snd_hda_gen_build_pcms(struct hda_codec *codec)
5016 {
5017         struct hda_gen_spec *spec = codec->spec;
5018         struct hda_pcm *info = spec->pcm_rec;
5019         const struct hda_pcm_stream *p;
5020         bool have_multi_adcs;
5021
5022         codec->num_pcms = 1;
5023         codec->pcm_info = info;
5024
5025         if (spec->no_analog)
5026                 goto skip_analog;
5027
5028         fill_pcm_stream_name(spec->stream_name_analog,
5029                              sizeof(spec->stream_name_analog),
5030                              " Analog", codec->chip_name);
5031         info->name = spec->stream_name_analog;
5032
5033         if (spec->multiout.num_dacs > 0) {
5034                 p = spec->stream_analog_playback;
5035                 if (!p)
5036                         p = &pcm_analog_playback;
5037                 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *p;
5038                 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dac_nids[0];
5039                 info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max =
5040                         spec->multiout.max_channels;
5041                 if (spec->autocfg.line_out_type == AUTO_PIN_SPEAKER_OUT &&
5042                     spec->autocfg.line_outs == 2)
5043                         info->stream[SNDRV_PCM_STREAM_PLAYBACK].chmap =
5044                                 snd_pcm_2_1_chmaps;
5045         }
5046         if (spec->num_adc_nids) {
5047                 p = spec->stream_analog_capture;
5048                 if (!p) {
5049                         if (spec->dyn_adc_switch)
5050                                 p = &dyn_adc_pcm_analog_capture;
5051                         else
5052                                 p = &pcm_analog_capture;
5053                 }
5054                 info->stream[SNDRV_PCM_STREAM_CAPTURE] = *p;
5055                 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adc_nids[0];
5056         }
5057
5058  skip_analog:
5059         /* SPDIF for stream index #1 */
5060         if (spec->multiout.dig_out_nid || spec->dig_in_nid) {
5061                 fill_pcm_stream_name(spec->stream_name_digital,
5062                                      sizeof(spec->stream_name_digital),
5063                                      " Digital", codec->chip_name);
5064                 codec->num_pcms = 2;
5065                 codec->slave_dig_outs = spec->multiout.slave_dig_outs;
5066                 info = spec->pcm_rec + 1;
5067                 info->name = spec->stream_name_digital;
5068                 if (spec->dig_out_type)
5069                         info->pcm_type = spec->dig_out_type;
5070                 else
5071                         info->pcm_type = HDA_PCM_TYPE_SPDIF;
5072                 if (spec->multiout.dig_out_nid) {
5073                         p = spec->stream_digital_playback;
5074                         if (!p)
5075                                 p = &pcm_digital_playback;
5076                         info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *p;
5077                         info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dig_out_nid;
5078                 }
5079                 if (spec->dig_in_nid) {
5080                         p = spec->stream_digital_capture;
5081                         if (!p)
5082                                 p = &pcm_digital_capture;
5083                         info->stream[SNDRV_PCM_STREAM_CAPTURE] = *p;
5084                         info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->dig_in_nid;
5085                 }
5086         }
5087
5088         if (spec->no_analog)
5089                 return 0;
5090
5091         /* If the use of more than one ADC is requested for the current
5092          * model, configure a second analog capture-only PCM.
5093          */
5094         have_multi_adcs = (spec->num_adc_nids > 1) &&
5095                 !spec->dyn_adc_switch && !spec->auto_mic;
5096         /* Additional Analaog capture for index #2 */
5097         if (spec->alt_dac_nid || have_multi_adcs) {
5098                 fill_pcm_stream_name(spec->stream_name_alt_analog,
5099                                      sizeof(spec->stream_name_alt_analog),
5100                              " Alt Analog", codec->chip_name);
5101                 codec->num_pcms = 3;
5102                 info = spec->pcm_rec + 2;
5103                 info->name = spec->stream_name_alt_analog;
5104                 if (spec->alt_dac_nid) {
5105                         p = spec->stream_analog_alt_playback;
5106                         if (!p)
5107                                 p = &pcm_analog_alt_playback;
5108                         info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *p;
5109                         info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid =
5110                                 spec->alt_dac_nid;
5111                 } else {
5112                         info->stream[SNDRV_PCM_STREAM_PLAYBACK] =
5113                                 pcm_null_stream;
5114                         info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = 0;
5115                 }
5116                 if (have_multi_adcs) {
5117                         p = spec->stream_analog_alt_capture;
5118                         if (!p)
5119                                 p = &pcm_analog_alt_capture;
5120                         info->stream[SNDRV_PCM_STREAM_CAPTURE] = *p;
5121                         info->stream[SNDRV_PCM_STREAM_CAPTURE].nid =
5122                                 spec->adc_nids[1];
5123                         info->stream[SNDRV_PCM_STREAM_CAPTURE].substreams =
5124                                 spec->num_adc_nids - 1;
5125                 } else {
5126                         info->stream[SNDRV_PCM_STREAM_CAPTURE] =
5127                                 pcm_null_stream;
5128                         info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = 0;
5129                 }
5130         }
5131
5132         return 0;
5133 }
5134 EXPORT_SYMBOL_GPL(snd_hda_gen_build_pcms);
5135
5136
5137 /*
5138  * Standard auto-parser initializations
5139  */
5140
5141 /* configure the given path as a proper output */
5142 static void set_output_and_unmute(struct hda_codec *codec, int path_idx)
5143 {
5144         struct nid_path *path;
5145         hda_nid_t pin;
5146
5147         path = snd_hda_get_path_from_idx(codec, path_idx);
5148         if (!path || !path->depth)
5149                 return;
5150         pin = path->path[path->depth - 1];
5151         restore_pin_ctl(codec, pin);
5152         snd_hda_activate_path(codec, path, path->active,
5153                               aamix_default(codec->spec));
5154         set_pin_eapd(codec, pin, path->active);
5155 }
5156
5157 /* initialize primary output paths */
5158 static void init_multi_out(struct hda_codec *codec)
5159 {
5160         struct hda_gen_spec *spec = codec->spec;
5161         int i;
5162
5163         for (i = 0; i < spec->autocfg.line_outs; i++)
5164                 set_output_and_unmute(codec, spec->out_paths[i]);
5165 }
5166
5167
5168 static void __init_extra_out(struct hda_codec *codec, int num_outs, int *paths)
5169 {
5170         int i;
5171
5172         for (i = 0; i < num_outs; i++)
5173                 set_output_and_unmute(codec, paths[i]);
5174 }
5175
5176 /* initialize hp and speaker paths */
5177 static void init_extra_out(struct hda_codec *codec)
5178 {
5179         struct hda_gen_spec *spec = codec->spec;
5180
5181         if (spec->autocfg.line_out_type != AUTO_PIN_HP_OUT)
5182                 __init_extra_out(codec, spec->autocfg.hp_outs, spec->hp_paths);
5183         if (spec->autocfg.line_out_type != AUTO_PIN_SPEAKER_OUT)
5184                 __init_extra_out(codec, spec->autocfg.speaker_outs,
5185                                  spec->speaker_paths);
5186 }
5187
5188 /* initialize multi-io paths */
5189 static void init_multi_io(struct hda_codec *codec)
5190 {
5191         struct hda_gen_spec *spec = codec->spec;
5192         int i;
5193
5194         for (i = 0; i < spec->multi_ios; i++) {
5195                 hda_nid_t pin = spec->multi_io[i].pin;
5196                 struct nid_path *path;
5197                 path = get_multiio_path(codec, i);
5198                 if (!path)
5199                         continue;
5200                 if (!spec->multi_io[i].ctl_in)
5201                         spec->multi_io[i].ctl_in =
5202                                 snd_hda_codec_get_pin_target(codec, pin);
5203                 snd_hda_activate_path(codec, path, path->active,
5204                                       aamix_default(spec));
5205         }
5206 }
5207
5208 static void init_aamix_paths(struct hda_codec *codec)
5209 {
5210         struct hda_gen_spec *spec = codec->spec;
5211
5212         if (!spec->have_aamix_ctl)
5213                 return;
5214         update_aamix_paths(codec, spec->aamix_mode, spec->out_paths[0],
5215                            spec->aamix_out_paths[0],
5216                            spec->autocfg.line_out_type);
5217         update_aamix_paths(codec, spec->aamix_mode, spec->hp_paths[0],
5218                            spec->aamix_out_paths[1],
5219                            AUTO_PIN_HP_OUT);
5220         update_aamix_paths(codec, spec->aamix_mode, spec->speaker_paths[0],
5221                            spec->aamix_out_paths[2],
5222                            AUTO_PIN_SPEAKER_OUT);
5223 }
5224
5225 /* set up input pins and loopback paths */
5226 static void init_analog_input(struct hda_codec *codec)
5227 {
5228         struct hda_gen_spec *spec = codec->spec;
5229         struct auto_pin_cfg *cfg = &spec->autocfg;
5230         int i;
5231
5232         for (i = 0; i < cfg->num_inputs; i++) {
5233                 hda_nid_t nid = cfg->inputs[i].pin;
5234                 if (is_input_pin(codec, nid))
5235                         restore_pin_ctl(codec, nid);
5236
5237                 /* init loopback inputs */
5238                 if (spec->mixer_nid) {
5239                         resume_path_from_idx(codec, spec->loopback_paths[i]);
5240                         resume_path_from_idx(codec, spec->loopback_merge_path);
5241                 }
5242         }
5243 }
5244
5245 /* initialize ADC paths */
5246 static void init_input_src(struct hda_codec *codec)
5247 {
5248         struct hda_gen_spec *spec = codec->spec;
5249         struct hda_input_mux *imux = &spec->input_mux;
5250         struct nid_path *path;
5251         int i, c, nums;
5252
5253         if (spec->dyn_adc_switch)
5254                 nums = 1;
5255         else
5256                 nums = spec->num_adc_nids;
5257
5258         for (c = 0; c < nums; c++) {
5259                 for (i = 0; i < imux->num_items; i++) {
5260                         path = get_input_path(codec, c, i);
5261                         if (path) {
5262                                 bool active = path->active;
5263                                 if (i == spec->cur_mux[c])
5264                                         active = true;
5265                                 snd_hda_activate_path(codec, path, active, false);
5266                         }
5267                 }
5268                 if (spec->hp_mic)
5269                         update_hp_mic(codec, c, true);
5270         }
5271
5272         if (spec->cap_sync_hook)
5273                 spec->cap_sync_hook(codec, NULL, NULL);
5274 }
5275
5276 /* set right pin controls for digital I/O */
5277 static void init_digital(struct hda_codec *codec)
5278 {
5279         struct hda_gen_spec *spec = codec->spec;
5280         int i;
5281         hda_nid_t pin;
5282
5283         for (i = 0; i < spec->autocfg.dig_outs; i++)
5284                 set_output_and_unmute(codec, spec->digout_paths[i]);
5285         pin = spec->autocfg.dig_in_pin;
5286         if (pin) {
5287                 restore_pin_ctl(codec, pin);
5288                 resume_path_from_idx(codec, spec->digin_path);
5289         }
5290 }
5291
5292 /* clear unsol-event tags on unused pins; Conexant codecs seem to leave
5293  * invalid unsol tags by some reason
5294  */
5295 static void clear_unsol_on_unused_pins(struct hda_codec *codec)
5296 {
5297         int i;
5298
5299         for (i = 0; i < codec->init_pins.used; i++) {
5300                 struct hda_pincfg *pin = snd_array_elem(&codec->init_pins, i);
5301                 hda_nid_t nid = pin->nid;
5302                 if (is_jack_detectable(codec, nid) &&
5303                     !snd_hda_jack_tbl_get(codec, nid))
5304                         snd_hda_codec_update_cache(codec, nid, 0,
5305                                         AC_VERB_SET_UNSOLICITED_ENABLE, 0);
5306         }
5307 }
5308
5309 /*
5310  * initialize the generic spec;
5311  * this can be put as patch_ops.init function
5312  */
5313 int snd_hda_gen_init(struct hda_codec *codec)
5314 {
5315         struct hda_gen_spec *spec = codec->spec;
5316
5317         if (spec->init_hook)
5318                 spec->init_hook(codec);
5319
5320         snd_hda_apply_verbs(codec);
5321
5322         codec->cached_write = 1;
5323
5324         init_multi_out(codec);
5325         init_extra_out(codec);
5326         init_multi_io(codec);
5327         init_aamix_paths(codec);
5328         init_analog_input(codec);
5329         init_input_src(codec);
5330         init_digital(codec);
5331
5332         clear_unsol_on_unused_pins(codec);
5333
5334         /* call init functions of standard auto-mute helpers */
5335         update_automute_all(codec);
5336
5337         snd_hda_codec_flush_cache(codec);
5338
5339         if (spec->vmaster_mute.sw_kctl && spec->vmaster_mute.hook)
5340                 snd_hda_sync_vmaster_hook(&spec->vmaster_mute);
5341
5342         hda_call_check_power_status(codec, 0x01);
5343         return 0;
5344 }
5345 EXPORT_SYMBOL_GPL(snd_hda_gen_init);
5346
5347 /*
5348  * free the generic spec;
5349  * this can be put as patch_ops.free function
5350  */
5351 void snd_hda_gen_free(struct hda_codec *codec)
5352 {
5353         snd_hda_detach_beep_device(codec);
5354         snd_hda_gen_spec_free(codec->spec);
5355         kfree(codec->spec);
5356         codec->spec = NULL;
5357 }
5358 EXPORT_SYMBOL_GPL(snd_hda_gen_free);
5359
5360 #ifdef CONFIG_PM
5361 /*
5362  * check the loopback power save state;
5363  * this can be put as patch_ops.check_power_status function
5364  */
5365 int snd_hda_gen_check_power_status(struct hda_codec *codec, hda_nid_t nid)
5366 {
5367         struct hda_gen_spec *spec = codec->spec;
5368         return snd_hda_check_amp_list_power(codec, &spec->loopback, nid);
5369 }
5370 EXPORT_SYMBOL_GPL(snd_hda_gen_check_power_status);
5371 #endif
5372
5373
5374 /*
5375  * the generic codec support
5376  */
5377
5378 static const struct hda_codec_ops generic_patch_ops = {
5379         .build_controls = snd_hda_gen_build_controls,
5380         .build_pcms = snd_hda_gen_build_pcms,
5381         .init = snd_hda_gen_init,
5382         .free = snd_hda_gen_free,
5383         .unsol_event = snd_hda_jack_unsol_event,
5384 #ifdef CONFIG_PM
5385         .check_power_status = snd_hda_gen_check_power_status,
5386 #endif
5387 };
5388
5389 int snd_hda_parse_generic_codec(struct hda_codec *codec)
5390 {
5391         struct hda_gen_spec *spec;
5392         int err;
5393
5394         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
5395         if (!spec)
5396                 return -ENOMEM;
5397         snd_hda_gen_spec_init(spec);
5398         codec->spec = spec;
5399
5400         err = snd_hda_parse_pin_defcfg(codec, &spec->autocfg, NULL, 0);
5401         if (err < 0)
5402                 return err;
5403
5404         err = snd_hda_gen_parse_auto_config(codec, &spec->autocfg);
5405         if (err < 0)
5406                 goto error;
5407
5408         codec->patch_ops = generic_patch_ops;
5409         return 0;
5410
5411 error:
5412         snd_hda_gen_free(codec);
5413         return err;
5414 }
5415 EXPORT_SYMBOL_GPL(snd_hda_parse_generic_codec);
5416
5417 MODULE_LICENSE("GPL");
5418 MODULE_DESCRIPTION("Generic HD-audio codec parser");