sound/pci/hda/hda_generic.c

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