sound/pci/hda/patch_realtek.c

   1 /*
   2  * Universal Interface for Intel High Definition Audio Codec
   3  *
   4  * HD audio interface patch for Realtek ALC codecs
   5  *
   6  * Copyright (c) 2004 Kailang Yang <kailang@realtek.com.tw>
   7  *                    PeiSen Hou <pshou@realtek.com.tw>
   8  *                    Takashi Iwai <tiwai@suse.de>
   9  *                    Jonathan Woithe <jwoithe@physics.adelaide.edu.au>
  10  *
  11  *  This driver is free software; you can redistribute it and/or modify
  12  *  it under the terms of the GNU General Public License as published by
  13  *  the Free Software Foundation; either version 2 of the License, or
  14  *  (at your option) any later version.
  15  *
  16  *  This driver is distributed in the hope that it will be useful,
  17  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19  *  GNU General Public License for more details.
  20  *
  21  *  You should have received a copy of the GNU General Public License
  22  *  along with this program; if not, write to the Free Software
  23  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  24  */
  25
  26 #include <linux/init.h>
  27 #include <linux/delay.h>
  28 #include <linux/slab.h>
  29 #include <linux/pci.h>
  30 #include <linux/module.h>
  31 #include <sound/core.h>
  32 #include <sound/jack.h>
  33 #include "hda_codec.h"
  34 #include "hda_local.h"
  35 #include "hda_beep.h"
  36
  37 /* unsol event tags */
  38 #define ALC_FRONT_EVENT         0x01
  39 #define ALC_DCVOL_EVENT         0x02
  40 #define ALC_HP_EVENT            0x04
  41 #define ALC_MIC_EVENT           0x08
  42
  43 /* for GPIO Poll */
  44 #define GPIO_MASK       0x03
  45
  46 /* extra amp-initialization sequence types */
  47 enum {
  48         ALC_INIT_NONE,
  49         ALC_INIT_DEFAULT,
  50         ALC_INIT_GPIO1,
  51         ALC_INIT_GPIO2,
  52         ALC_INIT_GPIO3,
  53 };
  54
  55 struct alc_customize_define {
  56         unsigned int  sku_cfg;
  57         unsigned char port_connectivity;
  58         unsigned char check_sum;
  59         unsigned char customization;
  60         unsigned char external_amp;
  61         unsigned int  enable_pcbeep:1;
  62         unsigned int  platform_type:1;
  63         unsigned int  swap:1;
  64         unsigned int  override:1;
  65         unsigned int  fixup:1; /* Means that this sku is set by driver, not read from hw */
  66 };
  67
  68 struct alc_fixup;
  69
  70 struct alc_multi_io {
  71         hda_nid_t pin;          /* multi-io widget pin NID */
  72         hda_nid_t dac;          /* DAC to be connected */
  73         unsigned int ctl_in;    /* cached input-pin control value */
  74 };
  75
  76 enum {
  77         ALC_AUTOMUTE_PIN,       /* change the pin control */
  78         ALC_AUTOMUTE_AMP,       /* mute/unmute the pin AMP */
  79         ALC_AUTOMUTE_MIXER,     /* mute/unmute mixer widget AMP */
  80 };
  81
  82 struct alc_spec {
  83         /* codec parameterization */
  84         const struct snd_kcontrol_new *mixers[5];       /* mixer arrays */
  85         unsigned int num_mixers;
  86         const struct snd_kcontrol_new *cap_mixer;       /* capture mixer */
  87         unsigned int beep_amp;  /* beep amp value, set via set_beep_amp() */
  88
  89         const struct hda_verb *init_verbs[10];  /* initialization verbs
  90                                                  * don't forget NULL
  91                                                  * termination!
  92                                                  */
  93         unsigned int num_init_verbs;
  94
  95         char stream_name_analog[32];    /* analog PCM stream */
  96         const struct hda_pcm_stream *stream_analog_playback;
  97         const struct hda_pcm_stream *stream_analog_capture;
  98         const struct hda_pcm_stream *stream_analog_alt_playback;
  99         const struct hda_pcm_stream *stream_analog_alt_capture;
 100
 101         char stream_name_digital[32];   /* digital PCM stream */
 102         const struct hda_pcm_stream *stream_digital_playback;
 103         const struct hda_pcm_stream *stream_digital_capture;
 104
 105         /* playback */
 106         struct hda_multi_out multiout;  /* playback set-up
 107                                          * max_channels, dacs must be set
 108                                          * dig_out_nid and hp_nid are optional
 109                                          */
 110         hda_nid_t alt_dac_nid;
 111         hda_nid_t slave_dig_outs[3];    /* optional - for auto-parsing */
 112         int dig_out_type;
 113
 114         /* capture */
 115         unsigned int num_adc_nids;
 116         const hda_nid_t *adc_nids;
 117         const hda_nid_t *capsrc_nids;
 118         hda_nid_t dig_in_nid;           /* digital-in NID; optional */
 119         hda_nid_t mixer_nid;            /* analog-mixer NID */
 120         DECLARE_BITMAP(vol_ctls, 0x20 << 1);
 121         DECLARE_BITMAP(sw_ctls, 0x20 << 1);
 122
 123         /* capture setup for dynamic dual-adc switch */
 124         hda_nid_t cur_adc;
 125         unsigned int cur_adc_stream_tag;
 126         unsigned int cur_adc_format;
 127
 128         /* capture source */
 129         unsigned int num_mux_defs;
 130         const struct hda_input_mux *input_mux;
 131         unsigned int cur_mux[3];
 132         hda_nid_t ext_mic_pin;
 133         hda_nid_t dock_mic_pin;
 134         hda_nid_t int_mic_pin;
 135
 136         /* channel model */
 137         const struct hda_channel_mode *channel_mode;
 138         int num_channel_mode;
 139         int need_dac_fix;
 140         int const_channel_count;
 141         int ext_channel_count;
 142
 143         /* PCM information */
 144         struct hda_pcm pcm_rec[3];      /* used in alc_build_pcms() */
 145
 146         /* dynamic controls, init_verbs and input_mux */
 147         struct auto_pin_cfg autocfg;
 148         struct alc_customize_define cdefine;
 149         struct snd_array kctls;
 150         struct hda_input_mux private_imux[3];
 151         hda_nid_t private_dac_nids[AUTO_CFG_MAX_OUTS];
 152         hda_nid_t private_adc_nids[AUTO_CFG_MAX_OUTS];
 153         hda_nid_t private_capsrc_nids[AUTO_CFG_MAX_OUTS];
 154         hda_nid_t imux_pins[HDA_MAX_NUM_INPUTS];
 155         unsigned int dyn_adc_idx[HDA_MAX_NUM_INPUTS];
 156         int int_mic_idx, ext_mic_idx, dock_mic_idx; /* for auto-mic */
 157
 158         /* hooks */
 159         void (*init_hook)(struct hda_codec *codec);
 160         void (*unsol_event)(struct hda_codec *codec, unsigned int res);
 161 #ifdef CONFIG_SND_HDA_POWER_SAVE
 162         void (*power_hook)(struct hda_codec *codec);
 163 #endif
 164         void (*shutup)(struct hda_codec *codec);
 165         void (*automute_hook)(struct hda_codec *codec);
 166
 167         /* for pin sensing */
 168         unsigned int hp_jack_present:1;
 169         unsigned int line_jack_present:1;
 170         unsigned int master_mute:1;
 171         unsigned int auto_mic:1;
 172         unsigned int auto_mic_valid_imux:1;     /* valid imux for auto-mic */
 173         unsigned int automute_speaker:1; /* automute speaker outputs */
 174         unsigned int automute_lo:1; /* automute LO outputs */
 175         unsigned int detect_hp:1;       /* Headphone detection enabled */
 176         unsigned int detect_lo:1;       /* Line-out detection enabled */
 177         unsigned int automute_speaker_possible:1; /* there are speakers and either LO or HP */
 178         unsigned int automute_lo_possible:1;      /* there are line outs and HP */
 179
 180         /* other flags */
 181         unsigned int no_analog :1; /* digital I/O only */
 182         unsigned int dyn_adc_switch:1; /* switch ADCs (for ALC275) */
 183         unsigned int single_input_src:1;
 184         unsigned int vol_in_capsrc:1; /* use capsrc volume (ADC has no vol) */
 185         unsigned int parse_flags; /* passed to snd_hda_parse_pin_defcfg() */
 186
 187         /* auto-mute control */
 188         int automute_mode;
 189         hda_nid_t automute_mixer_nid[AUTO_CFG_MAX_OUTS];
 190
 191         int init_amp;
 192         int codec_variant;      /* flag for other variants */
 193
 194         /* for virtual master */
 195         hda_nid_t vmaster_nid;
 196 #ifdef CONFIG_SND_HDA_POWER_SAVE
 197         struct hda_loopback_check loopback;
 198 #endif
 199
 200         /* for PLL fix */
 201         hda_nid_t pll_nid;
 202         unsigned int pll_coef_idx, pll_coef_bit;
 203         unsigned int coef0;
 204
 205         /* fix-up list */
 206         int fixup_id;
 207         const struct alc_fixup *fixup_list;
 208         const char *fixup_name;
 209
 210         /* multi-io */
 211         int multi_ios;
 212         struct alc_multi_io multi_io[4];
 213
 214         /* bind volumes */
 215         struct snd_array bind_ctls;
 216 };
 217
 218 #define ALC_MODEL_AUTO          0       /* common for all chips */
 219
 220 static bool check_amp_caps(struct hda_codec *codec, hda_nid_t nid,
 221                            int dir, unsigned int bits)
 222 {
 223         if (!nid)
 224                 return false;
 225         if (get_wcaps(codec, nid) & (1 << (dir + 1)))
 226                 if (query_amp_caps(codec, nid, dir) & bits)
 227                         return true;
 228         return false;
 229 }
 230
 231 #define nid_has_mute(codec, nid, dir) \
 232         check_amp_caps(codec, nid, dir, AC_AMPCAP_MUTE)
 233 #define nid_has_volume(codec, nid, dir) \
 234         check_amp_caps(codec, nid, dir, AC_AMPCAP_NUM_STEPS)
 235
 236 /*
 237  * input MUX handling
 238  */
 239 static int alc_mux_enum_info(struct snd_kcontrol *kcontrol,
 240                              struct snd_ctl_elem_info *uinfo)
 241 {
 242         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 243         struct alc_spec *spec = codec->spec;
 244         unsigned int mux_idx = snd_ctl_get_ioffidx(kcontrol, &uinfo->id);
 245         if (mux_idx >= spec->num_mux_defs)
 246                 mux_idx = 0;
 247         if (!spec->input_mux[mux_idx].num_items && mux_idx > 0)
 248                 mux_idx = 0;
 249         return snd_hda_input_mux_info(&spec->input_mux[mux_idx], uinfo);
 250 }
 251
 252 static int alc_mux_enum_get(struct snd_kcontrol *kcontrol,
 253                             struct snd_ctl_elem_value *ucontrol)
 254 {
 255         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 256         struct alc_spec *spec = codec->spec;
 257         unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
 258
 259         ucontrol->value.enumerated.item[0] = spec->cur_mux[adc_idx];
 260         return 0;
 261 }
 262
 263 static bool alc_dyn_adc_pcm_resetup(struct hda_codec *codec, int cur)
 264 {
 265         struct alc_spec *spec = codec->spec;
 266         hda_nid_t new_adc = spec->adc_nids[spec->dyn_adc_idx[cur]];
 267
 268         if (spec->cur_adc && spec->cur_adc != new_adc) {
 269                 /* stream is running, let's swap the current ADC */
 270                 __snd_hda_codec_cleanup_stream(codec, spec->cur_adc, 1);
 271                 spec->cur_adc = new_adc;
 272                 snd_hda_codec_setup_stream(codec, new_adc,
 273                                            spec->cur_adc_stream_tag, 0,
 274                                            spec->cur_adc_format);
 275                 return true;
 276         }
 277         return false;
 278 }
 279
 280 /* select the given imux item; either unmute exclusively or select the route */
 281 static int alc_mux_select(struct hda_codec *codec, unsigned int adc_idx,
 282                           unsigned int idx, bool force)
 283 {
 284         struct alc_spec *spec = codec->spec;
 285         const struct hda_input_mux *imux;
 286         unsigned int mux_idx;
 287         int i, type, num_conns;
 288         hda_nid_t nid;
 289
 290         mux_idx = adc_idx >= spec->num_mux_defs ? 0 : adc_idx;
 291         imux = &spec->input_mux[mux_idx];
 292         if (!imux->num_items && mux_idx > 0)
 293                 imux = &spec->input_mux[0];
 294
 295         if (idx >= imux->num_items)
 296                 idx = imux->num_items - 1;
 297         if (spec->cur_mux[adc_idx] == idx && !force)
 298                 return 0;
 299         spec->cur_mux[adc_idx] = idx;
 300
 301         if (spec->dyn_adc_switch) {
 302                 alc_dyn_adc_pcm_resetup(codec, idx);
 303                 adc_idx = spec->dyn_adc_idx[idx];
 304         }
 305
 306         nid = spec->capsrc_nids ?
 307                 spec->capsrc_nids[adc_idx] : spec->adc_nids[adc_idx];
 308
 309         /* no selection? */
 310         num_conns = snd_hda_get_conn_list(codec, nid, NULL);
 311         if (num_conns <= 1)
 312                 return 1;
 313
 314         type = get_wcaps_type(get_wcaps(codec, nid));
 315         if (type == AC_WID_AUD_MIX) {
 316                 /* Matrix-mixer style (e.g. ALC882) */
 317                 int active = imux->items[idx].index;
 318                 for (i = 0; i < num_conns; i++) {
 319                         unsigned int v = (i == active) ? 0 : HDA_AMP_MUTE;
 320                         snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT, i,
 321                                                  HDA_AMP_MUTE, v);
 322                 }
 323         } else {
 324                 /* MUX style (e.g. ALC880) */
 325                 snd_hda_codec_write_cache(codec, nid, 0,
 326                                           AC_VERB_SET_CONNECT_SEL,
 327                                           imux->items[idx].index);
 328         }
 329         return 1;
 330 }
 331
 332 static int alc_mux_enum_put(struct snd_kcontrol *kcontrol,
 333                             struct snd_ctl_elem_value *ucontrol)
 334 {
 335         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 336         unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
 337         return alc_mux_select(codec, adc_idx,
 338                               ucontrol->value.enumerated.item[0], false);
 339 }
 340
 341 /*
 342  * set up the input pin config (depending on the given auto-pin type)
 343  */
 344 static void alc_set_input_pin(struct hda_codec *codec, hda_nid_t nid,
 345                               int auto_pin_type)
 346 {
 347         unsigned int val = PIN_IN;
 348
 349         if (auto_pin_type == AUTO_PIN_MIC) {
 350                 unsigned int pincap;
 351                 unsigned int oldval;
 352                 oldval = snd_hda_codec_read(codec, nid, 0,
 353                                             AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
 354                 pincap = snd_hda_query_pin_caps(codec, nid);
 355                 pincap = (pincap & AC_PINCAP_VREF) >> AC_PINCAP_VREF_SHIFT;
 356                 /* if the default pin setup is vref50, we give it priority */
 357                 if ((pincap & AC_PINCAP_VREF_80) && oldval != PIN_VREF50)
 358                         val = PIN_VREF80;
 359                 else if (pincap & AC_PINCAP_VREF_50)
 360                         val = PIN_VREF50;
 361                 else if (pincap & AC_PINCAP_VREF_100)
 362                         val = PIN_VREF100;
 363                 else if (pincap & AC_PINCAP_VREF_GRD)
 364                         val = PIN_VREFGRD;
 365         }
 366         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, val);
 367 }
 368
 369 /*
 370  * Append the given mixer and verb elements for the later use
 371  * The mixer array is referred in build_controls(), and init_verbs are
 372  * called in init().
 373  */
 374 static void add_mixer(struct alc_spec *spec, const struct snd_kcontrol_new *mix)
 375 {
 376         if (snd_BUG_ON(spec->num_mixers >= ARRAY_SIZE(spec->mixers)))
 377                 return;
 378         spec->mixers[spec->num_mixers++] = mix;
 379 }
 380
 381 static void add_verb(struct alc_spec *spec, const struct hda_verb *verb)
 382 {
 383         if (snd_BUG_ON(spec->num_init_verbs >= ARRAY_SIZE(spec->init_verbs)))
 384                 return;
 385         spec->init_verbs[spec->num_init_verbs++] = verb;
 386 }
 387
 388 /*
 389  * GPIO setup tables, used in initialization
 390  */
 391 /* Enable GPIO mask and set output */
 392 static const struct hda_verb alc_gpio1_init_verbs[] = {
 393         {0x01, AC_VERB_SET_GPIO_MASK, 0x01},
 394         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
 395         {0x01, AC_VERB_SET_GPIO_DATA, 0x01},
 396         { }
 397 };
 398
 399 static const struct hda_verb alc_gpio2_init_verbs[] = {
 400         {0x01, AC_VERB_SET_GPIO_MASK, 0x02},
 401         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x02},
 402         {0x01, AC_VERB_SET_GPIO_DATA, 0x02},
 403         { }
 404 };
 405
 406 static const struct hda_verb alc_gpio3_init_verbs[] = {
 407         {0x01, AC_VERB_SET_GPIO_MASK, 0x03},
 408         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x03},
 409         {0x01, AC_VERB_SET_GPIO_DATA, 0x03},
 410         { }
 411 };
 412
 413 /*
 414  * Fix hardware PLL issue
 415  * On some codecs, the analog PLL gating control must be off while
 416  * the default value is 1.
 417  */
 418 static void alc_fix_pll(struct hda_codec *codec)
 419 {
 420         struct alc_spec *spec = codec->spec;
 421         unsigned int val;
 422
 423         if (!spec->pll_nid)
 424                 return;
 425         snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_COEF_INDEX,
 426                             spec->pll_coef_idx);
 427         val = snd_hda_codec_read(codec, spec->pll_nid, 0,
 428                                  AC_VERB_GET_PROC_COEF, 0);
 429         snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_COEF_INDEX,
 430                             spec->pll_coef_idx);
 431         snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_PROC_COEF,
 432                             val & ~(1 << spec->pll_coef_bit));
 433 }
 434
 435 static void alc_fix_pll_init(struct hda_codec *codec, hda_nid_t nid,
 436                              unsigned int coef_idx, unsigned int coef_bit)
 437 {
 438         struct alc_spec *spec = codec->spec;
 439         spec->pll_nid = nid;
 440         spec->pll_coef_idx = coef_idx;
 441         spec->pll_coef_bit = coef_bit;
 442         alc_fix_pll(codec);
 443 }
 444
 445 /*
 446  * Jack-reporting via input-jack layer
 447  */
 448
 449 /* initialization of jacks; currently checks only a few known pins */
 450 static int alc_init_jacks(struct hda_codec *codec)
 451 {
 452 #ifdef CONFIG_SND_HDA_INPUT_JACK
 453         struct alc_spec *spec = codec->spec;
 454         int err;
 455         unsigned int hp_nid = spec->autocfg.hp_pins[0];
 456         unsigned int mic_nid = spec->ext_mic_pin;
 457         unsigned int dock_nid = spec->dock_mic_pin;
 458
 459         if (hp_nid) {
 460                 err = snd_hda_input_jack_add(codec, hp_nid,
 461                                              SND_JACK_HEADPHONE, NULL);
 462                 if (err < 0)
 463                         return err;
 464                 snd_hda_input_jack_report(codec, hp_nid);
 465         }
 466
 467         if (mic_nid) {
 468                 err = snd_hda_input_jack_add(codec, mic_nid,
 469                                              SND_JACK_MICROPHONE, NULL);
 470                 if (err < 0)
 471                         return err;
 472                 snd_hda_input_jack_report(codec, mic_nid);
 473         }
 474         if (dock_nid) {
 475                 err = snd_hda_input_jack_add(codec, dock_nid,
 476                                              SND_JACK_MICROPHONE, NULL);
 477                 if (err < 0)
 478                         return err;
 479                 snd_hda_input_jack_report(codec, dock_nid);
 480         }
 481 #endif /* CONFIG_SND_HDA_INPUT_JACK */
 482         return 0;
 483 }
 484
 485 /*
 486  * Jack detections for HP auto-mute and mic-switch
 487  */
 488
 489 /* check each pin in the given array; returns true if any of them is plugged */
 490 static bool detect_jacks(struct hda_codec *codec, int num_pins, hda_nid_t *pins)
 491 {
 492         int i, present = 0;
 493
 494         for (i = 0; i < num_pins; i++) {
 495                 hda_nid_t nid = pins[i];
 496                 if (!nid)
 497                         break;
 498                 snd_hda_input_jack_report(codec, nid);
 499                 present |= snd_hda_jack_detect(codec, nid);
 500         }
 501         return present;
 502 }
 503
 504 /* standard HP/line-out auto-mute helper */
 505 static void do_automute(struct hda_codec *codec, int num_pins, hda_nid_t *pins,
 506                         bool mute, bool hp_out)
 507 {
 508         struct alc_spec *spec = codec->spec;
 509         unsigned int mute_bits = mute ? HDA_AMP_MUTE : 0;
 510         unsigned int pin_bits = mute ? 0 : (hp_out ? PIN_HP : PIN_OUT);
 511         int i;
 512
 513         for (i = 0; i < num_pins; i++) {
 514                 hda_nid_t nid = pins[i];
 515                 if (!nid)
 516                         break;
 517                 switch (spec->automute_mode) {
 518                 case ALC_AUTOMUTE_PIN:
 519                         snd_hda_codec_write(codec, nid, 0,
 520                                             AC_VERB_SET_PIN_WIDGET_CONTROL,
 521                                             pin_bits);
 522                         break;
 523                 case ALC_AUTOMUTE_AMP:
 524                         snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
 525                                                  HDA_AMP_MUTE, mute_bits);
 526                         break;
 527                 case ALC_AUTOMUTE_MIXER:
 528                         nid = spec->automute_mixer_nid[i];
 529                         if (!nid)
 530                                 break;
 531                         snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT, 0,
 532                                                  HDA_AMP_MUTE, mute_bits);
 533                         snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT, 1,
 534                                                  HDA_AMP_MUTE, mute_bits);
 535                         break;
 536                 }
 537         }
 538 }
 539
 540 /* Toggle outputs muting */
 541 static void update_outputs(struct hda_codec *codec)
 542 {
 543         struct alc_spec *spec = codec->spec;
 544         int on;
 545
 546         /* Control HP pins/amps depending on master_mute state;
 547          * in general, HP pins/amps control should be enabled in all cases,
 548          * but currently set only for master_mute, just to be safe
 549          */
 550         do_automute(codec, ARRAY_SIZE(spec->autocfg.hp_pins),
 551                     spec->autocfg.hp_pins, spec->master_mute, true);
 552
 553         if (!spec->automute_speaker)
 554                 on = 0;
 555         else
 556                 on = spec->hp_jack_present | spec->line_jack_present;
 557         on |= spec->master_mute;
 558         do_automute(codec, ARRAY_SIZE(spec->autocfg.speaker_pins),
 559                     spec->autocfg.speaker_pins, on, false);
 560
 561         /* toggle line-out mutes if needed, too */
 562         /* if LO is a copy of either HP or Speaker, don't need to handle it */
 563         if (spec->autocfg.line_out_pins[0] == spec->autocfg.hp_pins[0] ||
 564             spec->autocfg.line_out_pins[0] == spec->autocfg.speaker_pins[0])
 565                 return;
 566         if (!spec->automute_lo)
 567                 on = 0;
 568         else
 569                 on = spec->hp_jack_present;
 570         on |= spec->master_mute;
 571         do_automute(codec, ARRAY_SIZE(spec->autocfg.line_out_pins),
 572                     spec->autocfg.line_out_pins, on, false);
 573 }
 574
 575 static void call_update_outputs(struct hda_codec *codec)
 576 {
 577         struct alc_spec *spec = codec->spec;
 578         if (spec->automute_hook)
 579                 spec->automute_hook(codec);
 580         else
 581                 update_outputs(codec);
 582 }
 583
 584 /* standard HP-automute helper */
 585 static void alc_hp_automute(struct hda_codec *codec)
 586 {
 587         struct alc_spec *spec = codec->spec;
 588
 589         spec->hp_jack_present =
 590                 detect_jacks(codec, ARRAY_SIZE(spec->autocfg.hp_pins),
 591                              spec->autocfg.hp_pins);
 592         if (!spec->detect_hp || (!spec->automute_speaker && !spec->automute_lo))
 593                 return;
 594         call_update_outputs(codec);
 595 }
 596
 597 /* standard line-out-automute helper */
 598 static void alc_line_automute(struct hda_codec *codec)
 599 {
 600         struct alc_spec *spec = codec->spec;
 601
 602         /* check LO jack only when it's different from HP */
 603         if (spec->autocfg.line_out_pins[0] == spec->autocfg.hp_pins[0])
 604                 return;
 605
 606         spec->line_jack_present =
 607                 detect_jacks(codec, ARRAY_SIZE(spec->autocfg.line_out_pins),
 608                              spec->autocfg.line_out_pins);
 609         if (!spec->automute_speaker || !spec->detect_lo)
 610                 return;
 611         call_update_outputs(codec);
 612 }
 613
 614 #define get_connection_index(codec, mux, nid) \
 615         snd_hda_get_conn_index(codec, mux, nid, 0)
 616
 617 /* standard mic auto-switch helper */
 618 static void alc_mic_automute(struct hda_codec *codec)
 619 {
 620         struct alc_spec *spec = codec->spec;
 621         hda_nid_t *pins = spec->imux_pins;
 622
 623         if (!spec->auto_mic || !spec->auto_mic_valid_imux)
 624                 return;
 625         if (snd_BUG_ON(!spec->adc_nids))
 626                 return;
 627         if (snd_BUG_ON(spec->int_mic_idx < 0 || spec->ext_mic_idx < 0))
 628                 return;
 629
 630         if (snd_hda_jack_detect(codec, pins[spec->ext_mic_idx]))
 631                 alc_mux_select(codec, 0, spec->ext_mic_idx, false);
 632         else if (spec->dock_mic_idx >= 0 &&
 633                    snd_hda_jack_detect(codec, pins[spec->dock_mic_idx]))
 634                 alc_mux_select(codec, 0, spec->dock_mic_idx, false);
 635         else
 636                 alc_mux_select(codec, 0, spec->int_mic_idx, false);
 637
 638         snd_hda_input_jack_report(codec, pins[spec->ext_mic_idx]);
 639         if (spec->dock_mic_idx >= 0)
 640                 snd_hda_input_jack_report(codec, pins[spec->dock_mic_idx]);
 641 }
 642
 643 /* unsolicited event for HP jack sensing */
 644 static void alc_sku_unsol_event(struct hda_codec *codec, unsigned int res)
 645 {
 646         if (codec->vendor_id == 0x10ec0880)
 647                 res >>= 28;
 648         else
 649                 res >>= 26;
 650         switch (res) {
 651         case ALC_HP_EVENT:
 652                 alc_hp_automute(codec);
 653                 break;
 654         case ALC_FRONT_EVENT:
 655                 alc_line_automute(codec);
 656                 break;
 657         case ALC_MIC_EVENT:
 658                 alc_mic_automute(codec);
 659                 break;
 660         }
 661 }
 662
 663 /* call init functions of standard auto-mute helpers */
 664 static void alc_inithook(struct hda_codec *codec)
 665 {
 666         alc_hp_automute(codec);
 667         alc_line_automute(codec);
 668         alc_mic_automute(codec);
 669 }
 670
 671 /* additional initialization for ALC888 variants */
 672 static void alc888_coef_init(struct hda_codec *codec)
 673 {
 674         unsigned int tmp;
 675
 676         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 0);
 677         tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0);
 678         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 7);
 679         if ((tmp & 0xf0) == 0x20)
 680                 /* alc888S-VC */
 681                 snd_hda_codec_read(codec, 0x20, 0,
 682                                    AC_VERB_SET_PROC_COEF, 0x830);
 683          else
 684                  /* alc888-VB */
 685                  snd_hda_codec_read(codec, 0x20, 0,
 686                                     AC_VERB_SET_PROC_COEF, 0x3030);
 687 }
 688
 689 /* additional initialization for ALC889 variants */
 690 static void alc889_coef_init(struct hda_codec *codec)
 691 {
 692         unsigned int tmp;
 693
 694         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 7);
 695         tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0);
 696         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 7);
 697         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_PROC_COEF, tmp|0x2010);
 698 }
 699
 700 /* turn on/off EAPD control (only if available) */
 701 static void set_eapd(struct hda_codec *codec, hda_nid_t nid, int on)
 702 {
 703         if (get_wcaps_type(get_wcaps(codec, nid)) != AC_WID_PIN)
 704                 return;
 705         if (snd_hda_query_pin_caps(codec, nid) & AC_PINCAP_EAPD)
 706                 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_EAPD_BTLENABLE,
 707                                     on ? 2 : 0);
 708 }
 709
 710 /* turn on/off EAPD controls of the codec */
 711 static void alc_auto_setup_eapd(struct hda_codec *codec, bool on)
 712 {
 713         /* We currently only handle front, HP */
 714         static hda_nid_t pins[] = {
 715                 0x0f, 0x10, 0x14, 0x15, 0
 716         };
 717         hda_nid_t *p;
 718         for (p = pins; *p; p++)
 719                 set_eapd(codec, *p, on);
 720 }
 721
 722 /* generic shutup callback;
 723  * just turning off EPAD and a little pause for avoiding pop-noise
 724  */
 725 static void alc_eapd_shutup(struct hda_codec *codec)
 726 {
 727         alc_auto_setup_eapd(codec, false);
 728         msleep(200);
 729 }
 730
 731 /* generic EAPD initialization */
 732 static void alc_auto_init_amp(struct hda_codec *codec, int type)
 733 {
 734         unsigned int tmp;
 735
 736         alc_auto_setup_eapd(codec, true);
 737         switch (type) {
 738         case ALC_INIT_GPIO1:
 739                 snd_hda_sequence_write(codec, alc_gpio1_init_verbs);
 740                 break;
 741         case ALC_INIT_GPIO2:
 742                 snd_hda_sequence_write(codec, alc_gpio2_init_verbs);
 743                 break;
 744         case ALC_INIT_GPIO3:
 745                 snd_hda_sequence_write(codec, alc_gpio3_init_verbs);
 746                 break;
 747         case ALC_INIT_DEFAULT:
 748                 switch (codec->vendor_id) {
 749                 case 0x10ec0260:
 750                         snd_hda_codec_write(codec, 0x1a, 0,
 751                                             AC_VERB_SET_COEF_INDEX, 7);
 752                         tmp = snd_hda_codec_read(codec, 0x1a, 0,
 753                                                  AC_VERB_GET_PROC_COEF, 0);
 754                         snd_hda_codec_write(codec, 0x1a, 0,
 755                                             AC_VERB_SET_COEF_INDEX, 7);
 756                         snd_hda_codec_write(codec, 0x1a, 0,
 757                                             AC_VERB_SET_PROC_COEF,
 758                                             tmp | 0x2010);
 759                         break;
 760                 case 0x10ec0262:
 761                 case 0x10ec0880:
 762                 case 0x10ec0882:
 763                 case 0x10ec0883:
 764                 case 0x10ec0885:
 765                 case 0x10ec0887:
 766                 /*case 0x10ec0889:*/ /* this causes an SPDIF problem */
 767                         alc889_coef_init(codec);
 768                         break;
 769                 case 0x10ec0888:
 770                         alc888_coef_init(codec);
 771                         break;
 772 #if 0 /* XXX: This may cause the silent output on speaker on some machines */
 773                 case 0x10ec0267:
 774                 case 0x10ec0268:
 775                         snd_hda_codec_write(codec, 0x20, 0,
 776                                             AC_VERB_SET_COEF_INDEX, 7);
 777                         tmp = snd_hda_codec_read(codec, 0x20, 0,
 778                                                  AC_VERB_GET_PROC_COEF, 0);
 779                         snd_hda_codec_write(codec, 0x20, 0,
 780                                             AC_VERB_SET_COEF_INDEX, 7);
 781                         snd_hda_codec_write(codec, 0x20, 0,
 782                                             AC_VERB_SET_PROC_COEF,
 783                                             tmp | 0x3000);
 784                         break;
 785 #endif /* XXX */
 786                 }
 787                 break;
 788         }
 789 }
 790
 791 /*
 792  * Auto-Mute mode mixer enum support
 793  */
 794 static int alc_automute_mode_info(struct snd_kcontrol *kcontrol,
 795                                   struct snd_ctl_elem_info *uinfo)
 796 {
 797         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 798         struct alc_spec *spec = codec->spec;
 799         static const char * const texts2[] = {
 800                 "Disabled", "Enabled"
 801         };
 802         static const char * const texts3[] = {
 803                 "Disabled", "Speaker Only", "Line-Out+Speaker"
 804         };
 805         const char * const *texts;
 806
 807         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
 808         uinfo->count = 1;
 809         if (spec->automute_speaker_possible && spec->automute_lo_possible) {
 810                 uinfo->value.enumerated.items = 3;
 811                 texts = texts3;
 812         } else {
 813                 uinfo->value.enumerated.items = 2;
 814                 texts = texts2;
 815         }
 816         if (uinfo->value.enumerated.item >= uinfo->value.enumerated.items)
 817                 uinfo->value.enumerated.item = uinfo->value.enumerated.items - 1;
 818         strcpy(uinfo->value.enumerated.name,
 819                texts[uinfo->value.enumerated.item]);
 820         return 0;
 821 }
 822
 823 static int alc_automute_mode_get(struct snd_kcontrol *kcontrol,
 824                                  struct snd_ctl_elem_value *ucontrol)
 825 {
 826         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 827         struct alc_spec *spec = codec->spec;
 828         unsigned int val = 0;
 829         if (spec->automute_speaker)
 830                 val++;
 831         if (spec->automute_lo)
 832                 val++;
 833
 834         ucontrol->value.enumerated.item[0] = val;
 835         return 0;
 836 }
 837
 838 static int alc_automute_mode_put(struct snd_kcontrol *kcontrol,
 839                                  struct snd_ctl_elem_value *ucontrol)
 840 {
 841         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 842         struct alc_spec *spec = codec->spec;
 843
 844         switch (ucontrol->value.enumerated.item[0]) {
 845         case 0:
 846                 if (!spec->automute_speaker && !spec->automute_lo)
 847                         return 0;
 848                 spec->automute_speaker = 0;
 849                 spec->automute_lo = 0;
 850                 break;
 851         case 1:
 852                 if (spec->automute_speaker_possible) {
 853                         if (!spec->automute_lo && spec->automute_speaker)
 854                                 return 0;
 855                         spec->automute_speaker = 1;
 856                         spec->automute_lo = 0;
 857                 } else if (spec->automute_lo_possible) {
 858                         if (spec->automute_lo)
 859                                 return 0;
 860                         spec->automute_lo = 1;
 861                 } else
 862                         return -EINVAL;
 863                 break;
 864         case 2:
 865                 if (!spec->automute_lo_possible || !spec->automute_speaker_possible)
 866                         return -EINVAL;
 867                 if (spec->automute_speaker && spec->automute_lo)
 868                         return 0;
 869                 spec->automute_speaker = 1;
 870                 spec->automute_lo = 1;
 871                 break;
 872         default:
 873                 return -EINVAL;
 874         }
 875         call_update_outputs(codec);
 876         return 1;
 877 }
 878
 879 static const struct snd_kcontrol_new alc_automute_mode_enum = {
 880         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
 881         .name = "Auto-Mute Mode",
 882         .info = alc_automute_mode_info,
 883         .get = alc_automute_mode_get,
 884         .put = alc_automute_mode_put,
 885 };
 886
 887 static struct snd_kcontrol_new *alc_kcontrol_new(struct alc_spec *spec)
 888 {
 889         snd_array_init(&spec->kctls, sizeof(struct snd_kcontrol_new), 32);
 890         return snd_array_new(&spec->kctls);
 891 }
 892
 893 static int alc_add_automute_mode_enum(struct hda_codec *codec)
 894 {
 895         struct alc_spec *spec = codec->spec;
 896         struct snd_kcontrol_new *knew;
 897
 898         knew = alc_kcontrol_new(spec);
 899         if (!knew)
 900                 return -ENOMEM;
 901         *knew = alc_automute_mode_enum;
 902         knew->name = kstrdup("Auto-Mute Mode", GFP_KERNEL);
 903         if (!knew->name)
 904                 return -ENOMEM;
 905         return 0;
 906 }
 907
 908 /*
 909  * Check the availability of HP/line-out auto-mute;
 910  * Set up appropriately if really supported
 911  */
 912 static void alc_init_automute(struct hda_codec *codec)
 913 {
 914         struct alc_spec *spec = codec->spec;
 915         struct auto_pin_cfg *cfg = &spec->autocfg;
 916         int present = 0;
 917         int i;
 918
 919         if (cfg->hp_pins[0])
 920                 present++;
 921         if (cfg->line_out_pins[0])
 922                 present++;
 923         if (cfg->speaker_pins[0])
 924                 present++;
 925         if (present < 2) /* need two different output types */
 926                 return;
 927
 928         if (!cfg->speaker_pins[0] &&
 929             cfg->line_out_type == AUTO_PIN_SPEAKER_OUT) {
 930                 memcpy(cfg->speaker_pins, cfg->line_out_pins,
 931                        sizeof(cfg->speaker_pins));
 932                 cfg->speaker_outs = cfg->line_outs;
 933         }
 934
 935         if (!cfg->hp_pins[0] &&
 936             cfg->line_out_type == AUTO_PIN_HP_OUT) {
 937                 memcpy(cfg->hp_pins, cfg->line_out_pins,
 938                        sizeof(cfg->hp_pins));
 939                 cfg->hp_outs = cfg->line_outs;
 940         }
 941
 942         spec->automute_mode = ALC_AUTOMUTE_PIN;
 943
 944         for (i = 0; i < cfg->hp_outs; i++) {
 945                 hda_nid_t nid = cfg->hp_pins[i];
 946                 if (!is_jack_detectable(codec, nid))
 947                         continue;
 948                 snd_printdd("realtek: Enable HP auto-muting on NID 0x%x\n",
 949                             nid);
 950                 snd_hda_codec_write_cache(codec, nid, 0,
 951                                   AC_VERB_SET_UNSOLICITED_ENABLE,
 952                                   AC_USRSP_EN | ALC_HP_EVENT);
 953                 spec->detect_hp = 1;
 954         }
 955
 956         if (cfg->line_out_type == AUTO_PIN_LINE_OUT && cfg->line_outs) {
 957                 if (cfg->speaker_outs)
 958                         for (i = 0; i < cfg->line_outs; i++) {
 959                                 hda_nid_t nid = cfg->line_out_pins[i];
 960                                 if (!is_jack_detectable(codec, nid))
 961                                         continue;
 962                                 snd_printdd("realtek: Enable Line-Out "
 963                                             "auto-muting on NID 0x%x\n", nid);
 964                                 snd_hda_codec_write_cache(codec, nid, 0,
 965                                                 AC_VERB_SET_UNSOLICITED_ENABLE,
 966                                                 AC_USRSP_EN | ALC_FRONT_EVENT);
 967                                 spec->detect_lo = 1;
 968                 }
 969                 spec->automute_lo_possible = spec->detect_hp;
 970         }
 971
 972         spec->automute_speaker_possible = cfg->speaker_outs &&
 973                 (spec->detect_hp || spec->detect_lo);
 974
 975         spec->automute_lo = spec->automute_lo_possible;
 976         spec->automute_speaker = spec->automute_speaker_possible;
 977
 978         if (spec->automute_speaker_possible || spec->automute_lo_possible) {
 979                 /* create a control for automute mode */
 980                 alc_add_automute_mode_enum(codec);
 981                 spec->unsol_event = alc_sku_unsol_event;
 982         }
 983 }
 984
 985 /* return the position of NID in the list, or -1 if not found */
 986 static int find_idx_in_nid_list(hda_nid_t nid, const hda_nid_t *list, int nums)
 987 {
 988         int i;
 989         for (i = 0; i < nums; i++)
 990                 if (list[i] == nid)
 991                         return i;
 992         return -1;
 993 }
 994
 995 /* check whether dynamic ADC-switching is available */
 996 static bool alc_check_dyn_adc_switch(struct hda_codec *codec)
 997 {
 998         struct alc_spec *spec = codec->spec;
 999         struct hda_input_mux *imux = &spec->private_imux[0];
1000         int i, n, idx;
1001         hda_nid_t cap, pin;
1002
1003         if (imux != spec->input_mux) /* no dynamic imux? */
1004                 return false;
1005
1006         for (n = 0; n < spec->num_adc_nids; n++) {
1007                 cap = spec->private_capsrc_nids[n];
1008                 for (i = 0; i < imux->num_items; i++) {
1009                         pin = spec->imux_pins[i];
1010                         if (!pin)
1011                                 return false;
1012                         if (get_connection_index(codec, cap, pin) < 0)
1013                                 break;
1014                 }
1015                 if (i >= imux->num_items)
1016                         return true; /* no ADC-switch is needed */
1017         }
1018
1019         for (i = 0; i < imux->num_items; i++) {
1020                 pin = spec->imux_pins[i];
1021                 for (n = 0; n < spec->num_adc_nids; n++) {
1022                         cap = spec->private_capsrc_nids[n];
1023                         idx = get_connection_index(codec, cap, pin);
1024                         if (idx >= 0) {
1025                                 imux->items[i].index = idx;
1026                                 spec->dyn_adc_idx[i] = n;
1027                                 break;
1028                         }
1029                 }
1030         }
1031
1032         snd_printdd("realtek: enabling ADC switching\n");
1033         spec->dyn_adc_switch = 1;
1034         return true;
1035 }
1036
1037 /* rebuild imux for matching with the given auto-mic pins (if not yet) */
1038 static bool alc_rebuild_imux_for_auto_mic(struct hda_codec *codec)
1039 {
1040         struct alc_spec *spec = codec->spec;
1041         struct hda_input_mux *imux;
1042         static char * const texts[3] = {
1043                 "Mic", "Internal Mic", "Dock Mic"
1044         };
1045         int i;
1046
1047         if (!spec->auto_mic)
1048                 return false;
1049         imux = &spec->private_imux[0];
1050         if (spec->input_mux == imux)
1051                 return true;
1052         spec->imux_pins[0] = spec->ext_mic_pin;
1053         spec->imux_pins[1] = spec->int_mic_pin;
1054         spec->imux_pins[2] = spec->dock_mic_pin;
1055         for (i = 0; i < 3; i++) {
1056                 strcpy(imux->items[i].label, texts[i]);
1057                 if (spec->imux_pins[i])
1058                         imux->num_items = i + 1;
1059         }
1060         spec->num_mux_defs = 1;
1061         spec->input_mux = imux;
1062         return true;
1063 }
1064
1065 /* check whether all auto-mic pins are valid; setup indices if OK */
1066 static bool alc_auto_mic_check_imux(struct hda_codec *codec)
1067 {
1068         struct alc_spec *spec = codec->spec;
1069         const struct hda_input_mux *imux;
1070
1071         if (!spec->auto_mic)
1072                 return false;
1073         if (spec->auto_mic_valid_imux)
1074                 return true; /* already checked */
1075
1076         /* fill up imux indices */
1077         if (!alc_check_dyn_adc_switch(codec)) {
1078                 spec->auto_mic = 0;
1079                 return false;
1080         }
1081
1082         imux = spec->input_mux;
1083         spec->ext_mic_idx = find_idx_in_nid_list(spec->ext_mic_pin,
1084                                         spec->imux_pins, imux->num_items);
1085         spec->int_mic_idx = find_idx_in_nid_list(spec->int_mic_pin,
1086                                         spec->imux_pins, imux->num_items);
1087         spec->dock_mic_idx = find_idx_in_nid_list(spec->dock_mic_pin,
1088                                         spec->imux_pins, imux->num_items);
1089         if (spec->ext_mic_idx < 0 || spec->int_mic_idx < 0) {
1090                 spec->auto_mic = 0;
1091                 return false; /* no corresponding imux */
1092         }
1093
1094         snd_hda_codec_write_cache(codec, spec->ext_mic_pin, 0,
1095                                   AC_VERB_SET_UNSOLICITED_ENABLE,
1096                                   AC_USRSP_EN | ALC_MIC_EVENT);
1097         if (spec->dock_mic_pin)
1098                 snd_hda_codec_write_cache(codec, spec->dock_mic_pin, 0,
1099                                   AC_VERB_SET_UNSOLICITED_ENABLE,
1100                                   AC_USRSP_EN | ALC_MIC_EVENT);
1101
1102         spec->auto_mic_valid_imux = 1;
1103         spec->auto_mic = 1;
1104         return true;
1105 }
1106
1107 /*
1108  * Check the availability of auto-mic switch;
1109  * Set up if really supported
1110  */
1111 static void alc_init_auto_mic(struct hda_codec *codec)
1112 {
1113         struct alc_spec *spec = codec->spec;
1114         struct auto_pin_cfg *cfg = &spec->autocfg;
1115         hda_nid_t fixed, ext, dock;
1116         int i;
1117
1118         spec->ext_mic_idx = spec->int_mic_idx = spec->dock_mic_idx = -1;
1119
1120         fixed = ext = dock = 0;
1121         for (i = 0; i < cfg->num_inputs; i++) {
1122                 hda_nid_t nid = cfg->inputs[i].pin;
1123                 unsigned int defcfg;
1124                 defcfg = snd_hda_codec_get_pincfg(codec, nid);
1125                 switch (snd_hda_get_input_pin_attr(defcfg)) {
1126                 case INPUT_PIN_ATTR_INT:
1127                         if (fixed)
1128                                 return; /* already occupied */
1129                         if (cfg->inputs[i].type != AUTO_PIN_MIC)
1130                                 return; /* invalid type */
1131                         fixed = nid;
1132                         break;
1133                 case INPUT_PIN_ATTR_UNUSED:
1134                         return; /* invalid entry */
1135                 case INPUT_PIN_ATTR_DOCK:
1136                         if (dock)
1137                                 return; /* already occupied */
1138                         if (cfg->inputs[i].type > AUTO_PIN_LINE_IN)
1139                                 return; /* invalid type */
1140                         dock = nid;
1141                         break;
1142                 default:
1143                         if (ext)
1144                                 return; /* already occupied */
1145                         if (cfg->inputs[i].type != AUTO_PIN_MIC)
1146                                 return; /* invalid type */
1147                         ext = nid;
1148                         break;
1149                 }
1150         }
1151         if (!ext && dock) {
1152                 ext = dock;
1153                 dock = 0;
1154         }
1155         if (!ext || !fixed)
1156                 return;
1157         if (!is_jack_detectable(codec, ext))
1158                 return; /* no unsol support */
1159         if (dock && !is_jack_detectable(codec, dock))
1160                 return; /* no unsol support */
1161
1162         /* check imux indices */
1163         spec->ext_mic_pin = ext;
1164         spec->int_mic_pin = fixed;
1165         spec->dock_mic_pin = dock;
1166
1167         spec->auto_mic = 1;
1168         if (!alc_auto_mic_check_imux(codec))
1169                 return;
1170
1171         snd_printdd("realtek: Enable auto-mic switch on NID 0x%x/0x%x/0x%x\n",
1172                     ext, fixed, dock);
1173         spec->unsol_event = alc_sku_unsol_event;
1174 }
1175
1176 /* check the availabilities of auto-mute and auto-mic switches */
1177 static void alc_auto_check_switches(struct hda_codec *codec)
1178 {
1179         alc_init_automute(codec);
1180         alc_init_auto_mic(codec);
1181 }
1182
1183 /*
1184  * Realtek SSID verification
1185  */
1186
1187 /* Could be any non-zero and even value. When used as fixup, tells
1188  * the driver to ignore any present sku defines.
1189  */
1190 #define ALC_FIXUP_SKU_IGNORE (2)
1191
1192 static int alc_auto_parse_customize_define(struct hda_codec *codec)
1193 {
1194         unsigned int ass, tmp, i;
1195         unsigned nid = 0;
1196         struct alc_spec *spec = codec->spec;
1197
1198         spec->cdefine.enable_pcbeep = 1; /* assume always enabled */
1199
1200         if (spec->cdefine.fixup) {
1201                 ass = spec->cdefine.sku_cfg;
1202                 if (ass == ALC_FIXUP_SKU_IGNORE)
1203                         return -1;
1204                 goto do_sku;
1205         }
1206
1207         ass = codec->subsystem_id & 0xffff;
1208         if (ass != codec->bus->pci->subsystem_device && (ass & 1))
1209                 goto do_sku;
1210
1211         nid = 0x1d;
1212         if (codec->vendor_id == 0x10ec0260)
1213                 nid = 0x17;
1214         ass = snd_hda_codec_get_pincfg(codec, nid);
1215
1216         if (!(ass & 1)) {
1217                 printk(KERN_INFO "hda_codec: %s: SKU not ready 0x%08x\n",
1218                        codec->chip_name, ass);
1219                 return -1;
1220         }
1221
1222         /* check sum */
1223         tmp = 0;
1224         for (i = 1; i < 16; i++) {
1225                 if ((ass >> i) & 1)
1226                         tmp++;
1227         }
1228         if (((ass >> 16) & 0xf) != tmp)
1229                 return -1;
1230
1231         spec->cdefine.port_connectivity = ass >> 30;
1232         spec->cdefine.enable_pcbeep = (ass & 0x100000) >> 20;
1233         spec->cdefine.check_sum = (ass >> 16) & 0xf;
1234         spec->cdefine.customization = ass >> 8;
1235 do_sku:
1236         spec->cdefine.sku_cfg = ass;
1237         spec->cdefine.external_amp = (ass & 0x38) >> 3;
1238         spec->cdefine.platform_type = (ass & 0x4) >> 2;
1239         spec->cdefine.swap = (ass & 0x2) >> 1;
1240         spec->cdefine.override = ass & 0x1;
1241
1242         snd_printd("SKU: Nid=0x%x sku_cfg=0x%08x\n",
1243                    nid, spec->cdefine.sku_cfg);
1244         snd_printd("SKU: port_connectivity=0x%x\n",
1245                    spec->cdefine.port_connectivity);
1246         snd_printd("SKU: enable_pcbeep=0x%x\n", spec->cdefine.enable_pcbeep);
1247         snd_printd("SKU: check_sum=0x%08x\n", spec->cdefine.check_sum);
1248         snd_printd("SKU: customization=0x%08x\n", spec->cdefine.customization);
1249         snd_printd("SKU: external_amp=0x%x\n", spec->cdefine.external_amp);
1250         snd_printd("SKU: platform_type=0x%x\n", spec->cdefine.platform_type);
1251         snd_printd("SKU: swap=0x%x\n", spec->cdefine.swap);
1252         snd_printd("SKU: override=0x%x\n", spec->cdefine.override);
1253
1254         return 0;
1255 }
1256
1257 /* return true if the given NID is found in the list */
1258 static bool found_in_nid_list(hda_nid_t nid, const hda_nid_t *list, int nums)
1259 {
1260         return find_idx_in_nid_list(nid, list, nums) >= 0;
1261 }
1262
1263 /* check subsystem ID and set up device-specific initialization;
1264  * return 1 if initialized, 0 if invalid SSID
1265  */
1266 /* 32-bit subsystem ID for BIOS loading in HD Audio codec.
1267  *      31 ~ 16 :       Manufacture ID
1268  *      15 ~ 8  :       SKU ID
1269  *      7  ~ 0  :       Assembly ID
1270  *      port-A --> pin 39/41, port-E --> pin 14/15, port-D --> pin 35/36
1271  */
1272 static int alc_subsystem_id(struct hda_codec *codec,
1273                             hda_nid_t porta, hda_nid_t porte,
1274                             hda_nid_t portd, hda_nid_t porti)
1275 {
1276         unsigned int ass, tmp, i;
1277         unsigned nid;
1278         struct alc_spec *spec = codec->spec;
1279
1280         if (spec->cdefine.fixup) {
1281                 ass = spec->cdefine.sku_cfg;
1282                 if (ass == ALC_FIXUP_SKU_IGNORE)
1283                         return 0;
1284                 goto do_sku;
1285         }
1286
1287         ass = codec->subsystem_id & 0xffff;
1288         if ((ass != codec->bus->pci->subsystem_device) && (ass & 1))
1289                 goto do_sku;
1290
1291         /* invalid SSID, check the special NID pin defcfg instead */
1292         /*
1293          * 31~30        : port connectivity
1294          * 29~21        : reserve
1295          * 20           : PCBEEP input
1296          * 19~16        : Check sum (15:1)
1297          * 15~1         : Custom
1298          * 0            : override
1299         */
1300         nid = 0x1d;
1301         if (codec->vendor_id == 0x10ec0260)
1302                 nid = 0x17;
1303         ass = snd_hda_codec_get_pincfg(codec, nid);
1304         snd_printd("realtek: No valid SSID, "
1305                    "checking pincfg 0x%08x for NID 0x%x\n",
1306                    ass, nid);
1307         if (!(ass & 1))
1308                 return 0;
1309         if ((ass >> 30) != 1)   /* no physical connection */
1310                 return 0;
1311
1312         /* check sum */
1313         tmp = 0;
1314         for (i = 1; i < 16; i++) {
1315                 if ((ass >> i) & 1)
1316                         tmp++;
1317         }
1318         if (((ass >> 16) & 0xf) != tmp)
1319                 return 0;
1320 do_sku:
1321         snd_printd("realtek: Enabling init ASM_ID=0x%04x CODEC_ID=%08x\n",
1322                    ass & 0xffff, codec->vendor_id);
1323         /*
1324          * 0 : override
1325          * 1 :  Swap Jack
1326          * 2 : 0 --> Desktop, 1 --> Laptop
1327          * 3~5 : External Amplifier control
1328          * 7~6 : Reserved
1329         */
1330         tmp = (ass & 0x38) >> 3;        /* external Amp control */
1331         switch (tmp) {
1332         case 1:
1333                 spec->init_amp = ALC_INIT_GPIO1;
1334                 break;
1335         case 3:
1336                 spec->init_amp = ALC_INIT_GPIO2;
1337                 break;
1338         case 7:
1339                 spec->init_amp = ALC_INIT_GPIO3;
1340                 break;
1341         case 5:
1342         default:
1343                 spec->init_amp = ALC_INIT_DEFAULT;
1344                 break;
1345         }
1346
1347         /* is laptop or Desktop and enable the function "Mute internal speaker
1348          * when the external headphone out jack is plugged"
1349          */
1350         if (!(ass & 0x8000))
1351                 return 1;
1352         /*
1353          * 10~8 : Jack location
1354          * 12~11: Headphone out -> 00: PortA, 01: PortE, 02: PortD, 03: Resvered
1355          * 14~13: Resvered
1356          * 15   : 1 --> enable the function "Mute internal speaker
1357          *              when the external headphone out jack is plugged"
1358          */
1359         if (!spec->autocfg.hp_pins[0] &&
1360             !(spec->autocfg.line_out_pins[0] &&
1361               spec->autocfg.line_out_type == AUTO_PIN_HP_OUT)) {
1362                 hda_nid_t nid;
1363                 tmp = (ass >> 11) & 0x3;        /* HP to chassis */
1364                 if (tmp == 0)
1365                         nid = porta;
1366                 else if (tmp == 1)
1367                         nid = porte;
1368                 else if (tmp == 2)
1369                         nid = portd;
1370                 else if (tmp == 3)
1371                         nid = porti;
1372                 else
1373                         return 1;
1374                 if (found_in_nid_list(nid, spec->autocfg.line_out_pins,
1375                                       spec->autocfg.line_outs))
1376                         return 1;
1377                 spec->autocfg.hp_pins[0] = nid;
1378         }
1379         return 1;
1380 }
1381
1382 /* Check the validity of ALC subsystem-id
1383  * ports contains an array of 4 pin NIDs for port-A, E, D and I */
1384 static void alc_ssid_check(struct hda_codec *codec, const hda_nid_t *ports)
1385 {
1386         if (!alc_subsystem_id(codec, ports[0], ports[1], ports[2], ports[3])) {
1387                 struct alc_spec *spec = codec->spec;
1388                 snd_printd("realtek: "
1389                            "Enable default setup for auto mode as fallback\n");
1390                 spec->init_amp = ALC_INIT_DEFAULT;
1391         }
1392 }
1393
1394 /*
1395  * Fix-up pin default configurations and add default verbs
1396  */
1397
1398 struct alc_pincfg {
1399         hda_nid_t nid;
1400         u32 val;
1401 };
1402
1403 struct alc_model_fixup {
1404         const int id;
1405         const char *name;
1406 };
1407
1408 struct alc_fixup {
1409         int type;
1410         bool chained;
1411         int chain_id;
1412         union {
1413                 unsigned int sku;
1414                 const struct alc_pincfg *pins;
1415                 const struct hda_verb *verbs;
1416                 void (*func)(struct hda_codec *codec,
1417                              const struct alc_fixup *fix,
1418                              int action);
1419         } v;
1420 };
1421
1422 enum {
1423         ALC_FIXUP_INVALID,
1424         ALC_FIXUP_SKU,
1425         ALC_FIXUP_PINS,
1426         ALC_FIXUP_VERBS,
1427         ALC_FIXUP_FUNC,
1428 };
1429
1430 enum {
1431         ALC_FIXUP_ACT_PRE_PROBE,
1432         ALC_FIXUP_ACT_PROBE,
1433         ALC_FIXUP_ACT_INIT,
1434 };
1435
1436 static void alc_apply_fixup(struct hda_codec *codec, int action)
1437 {
1438         struct alc_spec *spec = codec->spec;
1439         int id = spec->fixup_id;
1440 #ifdef CONFIG_SND_DEBUG_VERBOSE
1441         const char *modelname = spec->fixup_name;
1442 #endif
1443         int depth = 0;
1444
1445         if (!spec->fixup_list)
1446                 return;
1447
1448         while (id >= 0) {
1449                 const struct alc_fixup *fix = spec->fixup_list + id;
1450                 const struct alc_pincfg *cfg;
1451
1452                 switch (fix->type) {
1453                 case ALC_FIXUP_SKU:
1454                         if (action != ALC_FIXUP_ACT_PRE_PROBE || !fix->v.sku)
1455                                 break;
1456                         snd_printdd(KERN_INFO "hda_codec: %s: "
1457                                     "Apply sku override for %s\n",
1458                                     codec->chip_name, modelname);
1459                         spec->cdefine.sku_cfg = fix->v.sku;
1460                         spec->cdefine.fixup = 1;
1461                         break;
1462                 case ALC_FIXUP_PINS:
1463                         cfg = fix->v.pins;
1464                         if (action != ALC_FIXUP_ACT_PRE_PROBE || !cfg)
1465                                 break;
1466                         snd_printdd(KERN_INFO "hda_codec: %s: "
1467                                     "Apply pincfg for %s\n",
1468                                     codec->chip_name, modelname);
1469                         for (; cfg->nid; cfg++)
1470                                 snd_hda_codec_set_pincfg(codec, cfg->nid,
1471                                                          cfg->val);
1472                         break;
1473                 case ALC_FIXUP_VERBS:
1474                         if (action != ALC_FIXUP_ACT_PROBE || !fix->v.verbs)
1475                                 break;
1476                         snd_printdd(KERN_INFO "hda_codec: %s: "
1477                                     "Apply fix-verbs for %s\n",
1478                                     codec->chip_name, modelname);
1479                         add_verb(codec->spec, fix->v.verbs);
1480                         break;
1481                 case ALC_FIXUP_FUNC:
1482                         if (!fix->v.func)
1483                                 break;
1484                         snd_printdd(KERN_INFO "hda_codec: %s: "
1485                                     "Apply fix-func for %s\n",
1486                                     codec->chip_name, modelname);
1487                         fix->v.func(codec, fix, action);
1488                         break;
1489                 default:
1490                         snd_printk(KERN_ERR "hda_codec: %s: "
1491                                    "Invalid fixup type %d\n",
1492                                    codec->chip_name, fix->type);
1493                         break;
1494                 }
1495                 if (!fix->chained)
1496                         break;
1497                 if (++depth > 10)
1498                         break;
1499                 id = fix->chain_id;
1500         }
1501 }
1502
1503 static void alc_pick_fixup(struct hda_codec *codec,
1504                            const struct alc_model_fixup *models,
1505                            const struct snd_pci_quirk *quirk,
1506                            const struct alc_fixup *fixlist)
1507 {
1508         struct alc_spec *spec = codec->spec;
1509         int id = -1;
1510         const char *name = NULL;
1511
1512         if (codec->modelname && models) {
1513                 while (models->name) {
1514                         if (!strcmp(codec->modelname, models->name)) {
1515                                 id = models->id;
1516                                 name = models->name;
1517                                 break;
1518                         }
1519                         models++;
1520                 }
1521         }
1522         if (id < 0) {
1523                 quirk = snd_pci_quirk_lookup(codec->bus->pci, quirk);
1524                 if (quirk) {
1525                         id = quirk->value;
1526 #ifdef CONFIG_SND_DEBUG_VERBOSE
1527                         name = quirk->name;
1528 #endif
1529                 }
1530         }
1531
1532         spec->fixup_id = id;
1533         if (id >= 0) {
1534                 spec->fixup_list = fixlist;
1535                 spec->fixup_name = name;
1536         }
1537 }
1538
1539 /*
1540  * COEF access helper functions
1541  */
1542 static int alc_read_coef_idx(struct hda_codec *codec,
1543                         unsigned int coef_idx)
1544 {
1545         unsigned int val;
1546         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX,
1547                                 coef_idx);
1548         val = snd_hda_codec_read(codec, 0x20, 0,
1549                                 AC_VERB_GET_PROC_COEF, 0);
1550         return val;
1551 }
1552
1553 static void alc_write_coef_idx(struct hda_codec *codec, unsigned int coef_idx,
1554                                                         unsigned int coef_val)
1555 {
1556         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX,
1557                             coef_idx);
1558         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_PROC_COEF,
1559                             coef_val);
1560 }
1561
1562 /* a special bypass for COEF 0; read the cached value at the second time */
1563 static unsigned int alc_get_coef0(struct hda_codec *codec)
1564 {
1565         struct alc_spec *spec = codec->spec;
1566         if (!spec->coef0)
1567                 spec->coef0 = alc_read_coef_idx(codec, 0);
1568         return spec->coef0;
1569 }
1570
1571 /*
1572  * Digital I/O handling
1573  */
1574
1575 /* set right pin controls for digital I/O */
1576 static void alc_auto_init_digital(struct hda_codec *codec)
1577 {
1578         struct alc_spec *spec = codec->spec;
1579         int i;
1580         hda_nid_t pin, dac;
1581
1582         for (i = 0; i < spec->autocfg.dig_outs; i++) {
1583                 pin = spec->autocfg.dig_out_pins[i];
1584                 if (!pin)
1585                         continue;
1586                 snd_hda_codec_write(codec, pin, 0,
1587                                     AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
1588                 if (!i)
1589                         dac = spec->multiout.dig_out_nid;
1590                 else
1591                         dac = spec->slave_dig_outs[i - 1];
1592                 if (!dac || !(get_wcaps(codec, dac) & AC_WCAP_OUT_AMP))
1593                         continue;
1594                 snd_hda_codec_write(codec, dac, 0,
1595                                     AC_VERB_SET_AMP_GAIN_MUTE,
1596                                     AMP_OUT_UNMUTE);
1597         }
1598         pin = spec->autocfg.dig_in_pin;
1599         if (pin)
1600                 snd_hda_codec_write(codec, pin, 0,
1601                                     AC_VERB_SET_PIN_WIDGET_CONTROL,
1602                                     PIN_IN);
1603 }
1604
1605 /* parse digital I/Os and set up NIDs in BIOS auto-parse mode */
1606 static void alc_auto_parse_digital(struct hda_codec *codec)
1607 {
1608         struct alc_spec *spec = codec->spec;
1609         int i, err, nums;
1610         hda_nid_t dig_nid;
1611
1612         /* support multiple SPDIFs; the secondary is set up as a slave */
1613         nums = 0;
1614         for (i = 0; i < spec->autocfg.dig_outs; i++) {
1615                 hda_nid_t conn[4];
1616                 err = snd_hda_get_connections(codec,
1617                                               spec->autocfg.dig_out_pins[i],
1618                                               conn, ARRAY_SIZE(conn));
1619                 if (err <= 0)
1620                         continue;
1621                 dig_nid = conn[0]; /* assume the first element is audio-out */
1622                 if (!nums) {
1623                         spec->multiout.dig_out_nid = dig_nid;
1624                         spec->dig_out_type = spec->autocfg.dig_out_type[0];
1625                 } else {
1626                         spec->multiout.slave_dig_outs = spec->slave_dig_outs;
1627                         if (nums >= ARRAY_SIZE(spec->slave_dig_outs) - 1)
1628                                 break;
1629                         spec->slave_dig_outs[nums - 1] = dig_nid;
1630                 }
1631                 nums++;
1632         }
1633
1634         if (spec->autocfg.dig_in_pin) {
1635                 dig_nid = codec->start_nid;
1636                 for (i = 0; i < codec->num_nodes; i++, dig_nid++) {
1637                         unsigned int wcaps = get_wcaps(codec, dig_nid);
1638                         if (get_wcaps_type(wcaps) != AC_WID_AUD_IN)
1639                                 continue;
1640                         if (!(wcaps & AC_WCAP_DIGITAL))
1641                                 continue;
1642                         if (!(wcaps & AC_WCAP_CONN_LIST))
1643                                 continue;
1644                         err = get_connection_index(codec, dig_nid,
1645                                                    spec->autocfg.dig_in_pin);
1646                         if (err >= 0) {
1647                                 spec->dig_in_nid = dig_nid;
1648                                 break;
1649                         }
1650                 }
1651         }
1652 }
1653
1654 /*
1655  * capture mixer elements
1656  */
1657 static int alc_cap_vol_info(struct snd_kcontrol *kcontrol,
1658                             struct snd_ctl_elem_info *uinfo)
1659 {
1660         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1661         struct alc_spec *spec = codec->spec;
1662         unsigned long val;
1663         int err;
1664
1665         mutex_lock(&codec->control_mutex);
1666         if (spec->vol_in_capsrc)
1667                 val = HDA_COMPOSE_AMP_VAL(spec->capsrc_nids[0], 3, 0, HDA_OUTPUT);
1668         else
1669                 val = HDA_COMPOSE_AMP_VAL(spec->adc_nids[0], 3, 0, HDA_INPUT);
1670         kcontrol->private_value = val;
1671         err = snd_hda_mixer_amp_volume_info(kcontrol, uinfo);
1672         mutex_unlock(&codec->control_mutex);
1673         return err;
1674 }
1675
1676 static int alc_cap_vol_tlv(struct snd_kcontrol *kcontrol, int op_flag,
1677                            unsigned int size, unsigned int __user *tlv)
1678 {
1679         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1680         struct alc_spec *spec = codec->spec;
1681         unsigned long val;
1682         int err;
1683
1684         mutex_lock(&codec->control_mutex);
1685         if (spec->vol_in_capsrc)
1686                 val = HDA_COMPOSE_AMP_VAL(spec->capsrc_nids[0], 3, 0, HDA_OUTPUT);
1687         else
1688                 val = HDA_COMPOSE_AMP_VAL(spec->adc_nids[0], 3, 0, HDA_INPUT);
1689         kcontrol->private_value = val;
1690         err = snd_hda_mixer_amp_tlv(kcontrol, op_flag, size, tlv);
1691         mutex_unlock(&codec->control_mutex);
1692         return err;
1693 }
1694
1695 typedef int (*getput_call_t)(struct snd_kcontrol *kcontrol,
1696                              struct snd_ctl_elem_value *ucontrol);
1697
1698 static int alc_cap_getput_caller(struct snd_kcontrol *kcontrol,
1699                                  struct snd_ctl_elem_value *ucontrol,
1700                                  getput_call_t func, bool check_adc_switch)
1701 {
1702         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1703         struct alc_spec *spec = codec->spec;
1704         int i, err = 0;
1705
1706         mutex_lock(&codec->control_mutex);
1707         if (check_adc_switch && spec->dyn_adc_switch) {
1708                 for (i = 0; i < spec->num_adc_nids; i++) {
1709                         kcontrol->private_value =
1710                                 HDA_COMPOSE_AMP_VAL(spec->adc_nids[i],
1711                                                     3, 0, HDA_INPUT);
1712                         err = func(kcontrol, ucontrol);
1713                         if (err < 0)
1714                                 goto error;
1715                 }
1716         } else {
1717                 i = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
1718                 if (spec->vol_in_capsrc)
1719                         kcontrol->private_value =
1720                                 HDA_COMPOSE_AMP_VAL(spec->capsrc_nids[i],
1721                                                     3, 0, HDA_OUTPUT);
1722                 else
1723                         kcontrol->private_value =
1724                                 HDA_COMPOSE_AMP_VAL(spec->adc_nids[i],
1725                                                     3, 0, HDA_INPUT);
1726                 err = func(kcontrol, ucontrol);
1727         }
1728  error:
1729         mutex_unlock(&codec->control_mutex);
1730         return err;
1731 }
1732
1733 static int alc_cap_vol_get(struct snd_kcontrol *kcontrol,
1734                            struct snd_ctl_elem_value *ucontrol)
1735 {
1736         return alc_cap_getput_caller(kcontrol, ucontrol,
1737                                      snd_hda_mixer_amp_volume_get, false);
1738 }
1739
1740 static int alc_cap_vol_put(struct snd_kcontrol *kcontrol,
1741                            struct snd_ctl_elem_value *ucontrol)
1742 {
1743         return alc_cap_getput_caller(kcontrol, ucontrol,
1744                                      snd_hda_mixer_amp_volume_put, true);
1745 }
1746
1747 /* capture mixer elements */
1748 #define alc_cap_sw_info         snd_ctl_boolean_stereo_info
1749
1750 static int alc_cap_sw_get(struct snd_kcontrol *kcontrol,
1751                           struct snd_ctl_elem_value *ucontrol)
1752 {
1753         return alc_cap_getput_caller(kcontrol, ucontrol,
1754                                      snd_hda_mixer_amp_switch_get, false);
1755 }
1756
1757 static int alc_cap_sw_put(struct snd_kcontrol *kcontrol,
1758                           struct snd_ctl_elem_value *ucontrol)
1759 {
1760         return alc_cap_getput_caller(kcontrol, ucontrol,
1761                                      snd_hda_mixer_amp_switch_put, true);
1762 }
1763
1764 #define _DEFINE_CAPMIX(num) \
1765         { \
1766                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
1767                 .name = "Capture Switch", \
1768                 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE, \
1769                 .count = num, \
1770                 .info = alc_cap_sw_info, \
1771                 .get = alc_cap_sw_get, \
1772                 .put = alc_cap_sw_put, \
1773         }, \
1774         { \
1775                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
1776                 .name = "Capture Volume", \
1777                 .access = (SNDRV_CTL_ELEM_ACCESS_READWRITE | \
1778                            SNDRV_CTL_ELEM_ACCESS_TLV_READ | \
1779                            SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK), \
1780                 .count = num, \
1781                 .info = alc_cap_vol_info, \
1782                 .get = alc_cap_vol_get, \
1783                 .put = alc_cap_vol_put, \
1784                 .tlv = { .c = alc_cap_vol_tlv }, \
1785         }
1786
1787 #define _DEFINE_CAPSRC(num) \
1788         { \
1789                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
1790                 /* .name = "Capture Source", */ \
1791                 .name = "Input Source", \
1792                 .count = num, \
1793                 .info = alc_mux_enum_info, \
1794                 .get = alc_mux_enum_get, \
1795                 .put = alc_mux_enum_put, \
1796         }
1797
1798 #define DEFINE_CAPMIX(num) \
1799 static const struct snd_kcontrol_new alc_capture_mixer ## num[] = { \
1800         _DEFINE_CAPMIX(num),                                  \
1801         _DEFINE_CAPSRC(num),                                  \
1802         { } /* end */                                         \
1803 }
1804
1805 #define DEFINE_CAPMIX_NOSRC(num) \
1806 static const struct snd_kcontrol_new alc_capture_mixer_nosrc ## num[] = { \
1807         _DEFINE_CAPMIX(num),                                        \
1808         { } /* end */                                               \
1809 }
1810
1811 /* up to three ADCs */
1812 DEFINE_CAPMIX(1);
1813 DEFINE_CAPMIX(2);
1814 DEFINE_CAPMIX(3);
1815 DEFINE_CAPMIX_NOSRC(1);
1816 DEFINE_CAPMIX_NOSRC(2);
1817 DEFINE_CAPMIX_NOSRC(3);
1818
1819 /*
1820  * virtual master controls
1821  */
1822
1823 /*
1824  * slave controls for virtual master
1825  */
1826 static const char * const alc_slave_vols[] = {
1827         "Front Playback Volume",
1828         "Surround Playback Volume",
1829         "Center Playback Volume",
1830         "LFE Playback Volume",
1831         "Side Playback Volume",
1832         "Headphone Playback Volume",
1833         "Speaker Playback Volume",
1834         "Mono Playback Volume",
1835         "Line-Out Playback Volume",
1836         "PCM Playback Volume",
1837         NULL,
1838 };
1839
1840 static const char * const alc_slave_sws[] = {
1841         "Front Playback Switch",
1842         "Surround Playback Switch",
1843         "Center Playback Switch",
1844         "LFE Playback Switch",
1845         "Side Playback Switch",
1846         "Headphone Playback Switch",
1847         "Speaker Playback Switch",
1848         "Mono Playback Switch",
1849         "IEC958 Playback Switch",
1850         "Line-Out Playback Switch",
1851         "PCM Playback Switch",
1852         NULL,
1853 };
1854
1855 /*
1856  * build control elements
1857  */
1858
1859 #define NID_MAPPING             (-1)
1860
1861 #define SUBDEV_SPEAKER_         (0 << 6)
1862 #define SUBDEV_HP_              (1 << 6)
1863 #define SUBDEV_LINE_            (2 << 6)
1864 #define SUBDEV_SPEAKER(x)       (SUBDEV_SPEAKER_ | ((x) & 0x3f))
1865 #define SUBDEV_HP(x)            (SUBDEV_HP_ | ((x) & 0x3f))
1866 #define SUBDEV_LINE(x)          (SUBDEV_LINE_ | ((x) & 0x3f))
1867
1868 static void alc_free_kctls(struct hda_codec *codec);
1869
1870 #ifdef CONFIG_SND_HDA_INPUT_BEEP
1871 /* additional beep mixers; the actual parameters are overwritten at build */
1872 static const struct snd_kcontrol_new alc_beep_mixer[] = {
1873         HDA_CODEC_VOLUME("Beep Playback Volume", 0, 0, HDA_INPUT),
1874         HDA_CODEC_MUTE_BEEP("Beep Playback Switch", 0, 0, HDA_INPUT),
1875         { } /* end */
1876 };
1877 #endif
1878
1879 static int alc_build_controls(struct hda_codec *codec)
1880 {
1881         struct alc_spec *spec = codec->spec;
1882         struct snd_kcontrol *kctl = NULL;
1883         const struct snd_kcontrol_new *knew;
1884         int i, j, err;
1885         unsigned int u;
1886         hda_nid_t nid;
1887
1888         for (i = 0; i < spec->num_mixers; i++) {
1889                 err = snd_hda_add_new_ctls(codec, spec->mixers[i]);
1890                 if (err < 0)
1891                         return err;
1892         }
1893         if (spec->cap_mixer) {
1894                 err = snd_hda_add_new_ctls(codec, spec->cap_mixer);
1895                 if (err < 0)
1896                         return err;
1897         }
1898         if (spec->multiout.dig_out_nid) {
1899                 err = snd_hda_create_spdif_out_ctls(codec,
1900                                                     spec->multiout.dig_out_nid,
1901                                                     spec->multiout.dig_out_nid);
1902                 if (err < 0)
1903                         return err;
1904                 if (!spec->no_analog) {
1905                         err = snd_hda_create_spdif_share_sw(codec,
1906                                                             &spec->multiout);
1907                         if (err < 0)
1908                                 return err;
1909                         spec->multiout.share_spdif = 1;
1910                 }
1911         }
1912         if (spec->dig_in_nid) {
1913                 err = snd_hda_create_spdif_in_ctls(codec, spec->dig_in_nid);
1914                 if (err < 0)
1915                         return err;
1916         }
1917
1918 #ifdef CONFIG_SND_HDA_INPUT_BEEP
1919         /* create beep controls if needed */
1920         if (spec->beep_amp) {
1921                 const struct snd_kcontrol_new *knew;
1922                 for (knew = alc_beep_mixer; knew->name; knew++) {
1923                         struct snd_kcontrol *kctl;
1924                         kctl = snd_ctl_new1(knew, codec);
1925                         if (!kctl)
1926                                 return -ENOMEM;
1927                         kctl->private_value = spec->beep_amp;
1928                         err = snd_hda_ctl_add(codec, 0, kctl);
1929                         if (err < 0)
1930                                 return err;
1931                 }
1932         }
1933 #endif
1934
1935         /* if we have no master control, let's create it */
1936         if (!spec->no_analog &&
1937             !snd_hda_find_mixer_ctl(codec, "Master Playback Volume")) {
1938                 unsigned int vmaster_tlv[4];
1939                 snd_hda_set_vmaster_tlv(codec, spec->vmaster_nid,
1940                                         HDA_OUTPUT, vmaster_tlv);
1941                 err = snd_hda_add_vmaster(codec, "Master Playback Volume",
1942                                           vmaster_tlv, alc_slave_vols);
1943                 if (err < 0)
1944                         return err;
1945         }
1946         if (!spec->no_analog &&
1947             !snd_hda_find_mixer_ctl(codec, "Master Playback Switch")) {
1948                 err = snd_hda_add_vmaster(codec, "Master Playback Switch",
1949                                           NULL, alc_slave_sws);
1950                 if (err < 0)
1951                         return err;
1952         }
1953
1954         /* assign Capture Source enums to NID */
1955         if (spec->capsrc_nids || spec->adc_nids) {
1956                 kctl = snd_hda_find_mixer_ctl(codec, "Capture Source");
1957                 if (!kctl)
1958                         kctl = snd_hda_find_mixer_ctl(codec, "Input Source");
1959                 for (i = 0; kctl && i < kctl->count; i++) {
1960                         const hda_nid_t *nids = spec->capsrc_nids;
1961                         if (!nids)
1962                                 nids = spec->adc_nids;
1963                         err = snd_hda_add_nid(codec, kctl, i, nids[i]);
1964                         if (err < 0)
1965                                 return err;
1966                 }
1967         }
1968         if (spec->cap_mixer && spec->adc_nids) {
1969                 const char *kname = kctl ? kctl->id.name : NULL;
1970                 for (knew = spec->cap_mixer; knew->name; knew++) {
1971                         if (kname && strcmp(knew->name, kname) == 0)
1972                                 continue;
1973                         kctl = snd_hda_find_mixer_ctl(codec, knew->name);
1974                         for (i = 0; kctl && i < kctl->count; i++) {
1975                                 err = snd_hda_add_nid(codec, kctl, i,
1976                                                       spec->adc_nids[i]);
1977                                 if (err < 0)
1978                                         return err;
1979                         }
1980                 }
1981         }
1982
1983         /* other nid->control mapping */
1984         for (i = 0; i < spec->num_mixers; i++) {
1985                 for (knew = spec->mixers[i]; knew->name; knew++) {
1986                         if (knew->iface != NID_MAPPING)
1987                                 continue;
1988                         kctl = snd_hda_find_mixer_ctl(codec, knew->name);
1989                         if (kctl == NULL)
1990                                 continue;
1991                         u = knew->subdevice;
1992                         for (j = 0; j < 4; j++, u >>= 8) {
1993                                 nid = u & 0x3f;
1994                                 if (nid == 0)
1995                                         continue;
1996                                 switch (u & 0xc0) {
1997                                 case SUBDEV_SPEAKER_:
1998                                         nid = spec->autocfg.speaker_pins[nid];
1999                                         break;
2000                                 case SUBDEV_LINE_:
2001                                         nid = spec->autocfg.line_out_pins[nid];
2002                                         break;
2003                                 case SUBDEV_HP_:
2004                                         nid = spec->autocfg.hp_pins[nid];
2005                                         break;
2006                                 default:
2007                                         continue;
2008                                 }
2009                                 err = snd_hda_add_nid(codec, kctl, 0, nid);
2010                                 if (err < 0)
2011                                         return err;
2012                         }
2013                         u = knew->private_value;
2014                         for (j = 0; j < 4; j++, u >>= 8) {
2015                                 nid = u & 0xff;
2016                                 if (nid == 0)
2017                                         continue;
2018                                 err = snd_hda_add_nid(codec, kctl, 0, nid);
2019                                 if (err < 0)
2020                                         return err;
2021                         }
2022                 }
2023         }
2024
2025         alc_free_kctls(codec); /* no longer needed */
2026
2027         return 0;
2028 }
2029
2030
2031 /*
2032  * Common callbacks
2033  */
2034
2035 static void alc_init_special_input_src(struct hda_codec *codec);
2036
2037 static int alc_init(struct hda_codec *codec)
2038 {
2039         struct alc_spec *spec = codec->spec;
2040         unsigned int i;
2041
2042         alc_fix_pll(codec);
2043         alc_auto_init_amp(codec, spec->init_amp);
2044
2045         for (i = 0; i < spec->num_init_verbs; i++)
2046                 snd_hda_sequence_write(codec, spec->init_verbs[i]);
2047         alc_init_special_input_src(codec);
2048
2049         if (spec->init_hook)
2050                 spec->init_hook(codec);
2051
2052         alc_apply_fixup(codec, ALC_FIXUP_ACT_INIT);
2053
2054         hda_call_check_power_status(codec, 0x01);
2055         return 0;
2056 }
2057
2058 static void alc_unsol_event(struct hda_codec *codec, unsigned int res)
2059 {
2060         struct alc_spec *spec = codec->spec;
2061
2062         if (spec->unsol_event)
2063                 spec->unsol_event(codec, res);
2064 }
2065
2066 #ifdef CONFIG_SND_HDA_POWER_SAVE
2067 static int alc_check_power_status(struct hda_codec *codec, hda_nid_t nid)
2068 {
2069         struct alc_spec *spec = codec->spec;
2070         return snd_hda_check_amp_list_power(codec, &spec->loopback, nid);
2071 }
2072 #endif
2073
2074 /*
2075  * Analog playback callbacks
2076  */
2077 static int alc_playback_pcm_open(struct hda_pcm_stream *hinfo,
2078                                     struct hda_codec *codec,
2079                                     struct snd_pcm_substream *substream)
2080 {
2081         struct alc_spec *spec = codec->spec;
2082         return snd_hda_multi_out_analog_open(codec, &spec->multiout, substream,
2083                                              hinfo);
2084 }
2085
2086 static int alc_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
2087                                        struct hda_codec *codec,
2088                                        unsigned int stream_tag,
2089                                        unsigned int format,
2090                                        struct snd_pcm_substream *substream)
2091 {
2092         struct alc_spec *spec = codec->spec;
2093         return snd_hda_multi_out_analog_prepare(codec, &spec->multiout,
2094                                                 stream_tag, format, substream);
2095 }
2096
2097 static int alc_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
2098                                        struct hda_codec *codec,
2099                                        struct snd_pcm_substream *substream)
2100 {
2101         struct alc_spec *spec = codec->spec;
2102         return snd_hda_multi_out_analog_cleanup(codec, &spec->multiout);
2103 }
2104
2105 /*
2106  * Digital out
2107  */
2108 static int alc_dig_playback_pcm_open(struct hda_pcm_stream *hinfo,
2109                                         struct hda_codec *codec,
2110                                         struct snd_pcm_substream *substream)
2111 {
2112         struct alc_spec *spec = codec->spec;
2113         return snd_hda_multi_out_dig_open(codec, &spec->multiout);
2114 }
2115
2116 static int alc_dig_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
2117                                            struct hda_codec *codec,
2118                                            unsigned int stream_tag,
2119                                            unsigned int format,
2120                                            struct snd_pcm_substream *substream)
2121 {
2122         struct alc_spec *spec = codec->spec;
2123         return snd_hda_multi_out_dig_prepare(codec, &spec->multiout,
2124                                              stream_tag, format, substream);
2125 }
2126
2127 static int alc_dig_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
2128                                            struct hda_codec *codec,
2129                                            struct snd_pcm_substream *substream)
2130 {
2131         struct alc_spec *spec = codec->spec;
2132         return snd_hda_multi_out_dig_cleanup(codec, &spec->multiout);
2133 }
2134
2135 static int alc_dig_playback_pcm_close(struct hda_pcm_stream *hinfo,
2136                                          struct hda_codec *codec,
2137                                          struct snd_pcm_substream *substream)
2138 {
2139         struct alc_spec *spec = codec->spec;
2140         return snd_hda_multi_out_dig_close(codec, &spec->multiout);
2141 }
2142
2143 /*
2144  * Analog capture
2145  */
2146 static int alc_alt_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
2147                                       struct hda_codec *codec,
2148                                       unsigned int stream_tag,
2149                                       unsigned int format,
2150                                       struct snd_pcm_substream *substream)
2151 {
2152         struct alc_spec *spec = codec->spec;
2153
2154         snd_hda_codec_setup_stream(codec, spec->adc_nids[substream->number + 1],
2155                                    stream_tag, 0, format);
2156         return 0;
2157 }
2158
2159 static int alc_alt_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
2160                                       struct hda_codec *codec,
2161                                       struct snd_pcm_substream *substream)
2162 {
2163         struct alc_spec *spec = codec->spec;
2164
2165         snd_hda_codec_cleanup_stream(codec,
2166                                      spec->adc_nids[substream->number + 1]);
2167         return 0;
2168 }
2169
2170 /* analog capture with dynamic dual-adc changes */
2171 static int dyn_adc_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
2172                                        struct hda_codec *codec,
2173                                        unsigned int stream_tag,
2174                                        unsigned int format,
2175                                        struct snd_pcm_substream *substream)
2176 {
2177         struct alc_spec *spec = codec->spec;
2178         spec->cur_adc = spec->adc_nids[spec->dyn_adc_idx[spec->cur_mux[0]]];
2179         spec->cur_adc_stream_tag = stream_tag;
2180         spec->cur_adc_format = format;
2181         snd_hda_codec_setup_stream(codec, spec->cur_adc, stream_tag, 0, format);
2182         return 0;
2183 }
2184
2185 static int dyn_adc_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
2186                                        struct hda_codec *codec,
2187                                        struct snd_pcm_substream *substream)
2188 {
2189         struct alc_spec *spec = codec->spec;
2190         snd_hda_codec_cleanup_stream(codec, spec->cur_adc);
2191         spec->cur_adc = 0;
2192         return 0;
2193 }
2194
2195 static const struct hda_pcm_stream dyn_adc_pcm_analog_capture = {
2196         .substreams = 1,
2197         .channels_min = 2,
2198         .channels_max = 2,
2199         .nid = 0, /* fill later */
2200         .ops = {
2201                 .prepare = dyn_adc_capture_pcm_prepare,
2202                 .cleanup = dyn_adc_capture_pcm_cleanup
2203         },
2204 };
2205
2206 /*
2207  */
2208 static const struct hda_pcm_stream alc_pcm_analog_playback = {
2209         .substreams = 1,
2210         .channels_min = 2,
2211         .channels_max = 8,
2212         /* NID is set in alc_build_pcms */
2213         .ops = {
2214                 .open = alc_playback_pcm_open,
2215                 .prepare = alc_playback_pcm_prepare,
2216                 .cleanup = alc_playback_pcm_cleanup
2217         },
2218 };
2219
2220 static const struct hda_pcm_stream alc_pcm_analog_capture = {
2221         .substreams = 1,
2222         .channels_min = 2,
2223         .channels_max = 2,
2224         /* NID is set in alc_build_pcms */
2225 };
2226
2227 static const struct hda_pcm_stream alc_pcm_analog_alt_playback = {
2228         .substreams = 1,
2229         .channels_min = 2,
2230         .channels_max = 2,
2231         /* NID is set in alc_build_pcms */
2232 };
2233
2234 static const struct hda_pcm_stream alc_pcm_analog_alt_capture = {
2235         .substreams = 2, /* can be overridden */
2236         .channels_min = 2,
2237         .channels_max = 2,
2238         /* NID is set in alc_build_pcms */
2239         .ops = {
2240                 .prepare = alc_alt_capture_pcm_prepare,
2241                 .cleanup = alc_alt_capture_pcm_cleanup
2242         },
2243 };
2244
2245 static const struct hda_pcm_stream alc_pcm_digital_playback = {
2246         .substreams = 1,
2247         .channels_min = 2,
2248         .channels_max = 2,
2249         /* NID is set in alc_build_pcms */
2250         .ops = {
2251                 .open = alc_dig_playback_pcm_open,
2252                 .close = alc_dig_playback_pcm_close,
2253                 .prepare = alc_dig_playback_pcm_prepare,
2254                 .cleanup = alc_dig_playback_pcm_cleanup
2255         },
2256 };
2257
2258 static const struct hda_pcm_stream alc_pcm_digital_capture = {
2259         .substreams = 1,
2260         .channels_min = 2,
2261         .channels_max = 2,
2262         /* NID is set in alc_build_pcms */
2263 };
2264
2265 /* Used by alc_build_pcms to flag that a PCM has no playback stream */
2266 static const struct hda_pcm_stream alc_pcm_null_stream = {
2267         .substreams = 0,
2268         .channels_min = 0,
2269         .channels_max = 0,
2270 };
2271
2272 static int alc_build_pcms(struct hda_codec *codec)
2273 {
2274         struct alc_spec *spec = codec->spec;
2275         struct hda_pcm *info = spec->pcm_rec;
2276         const struct hda_pcm_stream *p;
2277         bool have_multi_adcs;
2278         int i;
2279
2280         codec->num_pcms = 1;
2281         codec->pcm_info = info;
2282
2283         if (spec->no_analog)
2284                 goto skip_analog;
2285
2286         snprintf(spec->stream_name_analog, sizeof(spec->stream_name_analog),
2287                  "%s Analog", codec->chip_name);
2288         info->name = spec->stream_name_analog;
2289
2290         if (spec->multiout.dac_nids > 0) {
2291                 p = spec->stream_analog_playback;
2292                 if (!p)
2293                         p = &alc_pcm_analog_playback;
2294                 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *p;
2295                 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dac_nids[0];
2296         }
2297         if (spec->adc_nids) {
2298                 p = spec->stream_analog_capture;
2299                 if (!p) {
2300                         if (spec->dyn_adc_switch)
2301                                 p = &dyn_adc_pcm_analog_capture;
2302                         else
2303                                 p = &alc_pcm_analog_capture;
2304                 }
2305                 info->stream[SNDRV_PCM_STREAM_CAPTURE] = *p;
2306                 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adc_nids[0];
2307         }
2308
2309         if (spec->channel_mode) {
2310                 info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max = 0;
2311                 for (i = 0; i < spec->num_channel_mode; i++) {
2312                         if (spec->channel_mode[i].channels > info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max) {
2313                                 info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max = spec->channel_mode[i].channels;
2314                         }
2315                 }
2316         }
2317
2318  skip_analog:
2319         /* SPDIF for stream index #1 */
2320         if (spec->multiout.dig_out_nid || spec->dig_in_nid) {
2321                 snprintf(spec->stream_name_digital,
2322                          sizeof(spec->stream_name_digital),
2323                          "%s Digital", codec->chip_name);
2324                 codec->num_pcms = 2;
2325                 codec->slave_dig_outs = spec->multiout.slave_dig_outs;
2326                 info = spec->pcm_rec + 1;
2327                 info->name = spec->stream_name_digital;
2328                 if (spec->dig_out_type)
2329                         info->pcm_type = spec->dig_out_type;
2330                 else
2331                         info->pcm_type = HDA_PCM_TYPE_SPDIF;
2332                 if (spec->multiout.dig_out_nid) {
2333                         p = spec->stream_digital_playback;
2334                         if (!p)
2335                                 p = &alc_pcm_digital_playback;
2336                         info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *p;
2337                         info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dig_out_nid;
2338                 }
2339                 if (spec->dig_in_nid) {
2340                         p = spec->stream_digital_capture;
2341                         if (!p)
2342                                 p = &alc_pcm_digital_capture;
2343                         info->stream[SNDRV_PCM_STREAM_CAPTURE] = *p;
2344                         info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->dig_in_nid;
2345                 }
2346                 /* FIXME: do we need this for all Realtek codec models? */
2347                 codec->spdif_status_reset = 1;
2348         }
2349
2350         if (spec->no_analog)
2351                 return 0;
2352
2353         /* If the use of more than one ADC is requested for the current
2354          * model, configure a second analog capture-only PCM.
2355          */
2356         have_multi_adcs = (spec->num_adc_nids > 1) &&
2357                 !spec->dyn_adc_switch && !spec->auto_mic &&
2358                 (!spec->input_mux || spec->input_mux->num_items > 1);
2359         /* Additional Analaog capture for index #2 */
2360         if (spec->alt_dac_nid || have_multi_adcs) {
2361                 codec->num_pcms = 3;
2362                 info = spec->pcm_rec + 2;
2363                 info->name = spec->stream_name_analog;
2364                 if (spec->alt_dac_nid) {
2365                         p = spec->stream_analog_alt_playback;
2366                         if (!p)
2367                                 p = &alc_pcm_analog_alt_playback;
2368                         info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *p;
2369                         info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid =
2370                                 spec->alt_dac_nid;
2371                 } else {
2372                         info->stream[SNDRV_PCM_STREAM_PLAYBACK] =
2373                                 alc_pcm_null_stream;
2374                         info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = 0;
2375                 }
2376                 if (have_multi_adcs) {
2377                         p = spec->stream_analog_alt_capture;
2378                         if (!p)
2379                                 p = &alc_pcm_analog_alt_capture;
2380                         info->stream[SNDRV_PCM_STREAM_CAPTURE] = *p;
2381                         info->stream[SNDRV_PCM_STREAM_CAPTURE].nid =
2382                                 spec->adc_nids[1];
2383                         info->stream[SNDRV_PCM_STREAM_CAPTURE].substreams =
2384                                 spec->num_adc_nids - 1;
2385                 } else {
2386                         info->stream[SNDRV_PCM_STREAM_CAPTURE] =
2387                                 alc_pcm_null_stream;
2388                         info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = 0;
2389                 }
2390         }
2391
2392         return 0;
2393 }
2394
2395 static inline void alc_shutup(struct hda_codec *codec)
2396 {
2397         struct alc_spec *spec = codec->spec;
2398
2399         if (spec && spec->shutup)
2400                 spec->shutup(codec);
2401         snd_hda_shutup_pins(codec);
2402 }
2403
2404 static void alc_free_kctls(struct hda_codec *codec)
2405 {
2406         struct alc_spec *spec = codec->spec;
2407
2408         if (spec->kctls.list) {
2409                 struct snd_kcontrol_new *kctl = spec->kctls.list;
2410                 int i;
2411                 for (i = 0; i < spec->kctls.used; i++)
2412                         kfree(kctl[i].name);
2413         }
2414         snd_array_free(&spec->kctls);
2415 }
2416
2417 static void alc_free_bind_ctls(struct hda_codec *codec)
2418 {
2419         struct alc_spec *spec = codec->spec;
2420         if (spec->bind_ctls.list) {
2421                 struct hda_bind_ctls **ctl = spec->bind_ctls.list;
2422                 int i;
2423                 for (i = 0; i < spec->bind_ctls.used; i++)
2424                         kfree(ctl[i]);
2425         }
2426         snd_array_free(&spec->bind_ctls);
2427 }
2428
2429 static void alc_free(struct hda_codec *codec)
2430 {
2431         struct alc_spec *spec = codec->spec;
2432
2433         if (!spec)
2434                 return;
2435
2436         alc_shutup(codec);
2437         snd_hda_input_jack_free(codec);
2438         alc_free_kctls(codec);
2439         alc_free_bind_ctls(codec);
2440         kfree(spec);
2441         snd_hda_detach_beep_device(codec);
2442 }
2443
2444 #ifdef CONFIG_SND_HDA_POWER_SAVE
2445 static void alc_power_eapd(struct hda_codec *codec)
2446 {
2447         alc_auto_setup_eapd(codec, false);
2448 }
2449
2450 static int alc_suspend(struct hda_codec *codec, pm_message_t state)
2451 {
2452         struct alc_spec *spec = codec->spec;
2453         alc_shutup(codec);
2454         if (spec && spec->power_hook)
2455                 spec->power_hook(codec);
2456         return 0;
2457 }
2458 #endif
2459
2460 #ifdef CONFIG_PM
2461 static int alc_resume(struct hda_codec *codec)
2462 {
2463         msleep(150); /* to avoid pop noise */
2464         codec->patch_ops.init(codec);
2465         snd_hda_codec_resume_amp(codec);
2466         snd_hda_codec_resume_cache(codec);
2467         hda_call_check_power_status(codec, 0x01);
2468         return 0;
2469 }
2470 #endif
2471
2472 /*
2473  */
2474 static const struct hda_codec_ops alc_patch_ops = {
2475         .build_controls = alc_build_controls,
2476         .build_pcms = alc_build_pcms,
2477         .init = alc_init,
2478         .free = alc_free,
2479         .unsol_event = alc_unsol_event,
2480 #ifdef CONFIG_PM
2481         .resume = alc_resume,
2482 #endif
2483 #ifdef CONFIG_SND_HDA_POWER_SAVE
2484         .suspend = alc_suspend,
2485         .check_power_status = alc_check_power_status,
2486 #endif
2487         .reboot_notify = alc_shutup,
2488 };
2489
2490 /* replace the codec chip_name with the given string */
2491 static int alc_codec_rename(struct hda_codec *codec, const char *name)
2492 {
2493         kfree(codec->chip_name);
2494         codec->chip_name = kstrdup(name, GFP_KERNEL);
2495         if (!codec->chip_name) {
2496                 alc_free(codec);
2497                 return -ENOMEM;
2498         }
2499         return 0;
2500 }
2501
2502 /*
2503  * Rename codecs appropriately from COEF value
2504  */
2505 struct alc_codec_rename_table {
2506         unsigned int vendor_id;
2507         unsigned short coef_mask;
2508         unsigned short coef_bits;
2509         const char *name;
2510 };
2511
2512 static struct alc_codec_rename_table rename_tbl[] = {
2513         { 0x10ec0269, 0xfff0, 0x3010, "ALC277" },
2514         { 0x10ec0269, 0xf0f0, 0x2010, "ALC259" },
2515         { 0x10ec0269, 0xf0f0, 0x3010, "ALC258" },
2516         { 0x10ec0269, 0x00f0, 0x0010, "ALC269VB" },
2517         { 0x10ec0269, 0xffff, 0xa023, "ALC259" },
2518         { 0x10ec0269, 0xffff, 0x6023, "ALC281X" },
2519         { 0x10ec0269, 0x00f0, 0x0020, "ALC269VC" },
2520         { 0x10ec0887, 0x00f0, 0x0030, "ALC887-VD" },
2521         { 0x10ec0888, 0x00f0, 0x0030, "ALC888-VD" },
2522         { 0x10ec0888, 0xf0f0, 0x3020, "ALC886" },
2523         { 0x10ec0899, 0x2000, 0x2000, "ALC899" },
2524         { 0x10ec0892, 0xffff, 0x8020, "ALC661" },
2525         { 0x10ec0892, 0xffff, 0x8011, "ALC661" },
2526         { 0x10ec0892, 0xffff, 0x4011, "ALC656" },
2527         { } /* terminator */
2528 };
2529
2530 static int alc_codec_rename_from_preset(struct hda_codec *codec)
2531 {
2532         const struct alc_codec_rename_table *p;
2533
2534         for (p = rename_tbl; p->vendor_id; p++) {
2535                 if (p->vendor_id != codec->vendor_id)
2536                         continue;
2537                 if ((alc_get_coef0(codec) & p->coef_mask) == p->coef_bits)
2538                         return alc_codec_rename(codec, p->name);
2539         }
2540         return 0;
2541 }
2542
2543 /*
2544  * Automatic parse of I/O pins from the BIOS configuration
2545  */
2546
2547 enum {
2548         ALC_CTL_WIDGET_VOL,
2549         ALC_CTL_WIDGET_MUTE,
2550         ALC_CTL_BIND_MUTE,
2551         ALC_CTL_BIND_VOL,
2552         ALC_CTL_BIND_SW,
2553 };
2554 static const struct snd_kcontrol_new alc_control_templates[] = {
2555         HDA_CODEC_VOLUME(NULL, 0, 0, 0),
2556         HDA_CODEC_MUTE(NULL, 0, 0, 0),
2557         HDA_BIND_MUTE(NULL, 0, 0, 0),
2558         HDA_BIND_VOL(NULL, 0),
2559         HDA_BIND_SW(NULL, 0),
2560 };
2561
2562 /* add dynamic controls */
2563 static int add_control(struct alc_spec *spec, int type, const char *name,
2564                        int cidx, unsigned long val)
2565 {
2566         struct snd_kcontrol_new *knew;
2567
2568         knew = alc_kcontrol_new(spec);
2569         if (!knew)
2570                 return -ENOMEM;
2571         *knew = alc_control_templates[type];
2572         knew->name = kstrdup(name, GFP_KERNEL);
2573         if (!knew->name)
2574                 return -ENOMEM;
2575         knew->index = cidx;
2576         if (get_amp_nid_(val))
2577                 knew->subdevice = HDA_SUBDEV_AMP_FLAG;
2578         knew->private_value = val;
2579         return 0;
2580 }
2581
2582 static int add_control_with_pfx(struct alc_spec *spec, int type,
2583                                 const char *pfx, const char *dir,
2584                                 const char *sfx, int cidx, unsigned long val)
2585 {
2586         char name[32];
2587         snprintf(name, sizeof(name), "%s %s %s", pfx, dir, sfx);
2588         return add_control(spec, type, name, cidx, val);
2589 }
2590
2591 #define add_pb_vol_ctrl(spec, type, pfx, val)                   \
2592         add_control_with_pfx(spec, type, pfx, "Playback", "Volume", 0, val)
2593 #define add_pb_sw_ctrl(spec, type, pfx, val)                    \
2594         add_control_with_pfx(spec, type, pfx, "Playback", "Switch", 0, val)
2595 #define __add_pb_vol_ctrl(spec, type, pfx, cidx, val)                   \
2596         add_control_with_pfx(spec, type, pfx, "Playback", "Volume", cidx, val)
2597 #define __add_pb_sw_ctrl(spec, type, pfx, cidx, val)                    \
2598         add_control_with_pfx(spec, type, pfx, "Playback", "Switch", cidx, val)
2599
2600 static const char * const channel_name[4] = {
2601         "Front", "Surround", "CLFE", "Side"
2602 };
2603
2604 static const char *alc_get_line_out_pfx(struct alc_spec *spec, int ch,
2605                                         bool can_be_master, int *index)
2606 {
2607         struct auto_pin_cfg *cfg = &spec->autocfg;
2608
2609         *index = 0;
2610         if (cfg->line_outs == 1 && !spec->multi_ios &&
2611             !cfg->hp_outs && !cfg->speaker_outs && can_be_master)
2612                 return "Master";
2613
2614         switch (cfg->line_out_type) {
2615         case AUTO_PIN_SPEAKER_OUT:
2616                 if (cfg->line_outs == 1)
2617                         return "Speaker";
2618                 break;
2619         case AUTO_PIN_HP_OUT:
2620                 /* for multi-io case, only the primary out */
2621                 if (ch && spec->multi_ios)
2622                         break;
2623                 *index = ch;
2624                 return "Headphone";
2625         default:
2626                 if (cfg->line_outs == 1 && !spec->multi_ios)
2627                         return "PCM";
2628                 break;
2629         }
2630         if (snd_BUG_ON(ch >= ARRAY_SIZE(channel_name)))
2631                 return "PCM";
2632
2633         return channel_name[ch];
2634 }
2635
2636 /* create input playback/capture controls for the given pin */
2637 static int new_analog_input(struct alc_spec *spec, hda_nid_t pin,
2638                             const char *ctlname, int ctlidx,
2639                             int idx, hda_nid_t mix_nid)
2640 {
2641         int err;
2642
2643         err = __add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, ctlname, ctlidx,
2644                           HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT));
2645         if (err < 0)
2646                 return err;
2647         err = __add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, ctlname, ctlidx,
2648                           HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT));
2649         if (err < 0)
2650                 return err;
2651         return 0;
2652 }
2653
2654 static int alc_is_input_pin(struct hda_codec *codec, hda_nid_t nid)
2655 {
2656         unsigned int pincap = snd_hda_query_pin_caps(codec, nid);
2657         return (pincap & AC_PINCAP_IN) != 0;
2658 }
2659
2660 /* Parse the codec tree and retrieve ADCs and corresponding capsrc MUXs */
2661 static int alc_auto_fill_adc_caps(struct hda_codec *codec)
2662 {
2663         struct alc_spec *spec = codec->spec;
2664         hda_nid_t nid;
2665         hda_nid_t *adc_nids = spec->private_adc_nids;
2666         hda_nid_t *cap_nids = spec->private_capsrc_nids;
2667         int max_nums = ARRAY_SIZE(spec->private_adc_nids);
2668         int i, nums = 0;
2669
2670         nid = codec->start_nid;
2671         for (i = 0; i < codec->num_nodes; i++, nid++) {
2672                 hda_nid_t src;
2673                 const hda_nid_t *list;
2674                 unsigned int caps = get_wcaps(codec, nid);
2675                 int type = get_wcaps_type(caps);
2676
2677                 if (type != AC_WID_AUD_IN || (caps & AC_WCAP_DIGITAL))
2678                         continue;
2679                 adc_nids[nums] = nid;
2680                 cap_nids[nums] = nid;
2681                 src = nid;
2682                 for (;;) {
2683                         int n;
2684                         type = get_wcaps_type(get_wcaps(codec, src));
2685                         if (type == AC_WID_PIN)
2686                                 break;
2687                         if (type == AC_WID_AUD_SEL) {
2688                                 cap_nids[nums] = src;
2689                                 break;
2690                         }
2691                         n = snd_hda_get_conn_list(codec, src, &list);
2692                         if (n > 1) {
2693                                 cap_nids[nums] = src;
2694                                 break;
2695                         } else if (n != 1)
2696                                 break;
2697                         src = *list;
2698                 }
2699                 if (++nums >= max_nums)
2700                         break;
2701         }
2702         spec->adc_nids = spec->private_adc_nids;
2703         spec->capsrc_nids = spec->private_capsrc_nids;
2704         spec->num_adc_nids = nums;
2705         return nums;
2706 }
2707
2708 /* create playback/capture controls for input pins */
2709 static int alc_auto_create_input_ctls(struct hda_codec *codec)
2710 {
2711         struct alc_spec *spec = codec->spec;
2712         const struct auto_pin_cfg *cfg = &spec->autocfg;
2713         hda_nid_t mixer = spec->mixer_nid;
2714         struct hda_input_mux *imux = &spec->private_imux[0];
2715         int num_adcs;
2716         int i, c, err, idx, type_idx = 0;
2717         const char *prev_label = NULL;
2718
2719         num_adcs = alc_auto_fill_adc_caps(codec);
2720         if (num_adcs < 0)
2721                 return 0;
2722
2723         for (i = 0; i < cfg->num_inputs; i++) {
2724                 hda_nid_t pin;
2725                 const char *label;
2726
2727                 pin = cfg->inputs[i].pin;
2728                 if (!alc_is_input_pin(codec, pin))
2729                         continue;
2730
2731                 label = hda_get_autocfg_input_label(codec, cfg, i);
2732                 if (prev_label && !strcmp(label, prev_label))
2733                         type_idx++;
2734                 else
2735                         type_idx = 0;
2736                 prev_label = label;
2737
2738                 if (mixer) {
2739                         idx = get_connection_index(codec, mixer, pin);
2740                         if (idx >= 0) {
2741                                 err = new_analog_input(spec, pin,
2742                                                        label, type_idx,
2743                                                        idx, mixer);
2744                                 if (err < 0)
2745                                         return err;
2746                         }
2747                 }
2748
2749                 for (c = 0; c < num_adcs; c++) {
2750                         hda_nid_t cap = spec->capsrc_nids ?
2751                                 spec->capsrc_nids[c] : spec->adc_nids[c];
2752                         idx = get_connection_index(codec, cap, pin);
2753                         if (idx >= 0) {
2754                                 spec->imux_pins[imux->num_items] = pin;
2755                                 snd_hda_add_imux_item(imux, label, idx, NULL);
2756                                 break;
2757                         }
2758                 }
2759         }
2760
2761         spec->num_mux_defs = 1;
2762         spec->input_mux = imux;
2763
2764         return 0;
2765 }
2766
2767 static void alc_set_pin_output(struct hda_codec *codec, hda_nid_t nid,
2768                                unsigned int pin_type)
2769 {
2770         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
2771                             pin_type);
2772         /* unmute pin */
2773         if (nid_has_mute(codec, nid, HDA_OUTPUT))
2774                 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE,
2775                             AMP_OUT_UNMUTE);
2776 }
2777
2778 static int get_pin_type(int line_out_type)
2779 {
2780         if (line_out_type == AUTO_PIN_HP_OUT)
2781                 return PIN_HP;
2782         else
2783                 return PIN_OUT;
2784 }
2785
2786 static void alc_auto_init_analog_input(struct hda_codec *codec)
2787 {
2788         struct alc_spec *spec = codec->spec;
2789         struct auto_pin_cfg *cfg = &spec->autocfg;
2790         int i;
2791
2792         for (i = 0; i < cfg->num_inputs; i++) {
2793                 hda_nid_t nid = cfg->inputs[i].pin;
2794                 if (alc_is_input_pin(codec, nid)) {
2795                         alc_set_input_pin(codec, nid, cfg->inputs[i].type);
2796                         if (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP)
2797                                 snd_hda_codec_write(codec, nid, 0,
2798                                                     AC_VERB_SET_AMP_GAIN_MUTE,
2799                                                     AMP_OUT_MUTE);
2800                 }
2801         }
2802
2803         /* mute all loopback inputs */
2804         if (spec->mixer_nid) {
2805                 int nums = snd_hda_get_conn_list(codec, spec->mixer_nid, NULL);
2806                 for (i = 0; i < nums; i++)
2807                         snd_hda_codec_write(codec, spec->mixer_nid, 0,
2808                                             AC_VERB_SET_AMP_GAIN_MUTE,
2809                                             AMP_IN_MUTE(i));
2810         }
2811 }
2812
2813 /* convert from MIX nid to DAC */
2814 static hda_nid_t alc_auto_mix_to_dac(struct hda_codec *codec, hda_nid_t nid)
2815 {
2816         hda_nid_t list[5];
2817         int i, num;
2818
2819         if (get_wcaps_type(get_wcaps(codec, nid)) == AC_WID_AUD_OUT)
2820                 return nid;
2821         num = snd_hda_get_connections(codec, nid, list, ARRAY_SIZE(list));
2822         for (i = 0; i < num; i++) {
2823                 if (get_wcaps_type(get_wcaps(codec, list[i])) == AC_WID_AUD_OUT)
2824                         return list[i];
2825         }
2826         return 0;
2827 }
2828
2829 /* go down to the selector widget before the mixer */
2830 static hda_nid_t alc_go_down_to_selector(struct hda_codec *codec, hda_nid_t pin)
2831 {
2832         hda_nid_t srcs[5];
2833         int num = snd_hda_get_connections(codec, pin, srcs,
2834                                           ARRAY_SIZE(srcs));
2835         if (num != 1 ||
2836             get_wcaps_type(get_wcaps(codec, srcs[0])) != AC_WID_AUD_SEL)
2837                 return pin;
2838         return srcs[0];
2839 }
2840
2841 /* get MIX nid connected to the given pin targeted to DAC */
2842 static hda_nid_t alc_auto_dac_to_mix(struct hda_codec *codec, hda_nid_t pin,
2843                                    hda_nid_t dac)
2844 {
2845         hda_nid_t mix[5];
2846         int i, num;
2847
2848         pin = alc_go_down_to_selector(codec, pin);
2849         num = snd_hda_get_connections(codec, pin, mix, ARRAY_SIZE(mix));
2850         for (i = 0; i < num; i++) {
2851                 if (alc_auto_mix_to_dac(codec, mix[i]) == dac)
2852                         return mix[i];
2853         }
2854         return 0;
2855 }
2856
2857 /* select the connection from pin to DAC if needed */
2858 static int alc_auto_select_dac(struct hda_codec *codec, hda_nid_t pin,
2859                                hda_nid_t dac)
2860 {
2861         hda_nid_t mix[5];
2862         int i, num;
2863
2864         pin = alc_go_down_to_selector(codec, pin);
2865         num = snd_hda_get_connections(codec, pin, mix, ARRAY_SIZE(mix));
2866         if (num < 2)
2867                 return 0;
2868         for (i = 0; i < num; i++) {
2869                 if (alc_auto_mix_to_dac(codec, mix[i]) == dac) {
2870                         snd_hda_codec_update_cache(codec, pin, 0,
2871                                                    AC_VERB_SET_CONNECT_SEL, i);
2872                         return 0;
2873                 }
2874         }
2875         return 0;
2876 }
2877
2878 /* look for an empty DAC slot */
2879 static hda_nid_t alc_auto_look_for_dac(struct hda_codec *codec, hda_nid_t pin)
2880 {
2881         struct alc_spec *spec = codec->spec;
2882         hda_nid_t srcs[5];
2883         int i, num;
2884
2885         pin = alc_go_down_to_selector(codec, pin);
2886         num = snd_hda_get_connections(codec, pin, srcs, ARRAY_SIZE(srcs));
2887         for (i = 0; i < num; i++) {
2888                 hda_nid_t nid = alc_auto_mix_to_dac(codec, srcs[i]);
2889                 if (!nid)
2890                         continue;
2891                 if (found_in_nid_list(nid, spec->multiout.dac_nids,
2892                                       spec->multiout.num_dacs))
2893                         continue;
2894                 if (found_in_nid_list(nid, spec->multiout.hp_out_nid,
2895                                       ARRAY_SIZE(spec->multiout.hp_out_nid)))
2896                     continue;
2897                 if (found_in_nid_list(nid, spec->multiout.extra_out_nid,
2898                                       ARRAY_SIZE(spec->multiout.extra_out_nid)))
2899                     continue;
2900                 return nid;
2901         }
2902         return 0;
2903 }
2904
2905 static hda_nid_t get_dac_if_single(struct hda_codec *codec, hda_nid_t pin)
2906 {
2907         hda_nid_t sel = alc_go_down_to_selector(codec, pin);
2908         if (snd_hda_get_conn_list(codec, sel, NULL) == 1)
2909                 return alc_auto_look_for_dac(codec, pin);
2910         return 0;
2911 }
2912
2913 static int alc_auto_fill_extra_dacs(struct hda_codec *codec, int num_outs,
2914                                     const hda_nid_t *pins, hda_nid_t *dacs)
2915 {
2916         int i;
2917
2918         if (num_outs && !dacs[0]) {
2919                 dacs[0] = alc_auto_look_for_dac(codec, pins[0]);
2920                 if (!dacs[0])
2921                         return 0;
2922         }
2923
2924         for (i = 1; i < num_outs; i++)
2925                 dacs[i] = get_dac_if_single(codec, pins[i]);
2926         for (i = 1; i < num_outs; i++) {
2927                 if (!dacs[i])
2928                         dacs[i] = alc_auto_look_for_dac(codec, pins[i]);
2929         }
2930         return 0;
2931 }
2932
2933 static int alc_auto_fill_multi_ios(struct hda_codec *codec,
2934                                    unsigned int location);
2935
2936 /* fill in the dac_nids table from the parsed pin configuration */
2937 static int alc_auto_fill_dac_nids(struct hda_codec *codec)
2938 {
2939         struct alc_spec *spec = codec->spec;
2940         const struct auto_pin_cfg *cfg = &spec->autocfg;
2941         bool redone = false;
2942         int i;
2943
2944  again:
2945         /* set num_dacs once to full for alc_auto_look_for_dac() */
2946         spec->multiout.num_dacs = cfg->line_outs;
2947         spec->multiout.hp_out_nid[0] = 0;
2948         spec->multiout.extra_out_nid[0] = 0;
2949         memset(spec->private_dac_nids, 0, sizeof(spec->private_dac_nids));
2950         spec->multiout.dac_nids = spec->private_dac_nids;
2951
2952         /* fill hard-wired DACs first */
2953         if (!redone) {
2954                 for (i = 0; i < cfg->line_outs; i++)
2955                         spec->private_dac_nids[i] =
2956                                 get_dac_if_single(codec, cfg->line_out_pins[i]);
2957                 if (cfg->hp_outs)
2958                         spec->multiout.hp_out_nid[0] =
2959                                 get_dac_if_single(codec, cfg->hp_pins[0]);
2960                 if (cfg->speaker_outs)
2961                         spec->multiout.extra_out_nid[0] =
2962                                 get_dac_if_single(codec, cfg->speaker_pins[0]);
2963         }
2964
2965         for (i = 0; i < cfg->line_outs; i++) {
2966                 hda_nid_t pin = cfg->line_out_pins[i];
2967                 if (spec->private_dac_nids[i])
2968                         continue;
2969                 spec->private_dac_nids[i] = alc_auto_look_for_dac(codec, pin);
2970                 if (!spec->private_dac_nids[i] && !redone) {
2971                         /* if we can't find primary DACs, re-probe without
2972                          * checking the hard-wired DACs
2973                          */
2974                         redone = true;
2975                         goto again;
2976                 }
2977         }
2978
2979         /* re-count num_dacs and squash invalid entries */
2980         spec->multiout.num_dacs = 0;
2981         for (i = 0; i < cfg->line_outs; i++) {
2982                 if (spec->private_dac_nids[i])
2983                         spec->multiout.num_dacs++;
2984                 else
2985                         memmove(spec->private_dac_nids + i,
2986                                 spec->private_dac_nids + i + 1,
2987                                 sizeof(hda_nid_t) * (cfg->line_outs - i - 1));
2988         }
2989
2990         if (cfg->line_outs == 1 && cfg->line_out_type != AUTO_PIN_SPEAKER_OUT) {
2991                 /* try to fill multi-io first */
2992                 unsigned int location, defcfg;
2993                 int num_pins;
2994
2995                 defcfg = snd_hda_codec_get_pincfg(codec, cfg->line_out_pins[0]);
2996                 location = get_defcfg_location(defcfg);
2997
2998                 num_pins = alc_auto_fill_multi_ios(codec, location);
2999                 if (num_pins > 0) {
3000                         spec->multi_ios = num_pins;
3001                         spec->ext_channel_count = 2;
3002                         spec->multiout.num_dacs = num_pins + 1;
3003                 }
3004         }
3005
3006         if (cfg->line_out_type != AUTO_PIN_HP_OUT)
3007                 alc_auto_fill_extra_dacs(codec, cfg->hp_outs, cfg->hp_pins,
3008                                  spec->multiout.hp_out_nid);
3009         if (cfg->line_out_type != AUTO_PIN_SPEAKER_OUT)
3010                 alc_auto_fill_extra_dacs(codec, cfg->speaker_outs, cfg->speaker_pins,
3011                                  spec->multiout.extra_out_nid);
3012
3013         return 0;
3014 }
3015
3016 static inline unsigned int get_ctl_pos(unsigned int data)
3017 {
3018         hda_nid_t nid = get_amp_nid_(data);
3019         unsigned int dir = get_amp_direction_(data);
3020         return (nid << 1) | dir;
3021 }
3022
3023 #define is_ctl_used(bits, data) \
3024         test_bit(get_ctl_pos(data), bits)
3025 #define mark_ctl_usage(bits, data) \
3026         set_bit(get_ctl_pos(data), bits)
3027
3028 static int alc_auto_add_vol_ctl(struct hda_codec *codec,
3029                               const char *pfx, int cidx,
3030                               hda_nid_t nid, unsigned int chs)
3031 {
3032         struct alc_spec *spec = codec->spec;
3033         unsigned int val;
3034         if (!nid)
3035                 return 0;
3036         val = HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_OUTPUT);
3037         if (is_ctl_used(spec->vol_ctls, val) && chs != 2) /* exclude LFE */
3038                 return 0;
3039         mark_ctl_usage(spec->vol_ctls, val);
3040         return __add_pb_vol_ctrl(codec->spec, ALC_CTL_WIDGET_VOL, pfx, cidx,
3041                                  val);
3042 }
3043
3044 #define alc_auto_add_stereo_vol(codec, pfx, cidx, nid)  \
3045         alc_auto_add_vol_ctl(codec, pfx, cidx, nid, 3)
3046
3047 /* create a mute-switch for the given mixer widget;
3048  * if it has multiple sources (e.g. DAC and loopback), create a bind-mute
3049  */
3050 static int alc_auto_add_sw_ctl(struct hda_codec *codec,
3051                              const char *pfx, int cidx,
3052                              hda_nid_t nid, unsigned int chs)
3053 {
3054         struct alc_spec *spec = codec->spec;
3055         int wid_type;
3056         int type;
3057         unsigned long val;
3058         if (!nid)
3059                 return 0;
3060         wid_type = get_wcaps_type(get_wcaps(codec, nid));
3061         if (wid_type == AC_WID_PIN || wid_type == AC_WID_AUD_OUT) {
3062                 type = ALC_CTL_WIDGET_MUTE;
3063                 val = HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_OUTPUT);
3064         } else if (snd_hda_get_conn_list(codec, nid, NULL) == 1) {
3065                 type = ALC_CTL_WIDGET_MUTE;
3066                 val = HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_INPUT);
3067         } else {
3068                 type = ALC_CTL_BIND_MUTE;
3069                 val = HDA_COMPOSE_AMP_VAL(nid, chs, 2, HDA_INPUT);
3070         }
3071         if (is_ctl_used(spec->sw_ctls, val) && chs != 2) /* exclude LFE */
3072                 return 0;
3073         mark_ctl_usage(spec->sw_ctls, val);
3074         return __add_pb_sw_ctrl(codec->spec, type, pfx, cidx, val);
3075 }
3076
3077 #define alc_auto_add_stereo_sw(codec, pfx, cidx, nid)   \
3078         alc_auto_add_sw_ctl(codec, pfx, cidx, nid, 3)
3079
3080 static hda_nid_t alc_look_for_out_mute_nid(struct hda_codec *codec,
3081                                            hda_nid_t pin, hda_nid_t dac)
3082 {
3083         hda_nid_t mix = alc_auto_dac_to_mix(codec, pin, dac);
3084         if (nid_has_mute(codec, pin, HDA_OUTPUT))
3085                 return pin;
3086         else if (mix && nid_has_mute(codec, mix, HDA_INPUT))
3087                 return mix;
3088         else if (nid_has_mute(codec, dac, HDA_OUTPUT))
3089                 return dac;
3090         return 0;
3091 }
3092
3093 static hda_nid_t alc_look_for_out_vol_nid(struct hda_codec *codec,
3094                                           hda_nid_t pin, hda_nid_t dac)
3095 {
3096         hda_nid_t mix = alc_auto_dac_to_mix(codec, pin, dac);
3097         if (nid_has_volume(codec, dac, HDA_OUTPUT))
3098                 return dac;
3099         else if (nid_has_volume(codec, mix, HDA_OUTPUT))
3100                 return mix;
3101         else if (nid_has_volume(codec, pin, HDA_OUTPUT))
3102                 return pin;
3103         return 0;
3104 }
3105
3106 /* add playback controls from the parsed DAC table */
3107 static int alc_auto_create_multi_out_ctls(struct hda_codec *codec,
3108                                              const struct auto_pin_cfg *cfg)
3109 {
3110         struct alc_spec *spec = codec->spec;
3111         int i, err, noutputs;
3112
3113         noutputs = cfg->line_outs;
3114         if (spec->multi_ios > 0)
3115                 noutputs += spec->multi_ios;
3116
3117         for (i = 0; i < noutputs; i++) {
3118                 const char *name;
3119                 int index;
3120                 hda_nid_t dac, pin;
3121                 hda_nid_t sw, vol;
3122
3123                 dac = spec->multiout.dac_nids[i];
3124                 if (!dac)
3125                         continue;
3126                 if (i >= cfg->line_outs)
3127                         pin = spec->multi_io[i - 1].pin;
3128                 else
3129                         pin = cfg->line_out_pins[i];
3130
3131                 sw = alc_look_for_out_mute_nid(codec, pin, dac);
3132                 vol = alc_look_for_out_vol_nid(codec, pin, dac);
3133                 name = alc_get_line_out_pfx(spec, i, true, &index);
3134                 if (!name || !strcmp(name, "CLFE")) {
3135                         /* Center/LFE */
3136                         err = alc_auto_add_vol_ctl(codec, "Center", 0, vol, 1);
3137                         if (err < 0)
3138                                 return err;
3139                         err = alc_auto_add_vol_ctl(codec, "LFE", 0, vol, 2);
3140                         if (err < 0)
3141                                 return err;
3142                         err = alc_auto_add_sw_ctl(codec, "Center", 0, sw, 1);
3143                         if (err < 0)
3144                                 return err;
3145                         err = alc_auto_add_sw_ctl(codec, "LFE", 0, sw, 2);
3146                         if (err < 0)
3147                                 return err;
3148                 } else {
3149                         err = alc_auto_add_stereo_vol(codec, name, index, vol);
3150                         if (err < 0)
3151                                 return err;
3152                         err = alc_auto_add_stereo_sw(codec, name, index, sw);
3153                         if (err < 0)
3154                                 return err;
3155                 }
3156         }
3157         return 0;
3158 }
3159
3160 static int alc_auto_create_extra_out(struct hda_codec *codec, hda_nid_t pin,
3161                                      hda_nid_t dac, const char *pfx)
3162 {
3163         struct alc_spec *spec = codec->spec;
3164         hda_nid_t sw, vol;
3165         int err;
3166
3167         if (!dac) {
3168                 unsigned int val;
3169                 /* the corresponding DAC is already occupied */
3170                 if (!(get_wcaps(codec, pin) & AC_WCAP_OUT_AMP))
3171                         return 0; /* no way */
3172                 /* create a switch only */
3173                 val = HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT);
3174                 if (is_ctl_used(spec->sw_ctls, val))
3175                         return 0; /* already created */
3176                 mark_ctl_usage(spec->sw_ctls, val);
3177                 return add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, pfx, val);
3178         }
3179
3180         sw = alc_look_for_out_mute_nid(codec, pin, dac);
3181         vol = alc_look_for_out_vol_nid(codec, pin, dac);
3182         err = alc_auto_add_stereo_vol(codec, pfx, 0, vol);
3183         if (err < 0)
3184                 return err;
3185         err = alc_auto_add_stereo_sw(codec, pfx, 0, sw);
3186         if (err < 0)
3187                 return err;
3188         return 0;
3189 }
3190
3191 static struct hda_bind_ctls *new_bind_ctl(struct hda_codec *codec,
3192                                           unsigned int nums,
3193                                           struct hda_ctl_ops *ops)
3194 {
3195         struct alc_spec *spec = codec->spec;
3196         struct hda_bind_ctls **ctlp, *ctl;
3197         snd_array_init(&spec->bind_ctls, sizeof(ctl), 8);
3198         ctlp = snd_array_new(&spec->bind_ctls);
3199         if (!ctlp)
3200                 return NULL;
3201         ctl = kzalloc(sizeof(*ctl) + sizeof(long) * (nums + 1), GFP_KERNEL);
3202         *ctlp = ctl;
3203         if (ctl)
3204                 ctl->ops = ops;
3205         return ctl;
3206 }
3207
3208 /* add playback controls for speaker and HP outputs */
3209 static int alc_auto_create_extra_outs(struct hda_codec *codec, int num_pins,
3210                                       const hda_nid_t *pins,
3211                                       const hda_nid_t *dacs,
3212                                       const char *pfx)
3213 {
3214         struct alc_spec *spec = codec->spec;
3215         struct hda_bind_ctls *ctl;
3216         char name[32];
3217         int i, n, err;
3218
3219         if (!num_pins || !pins[0])
3220                 return 0;
3221
3222         if (num_pins == 1) {
3223                 hda_nid_t dac = *dacs;
3224                 if (!dac)
3225                         dac = spec->multiout.dac_nids[0];
3226                 return alc_auto_create_extra_out(codec, *pins, dac, pfx);
3227         }
3228
3229         if (dacs[num_pins - 1]) {
3230                 /* OK, we have a multi-output system with individual volumes */
3231                 for (i = 0; i < num_pins; i++) {
3232                         snprintf(name, sizeof(name), "%s %s",
3233                                  pfx, channel_name[i]);
3234                         err = alc_auto_create_extra_out(codec, pins[i], dacs[i],
3235                                                         name);
3236                         if (err < 0)
3237                                 return err;
3238                 }
3239                 return 0;
3240         }
3241
3242         /* Let's create a bind-controls */
3243         ctl = new_bind_ctl(codec, num_pins, &snd_hda_bind_sw);
3244         if (!ctl)
3245                 return -ENOMEM;
3246         n = 0;
3247         for (i = 0; i < num_pins; i++) {
3248                 if (get_wcaps(codec, pins[i]) & AC_WCAP_OUT_AMP)
3249                         ctl->values[n++] =
3250                                 HDA_COMPOSE_AMP_VAL(pins[i], 3, 0, HDA_OUTPUT);
3251         }
3252         if (n) {
3253                 snprintf(name, sizeof(name), "%s Playback Switch", pfx);
3254                 err = add_control(spec, ALC_CTL_BIND_SW, name, 0, (long)ctl);
3255                 if (err < 0)
3256                         return err;
3257         }
3258
3259         ctl = new_bind_ctl(codec, num_pins, &snd_hda_bind_vol);
3260         if (!ctl)
3261                 return -ENOMEM;
3262         n = 0;
3263         for (i = 0; i < num_pins; i++) {
3264                 hda_nid_t vol;
3265                 if (!pins[i] || !dacs[i])
3266                         continue;
3267                 vol = alc_look_for_out_vol_nid(codec, pins[i], dacs[i]);
3268                 if (vol)
3269                         ctl->values[n++] =
3270                                 HDA_COMPOSE_AMP_VAL(vol, 3, 0, HDA_OUTPUT);
3271         }
3272         if (n) {
3273                 snprintf(name, sizeof(name), "%s Playback Volume", pfx);
3274                 err = add_control(spec, ALC_CTL_BIND_VOL, name, 0, (long)ctl);
3275                 if (err < 0)
3276                         return err;
3277         }
3278         return 0;
3279 }
3280
3281 static int alc_auto_create_hp_out(struct hda_codec *codec)
3282 {
3283         struct alc_spec *spec = codec->spec;
3284         return alc_auto_create_extra_outs(codec, spec->autocfg.hp_outs,
3285                                           spec->autocfg.hp_pins,
3286                                           spec->multiout.hp_out_nid,
3287                                           "Headphone");
3288 }
3289
3290 static int alc_auto_create_speaker_out(struct hda_codec *codec)
3291 {
3292         struct alc_spec *spec = codec->spec;
3293         return alc_auto_create_extra_outs(codec, spec->autocfg.speaker_outs,
3294                                           spec->autocfg.speaker_pins,
3295                                           spec->multiout.extra_out_nid,
3296                                           "Speaker");
3297 }
3298
3299 static void alc_auto_set_output_and_unmute(struct hda_codec *codec,
3300                                               hda_nid_t pin, int pin_type,
3301                                               hda_nid_t dac)
3302 {
3303         int i, num;
3304         hda_nid_t nid, mix = 0;
3305         hda_nid_t srcs[HDA_MAX_CONNECTIONS];
3306
3307         alc_set_pin_output(codec, pin, pin_type);
3308         nid = alc_go_down_to_selector(codec, pin);
3309         num = snd_hda_get_connections(codec, nid, srcs, ARRAY_SIZE(srcs));
3310         for (i = 0; i < num; i++) {
3311                 if (alc_auto_mix_to_dac(codec, srcs[i]) != dac)
3312                         continue;
3313                 mix = srcs[i];
3314                 break;
3315         }
3316         if (!mix)
3317                 return;
3318
3319         /* need the manual connection? */
3320         if (num > 1)
3321                 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CONNECT_SEL, i);
3322         /* unmute mixer widget inputs */
3323         if (nid_has_mute(codec, mix, HDA_INPUT)) {
3324                 snd_hda_codec_write(codec, mix, 0, AC_VERB_SET_AMP_GAIN_MUTE,
3325                             AMP_IN_UNMUTE(0));
3326                 snd_hda_codec_write(codec, mix, 0, AC_VERB_SET_AMP_GAIN_MUTE,
3327                             AMP_IN_UNMUTE(1));
3328         }
3329         /* initialize volume */
3330         nid = alc_look_for_out_vol_nid(codec, pin, dac);
3331         if (nid)
3332                 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE,
3333                                     AMP_OUT_ZERO);
3334
3335         /* unmute DAC if it's not assigned to a mixer */
3336         nid = alc_look_for_out_mute_nid(codec, pin, dac);
3337         if (nid == mix && nid_has_mute(codec, dac, HDA_OUTPUT))
3338                 snd_hda_codec_write(codec, dac, 0, AC_VERB_SET_AMP_GAIN_MUTE,
3339                                     AMP_OUT_ZERO);
3340 }
3341
3342 static void alc_auto_init_multi_out(struct hda_codec *codec)
3343 {
3344         struct alc_spec *spec = codec->spec;
3345         int pin_type = get_pin_type(spec->autocfg.line_out_type);
3346         int i;
3347
3348         for (i = 0; i <= HDA_SIDE; i++) {
3349                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
3350                 if (nid)
3351                         alc_auto_set_output_and_unmute(codec, nid, pin_type,
3352                                         spec->multiout.dac_nids[i]);
3353         }
3354 }
3355
3356 static void alc_auto_init_extra_out(struct hda_codec *codec)
3357 {
3358         struct alc_spec *spec = codec->spec;
3359         int i;
3360         hda_nid_t pin, dac;
3361
3362         for (i = 0; i < spec->autocfg.hp_outs; i++) {
3363                 if (spec->autocfg.line_out_type == AUTO_PIN_HP_OUT)
3364                         break;
3365                 pin = spec->autocfg.hp_pins[i];
3366                 if (!pin)
3367                         break;
3368                 dac = spec->multiout.hp_out_nid[i];
3369                 if (!dac) {
3370                         if (i > 0 && spec->multiout.hp_out_nid[0])
3371                                 dac = spec->multiout.hp_out_nid[0];
3372                         else
3373                                 dac = spec->multiout.dac_nids[0];
3374                 }
3375                 alc_auto_set_output_and_unmute(codec, pin, PIN_HP, dac);
3376         }
3377         for (i = 0; i < spec->autocfg.speaker_outs; i++) {
3378                 if (spec->autocfg.line_out_type == AUTO_PIN_SPEAKER_OUT)
3379                         break;
3380                 pin = spec->autocfg.speaker_pins[i];
3381                 if (!pin)
3382                         break;
3383                 dac = spec->multiout.extra_out_nid[i];
3384                 if (!dac) {
3385                         if (i > 0 && spec->multiout.extra_out_nid[0])
3386                                 dac = spec->multiout.extra_out_nid[0];
3387                         else
3388                                 dac = spec->multiout.dac_nids[0];
3389                 }
3390                 alc_auto_set_output_and_unmute(codec, pin, PIN_OUT, dac);
3391         }
3392 }
3393
3394 /*
3395  * multi-io helper
3396  */
3397 static int alc_auto_fill_multi_ios(struct hda_codec *codec,
3398                                    unsigned int location)
3399 {
3400         struct alc_spec *spec = codec->spec;
3401         struct auto_pin_cfg *cfg = &spec->autocfg;
3402         hda_nid_t prime_dac = spec->private_dac_nids[0];
3403         int type, i, num_pins = 0;
3404
3405         for (type = AUTO_PIN_LINE_IN; type >= AUTO_PIN_MIC; type--) {
3406                 for (i = 0; i < cfg->num_inputs; i++) {
3407                         hda_nid_t nid = cfg->inputs[i].pin;
3408                         hda_nid_t dac;
3409                         unsigned int defcfg, caps;
3410                         if (cfg->inputs[i].type != type)
3411                                 continue;
3412                         defcfg = snd_hda_codec_get_pincfg(codec, nid);
3413                         if (get_defcfg_connect(defcfg) != AC_JACK_PORT_COMPLEX)
3414                                 continue;
3415                         if (location && get_defcfg_location(defcfg) != location)
3416                                 continue;
3417                         caps = snd_hda_query_pin_caps(codec, nid);
3418                         if (!(caps & AC_PINCAP_OUT))
3419                                 continue;
3420                         dac = alc_auto_look_for_dac(codec, nid);
3421                         if (!dac)
3422                                 continue;
3423                         spec->multi_io[num_pins].pin = nid;
3424                         spec->multi_io[num_pins].dac = dac;
3425                         num_pins++;
3426                         spec->private_dac_nids[spec->multiout.num_dacs++] = dac;
3427                 }
3428         }
3429         spec->multiout.num_dacs = 1;
3430         if (num_pins < 2) {
3431                 /* clear up again */
3432                 memset(spec->private_dac_nids, 0,
3433                        sizeof(spec->private_dac_nids));
3434                 spec->private_dac_nids[0] = prime_dac;
3435                 return 0;
3436         }
3437         return num_pins;
3438 }
3439
3440 static int alc_auto_ch_mode_info(struct snd_kcontrol *kcontrol,
3441                                  struct snd_ctl_elem_info *uinfo)
3442 {
3443         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3444         struct alc_spec *spec = codec->spec;
3445
3446         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
3447         uinfo->count = 1;
3448         uinfo->value.enumerated.items = spec->multi_ios + 1;
3449         if (uinfo->value.enumerated.item > spec->multi_ios)
3450                 uinfo->value.enumerated.item = spec->multi_ios;
3451         sprintf(uinfo->value.enumerated.name, "%dch",
3452                 (uinfo->value.enumerated.item + 1) * 2);
3453         return 0;
3454 }