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
1771         /* update jack retasking in case it modifies any of them */
1772         snd_hda_gen_hp_automute(codec, NULL);
1773         snd_hda_gen_line_automute(codec, NULL);
1774         snd_hda_gen_mic_autoswitch(codec, NULL);
1775
1776         return 0;
1777 }
1778
1779 static int ch_mode_put(struct snd_kcontrol *kcontrol,
1780                        struct snd_ctl_elem_value *ucontrol)
1781 {
1782         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1783         struct hda_gen_spec *spec = codec->spec;
1784         int i, ch;
1785
1786         ch = ucontrol->value.enumerated.item[0];
1787         if (ch < 0 || ch > spec->multi_ios)
1788                 return -EINVAL;
1789         if (ch == (spec->ext_channel_count - spec->min_channel_count) / 2)
1790                 return 0;
1791         spec->ext_channel_count = ch * 2 + spec->min_channel_count;
1792         for (i = 0; i < spec->multi_ios; i++)
1793                 set_multi_io(codec, i, i < ch);
1794         spec->multiout.max_channels = max(spec->ext_channel_count,
1795                                           spec->const_channel_count);
1796         if (spec->need_dac_fix)
1797                 spec->multiout.num_dacs = spec->multiout.max_channels / 2;
1798         return 1;
1799 }
1800
1801 static const struct snd_kcontrol_new channel_mode_enum = {
1802         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1803         .name = "Channel Mode",
1804         .info = ch_mode_info,
1805         .get = ch_mode_get,
1806         .put = ch_mode_put,
1807 };
1808
1809 static int create_multi_channel_mode(struct hda_codec *codec)
1810 {
1811         struct hda_gen_spec *spec = codec->spec;
1812
1813         if (spec->multi_ios > 0) {
1814                 if (!snd_hda_gen_add_kctl(spec, NULL, &channel_mode_enum))
1815                         return -ENOMEM;
1816         }
1817         return 0;
1818 }
1819
1820 /*
1821  * aamix loopback enable/disable switch
1822  */
1823
1824 #define loopback_mixing_info    indep_hp_info
1825
1826 static int loopback_mixing_get(struct snd_kcontrol *kcontrol,
1827                                struct snd_ctl_elem_value *ucontrol)
1828 {
1829         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1830         struct hda_gen_spec *spec = codec->spec;
1831         ucontrol->value.enumerated.item[0] = spec->aamix_mode;
1832         return 0;
1833 }
1834
1835 static void update_aamix_paths(struct hda_codec *codec, bool do_mix,
1836                                int nomix_path_idx, int mix_path_idx)
1837 {
1838         struct nid_path *nomix_path, *mix_path;
1839
1840         nomix_path = snd_hda_get_path_from_idx(codec, nomix_path_idx);
1841         mix_path = snd_hda_get_path_from_idx(codec, mix_path_idx);
1842         if (!nomix_path || !mix_path)
1843                 return;
1844         if (do_mix) {
1845                 snd_hda_activate_path(codec, nomix_path, false, true);
1846                 snd_hda_activate_path(codec, mix_path, true, true);
1847         } else {
1848                 snd_hda_activate_path(codec, mix_path, false, true);
1849                 snd_hda_activate_path(codec, nomix_path, true, true);
1850         }
1851 }
1852
1853 static int loopback_mixing_put(struct snd_kcontrol *kcontrol,
1854                                struct snd_ctl_elem_value *ucontrol)
1855 {
1856         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1857         struct hda_gen_spec *spec = codec->spec;
1858         unsigned int val = ucontrol->value.enumerated.item[0];
1859
1860         if (val == spec->aamix_mode)
1861                 return 0;
1862         spec->aamix_mode = val;
1863         update_aamix_paths(codec, val, spec->out_paths[0],
1864                            spec->aamix_out_paths[0]);
1865         update_aamix_paths(codec, val, spec->hp_paths[0],
1866                            spec->aamix_out_paths[1]);
1867         update_aamix_paths(codec, val, spec->speaker_paths[0],
1868                            spec->aamix_out_paths[2]);
1869         return 1;
1870 }
1871
1872 static const struct snd_kcontrol_new loopback_mixing_enum = {
1873         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1874         .name = "Loopback Mixing",
1875         .info = loopback_mixing_info,
1876         .get = loopback_mixing_get,
1877         .put = loopback_mixing_put,
1878 };
1879
1880 static int create_loopback_mixing_ctl(struct hda_codec *codec)
1881 {
1882         struct hda_gen_spec *spec = codec->spec;
1883
1884         if (!spec->mixer_nid)
1885                 return 0;
1886         if (!(spec->aamix_out_paths[0] || spec->aamix_out_paths[1] ||
1887               spec->aamix_out_paths[2]))
1888                 return 0;
1889         if (!snd_hda_gen_add_kctl(spec, NULL, &loopback_mixing_enum))
1890                 return -ENOMEM;
1891         return 0;
1892 }
1893
1894 /*
1895  * shared headphone/mic handling
1896  */
1897
1898 static void call_update_outputs(struct hda_codec *codec);
1899
1900 /* for shared I/O, change the pin-control accordingly */
1901 static void update_shared_mic_hp(struct hda_codec *codec, bool set_as_mic)
1902 {
1903         struct hda_gen_spec *spec = codec->spec;
1904         unsigned int val;
1905         hda_nid_t pin = spec->autocfg.inputs[1].pin;
1906         /* NOTE: this assumes that there are only two inputs, the
1907          * first is the real internal mic and the second is HP/mic jack.
1908          */
1909
1910         val = snd_hda_get_default_vref(codec, pin);
1911
1912         /* This pin does not have vref caps - let's enable vref on pin 0x18
1913            instead, as suggested by Realtek */
1914         if (val == AC_PINCTL_VREF_HIZ && spec->shared_mic_vref_pin) {
1915                 const hda_nid_t vref_pin = spec->shared_mic_vref_pin;
1916                 unsigned int vref_val = snd_hda_get_default_vref(codec, vref_pin);
1917                 if (vref_val != AC_PINCTL_VREF_HIZ)
1918                         snd_hda_set_pin_ctl_cache(codec, vref_pin,
1919                                         PIN_IN | (set_as_mic ? vref_val : 0));
1920         }
1921
1922         val = set_as_mic ? val | PIN_IN : PIN_HP;
1923         set_pin_target(codec, pin, val, true);
1924
1925         spec->automute_speaker = !set_as_mic;
1926         call_update_outputs(codec);
1927 }
1928
1929 /* create a shared input with the headphone out */
1930 static int create_shared_input(struct hda_codec *codec)
1931 {
1932         struct hda_gen_spec *spec = codec->spec;
1933         struct auto_pin_cfg *cfg = &spec->autocfg;
1934         unsigned int defcfg;
1935         hda_nid_t nid;
1936
1937         /* only one internal input pin? */
1938         if (cfg->num_inputs != 1)
1939                 return 0;
1940         defcfg = snd_hda_codec_get_pincfg(codec, cfg->inputs[0].pin);
1941         if (snd_hda_get_input_pin_attr(defcfg) != INPUT_PIN_ATTR_INT)
1942                 return 0;
1943
1944         if (cfg->hp_outs == 1 && cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
1945                 nid = cfg->hp_pins[0]; /* OK, we have a single HP-out */
1946         else if (cfg->line_outs == 1 && cfg->line_out_type == AUTO_PIN_HP_OUT)
1947                 nid = cfg->line_out_pins[0]; /* OK, we have a single line-out */
1948         else
1949                 return 0; /* both not available */
1950
1951         if (!(snd_hda_query_pin_caps(codec, nid) & AC_PINCAP_IN))
1952                 return 0; /* no input */
1953
1954         cfg->inputs[1].pin = nid;
1955         cfg->inputs[1].type = AUTO_PIN_MIC;
1956         cfg->num_inputs = 2;
1957         spec->shared_mic_hp = 1;
1958         snd_printdd("hda-codec: Enable shared I/O jack on NID 0x%x\n", nid);
1959         return 0;
1960 }
1961
1962
1963 /*
1964  * Parse input paths
1965  */
1966
1967 #ifdef CONFIG_PM
1968 /* add the powersave loopback-list entry */
1969 static void add_loopback_list(struct hda_gen_spec *spec, hda_nid_t mix, int idx)
1970 {
1971         struct hda_amp_list *list;
1972
1973         if (spec->num_loopbacks >= ARRAY_SIZE(spec->loopback_list) - 1)
1974                 return;
1975         list = spec->loopback_list + spec->num_loopbacks;
1976         list->nid = mix;
1977         list->dir = HDA_INPUT;
1978         list->idx = idx;
1979         spec->num_loopbacks++;
1980         spec->loopback.amplist = spec->loopback_list;
1981 }
1982 #else
1983 #define add_loopback_list(spec, mix, idx) /* NOP */
1984 #endif
1985
1986 /* create input playback/capture controls for the given pin */
1987 static int new_analog_input(struct hda_codec *codec, int input_idx,
1988                             hda_nid_t pin, const char *ctlname, int ctlidx,
1989                             hda_nid_t mix_nid)
1990 {
1991         struct hda_gen_spec *spec = codec->spec;
1992         struct nid_path *path;
1993         unsigned int val;
1994         int err, idx;
1995
1996         if (!nid_has_volume(codec, mix_nid, HDA_INPUT) &&
1997             !nid_has_mute(codec, mix_nid, HDA_INPUT))
1998                 return 0; /* no need for analog loopback */
1999
2000         path = snd_hda_add_new_path(codec, pin, mix_nid, 0);
2001         if (!path)
2002                 return -EINVAL;
2003         print_nid_path("loopback", path);
2004         spec->loopback_paths[input_idx] = snd_hda_get_path_idx(codec, path);
2005
2006         idx = path->idx[path->depth - 1];
2007         if (nid_has_volume(codec, mix_nid, HDA_INPUT)) {
2008                 val = HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT);
2009                 err = __add_pb_vol_ctrl(spec, HDA_CTL_WIDGET_VOL, ctlname, ctlidx, val);
2010                 if (err < 0)
2011                         return err;
2012                 path->ctls[NID_PATH_VOL_CTL] = val;
2013         }
2014
2015         if (nid_has_mute(codec, mix_nid, HDA_INPUT)) {
2016                 val = HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT);
2017                 err = __add_pb_sw_ctrl(spec, HDA_CTL_WIDGET_MUTE, ctlname, ctlidx, val);
2018                 if (err < 0)
2019                         return err;
2020                 path->ctls[NID_PATH_MUTE_CTL] = val;
2021         }
2022
2023         path->active = true;
2024         add_loopback_list(spec, mix_nid, idx);
2025         return 0;
2026 }
2027
2028 static int is_input_pin(struct hda_codec *codec, hda_nid_t nid)
2029 {
2030         unsigned int pincap = snd_hda_query_pin_caps(codec, nid);
2031         return (pincap & AC_PINCAP_IN) != 0;
2032 }
2033
2034 /* Parse the codec tree and retrieve ADCs */
2035 static int fill_adc_nids(struct hda_codec *codec)
2036 {
2037         struct hda_gen_spec *spec = codec->spec;
2038         hda_nid_t nid;
2039         hda_nid_t *adc_nids = spec->adc_nids;
2040         int max_nums = ARRAY_SIZE(spec->adc_nids);
2041         int i, nums = 0;
2042
2043         nid = codec->start_nid;
2044         for (i = 0; i < codec->num_nodes; i++, nid++) {
2045                 unsigned int caps = get_wcaps(codec, nid);
2046                 int type = get_wcaps_type(caps);
2047
2048                 if (type != AC_WID_AUD_IN || (caps & AC_WCAP_DIGITAL))
2049                         continue;
2050                 adc_nids[nums] = nid;
2051                 if (++nums >= max_nums)
2052                         break;
2053         }
2054         spec->num_adc_nids = nums;
2055         return nums;
2056 }
2057
2058 /* filter out invalid adc_nids that don't give all active input pins;
2059  * if needed, check whether dynamic ADC-switching is available
2060  */
2061 static int check_dyn_adc_switch(struct hda_codec *codec)
2062 {
2063         struct hda_gen_spec *spec = codec->spec;
2064         struct hda_input_mux *imux = &spec->input_mux;
2065         unsigned int ok_bits;
2066         int i, n, nums;
2067
2068  again:
2069         nums = 0;
2070         ok_bits = 0;
2071         for (n = 0; n < spec->num_adc_nids; n++) {
2072                 for (i = 0; i < imux->num_items; i++) {
2073                         if (!spec->input_paths[i][n])
2074                                 break;
2075                 }
2076                 if (i >= imux->num_items) {
2077                         ok_bits |= (1 << n);
2078                         nums++;
2079                 }
2080         }
2081
2082         if (!ok_bits) {
2083                 if (spec->shared_mic_hp) {
2084                         spec->shared_mic_hp = 0;
2085                         imux->num_items = 1;
2086                         goto again;
2087                 }
2088
2089                 /* check whether ADC-switch is possible */
2090                 for (i = 0; i < imux->num_items; i++) {
2091                         for (n = 0; n < spec->num_adc_nids; n++) {
2092                                 if (spec->input_paths[i][n]) {
2093                                         spec->dyn_adc_idx[i] = n;
2094                                         break;
2095                                 }
2096                         }
2097                 }
2098
2099                 snd_printdd("hda-codec: enabling ADC switching\n");
2100                 spec->dyn_adc_switch = 1;
2101         } else if (nums != spec->num_adc_nids) {
2102                 /* shrink the invalid adcs and input paths */
2103                 nums = 0;
2104                 for (n = 0; n < spec->num_adc_nids; n++) {
2105                         if (!(ok_bits & (1 << n)))
2106                                 continue;
2107                         if (n != nums) {
2108                                 spec->adc_nids[nums] = spec->adc_nids[n];
2109                                 for (i = 0; i < imux->num_items; i++) {
2110                                         invalidate_nid_path(codec,
2111                                                 spec->input_paths[i][nums]);
2112                                         spec->input_paths[i][nums] =
2113                                                 spec->input_paths[i][n];
2114                                 }
2115                         }
2116                         nums++;
2117                 }
2118                 spec->num_adc_nids = nums;
2119         }
2120
2121         if (imux->num_items == 1 || spec->shared_mic_hp) {
2122                 snd_printdd("hda-codec: reducing to a single ADC\n");
2123                 spec->num_adc_nids = 1; /* reduce to a single ADC */
2124         }
2125
2126         /* single index for individual volumes ctls */
2127         if (!spec->dyn_adc_switch && spec->multi_cap_vol)
2128                 spec->num_adc_nids = 1;
2129
2130         return 0;
2131 }
2132
2133 /* parse capture source paths from the given pin and create imux items */
2134 static int parse_capture_source(struct hda_codec *codec, hda_nid_t pin,
2135                                 int num_adcs, const char *label, int anchor)
2136 {
2137         struct hda_gen_spec *spec = codec->spec;
2138         struct hda_input_mux *imux = &spec->input_mux;
2139         int imux_idx = imux->num_items;
2140         bool imux_added = false;
2141         int c;
2142
2143         for (c = 0; c < num_adcs; c++) {
2144                 struct nid_path *path;
2145                 hda_nid_t adc = spec->adc_nids[c];
2146
2147                 if (!is_reachable_path(codec, pin, adc))
2148                         continue;
2149                 path = snd_hda_add_new_path(codec, pin, adc, anchor);
2150                 if (!path)
2151                         continue;
2152                 print_nid_path("input", path);
2153                 spec->input_paths[imux_idx][c] =
2154                         snd_hda_get_path_idx(codec, path);
2155
2156                 if (!imux_added) {
2157                         spec->imux_pins[imux->num_items] = pin;
2158                         snd_hda_add_imux_item(imux, label,
2159                                               imux->num_items, NULL);
2160                         imux_added = true;
2161                 }
2162         }
2163
2164         return 0;
2165 }
2166
2167 /*
2168  * create playback/capture controls for input pins
2169  */
2170 static int create_input_ctls(struct hda_codec *codec)
2171 {
2172         struct hda_gen_spec *spec = codec->spec;
2173         const struct auto_pin_cfg *cfg = &spec->autocfg;
2174         hda_nid_t mixer = spec->mixer_nid;
2175         int num_adcs;
2176         int i, err, type_idx = 0;
2177         const char *prev_label = NULL;
2178         unsigned int val;
2179
2180         num_adcs = fill_adc_nids(codec);
2181         if (num_adcs < 0)
2182                 return 0;
2183
2184         for (i = 0; i < cfg->num_inputs; i++) {
2185                 hda_nid_t pin;
2186                 const char *label;
2187
2188                 pin = cfg->inputs[i].pin;
2189                 if (!is_input_pin(codec, pin))
2190                         continue;
2191
2192                 label = hda_get_autocfg_input_label(codec, cfg, i);
2193                 if (prev_label && !strcmp(label, prev_label))
2194                         type_idx++;
2195                 else
2196                         type_idx = 0;
2197                 prev_label = label;
2198
2199                 val = PIN_IN;
2200                 if (cfg->inputs[i].type == AUTO_PIN_MIC)
2201                         val |= snd_hda_get_default_vref(codec, pin);
2202                 set_pin_target(codec, pin, val, false);
2203
2204                 if (mixer) {
2205                         if (is_reachable_path(codec, pin, mixer)) {
2206                                 err = new_analog_input(codec, i, pin,
2207                                                        label, type_idx, mixer);
2208                                 if (err < 0)
2209                                         return err;
2210                         }
2211                 }
2212
2213                 err = parse_capture_source(codec, pin, num_adcs, label, -mixer);
2214                 if (err < 0)
2215                         return err;
2216         }
2217
2218         if (mixer && spec->add_stereo_mix_input) {
2219                 err = parse_capture_source(codec, mixer, num_adcs,
2220                                            "Stereo Mix", 0);
2221                 if (err < 0)
2222                         return err;
2223         }
2224
2225         return 0;
2226 }
2227
2228
2229 /*
2230  * input source mux
2231  */
2232
2233 /* get the input path specified by the given adc and imux indices */
2234 static struct nid_path *get_input_path(struct hda_codec *codec, int adc_idx, int imux_idx)
2235 {
2236         struct hda_gen_spec *spec = codec->spec;
2237         if (spec->dyn_adc_switch)
2238                 adc_idx = spec->dyn_adc_idx[imux_idx];
2239         return snd_hda_get_path_from_idx(codec, spec->input_paths[imux_idx][adc_idx]);
2240 }
2241
2242 static int mux_select(struct hda_codec *codec, unsigned int adc_idx,
2243                       unsigned int idx);
2244
2245 static int mux_enum_info(struct snd_kcontrol *kcontrol,
2246                          struct snd_ctl_elem_info *uinfo)
2247 {
2248         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2249         struct hda_gen_spec *spec = codec->spec;
2250         return snd_hda_input_mux_info(&spec->input_mux, uinfo);
2251 }
2252
2253 static int mux_enum_get(struct snd_kcontrol *kcontrol,
2254                         struct snd_ctl_elem_value *ucontrol)
2255 {
2256         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2257         struct hda_gen_spec *spec = codec->spec;
2258         unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
2259
2260         ucontrol->value.enumerated.item[0] = spec->cur_mux[adc_idx];
2261         return 0;
2262 }
2263
2264 static int mux_enum_put(struct snd_kcontrol *kcontrol,
2265                             struct snd_ctl_elem_value *ucontrol)
2266 {
2267         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2268         unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
2269         return mux_select(codec, adc_idx,
2270                           ucontrol->value.enumerated.item[0]);
2271 }
2272
2273 static const struct snd_kcontrol_new cap_src_temp = {
2274         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2275         .name = "Input Source",
2276         .info = mux_enum_info,
2277         .get = mux_enum_get,
2278         .put = mux_enum_put,
2279 };
2280
2281 /*
2282  * capture volume and capture switch ctls
2283  */
2284
2285 typedef int (*put_call_t)(struct snd_kcontrol *kcontrol,
2286                           struct snd_ctl_elem_value *ucontrol);
2287
2288 /* call the given amp update function for all amps in the imux list at once */
2289 static int cap_put_caller(struct snd_kcontrol *kcontrol,
2290                           struct snd_ctl_elem_value *ucontrol,
2291                           put_call_t func, int type)
2292 {
2293         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2294         struct hda_gen_spec *spec = codec->spec;
2295         const struct hda_input_mux *imux;
2296         struct nid_path *path;
2297         int i, adc_idx, err = 0;
2298
2299         imux = &spec->input_mux;
2300         adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
2301         mutex_lock(&codec->control_mutex);
2302         /* we use the cache-only update at first since multiple input paths
2303          * may shared the same amp; by updating only caches, the redundant
2304          * writes to hardware can be reduced.
2305          */
2306         codec->cached_write = 1;
2307         for (i = 0; i < imux->num_items; i++) {
2308                 path = get_input_path(codec, adc_idx, i);
2309                 if (!path || !path->ctls[type])
2310                         continue;
2311                 kcontrol->private_value = path->ctls[type];
2312                 err = func(kcontrol, ucontrol);
2313                 if (err < 0)
2314                         goto error;
2315         }
2316  error:
2317         codec->cached_write = 0;
2318         mutex_unlock(&codec->control_mutex);
2319         snd_hda_codec_flush_amp_cache(codec); /* flush the updates */
2320         if (err >= 0 && spec->cap_sync_hook)
2321                 spec->cap_sync_hook(codec);
2322         return err;
2323 }
2324
2325 /* capture volume ctl callbacks */
2326 #define cap_vol_info            snd_hda_mixer_amp_volume_info
2327 #define cap_vol_get             snd_hda_mixer_amp_volume_get
2328 #define cap_vol_tlv             snd_hda_mixer_amp_tlv
2329
2330 static int cap_vol_put(struct snd_kcontrol *kcontrol,
2331                        struct snd_ctl_elem_value *ucontrol)
2332 {
2333         return cap_put_caller(kcontrol, ucontrol,
2334                               snd_hda_mixer_amp_volume_put,
2335                               NID_PATH_VOL_CTL);
2336 }
2337
2338 static const struct snd_kcontrol_new cap_vol_temp = {
2339         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2340         .name = "Capture Volume",
2341         .access = (SNDRV_CTL_ELEM_ACCESS_READWRITE |
2342                    SNDRV_CTL_ELEM_ACCESS_TLV_READ |
2343                    SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK),
2344         .info = cap_vol_info,
2345         .get = cap_vol_get,
2346         .put = cap_vol_put,
2347         .tlv = { .c = cap_vol_tlv },
2348 };
2349
2350 /* capture switch ctl callbacks */
2351 #define cap_sw_info             snd_ctl_boolean_stereo_info
2352 #define cap_sw_get              snd_hda_mixer_amp_switch_get
2353
2354 static int cap_sw_put(struct snd_kcontrol *kcontrol,
2355                       struct snd_ctl_elem_value *ucontrol)
2356 {
2357         return cap_put_caller(kcontrol, ucontrol,
2358                               snd_hda_mixer_amp_switch_put,
2359                               NID_PATH_MUTE_CTL);
2360 }
2361
2362 static const struct snd_kcontrol_new cap_sw_temp = {
2363         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2364         .name = "Capture Switch",
2365         .info = cap_sw_info,
2366         .get = cap_sw_get,
2367         .put = cap_sw_put,
2368 };
2369
2370 static int parse_capvol_in_path(struct hda_codec *codec, struct nid_path *path)
2371 {
2372         hda_nid_t nid;
2373         int i, depth;
2374
2375         path->ctls[NID_PATH_VOL_CTL] = path->ctls[NID_PATH_MUTE_CTL] = 0;
2376         for (depth = 0; depth < 3; depth++) {
2377                 if (depth >= path->depth)
2378                         return -EINVAL;
2379                 i = path->depth - depth - 1;
2380                 nid = path->path[i];
2381                 if (!path->ctls[NID_PATH_VOL_CTL]) {
2382                         if (nid_has_volume(codec, nid, HDA_OUTPUT))
2383                                 path->ctls[NID_PATH_VOL_CTL] =
2384                                         HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
2385                         else if (nid_has_volume(codec, nid, HDA_INPUT)) {
2386                                 int idx = path->idx[i];
2387                                 if (!depth && codec->single_adc_amp)
2388                                         idx = 0;
2389                                 path->ctls[NID_PATH_VOL_CTL] =
2390                                         HDA_COMPOSE_AMP_VAL(nid, 3, idx, HDA_INPUT);
2391                         }
2392                 }
2393                 if (!path->ctls[NID_PATH_MUTE_CTL]) {
2394                         if (nid_has_mute(codec, nid, HDA_OUTPUT))
2395                                 path->ctls[NID_PATH_MUTE_CTL] =
2396                                         HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
2397                         else if (nid_has_mute(codec, nid, HDA_INPUT)) {
2398                                 int idx = path->idx[i];
2399                                 if (!depth && codec->single_adc_amp)
2400                                         idx = 0;
2401                                 path->ctls[NID_PATH_MUTE_CTL] =
2402                                         HDA_COMPOSE_AMP_VAL(nid, 3, idx, HDA_INPUT);
2403                         }
2404                 }
2405         }
2406         return 0;
2407 }
2408
2409 static bool is_inv_dmic_pin(struct hda_codec *codec, hda_nid_t nid)
2410 {
2411         struct hda_gen_spec *spec = codec->spec;
2412         struct auto_pin_cfg *cfg = &spec->autocfg;
2413         unsigned int val;
2414         int i;
2415
2416         if (!spec->inv_dmic_split)
2417                 return false;
2418         for (i = 0; i < cfg->num_inputs; i++) {
2419                 if (cfg->inputs[i].pin != nid)
2420                         continue;
2421                 if (cfg->inputs[i].type != AUTO_PIN_MIC)
2422                         return false;
2423                 val = snd_hda_codec_get_pincfg(codec, nid);
2424                 return snd_hda_get_input_pin_attr(val) == INPUT_PIN_ATTR_INT;
2425         }
2426         return false;
2427 }
2428
2429 static int add_single_cap_ctl(struct hda_codec *codec, const char *label,
2430                               int idx, bool is_switch, unsigned int ctl,
2431                               bool inv_dmic)
2432 {
2433         struct hda_gen_spec *spec = codec->spec;
2434         char tmpname[44];
2435         int type = is_switch ? HDA_CTL_WIDGET_MUTE : HDA_CTL_WIDGET_VOL;
2436         const char *sfx = is_switch ? "Switch" : "Volume";
2437         unsigned int chs = inv_dmic ? 1 : 3;
2438         int err;
2439
2440         if (!ctl)
2441                 return 0;
2442
2443         if (label)
2444                 snprintf(tmpname, sizeof(tmpname),
2445                          "%s Capture %s", label, sfx);
2446         else
2447                 snprintf(tmpname, sizeof(tmpname),
2448                          "Capture %s", sfx);
2449         err = add_control(spec, type, tmpname, idx,
2450                           amp_val_replace_channels(ctl, chs));
2451         if (err < 0 || !inv_dmic)
2452                 return err;
2453
2454         /* Make independent right kcontrol */
2455         if (label)
2456                 snprintf(tmpname, sizeof(tmpname),
2457                          "Inverted %s Capture %s", label, sfx);
2458         else
2459                 snprintf(tmpname, sizeof(tmpname),
2460                          "Inverted Capture %s", sfx);
2461         return add_control(spec, type, tmpname, idx,
2462                            amp_val_replace_channels(ctl, 2));
2463 }
2464
2465 /* create single (and simple) capture volume and switch controls */
2466 static int create_single_cap_vol_ctl(struct hda_codec *codec, int idx,
2467                                      unsigned int vol_ctl, unsigned int sw_ctl,
2468                                      bool inv_dmic)
2469 {
2470         int err;
2471         err = add_single_cap_ctl(codec, NULL, idx, false, vol_ctl, inv_dmic);
2472         if (err < 0)
2473                 return err;
2474         err = add_single_cap_ctl(codec, NULL, idx, true, sw_ctl, inv_dmic);
2475         if (err < 0)
2476                 return err;
2477         return 0;
2478 }
2479
2480 /* create bound capture volume and switch controls */
2481 static int create_bind_cap_vol_ctl(struct hda_codec *codec, int idx,
2482                                    unsigned int vol_ctl, unsigned int sw_ctl)
2483 {
2484         struct hda_gen_spec *spec = codec->spec;
2485         struct snd_kcontrol_new *knew;
2486
2487         if (vol_ctl) {
2488                 knew = snd_hda_gen_add_kctl(spec, NULL, &cap_vol_temp);
2489                 if (!knew)
2490                         return -ENOMEM;
2491                 knew->index = idx;
2492                 knew->private_value = vol_ctl;
2493                 knew->subdevice = HDA_SUBDEV_AMP_FLAG;
2494         }
2495         if (sw_ctl) {
2496                 knew = snd_hda_gen_add_kctl(spec, NULL, &cap_sw_temp);
2497                 if (!knew)
2498                         return -ENOMEM;
2499                 knew->index = idx;
2500                 knew->private_value = sw_ctl;
2501                 knew->subdevice = HDA_SUBDEV_AMP_FLAG;
2502         }
2503         return 0;
2504 }
2505
2506 /* return the vol ctl when used first in the imux list */
2507 static unsigned int get_first_cap_ctl(struct hda_codec *codec, int idx, int type)
2508 {
2509         struct nid_path *path;
2510         unsigned int ctl;
2511         int i;
2512
2513         path = get_input_path(codec, 0, idx);
2514         if (!path)
2515                 return 0;
2516         ctl = path->ctls[type];
2517         if (!ctl)
2518                 return 0;
2519         for (i = 0; i < idx - 1; i++) {
2520                 path = get_input_path(codec, 0, i);
2521                 if (path && path->ctls[type] == ctl)
2522                         return 0;
2523         }
2524         return ctl;
2525 }
2526
2527 /* create individual capture volume and switch controls per input */
2528 static int create_multi_cap_vol_ctl(struct hda_codec *codec)
2529 {
2530         struct hda_gen_spec *spec = codec->spec;
2531         struct hda_input_mux *imux = &spec->input_mux;
2532         int i, err, type, type_idx = 0;
2533         const char *prev_label = NULL;
2534
2535         for (i = 0; i < imux->num_items; i++) {
2536                 const char *label;
2537                 bool inv_dmic;
2538                 label = hda_get_autocfg_input_label(codec, &spec->autocfg, i);
2539                 if (prev_label && !strcmp(label, prev_label))
2540                         type_idx++;
2541                 else
2542                         type_idx = 0;
2543                 prev_label = label;
2544                 inv_dmic = is_inv_dmic_pin(codec, spec->imux_pins[i]);
2545
2546                 for (type = 0; type < 2; type++) {
2547                         err = add_single_cap_ctl(codec, label, type_idx, type,
2548                                                  get_first_cap_ctl(codec, i, type),
2549                                                  inv_dmic);
2550                         if (err < 0)
2551                                 return err;
2552                 }
2553         }
2554         return 0;
2555 }
2556
2557 static int create_capture_mixers(struct hda_codec *codec)
2558 {
2559         struct hda_gen_spec *spec = codec->spec;
2560         struct hda_input_mux *imux = &spec->input_mux;
2561         int i, n, nums, err;
2562
2563         if (spec->dyn_adc_switch)
2564                 nums = 1;
2565         else
2566                 nums = spec->num_adc_nids;
2567
2568         if (!spec->auto_mic && imux->num_items > 1) {
2569                 struct snd_kcontrol_new *knew;
2570                 const char *name;
2571                 name = nums > 1 ? "Input Source" : "Capture Source";
2572                 knew = snd_hda_gen_add_kctl(spec, name, &cap_src_temp);
2573                 if (!knew)
2574                         return -ENOMEM;
2575                 knew->count = nums;
2576         }
2577
2578         for (n = 0; n < nums; n++) {
2579                 bool multi = false;
2580                 bool inv_dmic = false;
2581                 int vol, sw;
2582
2583                 vol = sw = 0;
2584                 for (i = 0; i < imux->num_items; i++) {
2585                         struct nid_path *path;
2586                         path = get_input_path(codec, n, i);
2587                         if (!path)
2588                                 continue;
2589                         parse_capvol_in_path(codec, path);
2590                         if (!vol)
2591                                 vol = path->ctls[NID_PATH_VOL_CTL];
2592                         else if (vol != path->ctls[NID_PATH_VOL_CTL])
2593                                 multi = true;
2594                         if (!sw)
2595                                 sw = path->ctls[NID_PATH_MUTE_CTL];
2596                         else if (sw != path->ctls[NID_PATH_MUTE_CTL])
2597                                 multi = true;
2598                         if (is_inv_dmic_pin(codec, spec->imux_pins[i]))
2599                                 inv_dmic = true;
2600                 }
2601
2602                 if (!multi)
2603                         err = create_single_cap_vol_ctl(codec, n, vol, sw,
2604                                                         inv_dmic);
2605                 else if (!spec->multi_cap_vol)
2606                         err = create_bind_cap_vol_ctl(codec, n, vol, sw);
2607                 else
2608                         err = create_multi_cap_vol_ctl(codec);
2609                 if (err < 0)
2610                         return err;
2611         }
2612
2613         return 0;
2614 }
2615
2616 /*
2617  * add mic boosts if needed
2618  */
2619 static int parse_mic_boost(struct hda_codec *codec)
2620 {
2621         struct hda_gen_spec *spec = codec->spec;
2622         struct auto_pin_cfg *cfg = &spec->autocfg;
2623         int i, err;
2624         int type_idx = 0;
2625         hda_nid_t nid;
2626         const char *prev_label = NULL;
2627
2628         for (i = 0; i < cfg->num_inputs; i++) {
2629                 if (cfg->inputs[i].type > AUTO_PIN_MIC)
2630                         break;
2631                 nid = cfg->inputs[i].pin;
2632                 if (get_wcaps(codec, nid) & AC_WCAP_IN_AMP) {
2633                         const char *label;
2634                         char boost_label[44];
2635                         struct nid_path *path;
2636                         unsigned int val;
2637
2638                         label = hda_get_autocfg_input_label(codec, cfg, i);
2639                         if (prev_label && !strcmp(label, prev_label))
2640                                 type_idx++;
2641                         else
2642                                 type_idx = 0;
2643                         prev_label = label;
2644
2645                         snprintf(boost_label, sizeof(boost_label),
2646                                  "%s Boost Volume", label);
2647                         val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT);
2648                         err = add_control(spec, HDA_CTL_WIDGET_VOL,
2649                                           boost_label, type_idx, val);
2650                         if (err < 0)
2651                                 return err;
2652
2653                         path = snd_hda_get_nid_path(codec, nid, 0);
2654                         if (path)
2655                                 path->ctls[NID_PATH_BOOST_CTL] = val;
2656                 }
2657         }
2658         return 0;
2659 }
2660
2661 /*
2662  * parse digital I/Os and set up NIDs in BIOS auto-parse mode
2663  */
2664 static void parse_digital(struct hda_codec *codec)
2665 {
2666         struct hda_gen_spec *spec = codec->spec;
2667         struct nid_path *path;
2668         int i, nums;
2669         hda_nid_t dig_nid, pin;
2670
2671         /* support multiple SPDIFs; the secondary is set up as a slave */
2672         nums = 0;
2673         for (i = 0; i < spec->autocfg.dig_outs; i++) {
2674                 pin = spec->autocfg.dig_out_pins[i];
2675                 dig_nid = look_for_dac(codec, pin, true);
2676                 if (!dig_nid)
2677                         continue;
2678                 path = snd_hda_add_new_path(codec, dig_nid, pin, 0);
2679                 if (!path)
2680                         continue;
2681                 print_nid_path("digout", path);
2682                 path->active = true;
2683                 spec->digout_paths[i] = snd_hda_get_path_idx(codec, path);
2684                 set_pin_target(codec, pin, PIN_OUT, false);
2685                 if (!nums) {
2686                         spec->multiout.dig_out_nid = dig_nid;
2687                         spec->dig_out_type = spec->autocfg.dig_out_type[0];
2688                 } else {
2689                         spec->multiout.slave_dig_outs = spec->slave_dig_outs;
2690                         if (nums >= ARRAY_SIZE(spec->slave_dig_outs) - 1)
2691                         break;
2692                         spec->slave_dig_outs[nums - 1] = dig_nid;
2693                 }
2694                 nums++;
2695         }
2696
2697         if (spec->autocfg.dig_in_pin) {
2698                 pin = spec->autocfg.dig_in_pin;
2699                 dig_nid = codec->start_nid;
2700                 for (i = 0; i < codec->num_nodes; i++, dig_nid++) {
2701                         unsigned int wcaps = get_wcaps(codec, dig_nid);
2702                         if (get_wcaps_type(wcaps) != AC_WID_AUD_IN)
2703                                 continue;
2704                         if (!(wcaps & AC_WCAP_DIGITAL))
2705                                 continue;
2706                         path = snd_hda_add_new_path(codec, pin, dig_nid, 0);
2707                         if (path) {
2708                                 print_nid_path("digin", path);
2709                                 path->active = true;
2710                                 spec->dig_in_nid = dig_nid;
2711                                 spec->digin_path = snd_hda_get_path_idx(codec, path);
2712                                 set_pin_target(codec, pin, PIN_IN, false);
2713                                 break;
2714                         }
2715                 }
2716         }
2717 }
2718
2719
2720 /*
2721  * input MUX handling
2722  */
2723
2724 static bool dyn_adc_pcm_resetup(struct hda_codec *codec, int cur);
2725
2726 /* select the given imux item; either unmute exclusively or select the route */
2727 static int mux_select(struct hda_codec *codec, unsigned int adc_idx,
2728                       unsigned int idx)
2729 {
2730         struct hda_gen_spec *spec = codec->spec;
2731         const struct hda_input_mux *imux;
2732         struct nid_path *path;
2733
2734         imux = &spec->input_mux;
2735         if (!imux->num_items)
2736                 return 0;
2737
2738         if (idx >= imux->num_items)
2739                 idx = imux->num_items - 1;
2740         if (spec->cur_mux[adc_idx] == idx)
2741                 return 0;
2742
2743         path = get_input_path(codec, adc_idx, spec->cur_mux[adc_idx]);
2744         if (!path)
2745                 return 0;
2746         if (path->active)
2747                 snd_hda_activate_path(codec, path, false, false);
2748
2749         spec->cur_mux[adc_idx] = idx;
2750
2751         if (spec->shared_mic_hp)
2752                 update_shared_mic_hp(codec, spec->cur_mux[adc_idx]);
2753
2754         if (spec->dyn_adc_switch)
2755                 dyn_adc_pcm_resetup(codec, idx);
2756
2757         path = get_input_path(codec, adc_idx, idx);
2758         if (!path)
2759                 return 0;
2760         if (path->active)
2761                 return 0;
2762         snd_hda_activate_path(codec, path, true, false);
2763         if (spec->cap_sync_hook)
2764                 spec->cap_sync_hook(codec);
2765         return 1;
2766 }
2767
2768
2769 /*
2770  * Jack detections for HP auto-mute and mic-switch
2771  */
2772
2773 /* check each pin in the given array; returns true if any of them is plugged */
2774 static bool detect_jacks(struct hda_codec *codec, int num_pins, hda_nid_t *pins)
2775 {
2776         int i, present = 0;
2777
2778         for (i = 0; i < num_pins; i++) {
2779                 hda_nid_t nid = pins[i];
2780                 if (!nid)
2781                         break;
2782                 /* don't detect pins retasked as inputs */
2783                 if (snd_hda_codec_get_pin_target(codec, nid) & AC_PINCTL_IN_EN)
2784                         continue;
2785                 present |= snd_hda_jack_detect(codec, nid);
2786         }
2787         return present;
2788 }
2789
2790 /* standard HP/line-out auto-mute helper */
2791 static void do_automute(struct hda_codec *codec, int num_pins, hda_nid_t *pins,
2792                         bool mute)
2793 {
2794         struct hda_gen_spec *spec = codec->spec;
2795         int i;
2796
2797         for (i = 0; i < num_pins; i++) {
2798                 hda_nid_t nid = pins[i];
2799                 unsigned int val;
2800                 if (!nid)
2801                         break;
2802                 /* don't reset VREF value in case it's controlling
2803                  * the amp (see alc861_fixup_asus_amp_vref_0f())
2804                  */
2805                 if (spec->keep_vref_in_automute)
2806                         val = snd_hda_codec_get_pin_target(codec, nid) & ~PIN_HP;
2807                 else
2808                         val = 0;
2809                 if (!mute)
2810                         val |= snd_hda_codec_get_pin_target(codec, nid);
2811                 /* here we call update_pin_ctl() so that the pinctl is changed
2812                  * without changing the pinctl target value;
2813                  * the original target value will be still referred at the
2814                  * init / resume again
2815                  */
2816                 update_pin_ctl(codec, nid, val);
2817                 set_pin_eapd(codec, nid, !mute);
2818         }
2819 }
2820
2821 /* Toggle outputs muting */
2822 void snd_hda_gen_update_outputs(struct hda_codec *codec)
2823 {
2824         struct hda_gen_spec *spec = codec->spec;
2825         int on;
2826
2827         /* Control HP pins/amps depending on master_mute state;
2828          * in general, HP pins/amps control should be enabled in all cases,
2829          * but currently set only for master_mute, just to be safe
2830          */
2831         if (!spec->shared_mic_hp) /* don't change HP-pin when shared with mic */
2832                 do_automute(codec, ARRAY_SIZE(spec->autocfg.hp_pins),
2833                     spec->autocfg.hp_pins, spec->master_mute);
2834
2835         if (!spec->automute_speaker)
2836                 on = 0;
2837         else
2838                 on = spec->hp_jack_present | spec->line_jack_present;
2839         on |= spec->master_mute;
2840         do_automute(codec, ARRAY_SIZE(spec->autocfg.speaker_pins),
2841                     spec->autocfg.speaker_pins, on);
2842
2843         /* toggle line-out mutes if needed, too */
2844         /* if LO is a copy of either HP or Speaker, don't need to handle it */
2845         if (spec->autocfg.line_out_pins[0] == spec->autocfg.hp_pins[0] ||
2846             spec->autocfg.line_out_pins[0] == spec->autocfg.speaker_pins[0])
2847                 return;
2848         if (!spec->automute_lo)
2849                 on = 0;
2850         else
2851                 on = spec->hp_jack_present;
2852         on |= spec->master_mute;
2853         do_automute(codec, ARRAY_SIZE(spec->autocfg.line_out_pins),
2854                     spec->autocfg.line_out_pins, on);
2855 }
2856 EXPORT_SYMBOL_HDA(snd_hda_gen_update_outputs);
2857
2858 static void call_update_outputs(struct hda_codec *codec)
2859 {
2860         struct hda_gen_spec *spec = codec->spec;
2861         if (spec->automute_hook)
2862                 spec->automute_hook(codec);
2863         else
2864                 snd_hda_gen_update_outputs(codec);
2865 }
2866
2867 /* standard HP-automute helper */
2868 void snd_hda_gen_hp_automute(struct hda_codec *codec, struct hda_jack_tbl *jack)
2869 {
2870         struct hda_gen_spec *spec = codec->spec;
2871
2872         spec->hp_jack_present =
2873                 detect_jacks(codec, ARRAY_SIZE(spec->autocfg.hp_pins),
2874                              spec->autocfg.hp_pins);
2875         if (!spec->detect_hp || (!spec->automute_speaker && !spec->automute_lo))
2876                 return;
2877         call_update_outputs(codec);
2878 }
2879 EXPORT_SYMBOL_HDA(snd_hda_gen_hp_automute);
2880
2881 /* standard line-out-automute helper */
2882 void snd_hda_gen_line_automute(struct hda_codec *codec, struct hda_jack_tbl *jack)
2883 {
2884         struct hda_gen_spec *spec = codec->spec;
2885
2886         if (spec->autocfg.line_out_type == AUTO_PIN_SPEAKER_OUT)
2887                 return;
2888         /* check LO jack only when it's different from HP */
2889         if (spec->autocfg.line_out_pins[0] == spec->autocfg.hp_pins[0])
2890                 return;
2891
2892         spec->line_jack_present =
2893                 detect_jacks(codec, ARRAY_SIZE(spec->autocfg.line_out_pins),
2894                              spec->autocfg.line_out_pins);
2895         if (!spec->automute_speaker || !spec->detect_lo)
2896                 return;
2897         call_update_outputs(codec);
2898 }
2899 EXPORT_SYMBOL_HDA(snd_hda_gen_line_automute);
2900
2901 /* standard mic auto-switch helper */
2902 void snd_hda_gen_mic_autoswitch(struct hda_codec *codec, struct hda_jack_tbl *jack)
2903 {
2904         struct hda_gen_spec *spec = codec->spec;
2905         int i;
2906
2907         if (!spec->auto_mic)
2908                 return;
2909
2910         for (i = spec->am_num_entries - 1; i > 0; i--) {
2911                 hda_nid_t pin = spec->am_entry[i].pin;
2912                 /* don't detect pins retasked as outputs */
2913                 if (snd_hda_codec_get_pin_target(codec, pin) & AC_PINCTL_OUT_EN)
2914                         continue;
2915                 if (snd_hda_jack_detect(codec, pin)) {
2916                         mux_select(codec, 0, spec->am_entry[i].idx);
2917                         return;
2918                 }
2919         }
2920         mux_select(codec, 0, spec->am_entry[0].idx);
2921 }
2922 EXPORT_SYMBOL_HDA(snd_hda_gen_mic_autoswitch);
2923
2924 /*
2925  * Auto-Mute mode mixer enum support
2926  */
2927 static int automute_mode_info(struct snd_kcontrol *kcontrol,
2928                               struct snd_ctl_elem_info *uinfo)
2929 {
2930         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2931         struct hda_gen_spec *spec = codec->spec;
2932         static const char * const texts3[] = {
2933                 "Disabled", "Speaker Only", "Line Out+Speaker"
2934         };
2935
2936         if (spec->automute_speaker_possible && spec->automute_lo_possible)
2937                 return snd_hda_enum_helper_info(kcontrol, uinfo, 3, texts3);
2938         return snd_hda_enum_bool_helper_info(kcontrol, uinfo);
2939 }
2940
2941 static int automute_mode_get(struct snd_kcontrol *kcontrol,
2942                              struct snd_ctl_elem_value *ucontrol)
2943 {
2944         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2945         struct hda_gen_spec *spec = codec->spec;
2946         unsigned int val = 0;
2947         if (spec->automute_speaker)
2948                 val++;
2949         if (spec->automute_lo)
2950                 val++;
2951
2952         ucontrol->value.enumerated.item[0] = val;
2953         return 0;
2954 }
2955
2956 static int automute_mode_put(struct snd_kcontrol *kcontrol,
2957                              struct snd_ctl_elem_value *ucontrol)
2958 {
2959         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2960         struct hda_gen_spec *spec = codec->spec;
2961
2962         switch (ucontrol->value.enumerated.item[0]) {
2963         case 0:
2964                 if (!spec->automute_speaker && !spec->automute_lo)
2965                         return 0;
2966                 spec->automute_speaker = 0;
2967                 spec->automute_lo = 0;
2968                 break;
2969         case 1:
2970                 if (spec->automute_speaker_possible) {
2971                         if (!spec->automute_lo && spec->automute_speaker)
2972                                 return 0;
2973                         spec->automute_speaker = 1;
2974                         spec->automute_lo = 0;
2975                 } else if (spec->automute_lo_possible) {
2976                         if (spec->automute_lo)
2977                                 return 0;
2978                         spec->automute_lo = 1;
2979                 } else
2980                         return -EINVAL;
2981                 break;
2982         case 2:
2983                 if (!spec->automute_lo_possible || !spec->automute_speaker_possible)
2984                         return -EINVAL;
2985                 if (spec->automute_speaker && spec->automute_lo)
2986                         return 0;
2987                 spec->automute_speaker = 1;
2988                 spec->automute_lo = 1;
2989                 break;
2990         default:
2991                 return -EINVAL;
2992         }
2993         call_update_outputs(codec);
2994         return 1;
2995 }
2996
2997 static const struct snd_kcontrol_new automute_mode_enum = {
2998         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2999         .name = "Auto-Mute Mode",
3000         .info = automute_mode_info,
3001         .get = automute_mode_get,
3002         .put = automute_mode_put,
3003 };
3004
3005 static int add_automute_mode_enum(struct hda_codec *codec)
3006 {
3007         struct hda_gen_spec *spec = codec->spec;
3008
3009         if (!snd_hda_gen_add_kctl(spec, NULL, &automute_mode_enum))
3010                 return -ENOMEM;
3011         return 0;
3012 }
3013
3014 /*
3015  * Check the availability of HP/line-out auto-mute;
3016  * Set up appropriately if really supported
3017  */
3018 static int check_auto_mute_availability(struct hda_codec *codec)
3019 {
3020         struct hda_gen_spec *spec = codec->spec;
3021         struct auto_pin_cfg *cfg = &spec->autocfg;
3022         int present = 0;
3023         int i, err;
3024
3025         if (cfg->hp_pins[0])
3026                 present++;
3027         if (cfg->line_out_pins[0])
3028                 present++;
3029         if (cfg->speaker_pins[0])
3030                 present++;
3031         if (present < 2) /* need two different output types */
3032                 return 0;
3033
3034         if (!cfg->speaker_pins[0] &&
3035             cfg->line_out_type == AUTO_PIN_SPEAKER_OUT) {
3036                 memcpy(cfg->speaker_pins, cfg->line_out_pins,
3037                        sizeof(cfg->speaker_pins));
3038                 cfg->speaker_outs = cfg->line_outs;
3039         }
3040
3041         if (!cfg->hp_pins[0] &&
3042             cfg->line_out_type == AUTO_PIN_HP_OUT) {
3043                 memcpy(cfg->hp_pins, cfg->line_out_pins,
3044                        sizeof(cfg->hp_pins));
3045                 cfg->hp_outs = cfg->line_outs;
3046         }
3047
3048         for (i = 0; i < cfg->hp_outs; i++) {
3049                 hda_nid_t nid = cfg->hp_pins[i];
3050                 if (!is_jack_detectable(codec, nid))
3051                         continue;
3052                 snd_printdd("hda-codec: Enable HP auto-muting on NID 0x%x\n",
3053                             nid);
3054                 snd_hda_jack_detect_enable_callback(codec, nid, HDA_GEN_HP_EVENT,
3055                                                     spec->hp_automute_hook ?
3056                                                     spec->hp_automute_hook :
3057                                                     snd_hda_gen_hp_automute);
3058                 spec->detect_hp = 1;
3059         }
3060
3061         if (cfg->line_out_type == AUTO_PIN_LINE_OUT && cfg->line_outs) {
3062                 if (cfg->speaker_outs)
3063                         for (i = 0; i < cfg->line_outs; i++) {
3064                                 hda_nid_t nid = cfg->line_out_pins[i];
3065                                 if (!is_jack_detectable(codec, nid))
3066                                         continue;
3067                                 snd_printdd("hda-codec: Enable Line-Out auto-muting on NID 0x%x\n", nid);
3068                                 snd_hda_jack_detect_enable_callback(codec, nid,
3069                                                                     HDA_GEN_FRONT_EVENT,
3070                                                                     spec->line_automute_hook ?
3071                                                                     spec->line_automute_hook :
3072                                                                     snd_hda_gen_line_automute);
3073                                 spec->detect_lo = 1;
3074                         }
3075                 spec->automute_lo_possible = spec->detect_hp;
3076         }
3077
3078         spec->automute_speaker_possible = cfg->speaker_outs &&
3079                 (spec->detect_hp || spec->detect_lo);
3080
3081         spec->automute_lo = spec->automute_lo_possible;
3082         spec->automute_speaker = spec->automute_speaker_possible;
3083
3084         if (spec->automute_speaker_possible || spec->automute_lo_possible) {
3085                 /* create a control for automute mode */
3086                 err = add_automute_mode_enum(codec);
3087                 if (err < 0)
3088                         return err;
3089         }
3090         return 0;
3091 }
3092
3093 /* check whether all auto-mic pins are valid; setup indices if OK */
3094 static bool auto_mic_check_imux(struct hda_codec *codec)
3095 {
3096         struct hda_gen_spec *spec = codec->spec;
3097         const struct hda_input_mux *imux;
3098         int i;
3099
3100         imux = &spec->input_mux;
3101         for (i = 0; i < spec->am_num_entries; i++) {
3102                 spec->am_entry[i].idx =
3103                         find_idx_in_nid_list(spec->am_entry[i].pin,
3104                                              spec->imux_pins, imux->num_items);
3105                 if (spec->am_entry[i].idx < 0)
3106                         return false; /* no corresponding imux */
3107         }
3108
3109         /* we don't need the jack detection for the first pin */
3110         for (i = 1; i < spec->am_num_entries; i++)
3111                 snd_hda_jack_detect_enable_callback(codec,
3112                                                     spec->am_entry[i].pin,
3113                                                     HDA_GEN_MIC_EVENT,
3114                                                     spec->mic_autoswitch_hook ?
3115                                                     spec->mic_autoswitch_hook :
3116                                                     snd_hda_gen_mic_autoswitch);
3117         return true;
3118 }
3119
3120 static int compare_attr(const void *ap, const void *bp)
3121 {
3122         const struct automic_entry *a = ap;
3123         const struct automic_entry *b = bp;
3124         return (int)(a->attr - b->attr);
3125 }
3126
3127 /*
3128  * Check the availability of auto-mic switch;
3129  * Set up if really supported
3130  */
3131 static int check_auto_mic_availability(struct hda_codec *codec)
3132 {
3133         struct hda_gen_spec *spec = codec->spec;
3134         struct auto_pin_cfg *cfg = &spec->autocfg;
3135         unsigned int types;
3136         int i, num_pins;
3137
3138         if (spec->suppress_auto_mic)
3139                 return 0;
3140
3141         types = 0;
3142         num_pins = 0;
3143         for (i = 0; i < cfg->num_inputs; i++) {
3144                 hda_nid_t nid = cfg->inputs[i].pin;
3145                 unsigned int attr;
3146                 attr = snd_hda_codec_get_pincfg(codec, nid);
3147                 attr = snd_hda_get_input_pin_attr(attr);
3148                 if (types & (1 << attr))
3149                         return 0; /* already occupied */
3150                 switch (attr) {
3151                 case INPUT_PIN_ATTR_INT:
3152                         if (cfg->inputs[i].type != AUTO_PIN_MIC)
3153                                 return 0; /* invalid type */
3154                         break;
3155                 case INPUT_PIN_ATTR_UNUSED:
3156                         return 0; /* invalid entry */
3157                 default:
3158                         if (cfg->inputs[i].type > AUTO_PIN_LINE_IN)
3159                                 return 0; /* invalid type */
3160                         if (!spec->line_in_auto_switch &&
3161                             cfg->inputs[i].type != AUTO_PIN_MIC)
3162                                 return 0; /* only mic is allowed */
3163                         if (!is_jack_detectable(codec, nid))
3164                                 return 0; /* no unsol support */
3165                         break;
3166                 }
3167                 if (num_pins >= MAX_AUTO_MIC_PINS)
3168                         return 0;
3169                 types |= (1 << attr);
3170                 spec->am_entry[num_pins].pin = nid;
3171                 spec->am_entry[num_pins].attr = attr;
3172                 num_pins++;
3173         }
3174
3175         if (num_pins < 2)
3176                 return 0;
3177
3178         spec->am_num_entries = num_pins;
3179         /* sort the am_entry in the order of attr so that the pin with a
3180          * higher attr will be selected when the jack is plugged.
3181          */
3182         sort(spec->am_entry, num_pins, sizeof(spec->am_entry[0]),
3183              compare_attr, NULL);
3184
3185         if (!auto_mic_check_imux(codec))
3186                 return 0;
3187
3188         spec->auto_mic = 1;
3189         spec->num_adc_nids = 1;
3190         spec->cur_mux[0] = spec->am_entry[0].idx;
3191         snd_printdd("hda-codec: Enable auto-mic switch on NID 0x%x/0x%x/0x%x\n",
3192                     spec->am_entry[0].pin,
3193                     spec->am_entry[1].pin,
3194                     spec->am_entry[2].pin);
3195
3196         return 0;
3197 }
3198
3199
3200 /*
3201  * Parse the given BIOS configuration and set up the hda_gen_spec
3202  *
3203  * return 1 if successful, 0 if the proper config is not found,
3204  * or a negative error code
3205  */
3206 int snd_hda_gen_parse_auto_config(struct hda_codec *codec,
3207                                   struct auto_pin_cfg *cfg)
3208 {
3209         struct hda_gen_spec *spec = codec->spec;
3210         int err;
3211
3212         if (cfg != &spec->autocfg) {
3213                 spec->autocfg = *cfg;
3214                 cfg = &spec->autocfg;
3215         }
3216
3217         if (!cfg->line_outs) {
3218                 if (cfg->dig_outs || cfg->dig_in_pin) {
3219                         spec->multiout.max_channels = 2;
3220                         spec->no_analog = 1;
3221                         goto dig_only;
3222                 }
3223                 return 0; /* can't find valid BIOS pin config */
3224         }
3225
3226         if (!spec->no_primary_hp &&
3227             cfg->line_out_type == AUTO_PIN_SPEAKER_OUT &&
3228             cfg->line_outs <= cfg->hp_outs) {
3229                 /* use HP as primary out */
3230                 cfg->speaker_outs = cfg->line_outs;
3231                 memcpy(cfg->speaker_pins, cfg->line_out_pins,
3232                        sizeof(cfg->speaker_pins));
3233                 cfg->line_outs = cfg->hp_outs;
3234                 memcpy(cfg->line_out_pins, cfg->hp_pins, sizeof(cfg->hp_pins));
3235                 cfg->hp_outs = 0;
3236                 memset(cfg->hp_pins, 0, sizeof(cfg->hp_pins));
3237                 cfg->line_out_type = AUTO_PIN_HP_OUT;
3238         }
3239
3240         err = parse_output_paths(codec);
3241         if (err < 0)
3242                 return err;
3243         err = create_multi_channel_mode(codec);
3244         if (err < 0)
3245                 return err;
3246         err = create_multi_out_ctls(codec, cfg);
3247         if (err < 0)
3248                 return err;
3249         err = create_hp_out_ctls(codec);
3250         if (err < 0)
3251                 return err;
3252         err = create_speaker_out_ctls(codec);
3253         if (err < 0)
3254                 return err;
3255         err = create_indep_hp_ctls(codec);
3256         if (err < 0)
3257                 return err;
3258         err = create_loopback_mixing_ctl(codec);
3259         if (err < 0)
3260                 return err;
3261         err = create_shared_input(codec);
3262         if (err < 0)
3263                 return err;
3264         err = create_input_ctls(codec);
3265         if (err < 0)
3266                 return err;
3267
3268         spec->const_channel_count = spec->ext_channel_count;
3269         /* check the multiple speaker and headphone pins */
3270         if (cfg->line_out_type != AUTO_PIN_SPEAKER_OUT)
3271                 spec->const_channel_count = max(spec->const_channel_count,
3272                                                 cfg->speaker_outs * 2);
3273         if (cfg->line_out_type != AUTO_PIN_HP_OUT)
3274                 spec->const_channel_count = max(spec->const_channel_count,
3275                                                 cfg->hp_outs * 2);
3276         spec->multiout.max_channels = max(spec->ext_channel_count,
3277                                           spec->const_channel_count);
3278
3279         err = check_auto_mute_availability(codec);
3280         if (err < 0)
3281                 return err;
3282
3283         err = check_dyn_adc_switch(codec);
3284         if (err < 0)
3285                 return err;
3286
3287         if (!spec->shared_mic_hp) {
3288                 err = check_auto_mic_availability(codec);
3289                 if (err < 0)
3290                         return err;
3291         }
3292
3293         err = create_capture_mixers(codec);
3294         if (err < 0)
3295                 return err;
3296
3297         err = parse_mic_boost(codec);
3298         if (err < 0)
3299                 return err;
3300
3301  dig_only:
3302         parse_digital(codec);
3303
3304         return 1;
3305 }
3306 EXPORT_SYMBOL_HDA(snd_hda_gen_parse_auto_config);
3307
3308
3309 /*
3310  * Build control elements
3311  */
3312
3313 /* slave controls for virtual master */
3314 static const char * const slave_pfxs[] = {
3315         "Front", "Surround", "Center", "LFE", "Side",
3316         "Headphone", "Speaker", "Mono", "Line Out",
3317         "CLFE", "Bass Speaker", "PCM",
3318         "Speaker Front", "Speaker Surround", "Speaker CLFE", "Speaker Side",
3319         "Headphone Front", "Headphone Surround", "Headphone CLFE",
3320         "Headphone Side",
3321         NULL,
3322 };
3323
3324 int snd_hda_gen_build_controls(struct hda_codec *codec)
3325 {
3326         struct hda_gen_spec *spec = codec->spec;
3327         int err;
3328
3329         if (spec->kctls.used) {
3330                 err = snd_hda_add_new_ctls(codec, spec->kctls.list);
3331                 if (err < 0)
3332                         return err;
3333         }
3334
3335         if (spec->multiout.dig_out_nid) {
3336                 err = snd_hda_create_dig_out_ctls(codec,
3337                                                   spec->multiout.dig_out_nid,
3338                                                   spec->multiout.dig_out_nid,
3339                                                   spec->pcm_rec[1].pcm_type);
3340                 if (err < 0)
3341                         return err;
3342                 if (!spec->no_analog) {
3343                         err = snd_hda_create_spdif_share_sw(codec,
3344                                                             &spec->multiout);
3345                         if (err < 0)
3346                                 return err;
3347                         spec->multiout.share_spdif = 1;
3348                 }
3349         }
3350         if (spec->dig_in_nid) {
3351                 err = snd_hda_create_spdif_in_ctls(codec, spec->dig_in_nid);
3352                 if (err < 0)
3353                         return err;
3354         }
3355
3356         /* if we have no master control, let's create it */
3357         if (!spec->no_analog &&
3358             !snd_hda_find_mixer_ctl(codec, "Master Playback Volume")) {
3359                 unsigned int vmaster_tlv[4];
3360                 snd_hda_set_vmaster_tlv(codec, spec->vmaster_nid,
3361                                         HDA_OUTPUT, vmaster_tlv);
3362                 err = snd_hda_add_vmaster(codec, "Master Playback Volume",
3363                                           vmaster_tlv, slave_pfxs,
3364                                           "Playback Volume");
3365                 if (err < 0)
3366                         return err;
3367         }
3368         if (!spec->no_analog &&
3369             !snd_hda_find_mixer_ctl(codec, "Master Playback Switch")) {
3370                 err = __snd_hda_add_vmaster(codec, "Master Playback Switch",
3371                                             NULL, slave_pfxs,
3372                                             "Playback Switch",
3373                                             true, &spec->vmaster_mute.sw_kctl);
3374                 if (err < 0)
3375                         return err;
3376                 if (spec->vmaster_mute.hook)
3377                         snd_hda_add_vmaster_hook(codec, &spec->vmaster_mute,
3378                                                  spec->vmaster_mute_enum);
3379         }
3380
3381         free_kctls(spec); /* no longer needed */
3382
3383         if (spec->shared_mic_hp) {
3384                 int err;
3385                 int nid = spec->autocfg.inputs[1].pin;
3386                 err = snd_hda_jack_add_kctl(codec, nid, "Headphone Mic", 0);
3387                 if (err < 0)
3388                         return err;
3389                 err = snd_hda_jack_detect_enable(codec, nid, 0);
3390                 if (err < 0)
3391                         return err;
3392         }
3393
3394         err = snd_hda_jack_add_kctls(codec, &spec->autocfg);
3395         if (err < 0)
3396                 return err;
3397
3398         return 0;
3399 }
3400 EXPORT_SYMBOL_HDA(snd_hda_gen_build_controls);
3401
3402
3403 /*
3404  * PCM definitions
3405  */
3406
3407 static void call_pcm_playback_hook(struct hda_pcm_stream *hinfo,
3408                                    struct hda_codec *codec,
3409                                    struct snd_pcm_substream *substream,
3410                                    int action)
3411 {
3412         struct hda_gen_spec *spec = codec->spec;
3413         if (spec->pcm_playback_hook)
3414                 spec->pcm_playback_hook(hinfo, codec, substream, action);
3415 }
3416
3417 /*
3418  * Analog playback callbacks
3419  */
3420 static int playback_pcm_open(struct hda_pcm_stream *hinfo,
3421                              struct hda_codec *codec,
3422                              struct snd_pcm_substream *substream)
3423 {
3424         struct hda_gen_spec *spec = codec->spec;
3425         int err;
3426
3427         mutex_lock(&spec->pcm_mutex);
3428         err = snd_hda_multi_out_analog_open(codec,
3429                                             &spec->multiout, substream,
3430                                              hinfo);
3431         if (!err) {
3432                 spec->active_streams |= 1 << STREAM_MULTI_OUT;
3433                 call_pcm_playback_hook(hinfo, codec, substream,
3434                                        HDA_GEN_PCM_ACT_OPEN);
3435         }
3436         mutex_unlock(&spec->pcm_mutex);
3437         return err;
3438 }
3439
3440 static int playback_pcm_prepare(struct hda_pcm_stream *hinfo,
3441                                 struct hda_codec *codec,
3442                                 unsigned int stream_tag,
3443                                 unsigned int format,
3444                                 struct snd_pcm_substream *substream)
3445 {
3446         struct hda_gen_spec *spec = codec->spec;
3447         int err;
3448
3449         err = snd_hda_multi_out_analog_prepare(codec, &spec->multiout,
3450                                                stream_tag, format, substream);
3451         if (!err)
3452                 call_pcm_playback_hook(hinfo, codec, substream,
3453                                        HDA_GEN_PCM_ACT_PREPARE);
3454         return err;
3455 }
3456
3457 static int playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
3458                                 struct hda_codec *codec,
3459                                 struct snd_pcm_substream *substream)
3460 {
3461         struct hda_gen_spec *spec = codec->spec;
3462         int err;
3463
3464         err = snd_hda_multi_out_analog_cleanup(codec, &spec->multiout);
3465         if (!err)
3466                 call_pcm_playback_hook(hinfo, codec, substream,
3467                                        HDA_GEN_PCM_ACT_CLEANUP);
3468         return err;
3469 }
3470
3471 static int playback_pcm_close(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         mutex_lock(&spec->pcm_mutex);
3477         spec->active_streams &= ~(1 << STREAM_MULTI_OUT);
3478         call_pcm_playback_hook(hinfo, codec, substream,
3479                                HDA_GEN_PCM_ACT_CLOSE);
3480         mutex_unlock(&spec->pcm_mutex);
3481         return 0;
3482 }
3483
3484 static int alt_playback_pcm_open(struct hda_pcm_stream *hinfo,
3485                                  struct hda_codec *codec,
3486                                  struct snd_pcm_substream *substream)
3487 {
3488         struct hda_gen_spec *spec = codec->spec;
3489         int err = 0;
3490
3491         mutex_lock(&spec->pcm_mutex);
3492         if (!spec->indep_hp_enabled)
3493                 err = -EBUSY;
3494         else
3495                 spec->active_streams |= 1 << STREAM_INDEP_HP;
3496         call_pcm_playback_hook(hinfo, codec, substream,
3497                                HDA_GEN_PCM_ACT_OPEN);
3498         mutex_unlock(&spec->pcm_mutex);
3499         return err;
3500 }
3501
3502 static int alt_playback_pcm_close(struct hda_pcm_stream *hinfo,
3503                                   struct hda_codec *codec,
3504                                   struct snd_pcm_substream *substream)
3505 {
3506         struct hda_gen_spec *spec = codec->spec;
3507         mutex_lock(&spec->pcm_mutex);
3508         spec->active_streams &= ~(1 << STREAM_INDEP_HP);
3509         call_pcm_playback_hook(hinfo, codec, substream,
3510                                HDA_GEN_PCM_ACT_CLOSE);
3511         mutex_unlock(&spec->pcm_mutex);
3512         return 0;
3513 }
3514
3515 static int alt_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
3516                                     struct hda_codec *codec,
3517                                     unsigned int stream_tag,
3518                                     unsigned int format,
3519                                     struct snd_pcm_substream *substream)
3520 {
3521         snd_hda_codec_setup_stream(codec, hinfo->nid, stream_tag, 0, format);
3522         call_pcm_playback_hook(hinfo, codec, substream,
3523                                HDA_GEN_PCM_ACT_PREPARE);
3524         return 0;
3525 }
3526
3527 static int alt_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
3528                                     struct hda_codec *codec,
3529                                     struct snd_pcm_substream *substream)
3530 {
3531         snd_hda_codec_cleanup_stream(codec, hinfo->nid);
3532         call_pcm_playback_hook(hinfo, codec, substream,
3533                                HDA_GEN_PCM_ACT_CLEANUP);
3534         return 0;
3535 }
3536
3537 /*
3538  * Digital out
3539  */
3540 static int dig_playback_pcm_open(struct hda_pcm_stream *hinfo,
3541                                  struct hda_codec *codec,
3542                                  struct snd_pcm_substream *substream)
3543 {
3544         struct hda_gen_spec *spec = codec->spec;
3545         return snd_hda_multi_out_dig_open(codec, &spec->multiout);
3546 }
3547
3548 static int dig_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
3549                                     struct hda_codec *codec,
3550                                     unsigned int stream_tag,
3551                                     unsigned int format,
3552                                     struct snd_pcm_substream *substream)
3553 {
3554         struct hda_gen_spec *spec = codec->spec;
3555         return snd_hda_multi_out_dig_prepare(codec, &spec->multiout,
3556                                              stream_tag, format, substream);
3557 }
3558
3559 static int dig_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
3560                                     struct hda_codec *codec,
3561                                     struct snd_pcm_substream *substream)
3562 {
3563         struct hda_gen_spec *spec = codec->spec;
3564         return snd_hda_multi_out_dig_cleanup(codec, &spec->multiout);
3565 }
3566
3567 static int dig_playback_pcm_close(struct hda_pcm_stream *hinfo,
3568                                   struct hda_codec *codec,
3569                                   struct snd_pcm_substream *substream)
3570 {
3571         struct hda_gen_spec *spec = codec->spec;
3572         return snd_hda_multi_out_dig_close(codec, &spec->multiout);
3573 }
3574
3575 /*
3576  * Analog capture
3577  */
3578 static int alt_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
3579                                    struct hda_codec *codec,
3580                                    unsigned int stream_tag,
3581                                    unsigned int format,
3582                                    struct snd_pcm_substream *substream)
3583 {
3584         struct hda_gen_spec *spec = codec->spec;
3585
3586         snd_hda_codec_setup_stream(codec, spec->adc_nids[substream->number + 1],
3587                                    stream_tag, 0, format);
3588         return 0;
3589 }
3590
3591 static int alt_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
3592                                    struct hda_codec *codec,
3593                                    struct snd_pcm_substream *substream)
3594 {
3595         struct hda_gen_spec *spec = codec->spec;
3596
3597         snd_hda_codec_cleanup_stream(codec,
3598                                      spec->adc_nids[substream->number + 1]);
3599         return 0;
3600 }
3601
3602 /*
3603  */
3604 static const struct hda_pcm_stream pcm_analog_playback = {
3605         .substreams = 1,
3606         .channels_min = 2,
3607         .channels_max = 8,
3608         /* NID is set in build_pcms */
3609         .ops = {
3610                 .open = playback_pcm_open,
3611                 .close = playback_pcm_close,
3612                 .prepare = playback_pcm_prepare,
3613                 .cleanup = playback_pcm_cleanup
3614         },
3615 };
3616
3617 static const struct hda_pcm_stream pcm_analog_capture = {
3618         .substreams = 1,
3619         .channels_min = 2,
3620         .channels_max = 2,
3621         /* NID is set in build_pcms */
3622 };
3623
3624 static const struct hda_pcm_stream pcm_analog_alt_playback = {
3625         .substreams = 1,
3626         .channels_min = 2,
3627         .channels_max = 2,
3628         /* NID is set in build_pcms */
3629         .ops = {
3630                 .open = alt_playback_pcm_open,
3631                 .close = alt_playback_pcm_close,
3632                 .prepare = alt_playback_pcm_prepare,
3633                 .cleanup = alt_playback_pcm_cleanup
3634         },
3635 };
3636
3637 static const struct hda_pcm_stream pcm_analog_alt_capture = {
3638         .substreams = 2, /* can be overridden */
3639         .channels_min = 2,
3640         .channels_max = 2,
3641         /* NID is set in build_pcms */
3642         .ops = {
3643                 .prepare = alt_capture_pcm_prepare,
3644                 .cleanup = alt_capture_pcm_cleanup
3645         },
3646 };
3647
3648 static const struct hda_pcm_stream pcm_digital_playback = {
3649         .substreams = 1,
3650         .channels_min = 2,
3651         .channels_max = 2,
3652         /* NID is set in build_pcms */
3653         .ops = {
3654                 .open = dig_playback_pcm_open,
3655                 .close = dig_playback_pcm_close,
3656                 .prepare = dig_playback_pcm_prepare,
3657                 .cleanup = dig_playback_pcm_cleanup
3658         },
3659 };
3660
3661 static const struct hda_pcm_stream pcm_digital_capture = {
3662         .substreams = 1,
3663         .channels_min = 2,
3664         .channels_max = 2,
3665         /* NID is set in build_pcms */
3666 };
3667
3668 /* Used by build_pcms to flag that a PCM has no playback stream */
3669 static const struct hda_pcm_stream pcm_null_stream = {
3670         .substreams = 0,
3671         .channels_min = 0,
3672         .channels_max = 0,
3673 };
3674
3675 /*
3676  * dynamic changing ADC PCM streams
3677  */
3678 static bool dyn_adc_pcm_resetup(struct hda_codec *codec, int cur)
3679 {
3680         struct hda_gen_spec *spec = codec->spec;
3681         hda_nid_t new_adc = spec->adc_nids[spec->dyn_adc_idx[cur]];
3682
3683         if (spec->cur_adc && spec->cur_adc != new_adc) {
3684                 /* stream is running, let's swap the current ADC */
3685                 __snd_hda_codec_cleanup_stream(codec, spec->cur_adc, 1);
3686                 spec->cur_adc = new_adc;
3687                 snd_hda_codec_setup_stream(codec, new_adc,
3688                                            spec->cur_adc_stream_tag, 0,
3689                                            spec->cur_adc_format);
3690                 return true;
3691         }
3692         return false;
3693 }
3694
3695 /* analog capture with dynamic dual-adc changes */
3696 static int dyn_adc_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
3697                                        struct hda_codec *codec,
3698                                        unsigned int stream_tag,
3699                                        unsigned int format,
3700                                        struct snd_pcm_substream *substream)
3701 {
3702         struct hda_gen_spec *spec = codec->spec;
3703         spec->cur_adc = spec->adc_nids[spec->dyn_adc_idx[spec->cur_mux[0]]];
3704         spec->cur_adc_stream_tag = stream_tag;
3705         spec->cur_adc_format = format;
3706         snd_hda_codec_setup_stream(codec, spec->cur_adc, stream_tag, 0, format);
3707         return 0;
3708 }
3709
3710 static int dyn_adc_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
3711                                        struct hda_codec *codec,
3712                                        struct snd_pcm_substream *substream)
3713 {
3714         struct hda_gen_spec *spec = codec->spec;
3715         snd_hda_codec_cleanup_stream(codec, spec->cur_adc);
3716         spec->cur_adc = 0;
3717         return 0;
3718 }
3719
3720 static const struct hda_pcm_stream dyn_adc_pcm_analog_capture = {
3721         .substreams = 1,
3722         .channels_min = 2,
3723         .channels_max = 2,
3724         .nid = 0, /* fill later */
3725         .ops = {
3726                 .prepare = dyn_adc_capture_pcm_prepare,
3727                 .cleanup = dyn_adc_capture_pcm_cleanup
3728         },
3729 };
3730
3731 static void fill_pcm_stream_name(char *str, size_t len, const char *sfx,
3732                                  const char *chip_name)
3733 {
3734         char *p;
3735
3736         if (*str)
3737                 return;
3738         strlcpy(str, chip_name, len);
3739
3740         /* drop non-alnum chars after a space */
3741         for (p = strchr(str, ' '); p; p = strchr(p + 1, ' ')) {
3742                 if (!isalnum(p[1])) {
3743                         *p = 0;
3744                         break;
3745                 }
3746         }
3747         strlcat(str, sfx, len);
3748 }
3749
3750 /* build PCM streams based on the parsed results */
3751 int snd_hda_gen_build_pcms(struct hda_codec *codec)
3752 {
3753         struct hda_gen_spec *spec = codec->spec;
3754         struct hda_pcm *info = spec->pcm_rec;
3755         const struct hda_pcm_stream *p;
3756         bool have_multi_adcs;
3757
3758         codec->num_pcms = 1;
3759         codec->pcm_info = info;
3760
3761         if (spec->no_analog)
3762                 goto skip_analog;
3763
3764         fill_pcm_stream_name(spec->stream_name_analog,
3765                              sizeof(spec->stream_name_analog),
3766                              " Analog", codec->chip_name);
3767         info->name = spec->stream_name_analog;
3768
3769         if (spec->multiout.num_dacs > 0) {
3770                 p = spec->stream_analog_playback;
3771                 if (!p)
3772                         p = &pcm_analog_playback;
3773                 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *p;
3774                 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dac_nids[0];
3775                 info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max =
3776                         spec->multiout.max_channels;
3777                 if (spec->autocfg.line_out_type == AUTO_PIN_SPEAKER_OUT &&
3778                     spec->autocfg.line_outs == 2)
3779                         info->stream[SNDRV_PCM_STREAM_PLAYBACK].chmap =
3780                                 snd_pcm_2_1_chmaps;
3781         }
3782         if (spec->num_adc_nids) {
3783                 p = spec->stream_analog_capture;
3784                 if (!p) {
3785                         if (spec->dyn_adc_switch)
3786                                 p = &dyn_adc_pcm_analog_capture;
3787                         else
3788                                 p = &pcm_analog_capture;
3789                 }
3790                 info->stream[SNDRV_PCM_STREAM_CAPTURE] = *p;
3791                 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adc_nids[0];
3792         }
3793
3794  skip_analog:
3795         /* SPDIF for stream index #1 */
3796         if (spec->multiout.dig_out_nid || spec->dig_in_nid) {
3797                 fill_pcm_stream_name(spec->stream_name_digital,
3798                                      sizeof(spec->stream_name_digital),
3799                                      " Digital", codec->chip_name);
3800                 codec->num_pcms = 2;
3801                 codec->slave_dig_outs = spec->multiout.slave_dig_outs;
3802                 info = spec->pcm_rec + 1;
3803                 info->name = spec->stream_name_digital;
3804                 if (spec->dig_out_type)
3805                         info->pcm_type = spec->dig_out_type;
3806                 else
3807                         info->pcm_type = HDA_PCM_TYPE_SPDIF;
3808                 if (spec->multiout.dig_out_nid) {
3809                         p = spec->stream_digital_playback;
3810                         if (!p)
3811                                 p = &pcm_digital_playback;
3812                         info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *p;
3813                         info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dig_out_nid;
3814                 }
3815                 if (spec->dig_in_nid) {
3816                         p = spec->stream_digital_capture;
3817                         if (!p)
3818                                 p = &pcm_digital_capture;
3819                         info->stream[SNDRV_PCM_STREAM_CAPTURE] = *p;
3820                         info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->dig_in_nid;
3821                 }
3822         }
3823
3824         if (spec->no_analog)
3825                 return 0;
3826
3827         /* If the use of more than one ADC is requested for the current
3828          * model, configure a second analog capture-only PCM.
3829          */
3830         have_multi_adcs = (spec->num_adc_nids > 1) &&
3831                 !spec->dyn_adc_switch && !spec->auto_mic;
3832         /* Additional Analaog capture for index #2 */
3833         if (spec->alt_dac_nid || have_multi_adcs) {
3834                 codec->num_pcms = 3;
3835                 info = spec->pcm_rec + 2;
3836                 info->name = spec->stream_name_analog;
3837                 if (spec->alt_dac_nid) {
3838                         p = spec->stream_analog_alt_playback;
3839                         if (!p)
3840                                 p = &pcm_analog_alt_playback;
3841                         info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *p;
3842                         info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid =
3843                                 spec->alt_dac_nid;
3844                 } else {
3845                         info->stream[SNDRV_PCM_STREAM_PLAYBACK] =
3846                                 pcm_null_stream;
3847                         info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = 0;
3848                 }
3849                 if (have_multi_adcs) {
3850                         p = spec->stream_analog_alt_capture;
3851                         if (!p)
3852                                 p = &pcm_analog_alt_capture;
3853                         info->stream[SNDRV_PCM_STREAM_CAPTURE] = *p;
3854                         info->stream[SNDRV_PCM_STREAM_CAPTURE].nid =
3855                                 spec->adc_nids[1];
3856                         info->stream[SNDRV_PCM_STREAM_CAPTURE].substreams =
3857                                 spec->num_adc_nids - 1;
3858                 } else {
3859                         info->stream[SNDRV_PCM_STREAM_CAPTURE] =
3860                                 pcm_null_stream;
3861                         info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = 0;
3862                 }
3863         }
3864
3865         return 0;
3866 }
3867 EXPORT_SYMBOL_HDA(snd_hda_gen_build_pcms);
3868
3869
3870 /*
3871  * Standard auto-parser initializations
3872  */
3873
3874 /* configure the given path as a proper output */
3875 static void set_output_and_unmute(struct hda_codec *codec, int path_idx)
3876 {
3877         struct nid_path *path;
3878         hda_nid_t pin;
3879
3880         path = snd_hda_get_path_from_idx(codec, path_idx);
3881         if (!path || !path->depth)
3882                 return;
3883         pin = path->path[path->depth - 1];
3884         restore_pin_ctl(codec, pin);
3885         snd_hda_activate_path(codec, path, path->active, true);
3886         set_pin_eapd(codec, pin, path->active);
3887 }
3888
3889 /* initialize primary output paths */
3890 static void init_multi_out(struct hda_codec *codec)
3891 {
3892         struct hda_gen_spec *spec = codec->spec;
3893         int i;
3894
3895         for (i = 0; i < spec->autocfg.line_outs; i++)
3896                 set_output_and_unmute(codec, spec->out_paths[i]);
3897 }
3898
3899
3900 static void __init_extra_out(struct hda_codec *codec, int num_outs, int *paths)
3901 {
3902         int i;
3903
3904         for (i = 0; i < num_outs; i++)
3905                 set_output_and_unmute(codec, paths[i]);
3906 }
3907
3908 /* initialize hp and speaker paths */
3909 static void init_extra_out(struct hda_codec *codec)
3910 {
3911         struct hda_gen_spec *spec = codec->spec;
3912
3913         if (spec->autocfg.line_out_type != AUTO_PIN_HP_OUT)
3914                 __init_extra_out(codec, spec->autocfg.hp_outs, spec->hp_paths);
3915         if (spec->autocfg.line_out_type != AUTO_PIN_SPEAKER_OUT)
3916                 __init_extra_out(codec, spec->autocfg.speaker_outs,
3917                                  spec->speaker_paths);
3918 }
3919
3920 /* initialize multi-io paths */
3921 static void init_multi_io(struct hda_codec *codec)
3922 {
3923         struct hda_gen_spec *spec = codec->spec;
3924         int i;
3925
3926         for (i = 0; i < spec->multi_ios; i++) {
3927                 hda_nid_t pin = spec->multi_io[i].pin;
3928                 struct nid_path *path;
3929                 path = get_multiio_path(codec, i);
3930                 if (!path)
3931                         continue;
3932                 if (!spec->multi_io[i].ctl_in)
3933                         spec->multi_io[i].ctl_in =
3934                                 snd_hda_codec_get_pin_target(codec, pin);
3935                 snd_hda_activate_path(codec, path, path->active, true);
3936         }
3937 }
3938
3939 /* set up input pins and loopback paths */
3940 static void init_analog_input(struct hda_codec *codec)
3941 {
3942         struct hda_gen_spec *spec = codec->spec;
3943         struct auto_pin_cfg *cfg = &spec->autocfg;
3944         int i;
3945
3946         for (i = 0; i < cfg->num_inputs; i++) {
3947                 hda_nid_t nid = cfg->inputs[i].pin;
3948                 if (is_input_pin(codec, nid))
3949                         restore_pin_ctl(codec, nid);
3950
3951                 /* init loopback inputs */
3952                 if (spec->mixer_nid) {
3953                         struct nid_path *path;
3954                         path = snd_hda_get_path_from_idx(codec, spec->loopback_paths[i]);
3955                         if (path)
3956                                 snd_hda_activate_path(codec, path,
3957                                                       path->active, false);
3958                 }
3959         }
3960 }
3961
3962 /* initialize ADC paths */
3963 static void init_input_src(struct hda_codec *codec)
3964 {
3965         struct hda_gen_spec *spec = codec->spec;
3966         struct hda_input_mux *imux = &spec->input_mux;
3967         struct nid_path *path;
3968         int i, c, nums;
3969
3970         if (spec->dyn_adc_switch)
3971                 nums = 1;
3972         else
3973                 nums = spec->num_adc_nids;
3974
3975         for (c = 0; c < nums; c++) {
3976                 for (i = 0; i < imux->num_items; i++) {
3977                         path = get_input_path(codec, c, i);
3978                         if (path) {
3979                                 bool active = path->active;
3980                                 if (i == spec->cur_mux[c])
3981                                         active = true;
3982                                 snd_hda_activate_path(codec, path, active, false);
3983                         }
3984                 }
3985         }
3986
3987         if (spec->shared_mic_hp)
3988                 update_shared_mic_hp(codec, spec->cur_mux[0]);
3989
3990         if (spec->cap_sync_hook)
3991                 spec->cap_sync_hook(codec);
3992 }
3993
3994 /* set right pin controls for digital I/O */
3995 static void init_digital(struct hda_codec *codec)
3996 {
3997         struct hda_gen_spec *spec = codec->spec;
3998         int i;
3999         hda_nid_t pin;
4000
4001         for (i = 0; i < spec->autocfg.dig_outs; i++)
4002                 set_output_and_unmute(codec, spec->digout_paths[i]);
4003         pin = spec->autocfg.dig_in_pin;
4004         if (pin) {
4005                 struct nid_path *path;
4006                 restore_pin_ctl(codec, pin);
4007                 path = snd_hda_get_path_from_idx(codec, spec->digin_path);
4008                 if (path)
4009                         snd_hda_activate_path(codec, path, path->active, false);
4010         }
4011 }
4012
4013 /* clear unsol-event tags on unused pins; Conexant codecs seem to leave
4014  * invalid unsol tags by some reason
4015  */
4016 static void clear_unsol_on_unused_pins(struct hda_codec *codec)
4017 {
4018         int i;
4019
4020         for (i = 0; i < codec->init_pins.used; i++) {
4021                 struct hda_pincfg *pin = snd_array_elem(&codec->init_pins, i);
4022                 hda_nid_t nid = pin->nid;
4023                 if (is_jack_detectable(codec, nid) &&
4024                     !snd_hda_jack_tbl_get(codec, nid))
4025                         snd_hda_codec_update_cache(codec, nid, 0,
4026                                         AC_VERB_SET_UNSOLICITED_ENABLE, 0);
4027         }
4028 }
4029
4030 /*
4031  * initialize the generic spec;
4032  * this can be put as patch_ops.init function
4033  */
4034 int snd_hda_gen_init(struct hda_codec *codec)
4035 {
4036         struct hda_gen_spec *spec = codec->spec;
4037
4038         if (spec->init_hook)
4039                 spec->init_hook(codec);
4040
4041         snd_hda_apply_verbs(codec);
4042
4043         codec->cached_write = 1;
4044
4045         init_multi_out(codec);
4046         init_extra_out(codec);
4047         init_multi_io(codec);
4048         init_analog_input(codec);
4049         init_input_src(codec);
4050         init_digital(codec);
4051
4052         clear_unsol_on_unused_pins(codec);
4053
4054         /* call init functions of standard auto-mute helpers */
4055         snd_hda_gen_hp_automute(codec, NULL);
4056         snd_hda_gen_line_automute(codec, NULL);
4057         snd_hda_gen_mic_autoswitch(codec, NULL);
4058
4059         snd_hda_codec_flush_amp_cache(codec);
4060         snd_hda_codec_flush_cmd_cache(codec);
4061
4062         if (spec->vmaster_mute.sw_kctl && spec->vmaster_mute.hook)
4063                 snd_hda_sync_vmaster_hook(&spec->vmaster_mute);
4064
4065         hda_call_check_power_status(codec, 0x01);
4066         return 0;
4067 }
4068 EXPORT_SYMBOL_HDA(snd_hda_gen_init);
4069
4070 /*
4071  * free the generic spec;
4072  * this can be put as patch_ops.free function
4073  */
4074 void snd_hda_gen_free(struct hda_codec *codec)
4075 {
4076         snd_hda_gen_spec_free(codec->spec);
4077         kfree(codec->spec);
4078         codec->spec = NULL;
4079 }
4080 EXPORT_SYMBOL_HDA(snd_hda_gen_free);
4081
4082 #ifdef CONFIG_PM
4083 /*
4084  * check the loopback power save state;
4085  * this can be put as patch_ops.check_power_status function
4086  */
4087 int snd_hda_gen_check_power_status(struct hda_codec *codec, hda_nid_t nid)
4088 {
4089         struct hda_gen_spec *spec = codec->spec;
4090         return snd_hda_check_amp_list_power(codec, &spec->loopback, nid);
4091 }
4092 EXPORT_SYMBOL_HDA(snd_hda_gen_check_power_status);
4093 #endif
4094
4095
4096 /*
4097  * the generic codec support
4098  */
4099
4100 static const struct hda_codec_ops generic_patch_ops = {
4101         .build_controls = snd_hda_gen_build_controls,
4102         .build_pcms = snd_hda_gen_build_pcms,
4103         .init = snd_hda_gen_init,
4104         .free = snd_hda_gen_free,
4105         .unsol_event = snd_hda_jack_unsol_event,
4106 #ifdef CONFIG_PM
4107         .check_power_status = snd_hda_gen_check_power_status,
4108 #endif
4109 };
4110
4111 int snd_hda_parse_generic_codec(struct hda_codec *codec)
4112 {
4113         struct hda_gen_spec *spec;
4114         int err;
4115
4116         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
4117         if (!spec)
4118                 return -ENOMEM;
4119         snd_hda_gen_spec_init(spec);
4120         codec->spec = spec;
4121
4122         err = snd_hda_parse_pin_defcfg(codec, &spec->autocfg, NULL, 0);
4123         if (err < 0)
4124                 return err;
4125
4126         err = snd_hda_gen_parse_auto_config(codec, &spec->autocfg);
4127         if (err < 0)
4128                 goto error;
4129
4130         codec->patch_ops = generic_patch_ops;
4131         return 0;
4132
4133 error:
4134         snd_hda_gen_free(codec);
4135         return err;
4136 }
4137 EXPORT_SYMBOL_HDA(snd_hda_parse_generic_codec);