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 }
3455
3456 static int alc_auto_ch_mode_get(struct snd_kcontrol *kcontrol,
3457                                 struct snd_ctl_elem_value *ucontrol)
3458 {
3459         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3460         struct alc_spec *spec = codec->spec;
3461         ucontrol->value.enumerated.item[0] = (spec->ext_channel_count - 1) / 2;
3462         return 0;
3463 }
3464
3465 static int alc_set_multi_io(struct hda_codec *codec, int idx, bool output)
3466 {
3467         struct alc_spec *spec = codec->spec;
3468         hda_nid_t nid = spec->multi_io[idx].pin;
3469
3470         if (!spec->multi_io[idx].ctl_in)
3471                 spec->multi_io[idx].ctl_in =
3472                         snd_hda_codec_read(codec, nid, 0,
3473                                            AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
3474         if (output) {
3475                 snd_hda_codec_update_cache(codec, nid, 0,
3476                                            AC_VERB_SET_PIN_WIDGET_CONTROL,
3477                                            PIN_OUT);
3478                 if (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP)
3479                         snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
3480                                                  HDA_AMP_MUTE, 0);
3481                 alc_auto_select_dac(codec, nid, spec->multi_io[idx].dac);
3482         } else {
3483                 if (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP)
3484                         snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
3485                                                  HDA_AMP_MUTE, HDA_AMP_MUTE);
3486                 snd_hda_codec_update_cache(codec, nid, 0,
3487                                            AC_VERB_SET_PIN_WIDGET_CONTROL,
3488                                            spec->multi_io[idx].ctl_in);
3489         }
3490         return 0;
3491 }
3492
3493 static int alc_auto_ch_mode_put(struct snd_kcontrol *kcontrol,
3494                                 struct snd_ctl_elem_value *ucontrol)
3495 {
3496         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3497         struct alc_spec *spec = codec->spec;
3498         int i, ch;
3499
3500         ch = ucontrol->value.enumerated.item[0];
3501         if (ch < 0 || ch > spec->multi_ios)
3502                 return -EINVAL;
3503         if (ch == (spec->ext_channel_count - 1) / 2)
3504                 return 0;
3505         spec->ext_channel_count = (ch + 1) * 2;
3506         for (i = 0; i < spec->multi_ios; i++)
3507                 alc_set_multi_io(codec, i, i < ch);
3508         spec->multiout.max_channels = spec->ext_channel_count;
3509         if (spec->need_dac_fix && !spec->const_channel_count)
3510                 spec->multiout.num_dacs = spec->multiout.max_channels / 2;
3511         return 1;
3512 }
3513
3514 static const struct snd_kcontrol_new alc_auto_channel_mode_enum = {
3515         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3516         .name = "Channel Mode",
3517         .info = alc_auto_ch_mode_info,
3518         .get = alc_auto_ch_mode_get,
3519         .put = alc_auto_ch_mode_put,
3520 };
3521
3522 static int alc_auto_add_multi_channel_mode(struct hda_codec *codec)
3523 {
3524         struct alc_spec *spec = codec->spec;
3525
3526         if (spec->multi_ios > 0) {
3527                 struct snd_kcontrol_new *knew;
3528
3529                 knew = alc_kcontrol_new(spec);
3530                 if (!knew)
3531                         return -ENOMEM;
3532                 *knew = alc_auto_channel_mode_enum;
3533                 knew->name = kstrdup("Channel Mode", GFP_KERNEL);
3534                 if (!knew->name)
3535                         return -ENOMEM;
3536         }
3537         return 0;
3538 }
3539
3540 /* filter out invalid adc_nids (and capsrc_nids) that don't give all
3541  * active input pins
3542  */
3543 static void alc_remove_invalid_adc_nids(struct hda_codec *codec)
3544 {
3545         struct alc_spec *spec = codec->spec;
3546         const struct hda_input_mux *imux;
3547         hda_nid_t adc_nids[ARRAY_SIZE(spec->private_adc_nids)];
3548         hda_nid_t capsrc_nids[ARRAY_SIZE(spec->private_adc_nids)];
3549         int i, n, nums;
3550
3551         imux = spec->input_mux;
3552         if (!imux)
3553                 return;
3554         if (spec->dyn_adc_switch)
3555                 return;
3556
3557         nums = 0;
3558         for (n = 0; n < spec->num_adc_nids; n++) {
3559                 hda_nid_t cap = spec->private_capsrc_nids[n];
3560                 int num_conns = snd_hda_get_conn_list(codec, cap, NULL);
3561                 for (i = 0; i < imux->num_items; i++) {
3562                         hda_nid_t pin = spec->imux_pins[i];
3563                         if (pin) {
3564                                 if (get_connection_index(codec, cap, pin) < 0)
3565                                         break;
3566                         } else if (num_conns <= imux->items[i].index)
3567                                 break;
3568                 }
3569                 if (i >= imux->num_items) {
3570                         adc_nids[nums] = spec->private_adc_nids[n];
3571                         capsrc_nids[nums++] = cap;
3572                 }
3573         }
3574         if (!nums) {
3575                 /* check whether ADC-switch is possible */
3576                 if (!alc_check_dyn_adc_switch(codec)) {
3577                         printk(KERN_WARNING "hda_codec: %s: no valid ADC found;"
3578                                " using fallback 0x%x\n",
3579                                codec->chip_name, spec->private_adc_nids[0]);
3580                         spec->num_adc_nids = 1;
3581                         spec->auto_mic = 0;
3582                         return;
3583                 }
3584         } else if (nums != spec->num_adc_nids) {
3585                 memcpy(spec->private_adc_nids, adc_nids,
3586                        nums * sizeof(hda_nid_t));
3587                 memcpy(spec->private_capsrc_nids, capsrc_nids,
3588                        nums * sizeof(hda_nid_t));
3589                 spec->num_adc_nids = nums;
3590         }
3591
3592         if (spec->auto_mic)
3593                 alc_auto_mic_check_imux(codec); /* check auto-mic setups */
3594         else if (spec->input_mux->num_items == 1)
3595                 spec->num_adc_nids = 1; /* reduce to a single ADC */
3596 }
3597
3598 /*
3599  * initialize ADC paths
3600  */
3601 static void alc_auto_init_adc(struct hda_codec *codec, int adc_idx)
3602 {
3603         struct alc_spec *spec = codec->spec;
3604         hda_nid_t nid;
3605
3606         nid = spec->adc_nids[adc_idx];
3607         /* mute ADC */
3608         if (nid_has_mute(codec, nid, HDA_INPUT)) {
3609                 snd_hda_codec_write(codec, nid, 0,
3610                                     AC_VERB_SET_AMP_GAIN_MUTE,
3611                                     AMP_IN_MUTE(0));
3612                 return;
3613         }
3614         if (!spec->capsrc_nids)
3615                 return;
3616         nid = spec->capsrc_nids[adc_idx];
3617         if (nid_has_mute(codec, nid, HDA_OUTPUT))
3618                 snd_hda_codec_write(codec, nid, 0,
3619                                     AC_VERB_SET_AMP_GAIN_MUTE,
3620                                     AMP_OUT_MUTE);
3621 }
3622
3623 static void alc_auto_init_input_src(struct hda_codec *codec)
3624 {
3625         struct alc_spec *spec = codec->spec;
3626         int c, nums;
3627
3628         for (c = 0; c < spec->num_adc_nids; c++)
3629                 alc_auto_init_adc(codec, c);
3630         if (spec->dyn_adc_switch)
3631                 nums = 1;
3632         else
3633                 nums = spec->num_adc_nids;
3634         for (c = 0; c < nums; c++)
3635                 alc_mux_select(codec, 0, spec->cur_mux[c], true);
3636 }
3637
3638 /* add mic boosts if needed */
3639 static int alc_auto_add_mic_boost(struct hda_codec *codec)
3640 {
3641         struct alc_spec *spec = codec->spec;
3642         struct auto_pin_cfg *cfg = &spec->autocfg;
3643         int i, err;
3644         int type_idx = 0;
3645         hda_nid_t nid;
3646         const char *prev_label = NULL;
3647
3648         for (i = 0; i < cfg->num_inputs; i++) {
3649                 if (cfg->inputs[i].type > AUTO_PIN_MIC)
3650                         break;
3651                 nid = cfg->inputs[i].pin;
3652                 if (get_wcaps(codec, nid) & AC_WCAP_IN_AMP) {
3653                         const char *label;
3654                         char boost_label[32];
3655
3656                         label = hda_get_autocfg_input_label(codec, cfg, i);
3657                         if (prev_label && !strcmp(label, prev_label))
3658                                 type_idx++;
3659                         else
3660                                 type_idx = 0;
3661                         prev_label = label;
3662
3663                         snprintf(boost_label, sizeof(boost_label),
3664                                  "%s Boost Volume", label);
3665                         err = add_control(spec, ALC_CTL_WIDGET_VOL,
3666                                           boost_label, type_idx,
3667                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT));
3668                         if (err < 0)
3669                                 return err;
3670                 }
3671         }
3672         return 0;
3673 }
3674
3675 /* select or unmute the given capsrc route */
3676 static void select_or_unmute_capsrc(struct hda_codec *codec, hda_nid_t cap,
3677                                     int idx)
3678 {
3679         if (get_wcaps_type(get_wcaps(codec, cap)) == AC_WID_AUD_MIX) {
3680                 snd_hda_codec_amp_stereo(codec, cap, HDA_INPUT, idx,
3681                                          HDA_AMP_MUTE, 0);
3682         } else if (snd_hda_get_conn_list(codec, cap, NULL) > 1) {
3683                 snd_hda_codec_write_cache(codec, cap, 0,
3684                                           AC_VERB_SET_CONNECT_SEL, idx);
3685         }
3686 }
3687
3688 /* set the default connection to that pin */
3689 static int init_capsrc_for_pin(struct hda_codec *codec, hda_nid_t pin)
3690 {
3691         struct alc_spec *spec = codec->spec;
3692         int i;
3693
3694         if (!pin)
3695                 return 0;
3696         for (i = 0; i < spec->num_adc_nids; i++) {
3697                 hda_nid_t cap = spec->capsrc_nids ?
3698                         spec->capsrc_nids[i] : spec->adc_nids[i];
3699                 int idx;
3700
3701                 idx = get_connection_index(codec, cap, pin);
3702                 if (idx < 0)
3703                         continue;
3704                 select_or_unmute_capsrc(codec, cap, idx);
3705                 return i; /* return the found index */
3706         }
3707         return -1; /* not found */
3708 }
3709
3710 /* initialize some special cases for input sources */
3711 static void alc_init_special_input_src(struct hda_codec *codec)
3712 {
3713         struct alc_spec *spec = codec->spec;
3714         int i;
3715
3716         for (i = 0; i < spec->autocfg.num_inputs; i++)
3717                 init_capsrc_for_pin(codec, spec->autocfg.inputs[i].pin);
3718 }
3719
3720 /* assign appropriate capture mixers */
3721 static void set_capture_mixer(struct hda_codec *codec)
3722 {
3723         struct alc_spec *spec = codec->spec;
3724         static const struct snd_kcontrol_new *caps[2][3] = {
3725                 { alc_capture_mixer_nosrc1,
3726                   alc_capture_mixer_nosrc2,
3727                   alc_capture_mixer_nosrc3 },
3728                 { alc_capture_mixer1,
3729                   alc_capture_mixer2,
3730                   alc_capture_mixer3 },
3731         };
3732
3733         /* check whether either of ADC or MUX has a volume control */
3734         if (!nid_has_volume(codec, spec->adc_nids[0], HDA_INPUT)) {
3735                 if (!spec->capsrc_nids)
3736                         return; /* no volume */
3737                 if (!nid_has_volume(codec, spec->capsrc_nids[0], HDA_OUTPUT))
3738                         return; /* no volume in capsrc, too */
3739                 spec->vol_in_capsrc = 1;
3740         }
3741
3742         if (spec->num_adc_nids > 0) {
3743                 int mux = 0;
3744                 int num_adcs = 0;
3745
3746                 if (spec->input_mux && spec->input_mux->num_items > 1)
3747                         mux = 1;
3748                 if (spec->auto_mic) {
3749                         num_adcs = 1;
3750                         mux = 0;
3751                 } else if (spec->dyn_adc_switch)
3752                         num_adcs = 1;
3753                 if (!num_adcs) {
3754                         if (spec->num_adc_nids > 3)
3755                                 spec->num_adc_nids = 3;
3756                         else if (!spec->num_adc_nids)
3757                                 return;
3758                         num_adcs = spec->num_adc_nids;
3759                 }
3760                 spec->cap_mixer = caps[mux][num_adcs - 1];
3761         }
3762 }
3763
3764 /*
3765  * standard auto-parser initializations
3766  */
3767 static void alc_auto_init_std(struct hda_codec *codec)
3768 {
3769         struct alc_spec *spec = codec->spec;
3770         alc_auto_init_multi_out(codec);
3771         alc_auto_init_extra_out(codec);
3772         alc_auto_init_analog_input(codec);
3773         alc_auto_init_input_src(codec);
3774         alc_auto_init_digital(codec);
3775         if (spec->unsol_event)
3776                 alc_inithook(codec);
3777 }
3778
3779 /*
3780  * Digital-beep handlers
3781  */
3782 #ifdef CONFIG_SND_HDA_INPUT_BEEP
3783 #define set_beep_amp(spec, nid, idx, dir) \
3784         ((spec)->beep_amp = HDA_COMPOSE_AMP_VAL(nid, 3, idx, dir))
3785
3786 static const struct snd_pci_quirk beep_white_list[] = {
3787         SND_PCI_QUIRK(0x1043, 0x829f, "ASUS", 1),
3788         SND_PCI_QUIRK(0x1043, 0x83ce, "EeePC", 1),
3789         SND_PCI_QUIRK(0x1043, 0x831a, "EeePC", 1),
3790         SND_PCI_QUIRK(0x1043, 0x834a, "EeePC", 1),
3791         SND_PCI_QUIRK(0x8086, 0xd613, "Intel", 1),
3792         {}
3793 };
3794
3795 static inline int has_cdefine_beep(struct hda_codec *codec)
3796 {
3797         struct alc_spec *spec = codec->spec;
3798         const struct snd_pci_quirk *q;
3799         q = snd_pci_quirk_lookup(codec->bus->pci, beep_white_list);
3800         if (q)
3801                 return q->value;
3802         return spec->cdefine.enable_pcbeep;
3803 }
3804 #else
3805 #define set_beep_amp(spec, nid, idx, dir) /* NOP */
3806 #define has_cdefine_beep(codec)         0
3807 #endif
3808
3809 /* parse the BIOS configuration and set up the alc_spec */
3810 /* return 1 if successful, 0 if the proper config is not found,
3811  * or a negative error code
3812  */
3813 static int alc_parse_auto_config(struct hda_codec *codec,
3814                                  const hda_nid_t *ignore_nids,
3815                                  const hda_nid_t *ssid_nids)
3816 {
3817         struct alc_spec *spec = codec->spec;
3818         struct auto_pin_cfg *cfg = &spec->autocfg;
3819         int err;
3820
3821         err = snd_hda_parse_pin_defcfg(codec, cfg, ignore_nids,
3822                                        spec->parse_flags);
3823         if (err < 0)
3824                 return err;
3825         if (!cfg->line_outs) {
3826                 if (cfg->dig_outs || cfg->dig_in_pin) {
3827                         spec->multiout.max_channels = 2;
3828                         spec->no_analog = 1;
3829                         goto dig_only;
3830                 }
3831                 return 0; /* can't find valid BIOS pin config */
3832         }
3833
3834         if (cfg->line_out_type == AUTO_PIN_SPEAKER_OUT &&
3835             cfg->line_outs <= cfg->hp_outs) {
3836                 /* use HP as primary out */
3837                 cfg->speaker_outs = cfg->line_outs;
3838                 memcpy(cfg->speaker_pins, cfg->line_out_pins,
3839                        sizeof(cfg->speaker_pins));
3840                 cfg->line_outs = cfg->hp_outs;
3841                 memcpy(cfg->line_out_pins, cfg->hp_pins, sizeof(cfg->hp_pins));
3842                 cfg->hp_outs = 0;
3843                 memset(cfg->hp_pins, 0, sizeof(cfg->hp_pins));
3844                 cfg->line_out_type = AUTO_PIN_HP_OUT;
3845         }
3846
3847         err = alc_auto_fill_dac_nids(codec);
3848         if (err < 0)
3849                 return err;
3850         err = alc_auto_add_multi_channel_mode(codec);
3851         if (err < 0)
3852                 return err;
3853         err = alc_auto_create_multi_out_ctls(codec, cfg);
3854         if (err < 0)
3855                 return err;
3856         err = alc_auto_create_hp_out(codec);
3857         if (err < 0)
3858                 return err;
3859         err = alc_auto_create_speaker_out(codec);
3860         if (err < 0)
3861                 return err;
3862         err = alc_auto_create_input_ctls(codec);
3863         if (err < 0)
3864                 return err;
3865
3866         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
3867
3868  dig_only:
3869         alc_auto_parse_digital(codec);
3870
3871         if (!spec->no_analog)
3872                 alc_remove_invalid_adc_nids(codec);
3873
3874         if (ssid_nids)
3875                 alc_ssid_check(codec, ssid_nids);
3876
3877         if (!spec->no_analog) {
3878                 alc_auto_check_switches(codec);
3879                 err = alc_auto_add_mic_boost(codec);
3880                 if (err < 0)
3881                         return err;
3882         }
3883
3884         if (spec->kctls.list)
3885                 add_mixer(spec, spec->kctls.list);
3886
3887         return 1;
3888 }
3889
3890 static int alc880_parse_auto_config(struct hda_codec *codec)
3891 {
3892         static const hda_nid_t alc880_ignore[] = { 0x1d, 0 };
3893         static const hda_nid_t alc880_ssids[] = { 0x15, 0x1b, 0x14, 0 };
3894         return alc_parse_auto_config(codec, alc880_ignore, alc880_ssids);
3895 }
3896
3897 #ifdef CONFIG_SND_HDA_POWER_SAVE
3898 static const struct hda_amp_list alc880_loopbacks[] = {
3899         { 0x0b, HDA_INPUT, 0 },
3900         { 0x0b, HDA_INPUT, 1 },
3901         { 0x0b, HDA_INPUT, 2 },
3902         { 0x0b, HDA_INPUT, 3 },
3903         { 0x0b, HDA_INPUT, 4 },
3904         { } /* end */
3905 };
3906 #endif
3907
3908 /*
3909  * board setups
3910  */
3911 #ifdef CONFIG_SND_HDA_ENABLE_REALTEK_QUIRKS
3912 #define alc_board_config \
3913         snd_hda_check_board_config
3914 #define alc_board_codec_sid_config \
3915         snd_hda_check_board_codec_sid_config
3916 #include "alc_quirks.c"
3917 #else
3918 #define alc_board_config(codec, nums, models, tbl)      -1
3919 #define alc_board_codec_sid_config(codec, nums, models, tbl)    -1
3920 #define setup_preset(codec, x)  /* NOP */
3921 #endif
3922
3923 /*
3924  * OK, here we have finally the patch for ALC880
3925  */
3926 #ifdef CONFIG_SND_HDA_ENABLE_REALTEK_QUIRKS
3927 #include "alc880_quirks.c"
3928 #endif
3929
3930 static int patch_alc880(struct hda_codec *codec)
3931 {
3932         struct alc_spec *spec;
3933         int board_config;
3934         int err;
3935
3936         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
3937         if (spec == NULL)
3938                 return -ENOMEM;
3939
3940         codec->spec = spec;
3941
3942         spec->mixer_nid = 0x0b;
3943         spec->need_dac_fix = 1;
3944
3945         board_config = alc_board_config(codec, ALC880_MODEL_LAST,
3946                                         alc880_models, alc880_cfg_tbl);
3947         if (board_config < 0) {
3948                 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
3949                        codec->chip_name);
3950                 board_config = ALC_MODEL_AUTO;
3951         }
3952
3953         if (board_config == ALC_MODEL_AUTO) {
3954                 /* automatic parse from the BIOS config */
3955                 err = alc880_parse_auto_config(codec);
3956                 if (err < 0)
3957                         goto error;
3958 #ifdef CONFIG_SND_HDA_ENABLE_REALTEK_QUIRKS
3959                 else if (!err) {
3960                         printk(KERN_INFO
3961                                "hda_codec: Cannot set up configuration "
3962                                "from BIOS.  Using 3-stack mode...\n");
3963                         board_config = ALC880_3ST;
3964                 }
3965 #endif
3966         }
3967
3968         if (board_config != ALC_MODEL_AUTO)
3969                 setup_preset(codec, &alc880_presets[board_config]);
3970
3971         if (!spec->no_analog && !spec->adc_nids) {
3972                 alc_auto_fill_adc_caps(codec);
3973                 alc_rebuild_imux_for_auto_mic(codec);
3974                 alc_remove_invalid_adc_nids(codec);
3975         }
3976
3977         if (!spec->no_analog && !spec->cap_mixer)
3978                 set_capture_mixer(codec);
3979
3980         if (!spec->no_analog) {
3981                 err = snd_hda_attach_beep_device(codec, 0x1);
3982                 if (err < 0)
3983                         goto error;
3984                 set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
3985         }
3986
3987         spec->vmaster_nid = 0x0c;
3988
3989         codec->patch_ops = alc_patch_ops;
3990         if (board_config == ALC_MODEL_AUTO)
3991                 spec->init_hook = alc_auto_init_std;
3992 #ifdef CONFIG_SND_HDA_POWER_SAVE
3993         if (!spec->loopback.amplist)
3994                 spec->loopback.amplist = alc880_loopbacks;
3995 #endif
3996
3997         return 0;
3998
3999  error:
4000         alc_free(codec);
4001         return err;
4002 }
4003
4004
4005 /*
4006  * ALC260 support
4007  */
4008 static int alc260_parse_auto_config(struct hda_codec *codec)
4009 {
4010         static const hda_nid_t alc260_ignore[] = { 0x17, 0 };
4011         static const hda_nid_t alc260_ssids[] = { 0x10, 0x15, 0x0f, 0 };
4012         return alc_parse_auto_config(codec, alc260_ignore, alc260_ssids);
4013 }
4014
4015 #ifdef CONFIG_SND_HDA_POWER_SAVE
4016 static const struct hda_amp_list alc260_loopbacks[] = {
4017         { 0x07, HDA_INPUT, 0 },
4018         { 0x07, HDA_INPUT, 1 },
4019         { 0x07, HDA_INPUT, 2 },
4020         { 0x07, HDA_INPUT, 3 },
4021         { 0x07, HDA_INPUT, 4 },
4022         { } /* end */
4023 };
4024 #endif
4025
4026 /*
4027  * Pin config fixes
4028  */
4029 enum {
4030         PINFIX_HP_DC5750,
4031 };
4032
4033 static const struct alc_fixup alc260_fixups[] = {
4034         [PINFIX_HP_DC5750] = {
4035                 .type = ALC_FIXUP_PINS,
4036                 .v.pins = (const struct alc_pincfg[]) {
4037                         { 0x11, 0x90130110 }, /* speaker */
4038                         { }
4039                 }
4040         },
4041 };
4042
4043 static const struct snd_pci_quirk alc260_fixup_tbl[] = {
4044         SND_PCI_QUIRK(0x103c, 0x280a, "HP dc5750", PINFIX_HP_DC5750),
4045         {}
4046 };
4047
4048 /*
4049  */
4050 #ifdef CONFIG_SND_HDA_ENABLE_REALTEK_QUIRKS
4051 #include "alc260_quirks.c"
4052 #endif
4053
4054 static int patch_alc260(struct hda_codec *codec)
4055 {
4056         struct alc_spec *spec;
4057         int err, board_config;
4058
4059         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
4060         if (spec == NULL)
4061                 return -ENOMEM;
4062
4063         codec->spec = spec;
4064
4065         spec->mixer_nid = 0x07;
4066
4067         board_config = alc_board_config(codec, ALC260_MODEL_LAST,
4068                                         alc260_models, alc260_cfg_tbl);
4069         if (board_config < 0) {
4070                 snd_printd(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
4071                            codec->chip_name);
4072                 board_config = ALC_MODEL_AUTO;
4073         }
4074
4075         if (board_config == ALC_MODEL_AUTO) {
4076                 alc_pick_fixup(codec, NULL, alc260_fixup_tbl, alc260_fixups);
4077                 alc_apply_fixup(codec, ALC_FIXUP_ACT_PRE_PROBE);
4078         }
4079
4080         if (board_config == ALC_MODEL_AUTO) {
4081                 /* automatic parse from the BIOS config */
4082                 err = alc260_parse_auto_config(codec);
4083                 if (err < 0)
4084                         goto error;
4085 #ifdef CONFIG_SND_HDA_ENABLE_REALTEK_QUIRKS
4086                 else if (!err) {
4087                         printk(KERN_INFO
4088                                "hda_codec: Cannot set up configuration "
4089                                "from BIOS.  Using base mode...\n");
4090                         board_config = ALC260_BASIC;
4091                 }
4092 #endif
4093         }
4094
4095         if (board_config != ALC_MODEL_AUTO)
4096                 setup_preset(codec, &alc260_presets[board_config]);
4097
4098         if (!spec->no_analog && !spec->adc_nids) {
4099                 alc_auto_fill_adc_caps(codec);
4100                 alc_rebuild_imux_for_auto_mic(codec);
4101                 alc_remove_invalid_adc_nids(codec);
4102         }
4103
4104         if (!spec->no_analog && !spec->cap_mixer)
4105                 set_capture_mixer(codec);
4106
4107         if (!spec->no_analog) {
4108                 err = snd_hda_attach_beep_device(codec, 0x1);
4109                 if (err < 0)
4110                         goto error;
4111                 set_beep_amp(spec, 0x07, 0x05, HDA_INPUT);
4112         }
4113
4114         alc_apply_fixup(codec, ALC_FIXUP_ACT_PROBE);
4115
4116         spec->vmaster_nid = 0x08;
4117
4118         codec->patch_ops = alc_patch_ops;
4119         if (board_config == ALC_MODEL_AUTO)
4120                 spec->init_hook = alc_auto_init_std;
4121         spec->shutup = alc_eapd_shutup;
4122 #ifdef CONFIG_SND_HDA_POWER_SAVE
4123         if (!spec->loopback.amplist)
4124                 spec->loopback.amplist = alc260_loopbacks;
4125 #endif
4126
4127         return 0;
4128
4129  error:
4130         alc_free(codec);
4131         return err;
4132 }
4133
4134
4135 /*
4136  * ALC882/883/885/888/889 support
4137  *
4138  * ALC882 is almost identical with ALC880 but has cleaner and more flexible
4139  * configuration.  Each pin widget can choose any input DACs and a mixer.
4140  * Each ADC is connected from a mixer of all inputs.  This makes possible
4141  * 6-channel independent captures.
4142  *
4143  * In addition, an independent DAC for the multi-playback (not used in this
4144  * driver yet).
4145  */
4146 #ifdef CONFIG_SND_HDA_POWER_SAVE
4147 #define alc882_loopbacks        alc880_loopbacks
4148 #endif
4149
4150 /*
4151  * Pin config fixes
4152  */
4153 enum {
4154         PINFIX_ABIT_AW9D_MAX,
4155         PINFIX_LENOVO_Y530,
4156         PINFIX_PB_M5210,
4157         PINFIX_ACER_ASPIRE_7736,
4158         PINFIX_ASUS_W90V,
4159 };
4160
4161 static const struct alc_fixup alc882_fixups[] = {
4162         [PINFIX_ABIT_AW9D_MAX] = {
4163                 .type = ALC_FIXUP_PINS,
4164                 .v.pins = (const struct alc_pincfg[]) {
4165                         { 0x15, 0x01080104 }, /* side */
4166                         { 0x16, 0x01011012 }, /* rear */
4167                         { 0x17, 0x01016011 }, /* clfe */
4168                         { }
4169                 }
4170         },
4171         [PINFIX_LENOVO_Y530] = {
4172                 .type = ALC_FIXUP_PINS,
4173                 .v.pins = (const struct alc_pincfg[]) {
4174                         { 0x15, 0x99130112 }, /* rear int speakers */
4175                         { 0x16, 0x99130111 }, /* subwoofer */
4176                         { }
4177                 }
4178         },
4179         [PINFIX_PB_M5210] = {
4180                 .type = ALC_FIXUP_VERBS,
4181                 .v.verbs = (const struct hda_verb[]) {
4182                         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50 },
4183                         {}
4184                 }
4185         },
4186         [PINFIX_ACER_ASPIRE_7736] = {
4187                 .type = ALC_FIXUP_SKU,
4188                 .v.sku = ALC_FIXUP_SKU_IGNORE,
4189         },
4190         [PINFIX_ASUS_W90V] = {
4191                 .type = ALC_FIXUP_PINS,
4192                 .v.pins = (const struct alc_pincfg[]) {
4193                         { 0x16, 0x99130110 }, /* fix sequence for CLFE */
4194                         { }
4195                 }
4196         },
4197 };
4198
4199 static const struct snd_pci_quirk alc882_fixup_tbl[] = {
4200         SND_PCI_QUIRK(0x1025, 0x0155, "Packard-Bell M5120", PINFIX_PB_M5210),
4201         SND_PCI_QUIRK(0x1043, 0x1873, "ASUS W90V", PINFIX_ASUS_W90V),
4202         SND_PCI_QUIRK(0x17aa, 0x3a0d, "Lenovo Y530", PINFIX_LENOVO_Y530),
4203         SND_PCI_QUIRK(0x147b, 0x107a, "Abit AW9D-MAX", PINFIX_ABIT_AW9D_MAX),
4204         SND_PCI_QUIRK(0x1025, 0x0296, "Acer Aspire 7736z", PINFIX_ACER_ASPIRE_7736),
4205         {}
4206 };
4207
4208 /*
4209  * BIOS auto configuration
4210  */
4211 /* almost identical with ALC880 parser... */
4212 static int alc882_parse_auto_config(struct hda_codec *codec)
4213 {
4214         static const hda_nid_t alc882_ignore[] = { 0x1d, 0 };
4215         static const hda_nid_t alc882_ssids[] = { 0x15, 0x1b, 0x14, 0 };
4216         return alc_parse_auto_config(codec, alc882_ignore, alc882_ssids);
4217 }
4218
4219 /*
4220  */
4221 #ifdef CONFIG_SND_HDA_ENABLE_REALTEK_QUIRKS
4222 #include "alc882_quirks.c"
4223 #endif
4224
4225 static int patch_alc882(struct hda_codec *codec)
4226 {
4227         struct alc_spec *spec;
4228         int err, board_config;
4229
4230         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
4231         if (spec == NULL)
4232                 return -ENOMEM;
4233
4234         codec->spec = spec;
4235
4236         spec->mixer_nid = 0x0b;
4237
4238         switch (codec->vendor_id) {
4239         case 0x10ec0882:
4240         case 0x10ec0885:
4241                 break;
4242         default:
4243                 /* ALC883 and variants */
4244                 alc_fix_pll_init(codec, 0x20, 0x0a, 10);
4245                 break;
4246         }
4247
4248         err = alc_codec_rename_from_preset(codec);
4249         if (err < 0)
4250                 goto error;
4251
4252         board_config = alc_board_config(codec, ALC882_MODEL_LAST,
4253                                         alc882_models, alc882_cfg_tbl);
4254
4255         if (board_config < 0)
4256                 board_config = alc_board_codec_sid_config(codec,
4257                         ALC882_MODEL_LAST, alc882_models, alc882_ssid_cfg_tbl);
4258
4259         if (board_config < 0) {
4260                 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
4261                        codec->chip_name);
4262                 board_config = ALC_MODEL_AUTO;
4263         }
4264
4265         if (board_config == ALC_MODEL_AUTO) {
4266                 alc_pick_fixup(codec, NULL, alc882_fixup_tbl, alc882_fixups);
4267                 alc_apply_fixup(codec, ALC_FIXUP_ACT_PRE_PROBE);
4268         }
4269
4270         alc_auto_parse_customize_define(codec);
4271
4272         if (board_config == ALC_MODEL_AUTO) {
4273                 /* automatic parse from the BIOS config */
4274                 err = alc882_parse_auto_config(codec);
4275                 if (err < 0)
4276                         goto error;
4277 #ifdef CONFIG_SND_HDA_ENABLE_REALTEK_QUIRKS
4278                 else if (!err) {
4279                         printk(KERN_INFO
4280                                "hda_codec: Cannot set up configuration "
4281                                "from BIOS.  Using base mode...\n");
4282                         board_config = ALC882_3ST_DIG;
4283                 }
4284 #endif
4285         }
4286
4287         if (board_config != ALC_MODEL_AUTO)
4288                 setup_preset(codec, &alc882_presets[board_config]);
4289
4290         if (!spec->no_analog && !spec->adc_nids) {
4291                 alc_auto_fill_adc_caps(codec);
4292                 alc_rebuild_imux_for_auto_mic(codec);
4293                 alc_remove_invalid_adc_nids(codec);
4294         }
4295
4296         if (!spec->no_analog && !spec->cap_mixer)
4297                 set_capture_mixer(codec);
4298
4299         if (!spec->no_analog && has_cdefine_beep(codec)) {
4300                 err = snd_hda_attach_beep_device(codec, 0x1);
4301                 if (err < 0)
4302                         goto error;
4303                 set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
4304         }
4305
4306         alc_apply_fixup(codec, ALC_FIXUP_ACT_PROBE);
4307
4308         spec->vmaster_nid = 0x0c;
4309
4310         codec->patch_ops = alc_patch_ops;
4311         if (board_config == ALC_MODEL_AUTO)
4312                 spec->init_hook = alc_auto_init_std;
4313
4314         alc_init_jacks(codec);
4315 #ifdef CONFIG_SND_HDA_POWER_SAVE
4316         if (!spec->loopback.amplist)
4317                 spec->loopback.amplist = alc882_loopbacks;
4318 #endif
4319
4320         return 0;
4321
4322  error:
4323         alc_free(codec);
4324         return err;
4325 }
4326
4327
4328 /*
4329  * ALC262 support
4330  */
4331 static int alc262_parse_auto_config(struct hda_codec *codec)
4332 {
4333         static const hda_nid_t alc262_ignore[] = { 0x1d, 0 };
4334         static const hda_nid_t alc262_ssids[] = { 0x15, 0x1b, 0x14, 0 };
4335         return alc_parse_auto_config(codec, alc262_ignore, alc262_ssids);
4336 }
4337
4338 /*
4339  * Pin config fixes
4340  */
4341 enum {
4342         PINFIX_FSC_H270,
4343         PINFIX_HP_Z200,
4344 };
4345
4346 static const struct alc_fixup alc262_fixups[] = {
4347         [PINFIX_FSC_H270] = {
4348                 .type = ALC_FIXUP_PINS,
4349                 .v.pins = (const struct alc_pincfg[]) {
4350                         { 0x14, 0x99130110 }, /* speaker */
4351                         { 0x15, 0x0221142f }, /* front HP */
4352                         { 0x1b, 0x0121141f }, /* rear HP */
4353                         { }
4354                 }
4355         },
4356         [PINFIX_HP_Z200] = {
4357                 .type = ALC_FIXUP_PINS,
4358                 .v.pins = (const struct alc_pincfg[]) {
4359                         { 0x16, 0x99130120 }, /* internal speaker */
4360                         { }
4361                 }
4362         },
4363 };
4364
4365 static const struct snd_pci_quirk alc262_fixup_tbl[] = {
4366         SND_PCI_QUIRK(0x103c, 0x170b, "HP Z200", PINFIX_HP_Z200),
4367         SND_PCI_QUIRK(0x1734, 0x1147, "FSC Celsius H270", PINFIX_FSC_H270),
4368         {}
4369 };
4370
4371
4372 #ifdef CONFIG_SND_HDA_POWER_SAVE
4373 #define alc262_loopbacks        alc880_loopbacks
4374 #endif
4375
4376 /*
4377  */
4378 #ifdef CONFIG_SND_HDA_ENABLE_REALTEK_QUIRKS
4379 #include "alc262_quirks.c"
4380 #endif
4381
4382 static int patch_alc262(struct hda_codec *codec)
4383 {
4384         struct alc_spec *spec;
4385         int board_config;
4386         int err;
4387
4388         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
4389         if (spec == NULL)
4390                 return -ENOMEM;
4391
4392         codec->spec = spec;
4393
4394         spec->mixer_nid = 0x0b;
4395
4396 #if 0
4397         /* pshou 07/11/05  set a zero PCM sample to DAC when FIFO is
4398          * under-run
4399          */
4400         {
4401         int tmp;
4402         snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_COEF_INDEX, 7);
4403         tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0);
4404         snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_COEF_INDEX, 7);
4405         snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_PROC_COEF, tmp | 0x80);
4406         }
4407 #endif
4408         alc_auto_parse_customize_define(codec);
4409
4410         alc_fix_pll_init(codec, 0x20, 0x0a, 10);
4411
4412         board_config = alc_board_config(codec, ALC262_MODEL_LAST,
4413                                         alc262_models, alc262_cfg_tbl);
4414
4415         if (board_config < 0) {
4416                 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
4417                        codec->chip_name);
4418                 board_config = ALC_MODEL_AUTO;
4419         }
4420
4421         if (board_config == ALC_MODEL_AUTO) {
4422                 alc_pick_fixup(codec, NULL, alc262_fixup_tbl, alc262_fixups);
4423                 alc_apply_fixup(codec, ALC_FIXUP_ACT_PRE_PROBE);
4424         }
4425
4426         if (board_config == ALC_MODEL_AUTO) {
4427                 /* automatic parse from the BIOS config */
4428                 err = alc262_parse_auto_config(codec);
4429                 if (err < 0)
4430                         goto error;
4431 #ifdef CONFIG_SND_HDA_ENABLE_REALTEK_QUIRKS
4432                 else if (!err) {
4433                         printk(KERN_INFO
4434                                "hda_codec: Cannot set up configuration "
4435                                "from BIOS.  Using base mode...\n");
4436                         board_config = ALC262_BASIC;
4437                 }
4438 #endif
4439         }
4440
4441         if (board_config != ALC_MODEL_AUTO)
4442                 setup_preset(codec, &alc262_presets[board_config]);
4443
4444         if (!spec->no_analog && !spec->adc_nids) {
4445                 alc_auto_fill_adc_caps(codec);
4446                 alc_rebuild_imux_for_auto_mic(codec);
4447                 alc_remove_invalid_adc_nids(codec);
4448         }
4449
4450         if (!spec->no_analog && !spec->cap_mixer)
4451                 set_capture_mixer(codec);
4452
4453         if (!spec->no_analog && has_cdefine_beep(codec)) {
4454                 err = snd_hda_attach_beep_device(codec, 0x1);
4455                 if (err < 0)
4456                         goto error;
4457                 set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
4458         }
4459
4460         alc_apply_fixup(codec, ALC_FIXUP_ACT_PROBE);
4461
4462         spec->vmaster_nid = 0x0c;
4463
4464         codec->patch_ops = alc_patch_ops;
4465         if (board_config == ALC_MODEL_AUTO)
4466                 spec->init_hook = alc_auto_init_std;
4467         spec->shutup = alc_eapd_shutup;
4468
4469         alc_init_jacks(codec);
4470 #ifdef CONFIG_SND_HDA_POWER_SAVE
4471         if (!spec->loopback.amplist)
4472                 spec->loopback.amplist = alc262_loopbacks;
4473 #endif
4474
4475         return 0;
4476
4477  error:
4478         alc_free(codec);
4479         return err;
4480 }
4481
4482 /*
4483  *  ALC268
4484  */
4485 /* bind Beep switches of both NID 0x0f and 0x10 */
4486 static const struct hda_bind_ctls alc268_bind_beep_sw = {
4487         .ops = &snd_hda_bind_sw,
4488         .values = {
4489                 HDA_COMPOSE_AMP_VAL(0x0f, 3, 1, HDA_INPUT),
4490                 HDA_COMPOSE_AMP_VAL(0x10, 3, 1, HDA_INPUT),
4491                 0
4492         },
4493 };
4494
4495 static const struct snd_kcontrol_new alc268_beep_mixer[] = {
4496         HDA_CODEC_VOLUME("Beep Playback Volume", 0x1d, 0x0, HDA_INPUT),
4497         HDA_BIND_SW("Beep Playback Switch", &alc268_bind_beep_sw),
4498         { }
4499 };
4500
4501 /* set PCBEEP vol = 0, mute connections */
4502 static const struct hda_verb alc268_beep_init_verbs[] = {
4503         {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4504         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4505         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4506         { }
4507 };
4508
4509 /*
4510  * BIOS auto configuration
4511  */
4512 static int alc268_parse_auto_config(struct hda_codec *codec)
4513 {
4514         static const hda_nid_t alc268_ssids[] = { 0x15, 0x1b, 0x14, 0 };
4515         struct alc_spec *spec = codec->spec;
4516         int err = alc_parse_auto_config(codec, NULL, alc268_ssids);
4517         if (err > 0) {
4518                 if (!spec->no_analog && spec->autocfg.speaker_pins[0] != 0x1d) {
4519                         add_mixer(spec, alc268_beep_mixer);
4520                         add_verb(spec, alc268_beep_init_verbs);
4521                 }
4522         }
4523         return err;
4524 }
4525
4526 /*
4527  */
4528 static int patch_alc268(struct hda_codec *codec)
4529 {
4530         struct alc_spec *spec;
4531         int i, has_beep, err;
4532
4533         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
4534         if (spec == NULL)
4535                 return -ENOMEM;
4536
4537         codec->spec = spec;
4538
4539         /* ALC268 has no aa-loopback mixer */
4540
4541         /* automatic parse from the BIOS config */
4542         err = alc268_parse_auto_config(codec);
4543         if (err < 0)
4544                 goto error;
4545
4546         has_beep = 0;
4547         for (i = 0; i < spec->num_mixers; i++) {
4548                 if (spec->mixers[i] == alc268_beep_mixer) {
4549                         has_beep = 1;
4550                         break;
4551                 }
4552         }
4553
4554         if (has_beep) {
4555                 err = snd_hda_attach_beep_device(codec, 0x1);
4556                 if (err < 0)
4557                         goto error;
4558                 if (!query_amp_caps(codec, 0x1d, HDA_INPUT))
4559                         /* override the amp caps for beep generator */
4560                         snd_hda_override_amp_caps(codec, 0x1d, HDA_INPUT,
4561                                           (0x0c << AC_AMPCAP_OFFSET_SHIFT) |
4562                                           (0x0c << AC_AMPCAP_NUM_STEPS_SHIFT) |
4563                                           (0x07 << AC_AMPCAP_STEP_SIZE_SHIFT) |
4564                                           (0 << AC_AMPCAP_MUTE_SHIFT));
4565         }
4566
4567         if (!spec->no_analog && !spec->adc_nids) {
4568                 alc_auto_fill_adc_caps(codec);
4569                 alc_rebuild_imux_for_auto_mic(codec);
4570                 alc_remove_invalid_adc_nids(codec);
4571         }
4572
4573         if (!spec->no_analog && !spec->cap_mixer)
4574                 set_capture_mixer(codec);
4575
4576         spec->vmaster_nid = 0x02;
4577
4578         codec->patch_ops = alc_patch_ops;
4579         spec->init_hook = alc_auto_init_std;
4580         spec->shutup = alc_eapd_shutup;
4581
4582         alc_init_jacks(codec);
4583
4584         return 0;
4585
4586  error:
4587         alc_free(codec);
4588         return err;
4589 }
4590
4591 /*
4592  * ALC269
4593  */
4594 #ifdef CONFIG_SND_HDA_POWER_SAVE
4595 #define alc269_loopbacks        alc880_loopbacks
4596 #endif
4597
4598 static const struct hda_pcm_stream alc269_44k_pcm_analog_playback = {
4599         .substreams = 1,
4600         .channels_min = 2,
4601         .channels_max = 8,
4602         .rates = SNDRV_PCM_RATE_44100, /* fixed rate */
4603         /* NID is set in alc_build_pcms */
4604         .ops = {
4605                 .open = alc_playback_pcm_open,
4606                 .prepare = alc_playback_pcm_prepare,
4607                 .cleanup = alc_playback_pcm_cleanup
4608         },
4609 };
4610
4611 static const struct hda_pcm_stream alc269_44k_pcm_analog_capture = {
4612         .substreams = 1,
4613         .channels_min = 2,
4614         .channels_max = 2,
4615         .rates = SNDRV_PCM_RATE_44100, /* fixed rate */
4616         /* NID is set in alc_build_pcms */
4617 };
4618
4619 #ifdef CONFIG_SND_HDA_POWER_SAVE
4620 static int alc269_mic2_for_mute_led(struct hda_codec *codec)
4621 {
4622         switch (codec->subsystem_id) {
4623         case 0x103c1586:
4624                 return 1;
4625         }
4626         return 0;
4627 }
4628
4629 static int alc269_mic2_mute_check_ps(struct hda_codec *codec, hda_nid_t nid)
4630 {
4631         /* update mute-LED according to the speaker mute state */
4632         if (nid == 0x01 || nid == 0x14) {
4633                 int pinval;
4634                 if (snd_hda_codec_amp_read(codec, 0x14, 0, HDA_OUTPUT, 0) &
4635                     HDA_AMP_MUTE)
4636                         pinval = 0x24;
4637                 else
4638                         pinval = 0x20;
4639                 /* mic2 vref pin is used for mute LED control */
4640                 snd_hda_codec_update_cache(codec, 0x19, 0,
4641                                            AC_VERB_SET_PIN_WIDGET_CONTROL,
4642                                            pinval);
4643         }
4644         return alc_check_power_status(codec, nid);
4645 }
4646 #endif /* CONFIG_SND_HDA_POWER_SAVE */
4647
4648 /* different alc269-variants */
4649 enum {
4650         ALC269_TYPE_ALC269VA,
4651         ALC269_TYPE_ALC269VB,
4652         ALC269_TYPE_ALC269VC,
4653 };
4654
4655 /*
4656  * BIOS auto configuration
4657  */
4658 static int alc269_parse_auto_config(struct hda_codec *codec)
4659 {
4660         static const hda_nid_t alc269_ignore[] = { 0x1d, 0 };
4661         static const hda_nid_t alc269_ssids[] = { 0, 0x1b, 0x14, 0x21 };
4662         static const hda_nid_t alc269va_ssids[] = { 0x15, 0x1b, 0x14, 0 };
4663         struct alc_spec *spec = codec->spec;
4664         const hda_nid_t *ssids = spec->codec_variant == ALC269_TYPE_ALC269VA ?
4665                 alc269va_ssids : alc269_ssids;
4666
4667         return alc_parse_auto_config(codec, alc269_ignore, ssids);
4668 }
4669
4670 static void alc269_toggle_power_output(struct hda_codec *codec, int power_up)
4671 {
4672         int val = alc_read_coef_idx(codec, 0x04);
4673         if (power_up)
4674                 val |= 1 << 11;
4675         else
4676                 val &= ~(1 << 11);
4677         alc_write_coef_idx(codec, 0x04, val);
4678 }
4679
4680 static void alc269_shutup(struct hda_codec *codec)
4681 {
4682         if ((alc_get_coef0(codec) & 0x00ff) == 0x017)
4683                 alc269_toggle_power_output(codec, 0);
4684         if ((alc_get_coef0(codec) & 0x00ff) == 0x018) {
4685                 alc269_toggle_power_output(codec, 0);
4686                 msleep(150);
4687         }
4688 }
4689
4690 #ifdef CONFIG_PM
4691 static int alc269_resume(struct hda_codec *codec)
4692 {
4693         if ((alc_get_coef0(codec) & 0x00ff) == 0x018) {
4694                 alc269_toggle_power_output(codec, 0);
4695                 msleep(150);
4696         }
4697
4698         codec->patch_ops.init(codec);
4699
4700         if ((alc_get_coef0(codec) & 0x00ff) == 0x017) {
4701                 alc269_toggle_power_output(codec, 1);
4702                 msleep(200);
4703         }
4704
4705         if ((alc_get_coef0(codec) & 0x00ff) == 0x018)
4706                 alc269_toggle_power_output(codec, 1);
4707
4708         snd_hda_codec_resume_amp(codec);
4709         snd_hda_codec_resume_cache(codec);
4710         hda_call_check_power_status(codec, 0x01);
4711         return 0;
4712 }
4713 #endif /* CONFIG_PM */
4714
4715 static void alc269_fixup_hweq(struct hda_codec *codec,
4716                                const struct alc_fixup *fix, int action)
4717 {
4718         int coef;
4719
4720         if (action != ALC_FIXUP_ACT_INIT)
4721                 return;
4722         coef = alc_read_coef_idx(codec, 0x1e);
4723         alc_write_coef_idx(codec, 0x1e, coef | 0x80);
4724 }
4725
4726 static void alc271_fixup_dmic(struct hda_codec *codec,
4727                               const struct alc_fixup *fix, int action)
4728 {
4729         static const struct hda_verb verbs[] = {
4730                 {0x20, AC_VERB_SET_COEF_INDEX, 0x0d},
4731                 {0x20, AC_VERB_SET_PROC_COEF, 0x4000},
4732                 {}
4733         };
4734         unsigned int cfg;
4735
4736         if (strcmp(codec->chip_name, "ALC271X"))
4737                 return;
4738         cfg = snd_hda_codec_get_pincfg(codec, 0x12);
4739         if (get_defcfg_connect(cfg) == AC_JACK_PORT_FIXED)
4740                 snd_hda_sequence_write(codec, verbs);
4741 }
4742
4743 static void alc269_fixup_pcm_44k(struct hda_codec *codec,
4744                                  const struct alc_fixup *fix, int action)
4745 {
4746         struct alc_spec *spec = codec->spec;
4747
4748         if (action != ALC_FIXUP_ACT_PROBE)
4749                 return;
4750
4751         /* Due to a hardware problem on Lenovo Ideadpad, we need to
4752          * fix the sample rate of analog I/O to 44.1kHz
4753          */
4754         spec->stream_analog_playback = &alc269_44k_pcm_analog_playback;
4755         spec->stream_analog_capture = &alc269_44k_pcm_analog_capture;
4756 }
4757
4758 static void alc269_fixup_stereo_dmic(struct hda_codec *codec,
4759                                      const struct alc_fixup *fix, int action)
4760 {
4761         int coef;
4762
4763         if (action != ALC_FIXUP_ACT_INIT)
4764                 return;
4765         /* The digital-mic unit sends PDM (differential signal) instead of
4766          * the standard PCM, thus you can't record a valid mono stream as is.
4767          * Below is a workaround specific to ALC269 to control the dmic
4768          * signal source as mono.
4769          */
4770         coef = alc_read_coef_idx(codec, 0x07);
4771         alc_write_coef_idx(codec, 0x07, coef | 0x80);
4772 }
4773
4774 static void alc269_quanta_automute(struct hda_codec *codec)
4775 {
4776         update_outputs(codec);
4777
4778         snd_hda_codec_write(codec, 0x20, 0,
4779                         AC_VERB_SET_COEF_INDEX, 0x0c);
4780         snd_hda_codec_write(codec, 0x20, 0,
4781                         AC_VERB_SET_PROC_COEF, 0x680);
4782
4783         snd_hda_codec_write(codec, 0x20, 0,
4784                         AC_VERB_SET_COEF_INDEX, 0x0c);
4785         snd_hda_codec_write(codec, 0x20, 0,
4786                         AC_VERB_SET_PROC_COEF, 0x480);
4787 }
4788
4789 static void alc269_fixup_quanta_mute(struct hda_codec *codec,
4790                                      const struct alc_fixup *fix, int action)
4791 {
4792         struct alc_spec *spec = codec->spec;
4793         if (action != ALC_FIXUP_ACT_PROBE)
4794                 return;
4795         spec->automute_hook = alc269_quanta_automute;
4796 }
4797
4798 enum {
4799         ALC269_FIXUP_SONY_VAIO,
4800         ALC275_FIXUP_SONY_VAIO_GPIO2,
4801         ALC269_FIXUP_DELL_M101Z,
4802         ALC269_FIXUP_SKU_IGNORE,
4803         ALC269_FIXUP_ASUS_G73JW,
4804         ALC269_FIXUP_LENOVO_EAPD,
4805         ALC275_FIXUP_SONY_HWEQ,
4806         ALC271_FIXUP_DMIC,
4807         ALC269_FIXUP_PCM_44K,
4808         ALC269_FIXUP_STEREO_DMIC,
4809         ALC269_FIXUP_QUANTA_MUTE,
4810         ALC269_FIXUP_LIFEBOOK,
4811         ALC269_FIXUP_AMIC,
4812         ALC269_FIXUP_DMIC,
4813         ALC269VB_FIXUP_AMIC,
4814         ALC269VB_FIXUP_DMIC,
4815 };
4816
4817 static const struct alc_fixup alc269_fixups[] = {
4818         [ALC269_FIXUP_SONY_VAIO] = {
4819                 .type = ALC_FIXUP_VERBS,
4820                 .v.verbs = (const struct hda_verb[]) {
4821                         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREFGRD},
4822                         {}
4823                 }
4824         },
4825         [ALC275_FIXUP_SONY_VAIO_GPIO2] = {
4826                 .type = ALC_FIXUP_VERBS,
4827                 .v.verbs = (const struct hda_verb[]) {
4828                         {0x01, AC_VERB_SET_GPIO_MASK, 0x04},
4829                         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x04},
4830                         {0x01, AC_VERB_SET_GPIO_DATA, 0x00},
4831                         { }
4832                 },
4833                 .chained = true,
4834                 .chain_id = ALC269_FIXUP_SONY_VAIO
4835         },
4836         [ALC269_FIXUP_DELL_M101Z] = {
4837                 .type = ALC_FIXUP_VERBS,
4838                 .v.verbs = (const struct hda_verb[]) {
4839                         /* Enables internal speaker */
4840                         {0x20, AC_VERB_SET_COEF_INDEX, 13},
4841                         {0x20, AC_VERB_SET_PROC_COEF, 0x4040},
4842                         {}
4843                 }
4844         },
4845         [ALC269_FIXUP_SKU_IGNORE] = {
4846                 .type = ALC_FIXUP_SKU,
4847                 .v.sku = ALC_FIXUP_SKU_IGNORE,
4848         },
4849         [ALC269_FIXUP_ASUS_G73JW] = {
4850                 .type = ALC_FIXUP_PINS,
4851                 .v.pins = (const struct alc_pincfg[]) {
4852                         { 0x17, 0x99130111 }, /* subwoofer */
4853                         { }
4854                 }
4855         },
4856         [ALC269_FIXUP_LENOVO_EAPD] = {
4857                 .type = ALC_FIXUP_VERBS,
4858                 .v.verbs = (const struct hda_verb[]) {
4859                         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 0},
4860                         {}
4861                 }
4862         },
4863         [ALC275_FIXUP_SONY_HWEQ] = {
4864                 .type = ALC_FIXUP_FUNC,
4865                 .v.func = alc269_fixup_hweq,
4866                 .chained = true,
4867                 .chain_id = ALC275_FIXUP_SONY_VAIO_GPIO2
4868         },
4869         [ALC271_FIXUP_DMIC] = {
4870                 .type = ALC_FIXUP_FUNC,
4871                 .v.func = alc271_fixup_dmic,
4872         },
4873         [ALC269_FIXUP_PCM_44K] = {
4874                 .type = ALC_FIXUP_FUNC,
4875                 .v.func = alc269_fixup_pcm_44k,
4876         },
4877         [ALC269_FIXUP_STEREO_DMIC] = {
4878                 .type = ALC_FIXUP_FUNC,
4879                 .v.func = alc269_fixup_stereo_dmic,
4880         },
4881         [ALC269_FIXUP_QUANTA_MUTE] = {
4882                 .type = ALC_FIXUP_FUNC,
4883                 .v.func = alc269_fixup_quanta_mute,
4884         },
4885         [ALC269_FIXUP_LIFEBOOK] = {
4886                 .type = ALC_FIXUP_PINS,
4887                 .v.pins = (const struct alc_pincfg[]) {
4888                         { 0x1a, 0x2101103f }, /* dock line-out */
4889                         { 0x1b, 0x23a11040 }, /* dock mic-in */
4890                         { }
4891                 },
4892                 .chained = true,
4893                 .chain_id = ALC269_FIXUP_QUANTA_MUTE
4894         },
4895         [ALC269_FIXUP_AMIC] = {
4896                 .type = ALC_FIXUP_PINS,
4897                 .v.pins = (const struct alc_pincfg[]) {
4898                         { 0x14, 0x99130110 }, /* speaker */
4899                         { 0x15, 0x0121401f }, /* HP out */
4900                         { 0x18, 0x01a19c20 }, /* mic */
4901                         { 0x19, 0x99a3092f }, /* int-mic */
4902                         { }
4903                 },
4904         },
4905         [ALC269_FIXUP_DMIC] = {
4906                 .type = ALC_FIXUP_PINS,
4907                 .v.pins = (const struct alc_pincfg[]) {
4908                         { 0x12, 0x99a3092f }, /* int-mic */
4909                         { 0x14, 0x99130110 }, /* speaker */
4910                         { 0x15, 0x0121401f }, /* HP out */
4911                         { 0x18, 0x01a19c20 }, /* mic */
4912                         { }
4913                 },
4914         },
4915         [ALC269VB_FIXUP_AMIC] = {
4916                 .type = ALC_FIXUP_PINS,
4917                 .v.pins = (const struct alc_pincfg[]) {
4918                         { 0x14, 0x99130110 }, /* speaker */
4919                         { 0x18, 0x01a19c20 }, /* mic */
4920                         { 0x19, 0x99a3092f }, /* int-mic */
4921                         { 0x21, 0x0121401f }, /* HP out */
4922                         { }
4923                 },
4924         },
4925         [ALC269_FIXUP_DMIC] = {
4926                 .type = ALC_FIXUP_PINS,
4927                 .v.pins = (const struct alc_pincfg[]) {
4928                         { 0x12, 0x99a3092f }, /* int-mic */
4929                         { 0x14, 0x99130110 }, /* speaker */
4930                         { 0x18, 0x01a19c20 }, /* mic */
4931                         { 0x21, 0x0121401f }, /* HP out */
4932                         { }
4933                 },
4934         },
4935 };
4936
4937 static const struct snd_pci_quirk alc269_fixup_tbl[] = {
4938         SND_PCI_QUIRK(0x1043, 0x1a13, "Asus G73Jw", ALC269_FIXUP_ASUS_G73JW),
4939         SND_PCI_QUIRK(0x1043, 0x16e3, "ASUS UX50", ALC269_FIXUP_STEREO_DMIC),
4940         SND_PCI_QUIRK(0x1043, 0x831a, "ASUS P901", ALC269_FIXUP_STEREO_DMIC),
4941         SND_PCI_QUIRK(0x1043, 0x834a, "ASUS S101", ALC269_FIXUP_STEREO_DMIC),
4942         SND_PCI_QUIRK(0x1043, 0x8398, "ASUS P1005", ALC269_FIXUP_STEREO_DMIC),
4943         SND_PCI_QUIRK(0x1043, 0x83ce, "ASUS P1005", ALC269_FIXUP_STEREO_DMIC),
4944         SND_PCI_QUIRK(0x104d, 0x9073, "Sony VAIO", ALC275_FIXUP_SONY_VAIO_GPIO2),
4945         SND_PCI_QUIRK(0x104d, 0x907b, "Sony VAIO", ALC275_FIXUP_SONY_HWEQ),
4946         SND_PCI_QUIRK(0x104d, 0x9084, "Sony VAIO", ALC275_FIXUP_SONY_HWEQ),
4947         SND_PCI_QUIRK_VENDOR(0x104d, "Sony VAIO", ALC269_FIXUP_SONY_VAIO),
4948         SND_PCI_QUIRK(0x1028, 0x0470, "Dell M101z", ALC269_FIXUP_DELL_M101Z),
4949         SND_PCI_QUIRK_VENDOR(0x1025, "Acer Aspire", ALC271_FIXUP_DMIC),
4950         SND_PCI_QUIRK(0x10cf, 0x1475, "Lifebook", ALC269_FIXUP_LIFEBOOK),
4951         SND_PCI_QUIRK(0x17aa, 0x20f2, "Thinkpad SL410/510", ALC269_FIXUP_SKU_IGNORE),
4952         SND_PCI_QUIRK(0x17aa, 0x215e, "Thinkpad L512", ALC269_FIXUP_SKU_IGNORE),
4953         SND_PCI_QUIRK(0x17aa, 0x21b8, "Thinkpad Edge 14", ALC269_FIXUP_SKU_IGNORE),
4954         SND_PCI_QUIRK(0x17aa, 0x21ca, "Thinkpad L412", ALC269_FIXUP_SKU_IGNORE),
4955         SND_PCI_QUIRK(0x17aa, 0x21e9, "Thinkpad Edge 15", ALC269_FIXUP_SKU_IGNORE),
4956         SND_PCI_QUIRK(0x17aa, 0x3bf8, "Quanta FL1", ALC269_FIXUP_QUANTA_MUTE),
4957         SND_PCI_QUIRK(0x17aa, 0x3bf8, "Lenovo Ideapd", ALC269_FIXUP_PCM_44K),
4958         SND_PCI_QUIRK(0x17aa, 0x9e54, "LENOVO NB", ALC269_FIXUP_LENOVO_EAPD),
4959
4960 #if 1
4961         /* Below is a quirk table taken from the old code.
4962          * Basically the device should work as is without the fixup table.
4963          * If BIOS doesn't give a proper info, enable the corresponding
4964          * fixup entry.
4965          */
4966         SND_PCI_QUIRK(0x1043, 0x8330, "ASUS Eeepc P703 P900A",
4967                       ALC269_FIXUP_AMIC),
4968         SND_PCI_QUIRK(0x1043, 0x1013, "ASUS N61Da", ALC269_FIXUP_AMIC),
4969         SND_PCI_QUIRK(0x1043, 0x1113, "ASUS N63Jn", ALC269_FIXUP_AMIC),
4970         SND_PCI_QUIRK(0x1043, 0x1143, "ASUS B53f", ALC269_FIXUP_AMIC),
4971         SND_PCI_QUIRK(0x1043, 0x1133, "ASUS UJ20ft", ALC269_FIXUP_AMIC),
4972         SND_PCI_QUIRK(0x1043, 0x1183, "ASUS K72DR", ALC269_FIXUP_AMIC),
4973         SND_PCI_QUIRK(0x1043, 0x11b3, "ASUS K52DR", ALC269_FIXUP_AMIC),
4974         SND_PCI_QUIRK(0x1043, 0x11e3, "ASUS U33Jc", ALC269_FIXUP_AMIC),
4975         SND_PCI_QUIRK(0x1043, 0x1273, "ASUS UL80Jt", ALC269_FIXUP_AMIC),
4976         SND_PCI_QUIRK(0x1043, 0x1283, "ASUS U53Jc", ALC269_FIXUP_AMIC),
4977         SND_PCI_QUIRK(0x1043, 0x12b3, "ASUS N82JV", ALC269_FIXUP_AMIC),
4978         SND_PCI_QUIRK(0x1043, 0x12d3, "ASUS N61Jv", ALC269_FIXUP_AMIC),
4979         SND_PCI_QUIRK(0x1043, 0x13a3, "ASUS UL30Vt", ALC269_FIXUP_AMIC),
4980         SND_PCI_QUIRK(0x1043, 0x1373, "ASUS G73JX", ALC269_FIXUP_AMIC),
4981         SND_PCI_QUIRK(0x1043, 0x1383, "ASUS UJ30Jc", ALC269_FIXUP_AMIC),
4982         SND_PCI_QUIRK(0x1043, 0x13d3, "ASUS N61JA", ALC269_FIXUP_AMIC),
4983         SND_PCI_QUIRK(0x1043, 0x1413, "ASUS UL50", ALC269_FIXUP_AMIC),
4984         SND_PCI_QUIRK(0x1043, 0x1443, "ASUS UL30", ALC269_FIXUP_AMIC),
4985         SND_PCI_QUIRK(0x1043, 0x1453, "ASUS M60Jv", ALC269_FIXUP_AMIC),
4986         SND_PCI_QUIRK(0x1043, 0x1483, "ASUS UL80", ALC269_FIXUP_AMIC),
4987         SND_PCI_QUIRK(0x1043, 0x14f3, "ASUS F83Vf", ALC269_FIXUP_AMIC),
4988         SND_PCI_QUIRK(0x1043, 0x14e3, "ASUS UL20", ALC269_FIXUP_AMIC),
4989         SND_PCI_QUIRK(0x1043, 0x1513, "ASUS UX30", ALC269_FIXUP_AMIC),
4990         SND_PCI_QUIRK(0x1043, 0x1593, "ASUS N51Vn", ALC269_FIXUP_AMIC),
4991         SND_PCI_QUIRK(0x1043, 0x15a3, "ASUS N60Jv", ALC269_FIXUP_AMIC),
4992         SND_PCI_QUIRK(0x1043, 0x15b3, "ASUS N60Dp", ALC269_FIXUP_AMIC),
4993         SND_PCI_QUIRK(0x1043, 0x15c3, "ASUS N70De", ALC269_FIXUP_AMIC),
4994         SND_PCI_QUIRK(0x1043, 0x15e3, "ASUS F83T", ALC269_FIXUP_AMIC),
4995         SND_PCI_QUIRK(0x1043, 0x1643, "ASUS M60J", ALC269_FIXUP_AMIC),
4996         SND_PCI_QUIRK(0x1043, 0x1653, "ASUS U50", ALC269_FIXUP_AMIC),
4997         SND_PCI_QUIRK(0x1043, 0x1693, "ASUS F50N", ALC269_FIXUP_AMIC),
4998         SND_PCI_QUIRK(0x1043, 0x16a3, "ASUS F5Q", ALC269_FIXUP_AMIC),
4999         SND_PCI_QUIRK(0x1043, 0x1723, "ASUS P80", ALC269_FIXUP_AMIC),
5000         SND_PCI_QUIRK(0x1043, 0x1743, "ASUS U80", ALC269_FIXUP_AMIC),
5001         SND_PCI_QUIRK(0x1043, 0x1773, "ASUS U20A", ALC269_FIXUP_AMIC),
5002         SND_PCI_QUIRK(0x1043, 0x1883, "ASUS F81Se", ALC269_FIXUP_AMIC),
5003         SND_PCI_QUIRK(0x152d, 0x1778, "Quanta ON1", ALC269_FIXUP_DMIC),
5004         SND_PCI_QUIRK(0x17aa, 0x3be9, "Quanta Wistron", ALC269_FIXUP_AMIC),
5005         SND_PCI_QUIRK(0x17aa, 0x3bf8, "Quanta FL1", ALC269_FIXUP_AMIC),
5006         SND_PCI_QUIRK(0x17ff, 0x059a, "Quanta EL3", ALC269_FIXUP_DMIC),
5007         SND_PCI_QUIRK(0x17ff, 0x059b, "Quanta JR1", ALC269_FIXUP_DMIC),
5008 #endif
5009         {}
5010 };
5011
5012 static const struct alc_model_fixup alc269_fixup_models[] = {
5013         {.id = ALC269_FIXUP_AMIC, .name = "laptop-amic"},
5014         {.id = ALC269_FIXUP_DMIC, .name = "laptop-dmic"},
5015         {}
5016 };
5017
5018
5019 static int alc269_fill_coef(struct hda_codec *codec)
5020 {
5021         int val;
5022
5023         if ((alc_get_coef0(codec) & 0x00ff) < 0x015) {
5024                 alc_write_coef_idx(codec, 0xf, 0x960b);
5025                 alc_write_coef_idx(codec, 0xe, 0x8817);
5026         }
5027
5028         if ((alc_get_coef0(codec) & 0x00ff) == 0x016) {
5029                 alc_write_coef_idx(codec, 0xf, 0x960b);
5030                 alc_write_coef_idx(codec, 0xe, 0x8814);
5031         }
5032
5033         if ((alc_get_coef0(codec) & 0x00ff) == 0x017) {
5034                 val = alc_read_coef_idx(codec, 0x04);
5035                 /* Power up output pin */
5036                 alc_write_coef_idx(codec, 0x04, val | (1<<11));
5037         }
5038
5039         if ((alc_get_coef0(codec) & 0x00ff) == 0x018) {
5040                 val = alc_read_coef_idx(codec, 0xd);
5041                 if ((val & 0x0c00) >> 10 != 0x1) {
5042                         /* Capless ramp up clock control */
5043                         alc_write_coef_idx(codec, 0xd, val | (1<<10));
5044                 }
5045                 val = alc_read_coef_idx(codec, 0x17);
5046                 if ((val & 0x01c0) >> 6 != 0x4) {
5047                         /* Class D power on reset */
5048                         alc_write_coef_idx(codec, 0x17, val | (1<<7));
5049                 }
5050         }
5051
5052         val = alc_read_coef_idx(codec, 0xd); /* Class D */
5053         alc_write_coef_idx(codec, 0xd, val | (1<<14));
5054
5055         val = alc_read_coef_idx(codec, 0x4); /* HP */
5056         alc_write_coef_idx(codec, 0x4, val | (1<<11));
5057
5058         return 0;
5059 }
5060
5061 /*
5062  */
5063 static int patch_alc269(struct hda_codec *codec)
5064 {
5065         struct alc_spec *spec;
5066         int err = 0;
5067
5068         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
5069         if (spec == NULL)
5070                 return -ENOMEM;
5071
5072         codec->spec = spec;
5073
5074         spec->mixer_nid = 0x0b;
5075
5076         alc_auto_parse_customize_define(codec);
5077
5078         err = alc_codec_rename_from_preset(codec);
5079         if (err < 0)
5080                 goto error;
5081
5082         if (codec->vendor_id == 0x10ec0269) {
5083                 spec->codec_variant = ALC269_TYPE_ALC269VA;
5084                 switch (alc_get_coef0(codec) & 0x00f0) {
5085                 case 0x0010:
5086                         if (codec->bus->pci->subsystem_vendor == 0x1025 &&
5087                             spec->cdefine.platform_type == 1)
5088                                 err = alc_codec_rename(codec, "ALC271X");
5089                         spec->codec_variant = ALC269_TYPE_ALC269VB;
5090                         break;
5091                 case 0x0020:
5092                         if (codec->bus->pci->subsystem_vendor == 0x17aa &&
5093                             codec->bus->pci->subsystem_device == 0x21f3)
5094                                 err = alc_codec_rename(codec, "ALC3202");
5095                         spec->codec_variant = ALC269_TYPE_ALC269VC;
5096                         break;
5097                 default:
5098                         alc_fix_pll_init(codec, 0x20, 0x04, 15);
5099                 }
5100                 if (err < 0)
5101                         goto error;
5102                 alc269_fill_coef(codec);
5103         }
5104
5105         alc_pick_fixup(codec, alc269_fixup_models,
5106                        alc269_fixup_tbl, alc269_fixups);
5107         alc_apply_fixup(codec, ALC_FIXUP_ACT_PRE_PROBE);
5108
5109         /* automatic parse from the BIOS config */
5110         err = alc269_parse_auto_config(codec);
5111         if (err < 0)
5112                 goto error;
5113
5114         if (!spec->no_analog && !spec->adc_nids) {
5115                 alc_auto_fill_adc_caps(codec);
5116                 alc_rebuild_imux_for_auto_mic(codec);
5117                 alc_remove_invalid_adc_nids(codec);
5118         }
5119
5120         if (!spec->no_analog && !spec->cap_mixer)
5121                 set_capture_mixer(codec);
5122
5123         if (!spec->no_analog && has_cdefine_beep(codec)) {
5124                 err = snd_hda_attach_beep_device(codec, 0x1);
5125                 if (err < 0)
5126                         goto error;
5127                 set_beep_amp(spec, 0x0b, 0x04, HDA_INPUT);
5128         }
5129
5130         alc_apply_fixup(codec, ALC_FIXUP_ACT_PROBE);
5131
5132         spec->vmaster_nid = 0x02;
5133
5134         codec->patch_ops = alc_patch_ops;
5135 #ifdef CONFIG_PM
5136         codec->patch_ops.resume = alc269_resume;
5137 #endif
5138         spec->init_hook = alc_auto_init_std;
5139         spec->shutup = alc269_shutup;
5140
5141         alc_init_jacks(codec);
5142 #ifdef CONFIG_SND_HDA_POWER_SAVE
5143         if (!spec->loopback.amplist)
5144                 spec->loopback.amplist = alc269_loopbacks;
5145         if (alc269_mic2_for_mute_led(codec))
5146                 codec->patch_ops.check_power_status = alc269_mic2_mute_check_ps;
5147 #endif
5148
5149         return 0;
5150
5151  error:
5152         alc_free(codec);
5153         return err;
5154 }
5155
5156 /*
5157  * ALC861
5158  */
5159
5160 static int alc861_parse_auto_config(struct hda_codec *codec)
5161 {
5162         static const hda_nid_t alc861_ignore[] = { 0x1d, 0 };
5163         static const hda_nid_t alc861_ssids[] = { 0x0e, 0x0f, 0x0b, 0 };
5164         return alc_parse_auto_config(codec, alc861_ignore, alc861_ssids);
5165 }
5166
5167 #ifdef CONFIG_SND_HDA_POWER_SAVE
5168 static const struct hda_amp_list alc861_loopbacks[] = {
5169         { 0x15, HDA_INPUT, 0 },
5170         { 0x15, HDA_INPUT, 1 },
5171         { 0x15, HDA_INPUT, 2 },
5172         { 0x15, HDA_INPUT, 3 },
5173         { } /* end */
5174 };
5175 #endif
5176
5177
5178 /* Pin config fixes */
5179 enum {
5180         PINFIX_FSC_AMILO_PI1505,
5181 };
5182
5183 static const struct alc_fixup alc861_fixups[] = {
5184         [PINFIX_FSC_AMILO_PI1505] = {
5185                 .type = ALC_FIXUP_PINS,
5186                 .v.pins = (const struct alc_pincfg[]) {
5187                         { 0x0b, 0x0221101f }, /* HP */
5188                         { 0x0f, 0x90170310 }, /* speaker */
5189                         { }
5190                 }
5191         },
5192 };
5193
5194 static const struct snd_pci_quirk alc861_fixup_tbl[] = {
5195         SND_PCI_QUIRK(0x1734, 0x10c7, "FSC Amilo Pi1505", PINFIX_FSC_AMILO_PI1505),
5196         {}
5197 };
5198
5199 /*
5200  */
5201 static int patch_alc861(struct hda_codec *codec)
5202 {
5203         struct alc_spec *spec;
5204         int err;
5205
5206         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
5207         if (spec == NULL)
5208                 return -ENOMEM;
5209
5210         codec->spec = spec;
5211
5212         spec->mixer_nid = 0x15;
5213
5214         alc_pick_fixup(codec, NULL, alc861_fixup_tbl, alc861_fixups);
5215         alc_apply_fixup(codec, ALC_FIXUP_ACT_PRE_PROBE);
5216
5217         /* automatic parse from the BIOS config */
5218         err = alc861_parse_auto_config(codec);
5219         if (err < 0)
5220                 goto error;
5221
5222         if (!spec->no_analog && !spec->adc_nids) {
5223                 alc_auto_fill_adc_caps(codec);
5224                 alc_rebuild_imux_for_auto_mic(codec);
5225                 alc_remove_invalid_adc_nids(codec);
5226         }
5227
5228         if (!spec->no_analog && !spec->cap_mixer)
5229                 set_capture_mixer(codec);
5230
5231         if (!spec->no_analog) {
5232                 err = snd_hda_attach_beep_device(codec, 0x23);
5233                 if (err < 0)
5234                         goto error;
5235                 set_beep_amp(spec, 0x23, 0, HDA_OUTPUT);
5236         }
5237
5238         spec->vmaster_nid = 0x03;
5239
5240         alc_apply_fixup(codec, ALC_FIXUP_ACT_PROBE);
5241
5242         codec->patch_ops = alc_patch_ops;
5243         spec->init_hook = alc_auto_init_std;
5244 #ifdef CONFIG_SND_HDA_POWER_SAVE
5245         spec->power_hook = alc_power_eapd;
5246         if (!spec->loopback.amplist)
5247                 spec->loopback.amplist = alc861_loopbacks;
5248 #endif
5249
5250         return 0;
5251
5252  error:
5253         alc_free(codec);
5254         return err;
5255 }
5256
5257 /*
5258  * ALC861-VD support
5259  *
5260  * Based on ALC882
5261  *
5262  * In addition, an independent DAC
5263  */
5264 #ifdef CONFIG_SND_HDA_POWER_SAVE
5265 #define alc861vd_loopbacks      alc880_loopbacks
5266 #endif
5267
5268 static int alc861vd_parse_auto_config(struct hda_codec *codec)
5269 {
5270         static const hda_nid_t alc861vd_ignore[] = { 0x1d, 0 };
5271         static const hda_nid_t alc861vd_ssids[] = { 0x15, 0x1b, 0x14, 0 };
5272         return alc_parse_auto_config(codec, alc861vd_ignore, alc861vd_ssids);
5273 }
5274
5275 enum {
5276         ALC660VD_FIX_ASUS_GPIO1,
5277         ALC861VD_FIX_DALLAS,
5278 };
5279
5280 /* exclude VREF80 */
5281 static void alc861vd_fixup_dallas(struct hda_codec *codec,
5282                                   const struct alc_fixup *fix, int action)
5283 {
5284         if (action == ALC_FIXUP_ACT_PRE_PROBE) {
5285                 snd_hda_override_pin_caps(codec, 0x18, 0x00001714);
5286                 snd_hda_override_pin_caps(codec, 0x19, 0x0000171c);
5287         }
5288 }
5289
5290 static const struct alc_fixup alc861vd_fixups[] = {
5291         [ALC660VD_FIX_ASUS_GPIO1] = {
5292                 .type = ALC_FIXUP_VERBS,
5293                 .v.verbs = (const struct hda_verb[]) {
5294                         /* reset GPIO1 */
5295                         {0x01, AC_VERB_SET_GPIO_MASK, 0x03},
5296                         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
5297                         {0x01, AC_VERB_SET_GPIO_DATA, 0x01},
5298                         { }
5299                 }
5300         },
5301         [ALC861VD_FIX_DALLAS] = {
5302                 .type = ALC_FIXUP_FUNC,
5303                 .v.func = alc861vd_fixup_dallas,
5304         },
5305 };
5306
5307 static const struct snd_pci_quirk alc861vd_fixup_tbl[] = {
5308         SND_PCI_QUIRK(0x103c, 0x30bf, "HP TX1000", ALC861VD_FIX_DALLAS),
5309         SND_PCI_QUIRK(0x1043, 0x1339, "ASUS A7-K", ALC660VD_FIX_ASUS_GPIO1),
5310         SND_PCI_QUIRK(0x1179, 0xff31, "Toshiba L30-149", ALC861VD_FIX_DALLAS),
5311         {}
5312 };
5313
5314 static const struct hda_verb alc660vd_eapd_verbs[] = {
5315         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
5316         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
5317         { }
5318 };
5319
5320 /*
5321  */
5322 static int patch_alc861vd(struct hda_codec *codec)
5323 {
5324         struct alc_spec *spec;
5325         int err;
5326
5327         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
5328         if (spec == NULL)
5329                 return -ENOMEM;
5330
5331         codec->spec = spec;
5332
5333         spec->mixer_nid = 0x0b;
5334
5335         alc_pick_fixup(codec, NULL, alc861vd_fixup_tbl, alc861vd_fixups);
5336         alc_apply_fixup(codec, ALC_FIXUP_ACT_PRE_PROBE);
5337
5338         /* automatic parse from the BIOS config */
5339         err = alc861vd_parse_auto_config(codec);
5340         if (err < 0)
5341                 goto error;
5342
5343         if (codec->vendor_id == 0x10ec0660) {
5344                 /* always turn on EAPD */
5345                 add_verb(spec, alc660vd_eapd_verbs);
5346         }
5347
5348         if (!spec->no_analog && !spec->adc_nids) {
5349                 alc_auto_fill_adc_caps(codec);
5350                 alc_rebuild_imux_for_auto_mic(codec);
5351                 alc_remove_invalid_adc_nids(codec);
5352         }
5353
5354         if (!spec->no_analog && !spec->cap_mixer)
5355                 set_capture_mixer(codec);
5356
5357         if (!spec->no_analog) {
5358                 err = snd_hda_attach_beep_device(codec, 0x23);
5359                 if (err < 0)
5360                         goto error;
5361                 set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
5362         }
5363
5364         spec->vmaster_nid = 0x02;
5365
5366         alc_apply_fixup(codec, ALC_FIXUP_ACT_PROBE);
5367
5368         codec->patch_ops = alc_patch_ops;
5369
5370         spec->init_hook = alc_auto_init_std;
5371         spec->shutup = alc_eapd_shutup;
5372 #ifdef CONFIG_SND_HDA_POWER_SAVE
5373         if (!spec->loopback.amplist)
5374                 spec->loopback.amplist = alc861vd_loopbacks;
5375 #endif
5376
5377         return 0;
5378
5379  error:
5380         alc_free(codec);
5381         return err;
5382 }
5383
5384 /*
5385  * ALC662 support
5386  *
5387  * ALC662 is almost identical with ALC880 but has cleaner and more flexible
5388  * configuration.  Each pin widget can choose any input DACs and a mixer.
5389  * Each ADC is connected from a mixer of all inputs.  This makes possible
5390  * 6-channel independent captures.
5391  *
5392  * In addition, an independent DAC for the multi-playback (not used in this
5393  * driver yet).
5394  */
5395 #ifdef CONFIG_SND_HDA_POWER_SAVE
5396 #define alc662_loopbacks        alc880_loopbacks
5397 #endif
5398
5399 /*
5400  * BIOS auto configuration
5401  */
5402
5403 static int alc662_parse_auto_config(struct hda_codec *codec)
5404 {
5405         static const hda_nid_t alc662_ignore[] = { 0x1d, 0 };
5406         static const hda_nid_t alc663_ssids[] = { 0x15, 0x1b, 0x14, 0x21 };
5407         static const hda_nid_t alc662_ssids[] = { 0x15, 0x1b, 0x14, 0 };
5408         const hda_nid_t *ssids;
5409
5410         if (codec->vendor_id == 0x10ec0272 || codec->vendor_id == 0x10ec0663 ||
5411             codec->vendor_id == 0x10ec0665 || codec->vendor_id == 0x10ec0670)
5412                 ssids = alc663_ssids;
5413         else
5414                 ssids = alc662_ssids;
5415         return alc_parse_auto_config(codec, alc662_ignore, ssids);
5416 }
5417
5418 static void alc272_fixup_mario(struct hda_codec *codec,
5419                                const struct alc_fixup *fix, int action)
5420 {
5421         if (action != ALC_FIXUP_ACT_PROBE)
5422                 return;
5423         if (snd_hda_override_amp_caps(codec, 0x2, HDA_OUTPUT,
5424                                       (0x3b << AC_AMPCAP_OFFSET_SHIFT) |
5425                                       (0x3b << AC_AMPCAP_NUM_STEPS_SHIFT) |
5426                                       (0x03 << AC_AMPCAP_STEP_SIZE_SHIFT) |
5427                                       (0 << AC_AMPCAP_MUTE_SHIFT)))
5428                 printk(KERN_WARNING
5429                        "hda_codec: failed to override amp caps for NID 0x2\n");
5430 }
5431
5432 enum {
5433         ALC662_FIXUP_ASPIRE,
5434         ALC662_FIXUP_IDEAPAD,
5435         ALC272_FIXUP_MARIO,
5436         ALC662_FIXUP_CZC_P10T,
5437         ALC662_FIXUP_SKU_IGNORE,
5438         ALC662_FIXUP_HP_RP5800,
5439         ALC662_FIXUP_ASUS_MODE1,
5440         ALC662_FIXUP_ASUS_MODE2,
5441         ALC662_FIXUP_ASUS_MODE3,
5442         ALC662_FIXUP_ASUS_MODE4,
5443         ALC662_FIXUP_ASUS_MODE5,
5444         ALC662_FIXUP_ASUS_MODE6,
5445         ALC662_FIXUP_ASUS_MODE7,
5446         ALC662_FIXUP_ASUS_MODE8,
5447 };
5448
5449 static const struct alc_fixup alc662_fixups[] = {
5450         [ALC662_FIXUP_ASPIRE] = {
5451                 .type = ALC_FIXUP_PINS,
5452                 .v.pins = (const struct alc_pincfg[]) {
5453                         { 0x15, 0x99130112 }, /* subwoofer */
5454                         { }
5455                 }
5456         },
5457         [ALC662_FIXUP_IDEAPAD] = {
5458                 .type = ALC_FIXUP_PINS,
5459                 .v.pins = (const struct alc_pincfg[]) {
5460                         { 0x17, 0x99130112 }, /* subwoofer */
5461                         { }
5462                 }
5463         },
5464         [ALC272_FIXUP_MARIO] = {
5465                 .type = ALC_FIXUP_FUNC,
5466                 .v.func = alc272_fixup_mario,
5467         },
5468         [ALC662_FIXUP_CZC_P10T] = {
5469                 .type = ALC_FIXUP_VERBS,
5470                 .v.verbs = (const struct hda_verb[]) {
5471                         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 0},
5472                         {}
5473                 }
5474         },
5475         [ALC662_FIXUP_SKU_IGNORE] = {
5476                 .type = ALC_FIXUP_SKU,
5477                 .v.sku = ALC_FIXUP_SKU_IGNORE,
5478         },
5479         [ALC662_FIXUP_HP_RP5800] = {
5480                 .type = ALC_FIXUP_PINS,
5481                 .v.pins = (const struct alc_pincfg[]) {
5482                         { 0x14, 0x0221201f }, /* HP out */
5483                         { }
5484                 },
5485                 .chained = true,
5486                 .chain_id = ALC662_FIXUP_SKU_IGNORE
5487         },
5488         [ALC662_FIXUP_ASUS_MODE1] = {
5489                 .type = ALC_FIXUP_PINS,
5490                 .v.pins = (const struct alc_pincfg[]) {
5491                         { 0x14, 0x99130110 }, /* speaker */
5492                         { 0x18, 0x01a19c20 }, /* mic */
5493                         { 0x19, 0x99a3092f }, /* int-mic */
5494                         { 0x21, 0x0121401f }, /* HP out */
5495                         { }
5496                 },
5497                 .chained = true,
5498                 .chain_id = ALC662_FIXUP_SKU_IGNORE
5499         },
5500         [ALC662_FIXUP_ASUS_MODE2] = {
5501                 .type = ALC_FIXUP_PINS,
5502                 .v.pins = (const struct alc_pincfg[]) {
5503                         { 0x14, 0x99130110 }, /* speaker */
5504                         { 0x18, 0x01a19820 }, /* mic */
5505                         { 0x19, 0x99a3092f }, /* int-mic */
5506                         { 0x1b, 0x0121401f }, /* HP out */
5507                         { }
5508                 },
5509                 .chained = true,
5510                 .chain_id = ALC662_FIXUP_SKU_IGNORE
5511         },
5512         [ALC662_FIXUP_ASUS_MODE3] = {
5513                 .type = ALC_FIXUP_PINS,
5514                 .v.pins = (const struct alc_pincfg[]) {
5515                         { 0x14, 0x99130110 }, /* speaker */
5516                         { 0x15, 0x0121441f }, /* HP */
5517                         { 0x18, 0x01a19840 }, /* mic */
5518                         { 0x19, 0x99a3094f }, /* int-mic */
5519                         { 0x21, 0x01211420 }, /* HP2 */
5520                         { }
5521                 },
5522                 .chained = true,
5523                 .chain_id = ALC662_FIXUP_SKU_IGNORE
5524         },
5525         [ALC662_FIXUP_ASUS_MODE4] = {
5526                 .type = ALC_FIXUP_PINS,
5527                 .v.pins = (const struct alc_pincfg[]) {
5528                         { 0x14, 0x99130110 }, /* speaker */
5529                         { 0x16, 0x99130111 }, /* speaker */
5530                         { 0x18, 0x01a19840 }, /* mic */
5531                         { 0x19, 0x99a3094f }, /* int-mic */
5532                         { 0x21, 0x0121441f }, /* HP */
5533                         { }
5534                 },
5535                 .chained = true,
5536                 .chain_id = ALC662_FIXUP_SKU_IGNORE
5537         },
5538         [ALC662_FIXUP_ASUS_MODE5] = {
5539                 .type = ALC_FIXUP_PINS,
5540                 .v.pins = (const struct alc_pincfg[]) {
5541                         { 0x14, 0x99130110 }, /* speaker */
5542                         { 0x15, 0x0121441f }, /* HP */
5543                         { 0x16, 0x99130111 }, /* speaker */
5544                         { 0x18, 0x01a19840 }, /* mic */
5545                         { 0x19, 0x99a3094f }, /* int-mic */
5546                         { }
5547                 },
5548                 .chained = true,
5549                 .chain_id = ALC662_FIXUP_SKU_IGNORE
5550         },
5551         [ALC662_FIXUP_ASUS_MODE6] = {
5552                 .type = ALC_FIXUP_PINS,
5553                 .v.pins = (const struct alc_pincfg[]) {
5554                         { 0x14, 0x99130110 }, /* speaker */
5555                         { 0x15, 0x01211420 }, /* HP2 */
5556                         { 0x18, 0x01a19840 }, /* mic */
5557                         { 0x19, 0x99a3094f }, /* int-mic */
5558                         { 0x1b, 0x0121441f }, /* HP */
5559                         { }
5560                 },
5561                 .chained = true,
5562                 .chain_id = ALC662_FIXUP_SKU_IGNORE
5563         },
5564         [ALC662_FIXUP_ASUS_MODE7] = {
5565                 .type = ALC_FIXUP_PINS,
5566                 .v.pins = (const struct alc_pincfg[]) {
5567                         { 0x14, 0x99130110 }, /* speaker */
5568                         { 0x17, 0x99130111 }, /* speaker */
5569                         { 0x18, 0x01a19840 }, /* mic */
5570                         { 0x19, 0x99a3094f }, /* int-mic */
5571                         { 0x1b, 0x01214020 }, /* HP */
5572                         { 0x21, 0x0121401f }, /* HP */
5573                         { }
5574                 },
5575                 .chained = true,
5576                 .chain_id = ALC662_FIXUP_SKU_IGNORE
5577         },
5578         [ALC662_FIXUP_ASUS_MODE8] = {
5579                 .type = ALC_FIXUP_PINS,
5580                 .v.pins = (const struct alc_pincfg[]) {
5581                         { 0x14, 0x99130110 }, /* speaker */
5582                         { 0x12, 0x99a30970 }, /* int-mic */
5583                         { 0x15, 0x01214020 }, /* HP */
5584                         { 0x17, 0x99130111 }, /* speaker */
5585                         { 0x18, 0x01a19840 }, /* mic */
5586                         { 0x21, 0x0121401f }, /* HP */
5587                         { }
5588                 },
5589                 .chained = true,
5590                 .chain_id = ALC662_FIXUP_SKU_IGNORE
5591         },
5592 };
5593
5594 static const struct snd_pci_quirk alc662_fixup_tbl[] = {
5595         SND_PCI_QUIRK(0x1019, 0x9087, "ECS", ALC662_FIXUP_ASUS_MODE2),
5596         SND_PCI_QUIRK(0x1025, 0x0308, "Acer Aspire 8942G", ALC662_FIXUP_ASPIRE),
5597         SND_PCI_QUIRK(0x1025, 0x031c, "Gateway NV79", ALC662_FIXUP_SKU_IGNORE),
5598         SND_PCI_QUIRK(0x1025, 0x038b, "Acer Aspire 8943G", ALC662_FIXUP_ASPIRE),
5599         SND_PCI_QUIRK(0x103c, 0x1632, "HP RP5800", ALC662_FIXUP_HP_RP5800),
5600         SND_PCI_QUIRK(0x105b, 0x0cd6, "Foxconn", ALC662_FIXUP_ASUS_MODE2),
5601         SND_PCI_QUIRK(0x144d, 0xc051, "Samsung R720", ALC662_FIXUP_IDEAPAD),
5602         SND_PCI_QUIRK(0x17aa, 0x38af, "Lenovo Ideapad Y550P", ALC662_FIXUP_IDEAPAD),
5603         SND_PCI_QUIRK(0x17aa, 0x3a0d, "Lenovo Ideapad Y550", ALC662_FIXUP_IDEAPAD),
5604         SND_PCI_QUIRK(0x1b35, 0x2206, "CZC P10T", ALC662_FIXUP_CZC_P10T),
5605
5606 #if 0
5607         /* Below is a quirk table taken from the old code.
5608          * Basically the device should work as is without the fixup table.
5609          * If BIOS doesn't give a proper info, enable the corresponding
5610          * fixup entry.
5611          */
5612         SND_PCI_QUIRK(0x1043, 0x1000, "ASUS N50Vm", ALC662_FIXUP_ASUS_MODE1),
5613         SND_PCI_QUIRK(0x1043, 0x1092, "ASUS NB", ALC662_FIXUP_ASUS_MODE3),
5614         SND_PCI_QUIRK(0x1043, 0x1173, "ASUS K73Jn", ALC662_FIXUP_ASUS_MODE1),
5615         SND_PCI_QUIRK(0x1043, 0x11c3, "ASUS M70V", ALC662_FIXUP_ASUS_MODE3),
5616         SND_PCI_QUIRK(0x1043, 0x11d3, "ASUS NB", ALC662_FIXUP_ASUS_MODE1),
5617         SND_PCI_QUIRK(0x1043, 0x11f3, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
5618         SND_PCI_QUIRK(0x1043, 0x1203, "ASUS NB", ALC662_FIXUP_ASUS_MODE1),
5619         SND_PCI_QUIRK(0x1043, 0x1303, "ASUS G60J", ALC662_FIXUP_ASUS_MODE1),
5620         SND_PCI_QUIRK(0x1043, 0x1333, "ASUS G60Jx", ALC662_FIXUP_ASUS_MODE1),
5621         SND_PCI_QUIRK(0x1043, 0x1339, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
5622         SND_PCI_QUIRK(0x1043, 0x13e3, "ASUS N71JA", ALC662_FIXUP_ASUS_MODE7),
5623         SND_PCI_QUIRK(0x1043, 0x1463, "ASUS N71", ALC662_FIXUP_ASUS_MODE7),
5624         SND_PCI_QUIRK(0x1043, 0x14d3, "ASUS G72", ALC662_FIXUP_ASUS_MODE8),
5625         SND_PCI_QUIRK(0x1043, 0x1563, "ASUS N90", ALC662_FIXUP_ASUS_MODE3),
5626         SND_PCI_QUIRK(0x1043, 0x15d3, "ASUS N50SF F50SF", ALC662_FIXUP_ASUS_MODE1),
5627         SND_PCI_QUIRK(0x1043, 0x16c3, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
5628         SND_PCI_QUIRK(0x1043, 0x16f3, "ASUS K40C K50C", ALC662_FIXUP_ASUS_MODE2),
5629         SND_PCI_QUIRK(0x1043, 0x1733, "ASUS N81De", ALC662_FIXUP_ASUS_MODE1),
5630         SND_PCI_QUIRK(0x1043, 0x1753, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
5631         SND_PCI_QUIRK(0x1043, 0x1763, "ASUS NB", ALC662_FIXUP_ASUS_MODE6),
5632         SND_PCI_QUIRK(0x1043, 0x1765, "ASUS NB", ALC662_FIXUP_ASUS_MODE6),
5633         SND_PCI_QUIRK(0x1043, 0x1783, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
5634         SND_PCI_QUIRK(0x1043, 0x1793, "ASUS F50GX", ALC662_FIXUP_ASUS_MODE1),
5635         SND_PCI_QUIRK(0x1043, 0x17b3, "ASUS F70SL", ALC662_FIXUP_ASUS_MODE3),
5636         SND_PCI_QUIRK(0x1043, 0x17f3, "ASUS X58LE", ALC662_FIXUP_ASUS_MODE2),
5637         SND_PCI_QUIRK(0x1043, 0x1813, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
5638         SND_PCI_QUIRK(0x1043, 0x1823, "ASUS NB", ALC662_FIXUP_ASUS_MODE5),
5639         SND_PCI_QUIRK(0x1043, 0x1833, "ASUS NB", ALC662_FIXUP_ASUS_MODE6),
5640         SND_PCI_QUIRK(0x1043, 0x1843, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
5641         SND_PCI_QUIRK(0x1043, 0x1853, "ASUS F50Z", ALC662_FIXUP_ASUS_MODE1),
5642         SND_PCI_QUIRK(0x1043, 0x1864, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
5643         SND_PCI_QUIRK(0x1043, 0x1876, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
5644         SND_PCI_QUIRK(0x1043, 0x1893, "ASUS M50Vm", ALC662_FIXUP_ASUS_MODE3),
5645         SND_PCI_QUIRK(0x1043, 0x1894, "ASUS X55", ALC662_FIXUP_ASUS_MODE3),
5646         SND_PCI_QUIRK(0x1043, 0x18b3, "ASUS N80Vc", ALC662_FIXUP_ASUS_MODE1),
5647         SND_PCI_QUIRK(0x1043, 0x18c3, "ASUS VX5", ALC662_FIXUP_ASUS_MODE1),
5648         SND_PCI_QUIRK(0x1043, 0x18d3, "ASUS N81Te", ALC662_FIXUP_ASUS_MODE1),
5649         SND_PCI_QUIRK(0x1043, 0x18f3, "ASUS N505Tp", ALC662_FIXUP_ASUS_MODE1),
5650         SND_PCI_QUIRK(0x1043, 0x1903, "ASUS F5GL", ALC662_FIXUP_ASUS_MODE1),
5651         SND_PCI_QUIRK(0x1043, 0x1913, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
5652         SND_PCI_QUIRK(0x1043, 0x1933, "ASUS F80Q", ALC662_FIXUP_ASUS_MODE2),
5653         SND_PCI_QUIRK(0x1043, 0x1943, "ASUS Vx3V", ALC662_FIXUP_ASUS_MODE1),
5654         SND_PCI_QUIRK(0x1043, 0x1953, "ASUS NB", ALC662_FIXUP_ASUS_MODE1),
5655         SND_PCI_QUIRK(0x1043, 0x1963, "ASUS X71C", ALC662_FIXUP_ASUS_MODE3),
5656         SND_PCI_QUIRK(0x1043, 0x1983, "ASUS N5051A", ALC662_FIXUP_ASUS_MODE1),
5657         SND_PCI_QUIRK(0x1043, 0x1993, "ASUS N20", ALC662_FIXUP_ASUS_MODE1),
5658         SND_PCI_QUIRK(0x1043, 0x19b3, "ASUS F7Z", ALC662_FIXUP_ASUS_MODE1),
5659         SND_PCI_QUIRK(0x1043, 0x19c3, "ASUS F5Z/F6x", ALC662_FIXUP_ASUS_MODE2),
5660         SND_PCI_QUIRK(0x1043, 0x19e3, "ASUS NB", ALC662_FIXUP_ASUS_MODE1),
5661         SND_PCI_QUIRK(0x1043, 0x19f3, "ASUS NB", ALC662_FIXUP_ASUS_MODE4),
5662 #endif
5663         {}
5664 };
5665
5666 static const struct alc_model_fixup alc662_fixup_models[] = {
5667         {.id = ALC272_FIXUP_MARIO, .name = "mario"},
5668         {.id = ALC662_FIXUP_ASUS_MODE1, .name = "asus-mode1"},
5669         {.id = ALC662_FIXUP_ASUS_MODE2, .name = "asus-mode2"},
5670         {.id = ALC662_FIXUP_ASUS_MODE3, .name = "asus-mode3"},
5671         {.id = ALC662_FIXUP_ASUS_MODE4, .name = "asus-mode4"},
5672         {.id = ALC662_FIXUP_ASUS_MODE5, .name = "asus-mode5"},
5673         {.id = ALC662_FIXUP_ASUS_MODE6, .name = "asus-mode6"},
5674         {.id = ALC662_FIXUP_ASUS_MODE7, .name = "asus-mode7"},
5675         {.id = ALC662_FIXUP_ASUS_MODE8, .name = "asus-mode8"},
5676         {}
5677 };
5678
5679
5680 /*
5681  */
5682 static int patch_alc662(struct hda_codec *codec)
5683 {
5684         struct alc_spec *spec;
5685         int err = 0;
5686
5687         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
5688         if (!spec)
5689                 return -ENOMEM;
5690
5691         codec->spec = spec;
5692
5693         spec->mixer_nid = 0x0b;
5694
5695         /* handle multiple HPs as is */
5696         spec->parse_flags = HDA_PINCFG_NO_HP_FIXUP;
5697
5698         alc_auto_parse_customize_define(codec);
5699
5700         alc_fix_pll_init(codec, 0x20, 0x04, 15);
5701
5702         err = alc_codec_rename_from_preset(codec);
5703         if (err < 0)
5704                 goto error;
5705
5706         if ((alc_get_coef0(codec) & (1 << 14)) &&
5707             codec->bus->pci->subsystem_vendor == 0x1025 &&
5708             spec->cdefine.platform_type == 1) {
5709                 if (alc_codec_rename(codec, "ALC272X") < 0)
5710                         goto error;
5711         }
5712
5713         alc_pick_fixup(codec, alc662_fixup_models,
5714                        alc662_fixup_tbl, alc662_fixups);
5715         alc_apply_fixup(codec, ALC_FIXUP_ACT_PRE_PROBE);
5716         /* automatic parse from the BIOS config */
5717         err = alc662_parse_auto_config(codec);
5718         if (err < 0)
5719                 goto error;
5720
5721         if (!spec->no_analog && !spec->adc_nids) {
5722                 alc_auto_fill_adc_caps(codec);
5723                 alc_rebuild_imux_for_auto_mic(codec);
5724                 alc_remove_invalid_adc_nids(codec);
5725         }
5726
5727         if (!spec->no_analog && !spec->cap_mixer)
5728                 set_capture_mixer(codec);
5729
5730         if (!spec->no_analog && has_cdefine_beep(codec)) {
5731                 err = snd_hda_attach_beep_device(codec, 0x1);
5732                 if (err < 0)
5733                         goto error;
5734                 switch (codec->vendor_id) {
5735                 case 0x10ec0662:
5736                         set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
5737                         break;
5738                 case 0x10ec0272:
5739                 case 0x10ec0663:
5740                 case 0x10ec0665:
5741                         set_beep_amp(spec, 0x0b, 0x04, HDA_INPUT);
5742                         break;
5743                 case 0x10ec0273:
5744                         set_beep_amp(spec, 0x0b, 0x03, HDA_INPUT);
5745                         break;
5746                 }
5747         }
5748         spec->vmaster_nid = 0x02;
5749
5750         alc_apply_fixup(codec, ALC_FIXUP_ACT_PROBE);
5751
5752         codec->patch_ops = alc_patch_ops;
5753         spec->init_hook = alc_auto_init_std;
5754         spec->shutup = alc_eapd_shutup;
5755
5756         alc_init_jacks(codec);
5757
5758 #ifdef CONFIG_SND_HDA_POWER_SAVE
5759         if (!spec->loopback.amplist)
5760                 spec->loopback.amplist = alc662_loopbacks;
5761 #endif
5762
5763         return 0;
5764
5765  error:
5766         alc_free(codec);
5767         return err;
5768 }
5769
5770 /*
5771  * ALC680 support
5772  */
5773
5774 static int alc680_parse_auto_config(struct hda_codec *codec)
5775 {
5776         return alc_parse_auto_config(codec, NULL, NULL);
5777 }
5778
5779 /*
5780  */
5781 static int patch_alc680(struct hda_codec *codec)
5782 {
5783         struct alc_spec *spec;
5784         int err;
5785
5786         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
5787         if (spec == NULL)
5788                 return -ENOMEM;
5789
5790         codec->spec = spec;
5791
5792         /* ALC680 has no aa-loopback mixer */
5793
5794         /* automatic parse from the BIOS config */
5795         err = alc680_parse_auto_config(codec);
5796         if (err < 0) {
5797                 alc_free(codec);
5798                 return err;
5799         }
5800
5801         if (!spec->no_analog && !spec->cap_mixer)
5802                 set_capture_mixer(codec);
5803
5804         spec->vmaster_nid = 0x02;
5805
5806         codec->patch_ops = alc_patch_ops;
5807         spec->init_hook = alc_auto_init_std;
5808
5809         return 0;
5810 }
5811
5812 /*
5813  * patch entries
5814  */
5815 static const struct hda_codec_preset snd_hda_preset_realtek[] = {
5816         { .id = 0x10ec0221, .name = "ALC221", .patch = patch_alc269 },
5817         { .id = 0x10ec0260, .name = "ALC260", .patch = patch_alc260 },
5818         { .id = 0x10ec0262, .name = "ALC262", .patch = patch_alc262 },
5819         { .id = 0x10ec0267, .name = "ALC267", .patch = patch_alc268 },
5820         { .id = 0x10ec0268, .name = "ALC268", .patch = patch_alc268 },
5821         { .id = 0x10ec0269, .name = "ALC269", .patch = patch_alc269 },
5822         { .id = 0x10ec0270, .name = "ALC270", .patch = patch_alc269 },
5823         { .id = 0x10ec0272, .name = "ALC272", .patch = patch_alc662 },
5824         { .id = 0x10ec0275, .name = "ALC275", .patch = patch_alc269 },
5825         { .id = 0x10ec0276, .name = "ALC276", .patch = patch_alc269 },
5826         { .id = 0x10ec0861, .rev = 0x100340, .name = "ALC660",
5827           .patch = patch_alc861 },
5828         { .id = 0x10ec0660, .name = "ALC660-VD", .patch = patch_alc861vd },
5829         { .id = 0x10ec0861, .name = "ALC861", .patch = patch_alc861 },
5830         { .id = 0x10ec0862, .name = "ALC861-VD", .patch = patch_alc861vd },
5831         { .id = 0x10ec0662, .rev = 0x100002, .name = "ALC662 rev2",
5832           .patch = patch_alc882 },
5833         { .id = 0x10ec0662, .rev = 0x100101, .name = "ALC662 rev1",
5834           .patch = patch_alc662 },
5835         { .id = 0x10ec0662, .rev = 0x100300, .name = "ALC662 rev3",
5836           .patch = patch_alc662 },
5837         { .id = 0x10ec0663, .name = "ALC663", .patch = patch_alc662 },
5838         { .id = 0x10ec0665, .name = "ALC665", .patch = patch_alc662 },
5839         { .id = 0x10ec0670, .name = "ALC670", .patch = patch_alc662 },
5840         { .id = 0x10ec0680, .name = "ALC680", .patch = patch_alc680 },
5841         { .id = 0x10ec0880, .name = "ALC880", .patch = patch_alc880 },
5842         { .id = 0x10ec0882, .name = "ALC882", .patch = patch_alc882 },
5843         { .id = 0x10ec0883, .name = "ALC883", .patch = patch_alc882 },
5844         { .id = 0x10ec0885, .rev = 0x100101, .name = "ALC889A",
5845           .patch = patch_alc882 },
5846         { .id = 0x10ec0885, .rev = 0x100103, .name = "ALC889A",
5847           .patch = patch_alc882 },
5848         { .id = 0x10ec0885, .name = "ALC885", .patch = patch_alc882 },
5849         { .id = 0x10ec0887, .name = "ALC887", .patch = patch_alc882 },
5850         { .id = 0x10ec0888, .rev = 0x100101, .name = "ALC1200",
5851           .patch = patch_alc882 },
5852         { .id = 0x10ec0888, .name = "ALC888", .patch = patch_alc882 },
5853         { .id = 0x10ec0889, .name = "ALC889", .patch = patch_alc882 },
5854         { .id = 0x10ec0892, .name = "ALC892", .patch = patch_alc662 },
5855         { .id = 0x10ec0899, .name = "ALC898", .patch = patch_alc882 },
5856         {} /* terminator */
5857 };
5858
5859 MODULE_ALIAS("snd-hda-codec-id:10ec*");
5860
5861 MODULE_LICENSE("GPL");
5862 MODULE_DESCRIPTION("Realtek HD-audio codec");
5863
5864 static struct hda_codec_preset_list realtek_list = {
5865         .preset = snd_hda_preset_realtek,
5866         .owner = THIS_MODULE,
5867 };
5868
5869 static int __init patch_realtek_init(void)
5870 {
5871         return snd_hda_add_codec_preset(&realtek_list);
5872 }
5873
5874 static void __exit patch_realtek_exit(void)
5875 {
5876         snd_hda_delete_codec_preset(&realtek_list);
5877 }
5878
5879 module_init(patch_realtek_init)
5880 module_exit(patch_realtek_exit)