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