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