sound/pci/hda/hda_generic.c

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