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