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