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