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 #define MAX_VOL_NIDS    0x40
  83
  84 struct alc_spec {
  85         /* codec parameterization */
  86         const struct snd_kcontrol_new *mixers[5];       /* mixer arrays */
  87         unsigned int num_mixers;
  88         const struct snd_kcontrol_new *cap_mixer;       /* capture mixer */
  89         unsigned int beep_amp;  /* beep amp value, set via set_beep_amp() */
  90
  91         const struct hda_verb *init_verbs[10];  /* initialization verbs
  92                                                  * don't forget NULL
  93                                                  * termination!
  94                                                  */
  95         unsigned int num_init_verbs;
  96
  97         char stream_name_analog[32];    /* analog PCM stream */
  98         const struct hda_pcm_stream *stream_analog_playback;
  99         const struct hda_pcm_stream *stream_analog_capture;
 100         const struct hda_pcm_stream *stream_analog_alt_playback;
 101         const struct hda_pcm_stream *stream_analog_alt_capture;
 102
 103         char stream_name_digital[32];   /* digital PCM stream */
 104         const struct hda_pcm_stream *stream_digital_playback;
 105         const struct hda_pcm_stream *stream_digital_capture;
 106
 107         /* playback */
 108         struct hda_multi_out multiout;  /* playback set-up
 109                                          * max_channels, dacs must be set
 110                                          * dig_out_nid and hp_nid are optional
 111                                          */
 112         hda_nid_t alt_dac_nid;
 113         hda_nid_t slave_dig_outs[3];    /* optional - for auto-parsing */
 114         int dig_out_type;
 115
 116         /* capture */
 117         unsigned int num_adc_nids;
 118         const hda_nid_t *adc_nids;
 119         const hda_nid_t *capsrc_nids;
 120         hda_nid_t dig_in_nid;           /* digital-in NID; optional */
 121         hda_nid_t mixer_nid;            /* analog-mixer NID */
 122         DECLARE_BITMAP(vol_ctls, MAX_VOL_NIDS << 1);
 123         DECLARE_BITMAP(sw_ctls, MAX_VOL_NIDS << 1);
 124
 125         /* capture setup for dynamic dual-adc switch */
 126         hda_nid_t cur_adc;
 127         unsigned int cur_adc_stream_tag;
 128         unsigned int cur_adc_format;
 129
 130         /* capture source */
 131         unsigned int num_mux_defs;
 132         const struct hda_input_mux *input_mux;
 133         unsigned int cur_mux[3];
 134         hda_nid_t ext_mic_pin;
 135         hda_nid_t dock_mic_pin;
 136         hda_nid_t int_mic_pin;
 137
 138         /* channel model */
 139         const struct hda_channel_mode *channel_mode;
 140         int num_channel_mode;
 141         int need_dac_fix;
 142         int const_channel_count;
 143         int ext_channel_count;
 144
 145         /* PCM information */
 146         struct hda_pcm pcm_rec[3];      /* used in alc_build_pcms() */
 147
 148         /* dynamic controls, init_verbs and input_mux */
 149         struct auto_pin_cfg autocfg;
 150         struct alc_customize_define cdefine;
 151         struct snd_array kctls;
 152         struct hda_input_mux private_imux[3];
 153         hda_nid_t private_dac_nids[AUTO_CFG_MAX_OUTS];
 154         hda_nid_t private_adc_nids[AUTO_CFG_MAX_OUTS];
 155         hda_nid_t private_capsrc_nids[AUTO_CFG_MAX_OUTS];
 156         hda_nid_t imux_pins[HDA_MAX_NUM_INPUTS];
 157         unsigned int dyn_adc_idx[HDA_MAX_NUM_INPUTS];
 158         int int_mic_idx, ext_mic_idx, dock_mic_idx; /* for auto-mic */
 159
 160         /* hooks */
 161         void (*init_hook)(struct hda_codec *codec);
 162         void (*unsol_event)(struct hda_codec *codec, unsigned int res);
 163 #ifdef CONFIG_SND_HDA_POWER_SAVE
 164         void (*power_hook)(struct hda_codec *codec);
 165 #endif
 166         void (*shutup)(struct hda_codec *codec);
 167         void (*automute_hook)(struct hda_codec *codec);
 168
 169         /* for pin sensing */
 170         unsigned int hp_jack_present:1;
 171         unsigned int line_jack_present:1;
 172         unsigned int master_mute:1;
 173         unsigned int auto_mic:1;
 174         unsigned int auto_mic_valid_imux:1;     /* valid imux for auto-mic */
 175         unsigned int automute_speaker:1; /* automute speaker outputs */
 176         unsigned int automute_lo:1; /* automute LO outputs */
 177         unsigned int detect_hp:1;       /* Headphone detection enabled */
 178         unsigned int detect_lo:1;       /* Line-out detection enabled */
 179         unsigned int automute_speaker_possible:1; /* there are speakers and either LO or HP */
 180         unsigned int automute_lo_possible:1;      /* there are line outs and HP */
 181         unsigned int keep_vref_in_automute:1; /* Don't clear VREF in automute */
 182
 183         /* other flags */
 184         unsigned int no_analog :1; /* digital I/O only */
 185         unsigned int dyn_adc_switch:1; /* switch ADCs (for ALC275) */
 186         unsigned int single_input_src:1;
 187         unsigned int vol_in_capsrc:1; /* use capsrc volume (ADC has no vol) */
 188         unsigned int parse_flags; /* passed to snd_hda_parse_pin_defcfg() */
 189
 190         /* auto-mute control */
 191         int automute_mode;
 192         hda_nid_t automute_mixer_nid[AUTO_CFG_MAX_OUTS];
 193
 194         int init_amp;
 195         int codec_variant;      /* flag for other variants */
 196
 197         /* for virtual master */
 198         hda_nid_t vmaster_nid;
 199 #ifdef CONFIG_SND_HDA_POWER_SAVE
 200         struct hda_loopback_check loopback;
 201 #endif
 202
 203         /* for PLL fix */
 204         hda_nid_t pll_nid;
 205         unsigned int pll_coef_idx, pll_coef_bit;
 206         unsigned int coef0;
 207
 208         /* fix-up list */
 209         int fixup_id;
 210         const struct alc_fixup *fixup_list;
 211         const char *fixup_name;
 212
 213         /* multi-io */
 214         int multi_ios;
 215         struct alc_multi_io multi_io[4];
 216
 217         /* bind volumes */
 218         struct snd_array bind_ctls;
 219 };
 220
 221 #define ALC_MODEL_AUTO          0       /* common for all chips */
 222
 223 static bool check_amp_caps(struct hda_codec *codec, hda_nid_t nid,
 224                            int dir, unsigned int bits)
 225 {
 226         if (!nid)
 227                 return false;
 228         if (get_wcaps(codec, nid) & (1 << (dir + 1)))
 229                 if (query_amp_caps(codec, nid, dir) & bits)
 230                         return true;
 231         return false;
 232 }
 233
 234 #define nid_has_mute(codec, nid, dir) \
 235         check_amp_caps(codec, nid, dir, AC_AMPCAP_MUTE)
 236 #define nid_has_volume(codec, nid, dir) \
 237         check_amp_caps(codec, nid, dir, AC_AMPCAP_NUM_STEPS)
 238
 239 /*
 240  * input MUX handling
 241  */
 242 static int alc_mux_enum_info(struct snd_kcontrol *kcontrol,
 243                              struct snd_ctl_elem_info *uinfo)
 244 {
 245         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 246         struct alc_spec *spec = codec->spec;
 247         unsigned int mux_idx = snd_ctl_get_ioffidx(kcontrol, &uinfo->id);
 248         if (mux_idx >= spec->num_mux_defs)
 249                 mux_idx = 0;
 250         if (!spec->input_mux[mux_idx].num_items && mux_idx > 0)
 251                 mux_idx = 0;
 252         return snd_hda_input_mux_info(&spec->input_mux[mux_idx], uinfo);
 253 }
 254
 255 static int alc_mux_enum_get(struct snd_kcontrol *kcontrol,
 256                             struct snd_ctl_elem_value *ucontrol)
 257 {
 258         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 259         struct alc_spec *spec = codec->spec;
 260         unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
 261
 262         ucontrol->value.enumerated.item[0] = spec->cur_mux[adc_idx];
 263         return 0;
 264 }
 265
 266 static bool alc_dyn_adc_pcm_resetup(struct hda_codec *codec, int cur)
 267 {
 268         struct alc_spec *spec = codec->spec;
 269         hda_nid_t new_adc = spec->adc_nids[spec->dyn_adc_idx[cur]];
 270
 271         if (spec->cur_adc && spec->cur_adc != new_adc) {
 272                 /* stream is running, let's swap the current ADC */
 273                 __snd_hda_codec_cleanup_stream(codec, spec->cur_adc, 1);
 274                 spec->cur_adc = new_adc;
 275                 snd_hda_codec_setup_stream(codec, new_adc,
 276                                            spec->cur_adc_stream_tag, 0,
 277                                            spec->cur_adc_format);
 278                 return true;
 279         }
 280         return false;
 281 }
 282
 283 static inline hda_nid_t get_capsrc(struct alc_spec *spec, int idx)
 284 {
 285         return spec->capsrc_nids ?
 286                 spec->capsrc_nids[idx] : spec->adc_nids[idx];
 287 }
 288
 289 /* select the given imux item; either unmute exclusively or select the route */
 290 static int alc_mux_select(struct hda_codec *codec, unsigned int adc_idx,
 291                           unsigned int idx, bool force)
 292 {
 293         struct alc_spec *spec = codec->spec;
 294         const struct hda_input_mux *imux;
 295         unsigned int mux_idx;
 296         int i, type, num_conns;
 297         hda_nid_t nid;
 298
 299         mux_idx = adc_idx >= spec->num_mux_defs ? 0 : adc_idx;
 300         imux = &spec->input_mux[mux_idx];
 301         if (!imux->num_items && mux_idx > 0)
 302                 imux = &spec->input_mux[0];
 303         if (!imux->num_items)
 304                 return 0;
 305
 306         if (idx >= imux->num_items)
 307                 idx = imux->num_items - 1;
 308         if (spec->cur_mux[adc_idx] == idx && !force)
 309                 return 0;
 310         spec->cur_mux[adc_idx] = idx;
 311
 312         if (spec->dyn_adc_switch) {
 313                 alc_dyn_adc_pcm_resetup(codec, idx);
 314                 adc_idx = spec->dyn_adc_idx[idx];
 315         }
 316
 317         nid = get_capsrc(spec, adc_idx);
 318
 319         /* no selection? */
 320         num_conns = snd_hda_get_conn_list(codec, nid, NULL);
 321         if (num_conns <= 1)
 322                 return 1;
 323
 324         type = get_wcaps_type(get_wcaps(codec, nid));
 325         if (type == AC_WID_AUD_MIX) {
 326                 /* Matrix-mixer style (e.g. ALC882) */
 327                 int active = imux->items[idx].index;
 328                 for (i = 0; i < num_conns; i++) {
 329                         unsigned int v = (i == active) ? 0 : HDA_AMP_MUTE;
 330                         snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT, i,
 331                                                  HDA_AMP_MUTE, v);
 332                 }
 333         } else {
 334                 /* MUX style (e.g. ALC880) */
 335                 snd_hda_codec_write_cache(codec, nid, 0,
 336                                           AC_VERB_SET_CONNECT_SEL,
 337                                           imux->items[idx].index);
 338         }
 339         return 1;
 340 }
 341
 342 static int alc_mux_enum_put(struct snd_kcontrol *kcontrol,
 343                             struct snd_ctl_elem_value *ucontrol)
 344 {
 345         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 346         unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
 347         return alc_mux_select(codec, adc_idx,
 348                               ucontrol->value.enumerated.item[0], false);
 349 }
 350
 351 /*
 352  * set up the input pin config (depending on the given auto-pin type)
 353  */
 354 static void alc_set_input_pin(struct hda_codec *codec, hda_nid_t nid,
 355                               int auto_pin_type)
 356 {
 357         unsigned int val = PIN_IN;
 358
 359         if (auto_pin_type == AUTO_PIN_MIC) {
 360                 unsigned int pincap;
 361                 unsigned int oldval;
 362                 oldval = snd_hda_codec_read(codec, nid, 0,
 363                                             AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
 364                 pincap = snd_hda_query_pin_caps(codec, nid);
 365                 pincap = (pincap & AC_PINCAP_VREF) >> AC_PINCAP_VREF_SHIFT;
 366                 /* if the default pin setup is vref50, we give it priority */
 367                 if ((pincap & AC_PINCAP_VREF_80) && oldval != PIN_VREF50)
 368                         val = PIN_VREF80;
 369                 else if (pincap & AC_PINCAP_VREF_50)
 370                         val = PIN_VREF50;
 371                 else if (pincap & AC_PINCAP_VREF_100)
 372                         val = PIN_VREF100;
 373                 else if (pincap & AC_PINCAP_VREF_GRD)
 374                         val = PIN_VREFGRD;
 375         }
 376         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, val);
 377 }
 378
 379 /*
 380  * Append the given mixer and verb elements for the later use
 381  * The mixer array is referred in build_controls(), and init_verbs are
 382  * called in init().
 383  */
 384 static void add_mixer(struct alc_spec *spec, const struct snd_kcontrol_new *mix)
 385 {
 386         if (snd_BUG_ON(spec->num_mixers >= ARRAY_SIZE(spec->mixers)))
 387                 return;
 388         spec->mixers[spec->num_mixers++] = mix;
 389 }
 390
 391 static void add_verb(struct alc_spec *spec, const struct hda_verb *verb)
 392 {
 393         if (snd_BUG_ON(spec->num_init_verbs >= ARRAY_SIZE(spec->init_verbs)))
 394                 return;
 395         spec->init_verbs[spec->num_init_verbs++] = verb;
 396 }
 397
 398 /*
 399  * GPIO setup tables, used in initialization
 400  */
 401 /* Enable GPIO mask and set output */
 402 static const struct hda_verb alc_gpio1_init_verbs[] = {
 403         {0x01, AC_VERB_SET_GPIO_MASK, 0x01},
 404         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
 405         {0x01, AC_VERB_SET_GPIO_DATA, 0x01},
 406         { }
 407 };
 408
 409 static const struct hda_verb alc_gpio2_init_verbs[] = {
 410         {0x01, AC_VERB_SET_GPIO_MASK, 0x02},
 411         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x02},
 412         {0x01, AC_VERB_SET_GPIO_DATA, 0x02},
 413         { }
 414 };
 415
 416 static const struct hda_verb alc_gpio3_init_verbs[] = {
 417         {0x01, AC_VERB_SET_GPIO_MASK, 0x03},
 418         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x03},
 419         {0x01, AC_VERB_SET_GPIO_DATA, 0x03},
 420         { }
 421 };
 422
 423 /*
 424  * Fix hardware PLL issue
 425  * On some codecs, the analog PLL gating control must be off while
 426  * the default value is 1.
 427  */
 428 static void alc_fix_pll(struct hda_codec *codec)
 429 {
 430         struct alc_spec *spec = codec->spec;
 431         unsigned int val;
 432
 433         if (!spec->pll_nid)
 434                 return;
 435         snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_COEF_INDEX,
 436                             spec->pll_coef_idx);
 437         val = snd_hda_codec_read(codec, spec->pll_nid, 0,
 438                                  AC_VERB_GET_PROC_COEF, 0);
 439         snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_COEF_INDEX,
 440                             spec->pll_coef_idx);
 441         snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_PROC_COEF,
 442                             val & ~(1 << spec->pll_coef_bit));
 443 }
 444
 445 static void alc_fix_pll_init(struct hda_codec *codec, hda_nid_t nid,
 446                              unsigned int coef_idx, unsigned int coef_bit)
 447 {
 448         struct alc_spec *spec = codec->spec;
 449         spec->pll_nid = nid;
 450         spec->pll_coef_idx = coef_idx;
 451         spec->pll_coef_bit = coef_bit;
 452         alc_fix_pll(codec);
 453 }
 454
 455 /*
 456  * Jack-reporting via input-jack layer
 457  */
 458
 459 /* initialization of jacks; currently checks only a few known pins */
 460 static int alc_init_jacks(struct hda_codec *codec)
 461 {
 462 #ifdef CONFIG_SND_HDA_INPUT_JACK
 463         struct alc_spec *spec = codec->spec;
 464         int err;
 465         unsigned int hp_nid = spec->autocfg.hp_pins[0];
 466         unsigned int mic_nid = spec->ext_mic_pin;
 467         unsigned int dock_nid = spec->dock_mic_pin;
 468
 469         if (hp_nid) {
 470                 err = snd_hda_input_jack_add(codec, hp_nid,
 471                                              SND_JACK_HEADPHONE, NULL);
 472                 if (err < 0)
 473                         return err;
 474                 snd_hda_input_jack_report(codec, hp_nid);
 475         }
 476
 477         if (mic_nid) {
 478                 err = snd_hda_input_jack_add(codec, mic_nid,
 479                                              SND_JACK_MICROPHONE, NULL);
 480                 if (err < 0)
 481                         return err;
 482                 snd_hda_input_jack_report(codec, mic_nid);
 483         }
 484         if (dock_nid) {
 485                 err = snd_hda_input_jack_add(codec, dock_nid,
 486                                              SND_JACK_MICROPHONE, NULL);
 487                 if (err < 0)
 488                         return err;
 489                 snd_hda_input_jack_report(codec, dock_nid);
 490         }
 491 #endif /* CONFIG_SND_HDA_INPUT_JACK */
 492         return 0;
 493 }
 494
 495 /*
 496  * Jack detections for HP auto-mute and mic-switch
 497  */
 498
 499 /* check each pin in the given array; returns true if any of them is plugged */
 500 static bool detect_jacks(struct hda_codec *codec, int num_pins, hda_nid_t *pins)
 501 {
 502         int i, present = 0;
 503
 504         for (i = 0; i < num_pins; i++) {
 505                 hda_nid_t nid = pins[i];
 506                 if (!nid)
 507                         break;
 508                 snd_hda_input_jack_report(codec, nid);
 509                 present |= snd_hda_jack_detect(codec, nid);
 510         }
 511         return present;
 512 }
 513
 514 /* standard HP/line-out auto-mute helper */
 515 static void do_automute(struct hda_codec *codec, int num_pins, hda_nid_t *pins,
 516                         bool mute, bool hp_out)
 517 {
 518         struct alc_spec *spec = codec->spec;
 519         unsigned int mute_bits = mute ? HDA_AMP_MUTE : 0;
 520         unsigned int pin_bits = mute ? 0 : (hp_out ? PIN_HP : PIN_OUT);
 521         int i;
 522
 523         for (i = 0; i < num_pins; i++) {
 524                 hda_nid_t nid = pins[i];
 525                 unsigned int val;
 526                 if (!nid)
 527                         break;
 528                 switch (spec->automute_mode) {
 529                 case ALC_AUTOMUTE_PIN:
 530                         /* don't reset VREF value in case it's controlling
 531                          * the amp (see alc861_fixup_asus_amp_vref_0f())
 532                          */
 533                         if (spec->keep_vref_in_automute) {
 534                                 val = snd_hda_codec_read(codec, nid, 0,
 535                                         AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
 536                                 val &= ~PIN_HP;
 537                         } else
 538                                 val = 0;
 539                         val |= pin_bits;
 540                         snd_hda_codec_write(codec, nid, 0,
 541                                             AC_VERB_SET_PIN_WIDGET_CONTROL,
 542                                             val);
 543                         break;
 544                 case ALC_AUTOMUTE_AMP:
 545                         snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
 546                                                  HDA_AMP_MUTE, mute_bits);
 547                         break;
 548                 case ALC_AUTOMUTE_MIXER:
 549                         nid = spec->automute_mixer_nid[i];
 550                         if (!nid)
 551                                 break;
 552                         snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT, 0,
 553                                                  HDA_AMP_MUTE, mute_bits);
 554                         snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT, 1,
 555                                                  HDA_AMP_MUTE, mute_bits);
 556                         break;
 557                 }
 558         }
 559 }
 560
 561 /* Toggle outputs muting */
 562 static void update_outputs(struct hda_codec *codec)
 563 {
 564         struct alc_spec *spec = codec->spec;
 565         int on;
 566
 567         /* Control HP pins/amps depending on master_mute state;
 568          * in general, HP pins/amps control should be enabled in all cases,
 569          * but currently set only for master_mute, just to be safe
 570          */
 571         do_automute(codec, ARRAY_SIZE(spec->autocfg.hp_pins),
 572                     spec->autocfg.hp_pins, spec->master_mute, true);
 573
 574         if (!spec->automute_speaker)
 575                 on = 0;
 576         else
 577                 on = spec->hp_jack_present | spec->line_jack_present;
 578         on |= spec->master_mute;
 579         do_automute(codec, ARRAY_SIZE(spec->autocfg.speaker_pins),
 580                     spec->autocfg.speaker_pins, on, false);
 581
 582         /* toggle line-out mutes if needed, too */
 583         /* if LO is a copy of either HP or Speaker, don't need to handle it */
 584         if (spec->autocfg.line_out_pins[0] == spec->autocfg.hp_pins[0] ||
 585             spec->autocfg.line_out_pins[0] == spec->autocfg.speaker_pins[0])
 586                 return;
 587         if (!spec->automute_lo)
 588                 on = 0;
 589         else
 590                 on = spec->hp_jack_present;
 591         on |= spec->master_mute;
 592         do_automute(codec, ARRAY_SIZE(spec->autocfg.line_out_pins),
 593                     spec->autocfg.line_out_pins, on, false);
 594 }
 595
 596 static void call_update_outputs(struct hda_codec *codec)
 597 {
 598         struct alc_spec *spec = codec->spec;
 599         if (spec->automute_hook)
 600                 spec->automute_hook(codec);
 601         else
 602                 update_outputs(codec);
 603 }
 604
 605 /* standard HP-automute helper */
 606 static void alc_hp_automute(struct hda_codec *codec)
 607 {
 608         struct alc_spec *spec = codec->spec;
 609
 610         spec->hp_jack_present =
 611                 detect_jacks(codec, ARRAY_SIZE(spec->autocfg.hp_pins),
 612                              spec->autocfg.hp_pins);
 613         if (!spec->detect_hp || (!spec->automute_speaker && !spec->automute_lo))
 614                 return;
 615         call_update_outputs(codec);
 616 }
 617
 618 /* standard line-out-automute helper */
 619 static void alc_line_automute(struct hda_codec *codec)
 620 {
 621         struct alc_spec *spec = codec->spec;
 622
 623         if (spec->autocfg.line_out_type == AUTO_PIN_SPEAKER_OUT)
 624                 return;
 625         /* check LO jack only when it's different from HP */
 626         if (spec->autocfg.line_out_pins[0] == spec->autocfg.hp_pins[0])
 627                 return;
 628
 629         spec->line_jack_present =
 630                 detect_jacks(codec, ARRAY_SIZE(spec->autocfg.line_out_pins),
 631                              spec->autocfg.line_out_pins);
 632         if (!spec->automute_speaker || !spec->detect_lo)
 633                 return;
 634         call_update_outputs(codec);
 635 }
 636
 637 #define get_connection_index(codec, mux, nid) \
 638         snd_hda_get_conn_index(codec, mux, nid, 0)
 639
 640 /* standard mic auto-switch helper */
 641 static void alc_mic_automute(struct hda_codec *codec)
 642 {
 643         struct alc_spec *spec = codec->spec;
 644         hda_nid_t *pins = spec->imux_pins;
 645
 646         if (!spec->auto_mic || !spec->auto_mic_valid_imux)
 647                 return;
 648         if (snd_BUG_ON(!spec->adc_nids))
 649                 return;
 650         if (snd_BUG_ON(spec->int_mic_idx < 0 || spec->ext_mic_idx < 0))
 651                 return;
 652
 653         if (snd_hda_jack_detect(codec, pins[spec->ext_mic_idx]))
 654                 alc_mux_select(codec, 0, spec->ext_mic_idx, false);
 655         else if (spec->dock_mic_idx >= 0 &&
 656                    snd_hda_jack_detect(codec, pins[spec->dock_mic_idx]))
 657                 alc_mux_select(codec, 0, spec->dock_mic_idx, false);
 658         else
 659                 alc_mux_select(codec, 0, spec->int_mic_idx, false);
 660
 661         snd_hda_input_jack_report(codec, pins[spec->ext_mic_idx]);
 662         if (spec->dock_mic_idx >= 0)
 663                 snd_hda_input_jack_report(codec, pins[spec->dock_mic_idx]);
 664 }
 665
 666 /* unsolicited event for HP jack sensing */
 667 static void alc_sku_unsol_event(struct hda_codec *codec, unsigned int res)
 668 {
 669         if (codec->vendor_id == 0x10ec0880)
 670                 res >>= 28;
 671         else
 672                 res >>= 26;
 673         switch (res) {
 674         case ALC_HP_EVENT:
 675                 alc_hp_automute(codec);
 676                 break;
 677         case ALC_FRONT_EVENT:
 678                 alc_line_automute(codec);
 679                 break;
 680         case ALC_MIC_EVENT:
 681                 alc_mic_automute(codec);
 682                 break;
 683         }
 684 }
 685
 686 /* call init functions of standard auto-mute helpers */
 687 static void alc_inithook(struct hda_codec *codec)
 688 {
 689         alc_hp_automute(codec);
 690         alc_line_automute(codec);
 691         alc_mic_automute(codec);
 692 }
 693
 694 /* additional initialization for ALC888 variants */
 695 static void alc888_coef_init(struct hda_codec *codec)
 696 {
 697         unsigned int tmp;
 698
 699         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 0);
 700         tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0);
 701         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 7);
 702         if ((tmp & 0xf0) == 0x20)
 703                 /* alc888S-VC */
 704                 snd_hda_codec_read(codec, 0x20, 0,
 705                                    AC_VERB_SET_PROC_COEF, 0x830);
 706          else
 707                  /* alc888-VB */
 708                  snd_hda_codec_read(codec, 0x20, 0,
 709                                     AC_VERB_SET_PROC_COEF, 0x3030);
 710 }
 711
 712 /* additional initialization for ALC889 variants */
 713 static void alc889_coef_init(struct hda_codec *codec)
 714 {
 715         unsigned int tmp;
 716
 717         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 7);
 718         tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0);
 719         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 7);
 720         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_PROC_COEF, tmp|0x2010);
 721 }
 722
 723 /* turn on/off EAPD control (only if available) */
 724 static void set_eapd(struct hda_codec *codec, hda_nid_t nid, int on)
 725 {
 726         if (get_wcaps_type(get_wcaps(codec, nid)) != AC_WID_PIN)
 727                 return;
 728         if (snd_hda_query_pin_caps(codec, nid) & AC_PINCAP_EAPD)
 729                 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_EAPD_BTLENABLE,
 730                                     on ? 2 : 0);
 731 }
 732
 733 /* turn on/off EAPD controls of the codec */
 734 static void alc_auto_setup_eapd(struct hda_codec *codec, bool on)
 735 {
 736         /* We currently only handle front, HP */
 737         static hda_nid_t pins[] = {
 738                 0x0f, 0x10, 0x14, 0x15, 0
 739         };
 740         hda_nid_t *p;
 741         for (p = pins; *p; p++)
 742                 set_eapd(codec, *p, on);
 743 }
 744
 745 /* generic shutup callback;
 746  * just turning off EPAD and a little pause for avoiding pop-noise
 747  */
 748 static void alc_eapd_shutup(struct hda_codec *codec)
 749 {
 750         alc_auto_setup_eapd(codec, false);
 751         msleep(200);
 752 }
 753
 754 /* generic EAPD initialization */
 755 static void alc_auto_init_amp(struct hda_codec *codec, int type)
 756 {
 757         unsigned int tmp;
 758
 759         alc_auto_setup_eapd(codec, true);
 760         switch (type) {
 761         case ALC_INIT_GPIO1:
 762                 snd_hda_sequence_write(codec, alc_gpio1_init_verbs);
 763                 break;
 764         case ALC_INIT_GPIO2:
 765                 snd_hda_sequence_write(codec, alc_gpio2_init_verbs);
 766                 break;
 767         case ALC_INIT_GPIO3:
 768                 snd_hda_sequence_write(codec, alc_gpio3_init_verbs);
 769                 break;
 770         case ALC_INIT_DEFAULT:
 771                 switch (codec->vendor_id) {
 772                 case 0x10ec0260:
 773                         snd_hda_codec_write(codec, 0x1a, 0,
 774                                             AC_VERB_SET_COEF_INDEX, 7);
 775                         tmp = snd_hda_codec_read(codec, 0x1a, 0,
 776                                                  AC_VERB_GET_PROC_COEF, 0);
 777                         snd_hda_codec_write(codec, 0x1a, 0,
 778                                             AC_VERB_SET_COEF_INDEX, 7);
 779                         snd_hda_codec_write(codec, 0x1a, 0,
 780                                             AC_VERB_SET_PROC_COEF,
 781                                             tmp | 0x2010);
 782                         break;
 783                 case 0x10ec0262:
 784                 case 0x10ec0880:
 785                 case 0x10ec0882:
 786                 case 0x10ec0883:
 787                 case 0x10ec0885:
 788                 case 0x10ec0887:
 789                 /*case 0x10ec0889:*/ /* this causes an SPDIF problem */
 790                         alc889_coef_init(codec);
 791                         break;
 792                 case 0x10ec0888:
 793                         alc888_coef_init(codec);
 794                         break;
 795 #if 0 /* XXX: This may cause the silent output on speaker on some machines */
 796                 case 0x10ec0267:
 797                 case 0x10ec0268:
 798                         snd_hda_codec_write(codec, 0x20, 0,
 799                                             AC_VERB_SET_COEF_INDEX, 7);
 800                         tmp = snd_hda_codec_read(codec, 0x20, 0,
 801                                                  AC_VERB_GET_PROC_COEF, 0);
 802                         snd_hda_codec_write(codec, 0x20, 0,
 803                                             AC_VERB_SET_COEF_INDEX, 7);
 804                         snd_hda_codec_write(codec, 0x20, 0,
 805                                             AC_VERB_SET_PROC_COEF,
 806                                             tmp | 0x3000);
 807                         break;
 808 #endif /* XXX */
 809                 }
 810                 break;
 811         }
 812 }
 813
 814 /*
 815  * Auto-Mute mode mixer enum support
 816  */
 817 static int alc_automute_mode_info(struct snd_kcontrol *kcontrol,
 818                                   struct snd_ctl_elem_info *uinfo)
 819 {
 820         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 821         struct alc_spec *spec = codec->spec;
 822         static const char * const texts2[] = {
 823                 "Disabled", "Enabled"
 824         };
 825         static const char * const texts3[] = {
 826                 "Disabled", "Speaker Only", "Line-Out+Speaker"
 827         };
 828         const char * const *texts;
 829
 830         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
 831         uinfo->count = 1;
 832         if (spec->automute_speaker_possible && spec->automute_lo_possible) {
 833                 uinfo->value.enumerated.items = 3;
 834                 texts = texts3;
 835         } else {
 836                 uinfo->value.enumerated.items = 2;
 837                 texts = texts2;
 838         }
 839         if (uinfo->value.enumerated.item >= uinfo->value.enumerated.items)
 840                 uinfo->value.enumerated.item = uinfo->value.enumerated.items - 1;
 841         strcpy(uinfo->value.enumerated.name,
 842                texts[uinfo->value.enumerated.item]);
 843         return 0;
 844 }
 845
 846 static int alc_automute_mode_get(struct snd_kcontrol *kcontrol,
 847                                  struct snd_ctl_elem_value *ucontrol)
 848 {
 849         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 850         struct alc_spec *spec = codec->spec;
 851         unsigned int val = 0;
 852         if (spec->automute_speaker)
 853                 val++;
 854         if (spec->automute_lo)
 855                 val++;
 856
 857         ucontrol->value.enumerated.item[0] = val;
 858         return 0;
 859 }
 860
 861 static int alc_automute_mode_put(struct snd_kcontrol *kcontrol,
 862                                  struct snd_ctl_elem_value *ucontrol)
 863 {
 864         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 865         struct alc_spec *spec = codec->spec;
 866
 867         switch (ucontrol->value.enumerated.item[0]) {
 868         case 0:
 869                 if (!spec->automute_speaker && !spec->automute_lo)
 870                         return 0;
 871                 spec->automute_speaker = 0;
 872                 spec->automute_lo = 0;
 873                 break;
 874         case 1:
 875                 if (spec->automute_speaker_possible) {
 876                         if (!spec->automute_lo && spec->automute_speaker)
 877                                 return 0;
 878                         spec->automute_speaker = 1;
 879                         spec->automute_lo = 0;
 880                 } else if (spec->automute_lo_possible) {
 881                         if (spec->automute_lo)
 882                                 return 0;
 883                         spec->automute_lo = 1;
 884                 } else
 885                         return -EINVAL;
 886                 break;
 887         case 2:
 888                 if (!spec->automute_lo_possible || !spec->automute_speaker_possible)
 889                         return -EINVAL;
 890                 if (spec->automute_speaker && spec->automute_lo)
 891                         return 0;
 892                 spec->automute_speaker = 1;
 893                 spec->automute_lo = 1;
 894                 break;
 895         default:
 896                 return -EINVAL;
 897         }
 898         call_update_outputs(codec);
 899         return 1;
 900 }
 901
 902 static const struct snd_kcontrol_new alc_automute_mode_enum = {
 903         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
 904         .name = "Auto-Mute Mode",
 905         .info = alc_automute_mode_info,
 906         .get = alc_automute_mode_get,
 907         .put = alc_automute_mode_put,
 908 };
 909
 910 static struct snd_kcontrol_new *alc_kcontrol_new(struct alc_spec *spec)
 911 {
 912         snd_array_init(&spec->kctls, sizeof(struct snd_kcontrol_new), 32);
 913         return snd_array_new(&spec->kctls);
 914 }
 915
 916 static int alc_add_automute_mode_enum(struct hda_codec *codec)
 917 {
 918         struct alc_spec *spec = codec->spec;
 919         struct snd_kcontrol_new *knew;
 920
 921         knew = alc_kcontrol_new(spec);
 922         if (!knew)
 923                 return -ENOMEM;
 924         *knew = alc_automute_mode_enum;
 925         knew->name = kstrdup("Auto-Mute Mode", GFP_KERNEL);
 926         if (!knew->name)
 927                 return -ENOMEM;
 928         return 0;
 929 }
 930
 931 /*
 932  * Check the availability of HP/line-out auto-mute;
 933  * Set up appropriately if really supported
 934  */
 935 static void alc_init_automute(struct hda_codec *codec)
 936 {
 937         struct alc_spec *spec = codec->spec;
 938         struct auto_pin_cfg *cfg = &spec->autocfg;
 939         int present = 0;
 940         int i;
 941
 942         if (cfg->hp_pins[0])
 943                 present++;
 944         if (cfg->line_out_pins[0])
 945                 present++;
 946         if (cfg->speaker_pins[0])
 947                 present++;
 948         if (present < 2) /* need two different output types */
 949                 return;
 950
 951         if (!cfg->speaker_pins[0] &&
 952             cfg->line_out_type == AUTO_PIN_SPEAKER_OUT) {
 953                 memcpy(cfg->speaker_pins, cfg->line_out_pins,
 954                        sizeof(cfg->speaker_pins));
 955                 cfg->speaker_outs = cfg->line_outs;
 956         }
 957
 958         if (!cfg->hp_pins[0] &&
 959             cfg->line_out_type == AUTO_PIN_HP_OUT) {
 960                 memcpy(cfg->hp_pins, cfg->line_out_pins,
 961                        sizeof(cfg->hp_pins));
 962                 cfg->hp_outs = cfg->line_outs;
 963         }
 964
 965         spec->automute_mode = ALC_AUTOMUTE_PIN;
 966
 967         for (i = 0; i < cfg->hp_outs; i++) {
 968                 hda_nid_t nid = cfg->hp_pins[i];
 969                 if (!is_jack_detectable(codec, nid))
 970                         continue;
 971                 snd_printdd("realtek: Enable HP auto-muting on NID 0x%x\n",
 972                             nid);
 973                 snd_hda_codec_write_cache(codec, nid, 0,
 974                                   AC_VERB_SET_UNSOLICITED_ENABLE,
 975                                   AC_USRSP_EN | ALC_HP_EVENT);
 976                 spec->detect_hp = 1;
 977         }
 978
 979         if (cfg->line_out_type == AUTO_PIN_LINE_OUT && cfg->line_outs) {
 980                 if (cfg->speaker_outs)
 981                         for (i = 0; i < cfg->line_outs; i++) {
 982                                 hda_nid_t nid = cfg->line_out_pins[i];
 983                                 if (!is_jack_detectable(codec, nid))
 984                                         continue;
 985                                 snd_printdd("realtek: Enable Line-Out "
 986                                             "auto-muting on NID 0x%x\n", nid);
 987                                 snd_hda_codec_write_cache(codec, nid, 0,
 988                                                 AC_VERB_SET_UNSOLICITED_ENABLE,
 989                                                 AC_USRSP_EN | ALC_FRONT_EVENT);
 990                                 spec->detect_lo = 1;
 991                 }
 992                 spec->automute_lo_possible = spec->detect_hp;
 993         }
 994
 995         spec->automute_speaker_possible = cfg->speaker_outs &&
 996                 (spec->detect_hp || spec->detect_lo);
 997
 998         spec->automute_lo = spec->automute_lo_possible;
 999         spec->automute_speaker = spec->automute_speaker_possible;
1000
1001         if (spec->automute_speaker_possible || spec->automute_lo_possible) {
1002                 /* create a control for automute mode */
1003                 alc_add_automute_mode_enum(codec);
1004                 spec->unsol_event = alc_sku_unsol_event;
1005         }
1006 }
1007
1008 /* return the position of NID in the list, or -1 if not found */
1009 static int find_idx_in_nid_list(hda_nid_t nid, const hda_nid_t *list, int nums)
1010 {
1011         int i;
1012         for (i = 0; i < nums; i++)
1013                 if (list[i] == nid)
1014                         return i;
1015         return -1;
1016 }
1017
1018 /* check whether dynamic ADC-switching is available */
1019 static bool alc_check_dyn_adc_switch(struct hda_codec *codec)
1020 {
1021         struct alc_spec *spec = codec->spec;
1022         struct hda_input_mux *imux = &spec->private_imux[0];
1023         int i, n, idx;
1024         hda_nid_t cap, pin;
1025
1026         if (imux != spec->input_mux) /* no dynamic imux? */
1027                 return false;
1028
1029         for (n = 0; n < spec->num_adc_nids; n++) {
1030                 cap = spec->private_capsrc_nids[n];
1031                 for (i = 0; i < imux->num_items; i++) {
1032                         pin = spec->imux_pins[i];
1033                         if (!pin)
1034                                 return false;
1035                         if (get_connection_index(codec, cap, pin) < 0)
1036                                 break;
1037                 }
1038                 if (i >= imux->num_items)
1039                         return true; /* no ADC-switch is needed */
1040         }
1041
1042         for (i = 0; i < imux->num_items; i++) {
1043                 pin = spec->imux_pins[i];
1044                 for (n = 0; n < spec->num_adc_nids; n++) {
1045                         cap = spec->private_capsrc_nids[n];
1046                         idx = get_connection_index(codec, cap, pin);
1047                         if (idx >= 0) {
1048                                 imux->items[i].index = idx;
1049                                 spec->dyn_adc_idx[i] = n;
1050                                 break;
1051                         }
1052                 }
1053         }
1054
1055         snd_printdd("realtek: enabling ADC switching\n");
1056         spec->dyn_adc_switch = 1;
1057         return true;
1058 }
1059
1060 /* rebuild imux for matching with the given auto-mic pins (if not yet) */
1061 static bool alc_rebuild_imux_for_auto_mic(struct hda_codec *codec)
1062 {
1063         struct alc_spec *spec = codec->spec;
1064         struct hda_input_mux *imux;
1065         static char * const texts[3] = {
1066                 "Mic", "Internal Mic", "Dock Mic"
1067         };
1068         int i;
1069
1070         if (!spec->auto_mic)
1071                 return false;
1072         imux = &spec->private_imux[0];
1073         if (spec->input_mux == imux)
1074                 return true;
1075         spec->imux_pins[0] = spec->ext_mic_pin;
1076         spec->imux_pins[1] = spec->int_mic_pin;
1077         spec->imux_pins[2] = spec->dock_mic_pin;
1078         for (i = 0; i < 3; i++) {
1079                 strcpy(imux->items[i].label, texts[i]);
1080                 if (spec->imux_pins[i]) {
1081                         hda_nid_t pin = spec->imux_pins[i];
1082                         int c;
1083                         for (c = 0; c < spec->num_adc_nids; c++) {
1084                                 hda_nid_t cap = get_capsrc(spec, c);
1085                                 int idx = get_connection_index(codec, cap, pin);
1086                                 if (idx >= 0) {
1087                                         imux->items[i].index = idx;
1088                                         break;
1089                                 }
1090                         }
1091                         imux->num_items = i + 1;
1092                 }
1093         }
1094         spec->num_mux_defs = 1;
1095         spec->input_mux = imux;
1096         return true;
1097 }
1098
1099 /* check whether all auto-mic pins are valid; setup indices if OK */
1100 static bool alc_auto_mic_check_imux(struct hda_codec *codec)
1101 {
1102         struct alc_spec *spec = codec->spec;
1103         const struct hda_input_mux *imux;
1104
1105         if (!spec->auto_mic)
1106                 return false;
1107         if (spec->auto_mic_valid_imux)
1108                 return true; /* already checked */
1109
1110         /* fill up imux indices */
1111         if (!alc_check_dyn_adc_switch(codec)) {
1112                 spec->auto_mic = 0;
1113                 return false;
1114         }
1115
1116         imux = spec->input_mux;
1117         spec->ext_mic_idx = find_idx_in_nid_list(spec->ext_mic_pin,
1118                                         spec->imux_pins, imux->num_items);
1119         spec->int_mic_idx = find_idx_in_nid_list(spec->int_mic_pin,
1120                                         spec->imux_pins, imux->num_items);
1121         spec->dock_mic_idx = find_idx_in_nid_list(spec->dock_mic_pin,
1122                                         spec->imux_pins, imux->num_items);
1123         if (spec->ext_mic_idx < 0 || spec->int_mic_idx < 0) {
1124                 spec->auto_mic = 0;
1125                 return false; /* no corresponding imux */
1126         }
1127
1128         snd_hda_codec_write_cache(codec, spec->ext_mic_pin, 0,
1129                                   AC_VERB_SET_UNSOLICITED_ENABLE,
1130                                   AC_USRSP_EN | ALC_MIC_EVENT);
1131         if (spec->dock_mic_pin)
1132                 snd_hda_codec_write_cache(codec, spec->dock_mic_pin, 0,
1133                                   AC_VERB_SET_UNSOLICITED_ENABLE,
1134                                   AC_USRSP_EN | ALC_MIC_EVENT);
1135
1136         spec->auto_mic_valid_imux = 1;
1137         spec->auto_mic = 1;
1138         return true;
1139 }
1140
1141 /*
1142  * Check the availability of auto-mic switch;
1143  * Set up if really supported
1144  */
1145 static void alc_init_auto_mic(struct hda_codec *codec)
1146 {
1147         struct alc_spec *spec = codec->spec;
1148         struct auto_pin_cfg *cfg = &spec->autocfg;
1149         hda_nid_t fixed, ext, dock;
1150         int i;
1151
1152         spec->ext_mic_idx = spec->int_mic_idx = spec->dock_mic_idx = -1;
1153
1154         fixed = ext = dock = 0;
1155         for (i = 0; i < cfg->num_inputs; i++) {
1156                 hda_nid_t nid = cfg->inputs[i].pin;
1157                 unsigned int defcfg;
1158                 defcfg = snd_hda_codec_get_pincfg(codec, nid);
1159                 switch (snd_hda_get_input_pin_attr(defcfg)) {
1160                 case INPUT_PIN_ATTR_INT:
1161                         if (fixed)
1162                                 return; /* already occupied */
1163                         if (cfg->inputs[i].type != AUTO_PIN_MIC)
1164                                 return; /* invalid type */
1165                         fixed = nid;
1166                         break;
1167                 case INPUT_PIN_ATTR_UNUSED:
1168                         return; /* invalid entry */
1169                 case INPUT_PIN_ATTR_DOCK:
1170                         if (dock)
1171                                 return; /* already occupied */
1172                         if (cfg->inputs[i].type > AUTO_PIN_LINE_IN)
1173                                 return; /* invalid type */
1174                         dock = nid;
1175                         break;
1176                 default:
1177                         if (ext)
1178                                 return; /* already occupied */
1179                         if (cfg->inputs[i].type != AUTO_PIN_MIC)
1180                                 return; /* invalid type */
1181                         ext = nid;
1182                         break;
1183                 }
1184         }
1185         if (!ext && dock) {
1186                 ext = dock;
1187                 dock = 0;
1188         }
1189         if (!ext || !fixed)
1190                 return;
1191         if (!is_jack_detectable(codec, ext))
1192                 return; /* no unsol support */
1193         if (dock && !is_jack_detectable(codec, dock))
1194                 return; /* no unsol support */
1195
1196         /* check imux indices */
1197         spec->ext_mic_pin = ext;
1198         spec->int_mic_pin = fixed;
1199         spec->dock_mic_pin = dock;
1200
1201         spec->auto_mic = 1;
1202         if (!alc_auto_mic_check_imux(codec))
1203                 return;
1204
1205         snd_printdd("realtek: Enable auto-mic switch on NID 0x%x/0x%x/0x%x\n",
1206                     ext, fixed, dock);
1207         spec->unsol_event = alc_sku_unsol_event;
1208 }
1209
1210 /* check the availabilities of auto-mute and auto-mic switches */
1211 static void alc_auto_check_switches(struct hda_codec *codec)
1212 {
1213         alc_init_automute(codec);
1214         alc_init_auto_mic(codec);
1215 }
1216
1217 /*
1218  * Realtek SSID verification
1219  */
1220
1221 /* Could be any non-zero and even value. When used as fixup, tells
1222  * the driver to ignore any present sku defines.
1223  */
1224 #define ALC_FIXUP_SKU_IGNORE (2)
1225
1226 static int alc_auto_parse_customize_define(struct hda_codec *codec)
1227 {
1228         unsigned int ass, tmp, i;
1229         unsigned nid = 0;
1230         struct alc_spec *spec = codec->spec;
1231
1232         spec->cdefine.enable_pcbeep = 1; /* assume always enabled */
1233
1234         if (spec->cdefine.fixup) {
1235                 ass = spec->cdefine.sku_cfg;
1236                 if (ass == ALC_FIXUP_SKU_IGNORE)
1237                         return -1;
1238                 goto do_sku;
1239         }
1240
1241         ass = codec->subsystem_id & 0xffff;
1242         if (ass != codec->bus->pci->subsystem_device && (ass & 1))
1243                 goto do_sku;
1244
1245         nid = 0x1d;
1246         if (codec->vendor_id == 0x10ec0260)
1247                 nid = 0x17;
1248         ass = snd_hda_codec_get_pincfg(codec, nid);
1249
1250         if (!(ass & 1)) {
1251                 printk(KERN_INFO "hda_codec: %s: SKU not ready 0x%08x\n",
1252                        codec->chip_name, ass);
1253                 return -1;
1254         }
1255
1256         /* check sum */
1257         tmp = 0;
1258         for (i = 1; i < 16; i++) {
1259                 if ((ass >> i) & 1)
1260                         tmp++;
1261         }
1262         if (((ass >> 16) & 0xf) != tmp)
1263                 return -1;
1264
1265         spec->cdefine.port_connectivity = ass >> 30;
1266         spec->cdefine.enable_pcbeep = (ass & 0x100000) >> 20;
1267         spec->cdefine.check_sum = (ass >> 16) & 0xf;
1268         spec->cdefine.customization = ass >> 8;
1269 do_sku:
1270         spec->cdefine.sku_cfg = ass;
1271         spec->cdefine.external_amp = (ass & 0x38) >> 3;
1272         spec->cdefine.platform_type = (ass & 0x4) >> 2;
1273         spec->cdefine.swap = (ass & 0x2) >> 1;
1274         spec->cdefine.override = ass & 0x1;
1275
1276         snd_printd("SKU: Nid=0x%x sku_cfg=0x%08x\n",
1277                    nid, spec->cdefine.sku_cfg);
1278         snd_printd("SKU: port_connectivity=0x%x\n",
1279                    spec->cdefine.port_connectivity);
1280         snd_printd("SKU: enable_pcbeep=0x%x\n", spec->cdefine.enable_pcbeep);
1281         snd_printd("SKU: check_sum=0x%08x\n", spec->cdefine.check_sum);
1282         snd_printd("SKU: customization=0x%08x\n", spec->cdefine.customization);
1283         snd_printd("SKU: external_amp=0x%x\n", spec->cdefine.external_amp);
1284         snd_printd("SKU: platform_type=0x%x\n", spec->cdefine.platform_type);
1285         snd_printd("SKU: swap=0x%x\n", spec->cdefine.swap);
1286         snd_printd("SKU: override=0x%x\n", spec->cdefine.override);
1287
1288         return 0;
1289 }
1290
1291 /* return true if the given NID is found in the list */
1292 static bool found_in_nid_list(hda_nid_t nid, const hda_nid_t *list, int nums)
1293 {
1294         return find_idx_in_nid_list(nid, list, nums) >= 0;
1295 }
1296
1297 /* check subsystem ID and set up device-specific initialization;
1298  * return 1 if initialized, 0 if invalid SSID
1299  */
1300 /* 32-bit subsystem ID for BIOS loading in HD Audio codec.
1301  *      31 ~ 16 :       Manufacture ID
1302  *      15 ~ 8  :       SKU ID
1303  *      7  ~ 0  :       Assembly ID
1304  *      port-A --> pin 39/41, port-E --> pin 14/15, port-D --> pin 35/36
1305  */
1306 static int alc_subsystem_id(struct hda_codec *codec,
1307                             hda_nid_t porta, hda_nid_t porte,
1308                             hda_nid_t portd, hda_nid_t porti)
1309 {
1310         unsigned int ass, tmp, i;
1311         unsigned nid;
1312         struct alc_spec *spec = codec->spec;
1313
1314         if (spec->cdefine.fixup) {
1315                 ass = spec->cdefine.sku_cfg;
1316                 if (ass == ALC_FIXUP_SKU_IGNORE)
1317                         return 0;
1318                 goto do_sku;
1319         }
1320
1321         ass = codec->subsystem_id & 0xffff;
1322         if ((ass != codec->bus->pci->subsystem_device) && (ass & 1))
1323                 goto do_sku;
1324
1325         /* invalid SSID, check the special NID pin defcfg instead */
1326         /*
1327          * 31~30        : port connectivity
1328          * 29~21        : reserve
1329          * 20           : PCBEEP input
1330          * 19~16        : Check sum (15:1)
1331          * 15~1         : Custom
1332          * 0            : override
1333         */
1334         nid = 0x1d;
1335         if (codec->vendor_id == 0x10ec0260)
1336                 nid = 0x17;
1337         ass = snd_hda_codec_get_pincfg(codec, nid);
1338         snd_printd("realtek: No valid SSID, "
1339                    "checking pincfg 0x%08x for NID 0x%x\n",
1340                    ass, nid);
1341         if (!(ass & 1))
1342                 return 0;
1343         if ((ass >> 30) != 1)   /* no physical connection */
1344                 return 0;
1345
1346         /* check sum */
1347         tmp = 0;
1348         for (i = 1; i < 16; i++) {
1349                 if ((ass >> i) & 1)
1350                         tmp++;
1351         }
1352         if (((ass >> 16) & 0xf) != tmp)
1353                 return 0;
1354 do_sku:
1355         snd_printd("realtek: Enabling init ASM_ID=0x%04x CODEC_ID=%08x\n",
1356                    ass & 0xffff, codec->vendor_id);
1357         /*
1358          * 0 : override
1359          * 1 :  Swap Jack
1360          * 2 : 0 --> Desktop, 1 --> Laptop
1361          * 3~5 : External Amplifier control
1362          * 7~6 : Reserved
1363         */
1364         tmp = (ass & 0x38) >> 3;        /* external Amp control */
1365         switch (tmp) {
1366         case 1:
1367                 spec->init_amp = ALC_INIT_GPIO1;
1368                 break;
1369         case 3:
1370                 spec->init_amp = ALC_INIT_GPIO2;
1371                 break;
1372         case 7:
1373                 spec->init_amp = ALC_INIT_GPIO3;
1374                 break;
1375         case 5:
1376         default:
1377                 spec->init_amp = ALC_INIT_DEFAULT;
1378                 break;
1379         }
1380
1381         /* is laptop or Desktop and enable the function "Mute internal speaker
1382          * when the external headphone out jack is plugged"
1383          */
1384         if (!(ass & 0x8000))
1385                 return 1;
1386         /*
1387          * 10~8 : Jack location
1388          * 12~11: Headphone out -> 00: PortA, 01: PortE, 02: PortD, 03: Resvered
1389          * 14~13: Resvered
1390          * 15   : 1 --> enable the function "Mute internal speaker
1391          *              when the external headphone out jack is plugged"
1392          */
1393         if (!spec->autocfg.hp_pins[0] &&
1394             !(spec->autocfg.line_out_pins[0] &&
1395               spec->autocfg.line_out_type == AUTO_PIN_HP_OUT)) {
1396                 hda_nid_t nid;
1397                 tmp = (ass >> 11) & 0x3;        /* HP to chassis */
1398                 if (tmp == 0)
1399                         nid = porta;
1400                 else if (tmp == 1)
1401                         nid = porte;
1402                 else if (tmp == 2)
1403                         nid = portd;
1404                 else if (tmp == 3)
1405                         nid = porti;
1406                 else
1407                         return 1;
1408                 if (found_in_nid_list(nid, spec->autocfg.line_out_pins,
1409                                       spec->autocfg.line_outs))
1410                         return 1;
1411                 spec->autocfg.hp_pins[0] = nid;
1412         }
1413         return 1;
1414 }
1415
1416 /* Check the validity of ALC subsystem-id
1417  * ports contains an array of 4 pin NIDs for port-A, E, D and I */
1418 static void alc_ssid_check(struct hda_codec *codec, const hda_nid_t *ports)
1419 {
1420         if (!alc_subsystem_id(codec, ports[0], ports[1], ports[2], ports[3])) {
1421                 struct alc_spec *spec = codec->spec;
1422                 snd_printd("realtek: "
1423                            "Enable default setup for auto mode as fallback\n");
1424                 spec->init_amp = ALC_INIT_DEFAULT;
1425         }
1426 }
1427
1428 /*
1429  * Fix-up pin default configurations and add default verbs
1430  */
1431
1432 struct alc_pincfg {
1433         hda_nid_t nid;
1434         u32 val;
1435 };
1436
1437 struct alc_model_fixup {
1438         const int id;
1439         const char *name;
1440 };
1441
1442 struct alc_fixup {
1443         int type;
1444         bool chained;
1445         int chain_id;
1446         union {
1447                 unsigned int sku;
1448                 const struct alc_pincfg *pins;
1449                 const struct hda_verb *verbs;
1450                 void (*func)(struct hda_codec *codec,
1451                              const struct alc_fixup *fix,
1452                              int action);
1453         } v;
1454 };
1455
1456 enum {
1457         ALC_FIXUP_INVALID,
1458         ALC_FIXUP_SKU,
1459         ALC_FIXUP_PINS,
1460         ALC_FIXUP_VERBS,
1461         ALC_FIXUP_FUNC,
1462 };
1463
1464 enum {
1465         ALC_FIXUP_ACT_PRE_PROBE,
1466         ALC_FIXUP_ACT_PROBE,
1467         ALC_FIXUP_ACT_INIT,
1468 };
1469
1470 static void alc_apply_fixup(struct hda_codec *codec, int action)
1471 {
1472         struct alc_spec *spec = codec->spec;
1473         int id = spec->fixup_id;
1474 #ifdef CONFIG_SND_DEBUG_VERBOSE
1475         const char *modelname = spec->fixup_name;
1476 #endif
1477         int depth = 0;
1478
1479         if (!spec->fixup_list)
1480                 return;
1481
1482         while (id >= 0) {
1483                 const struct alc_fixup *fix = spec->fixup_list + id;
1484                 const struct alc_pincfg *cfg;
1485
1486                 switch (fix->type) {
1487                 case ALC_FIXUP_SKU:
1488                         if (action != ALC_FIXUP_ACT_PRE_PROBE || !fix->v.sku)
1489                                 break;
1490                         snd_printdd(KERN_INFO "hda_codec: %s: "
1491                                     "Apply sku override for %s\n",
1492                                     codec->chip_name, modelname);
1493                         spec->cdefine.sku_cfg = fix->v.sku;
1494                         spec->cdefine.fixup = 1;
1495                         break;
1496                 case ALC_FIXUP_PINS:
1497                         cfg = fix->v.pins;
1498                         if (action != ALC_FIXUP_ACT_PRE_PROBE || !cfg)
1499                                 break;
1500                         snd_printdd(KERN_INFO "hda_codec: %s: "
1501                                     "Apply pincfg for %s\n",
1502                                     codec->chip_name, modelname);
1503                         for (; cfg->nid; cfg++)
1504                                 snd_hda_codec_set_pincfg(codec, cfg->nid,
1505                                                          cfg->val);
1506                         break;
1507                 case ALC_FIXUP_VERBS:
1508                         if (action != ALC_FIXUP_ACT_PROBE || !fix->v.verbs)
1509                                 break;
1510                         snd_printdd(KERN_INFO "hda_codec: %s: "
1511                                     "Apply fix-verbs for %s\n",
1512                                     codec->chip_name, modelname);
1513                         add_verb(codec->spec, fix->v.verbs);
1514                         break;
1515                 case ALC_FIXUP_FUNC:
1516                         if (!fix->v.func)
1517                                 break;
1518                         snd_printdd(KERN_INFO "hda_codec: %s: "
1519                                     "Apply fix-func for %s\n",
1520                                     codec->chip_name, modelname);
1521                         fix->v.func(codec, fix, action);
1522                         break;
1523                 default:
1524                         snd_printk(KERN_ERR "hda_codec: %s: "
1525                                    "Invalid fixup type %d\n",
1526                                    codec->chip_name, fix->type);
1527                         break;
1528                 }
1529                 if (!fix->chained)
1530                         break;
1531                 if (++depth > 10)
1532                         break;
1533                 id = fix->chain_id;
1534         }
1535 }
1536
1537 static void alc_pick_fixup(struct hda_codec *codec,
1538                            const struct alc_model_fixup *models,
1539                            const struct snd_pci_quirk *quirk,
1540                            const struct alc_fixup *fixlist)
1541 {
1542         struct alc_spec *spec = codec->spec;
1543         int id = -1;
1544         const char *name = NULL;
1545
1546         if (codec->modelname && models) {
1547                 while (models->name) {
1548                         if (!strcmp(codec->modelname, models->name)) {
1549                                 id = models->id;
1550                                 name = models->name;
1551                                 break;
1552                         }
1553                         models++;
1554                 }
1555         }
1556         if (id < 0) {
1557                 quirk = snd_pci_quirk_lookup(codec->bus->pci, quirk);
1558                 if (quirk) {
1559                         id = quirk->value;
1560 #ifdef CONFIG_SND_DEBUG_VERBOSE
1561                         name = quirk->name;
1562 #endif
1563                 }
1564         }
1565
1566         spec->fixup_id = id;
1567         if (id >= 0) {
1568                 spec->fixup_list = fixlist;
1569                 spec->fixup_name = name;
1570         }
1571 }
1572
1573 /*
1574  * COEF access helper functions
1575  */
1576 static int alc_read_coef_idx(struct hda_codec *codec,
1577                         unsigned int coef_idx)
1578 {
1579         unsigned int val;
1580         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX,
1581                                 coef_idx);
1582         val = snd_hda_codec_read(codec, 0x20, 0,
1583                                 AC_VERB_GET_PROC_COEF, 0);
1584         return val;
1585 }
1586
1587 static void alc_write_coef_idx(struct hda_codec *codec, unsigned int coef_idx,
1588                                                         unsigned int coef_val)
1589 {
1590         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX,
1591                             coef_idx);
1592         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_PROC_COEF,
1593                             coef_val);
1594 }
1595
1596 /* a special bypass for COEF 0; read the cached value at the second time */
1597 static unsigned int alc_get_coef0(struct hda_codec *codec)
1598 {
1599         struct alc_spec *spec = codec->spec;
1600         if (!spec->coef0)
1601                 spec->coef0 = alc_read_coef_idx(codec, 0);
1602         return spec->coef0;
1603 }
1604
1605 /*
1606  * Digital I/O handling
1607  */
1608
1609 /* set right pin controls for digital I/O */
1610 static void alc_auto_init_digital(struct hda_codec *codec)
1611 {
1612         struct alc_spec *spec = codec->spec;
1613         int i;
1614         hda_nid_t pin, dac;
1615
1616         for (i = 0; i < spec->autocfg.dig_outs; i++) {
1617                 pin = spec->autocfg.dig_out_pins[i];
1618                 if (!pin)
1619                         continue;
1620                 snd_hda_codec_write(codec, pin, 0,
1621                                     AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
1622                 if (!i)
1623                         dac = spec->multiout.dig_out_nid;
1624                 else
1625                         dac = spec->slave_dig_outs[i - 1];
1626                 if (!dac || !(get_wcaps(codec, dac) & AC_WCAP_OUT_AMP))
1627                         continue;
1628                 snd_hda_codec_write(codec, dac, 0,
1629                                     AC_VERB_SET_AMP_GAIN_MUTE,
1630                                     AMP_OUT_UNMUTE);
1631         }
1632         pin = spec->autocfg.dig_in_pin;
1633         if (pin)
1634                 snd_hda_codec_write(codec, pin, 0,
1635                                     AC_VERB_SET_PIN_WIDGET_CONTROL,
1636                                     PIN_IN);
1637 }
1638
1639 /* parse digital I/Os and set up NIDs in BIOS auto-parse mode */
1640 static void alc_auto_parse_digital(struct hda_codec *codec)
1641 {
1642         struct alc_spec *spec = codec->spec;
1643         int i, err, nums;
1644         hda_nid_t dig_nid;
1645
1646         /* support multiple SPDIFs; the secondary is set up as a slave */
1647         nums = 0;
1648         for (i = 0; i < spec->autocfg.dig_outs; i++) {
1649                 hda_nid_t conn[4];
1650                 err = snd_hda_get_connections(codec,
1651                                               spec->autocfg.dig_out_pins[i],
1652                                               conn, ARRAY_SIZE(conn));
1653                 if (err <= 0)
1654                         continue;
1655                 dig_nid = conn[0]; /* assume the first element is audio-out */
1656                 if (!nums) {
1657                         spec->multiout.dig_out_nid = dig_nid;
1658                         spec->dig_out_type = spec->autocfg.dig_out_type[0];
1659                 } else {
1660                         spec->multiout.slave_dig_outs = spec->slave_dig_outs;
1661                         if (nums >= ARRAY_SIZE(spec->slave_dig_outs) - 1)
1662                                 break;
1663                         spec->slave_dig_outs[nums - 1] = dig_nid;
1664                 }
1665                 nums++;
1666         }
1667
1668         if (spec->autocfg.dig_in_pin) {
1669                 dig_nid = codec->start_nid;
1670                 for (i = 0; i < codec->num_nodes; i++, dig_nid++) {
1671                         unsigned int wcaps = get_wcaps(codec, dig_nid);
1672                         if (get_wcaps_type(wcaps) != AC_WID_AUD_IN)
1673                                 continue;
1674                         if (!(wcaps & AC_WCAP_DIGITAL))
1675                                 continue;
1676                         if (!(wcaps & AC_WCAP_CONN_LIST))
1677                                 continue;
1678                         err = get_connection_index(codec, dig_nid,
1679                                                    spec->autocfg.dig_in_pin);
1680                         if (err >= 0) {
1681                                 spec->dig_in_nid = dig_nid;
1682                                 break;
1683                         }
1684                 }
1685         }
1686 }
1687
1688 /*
1689  * capture mixer elements
1690  */
1691 static int alc_cap_vol_info(struct snd_kcontrol *kcontrol,
1692                             struct snd_ctl_elem_info *uinfo)
1693 {
1694         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1695         struct alc_spec *spec = codec->spec;
1696         unsigned long val;
1697         int err;
1698
1699         mutex_lock(&codec->control_mutex);
1700         if (spec->vol_in_capsrc)
1701                 val = HDA_COMPOSE_AMP_VAL(spec->capsrc_nids[0], 3, 0, HDA_OUTPUT);
1702         else
1703                 val = HDA_COMPOSE_AMP_VAL(spec->adc_nids[0], 3, 0, HDA_INPUT);
1704         kcontrol->private_value = val;
1705         err = snd_hda_mixer_amp_volume_info(kcontrol, uinfo);
1706         mutex_unlock(&codec->control_mutex);
1707         return err;
1708 }
1709
1710 static int alc_cap_vol_tlv(struct snd_kcontrol *kcontrol, int op_flag,
1711                            unsigned int size, unsigned int __user *tlv)
1712 {
1713         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1714         struct alc_spec *spec = codec->spec;
1715         unsigned long val;
1716         int err;
1717
1718         mutex_lock(&codec->control_mutex);
1719         if (spec->vol_in_capsrc)
1720                 val = HDA_COMPOSE_AMP_VAL(spec->capsrc_nids[0], 3, 0, HDA_OUTPUT);
1721         else
1722                 val = HDA_COMPOSE_AMP_VAL(spec->adc_nids[0], 3, 0, HDA_INPUT);
1723         kcontrol->private_value = val;
1724         err = snd_hda_mixer_amp_tlv(kcontrol, op_flag, size, tlv);
1725         mutex_unlock(&codec->control_mutex);
1726         return err;
1727 }
1728
1729 typedef int (*getput_call_t)(struct snd_kcontrol *kcontrol,
1730                              struct snd_ctl_elem_value *ucontrol);
1731
1732 static int alc_cap_getput_caller(struct snd_kcontrol *kcontrol,
1733                                  struct snd_ctl_elem_value *ucontrol,
1734                                  getput_call_t func, bool check_adc_switch)
1735 {
1736         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1737         struct alc_spec *spec = codec->spec;
1738         int i, err = 0;
1739
1740         mutex_lock(&codec->control_mutex);
1741         if (check_adc_switch && spec->dyn_adc_switch) {
1742                 for (i = 0; i < spec->num_adc_nids; i++) {
1743                         kcontrol->private_value =
1744                                 HDA_COMPOSE_AMP_VAL(spec->adc_nids[i],
1745                                                     3, 0, HDA_INPUT);
1746                         err = func(kcontrol, ucontrol);
1747                         if (err < 0)
1748                                 goto error;
1749                 }
1750         } else {
1751                 i = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
1752                 if (spec->vol_in_capsrc)
1753                         kcontrol->private_value =
1754                                 HDA_COMPOSE_AMP_VAL(spec->capsrc_nids[i],
1755                                                     3, 0, HDA_OUTPUT);
1756                 else
1757                         kcontrol->private_value =
1758                                 HDA_COMPOSE_AMP_VAL(spec->adc_nids[i],
1759                                                     3, 0, HDA_INPUT);
1760                 err = func(kcontrol, ucontrol);
1761         }
1762  error:
1763         mutex_unlock(&codec->control_mutex);
1764         return err;
1765 }
1766
1767 static int alc_cap_vol_get(struct snd_kcontrol *kcontrol,
1768                            struct snd_ctl_elem_value *ucontrol)
1769 {
1770         return alc_cap_getput_caller(kcontrol, ucontrol,
1771                                      snd_hda_mixer_amp_volume_get, false);
1772 }
1773
1774 static int alc_cap_vol_put(struct snd_kcontrol *kcontrol,
1775                            struct snd_ctl_elem_value *ucontrol)
1776 {
1777         return alc_cap_getput_caller(kcontrol, ucontrol,
1778                                      snd_hda_mixer_amp_volume_put, true);
1779 }
1780
1781 /* capture mixer elements */
1782 #define alc_cap_sw_info         snd_ctl_boolean_stereo_info
1783
1784 static int alc_cap_sw_get(struct snd_kcontrol *kcontrol,
1785                           struct snd_ctl_elem_value *ucontrol)
1786 {
1787         return alc_cap_getput_caller(kcontrol, ucontrol,
1788                                      snd_hda_mixer_amp_switch_get, false);
1789 }
1790
1791 static int alc_cap_sw_put(struct snd_kcontrol *kcontrol,
1792                           struct snd_ctl_elem_value *ucontrol)
1793 {
1794         return alc_cap_getput_caller(kcontrol, ucontrol,
1795                                      snd_hda_mixer_amp_switch_put, true);
1796 }
1797
1798 #define _DEFINE_CAPMIX(num) \
1799         { \
1800                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
1801                 .name = "Capture Switch", \
1802                 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE, \
1803                 .count = num, \
1804                 .info = alc_cap_sw_info, \
1805                 .get = alc_cap_sw_get, \
1806                 .put = alc_cap_sw_put, \
1807         }, \
1808         { \
1809                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
1810                 .name = "Capture Volume", \
1811                 .access = (SNDRV_CTL_ELEM_ACCESS_READWRITE | \
1812                            SNDRV_CTL_ELEM_ACCESS_TLV_READ | \
1813                            SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK), \
1814                 .count = num, \
1815                 .info = alc_cap_vol_info, \
1816                 .get = alc_cap_vol_get, \
1817                 .put = alc_cap_vol_put, \
1818                 .tlv = { .c = alc_cap_vol_tlv }, \
1819         }
1820
1821 #define _DEFINE_CAPSRC(num) \
1822         { \
1823                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
1824                 /* .name = "Capture Source", */ \
1825                 .name = "Input Source", \
1826                 .count = num, \
1827                 .info = alc_mux_enum_info, \
1828                 .get = alc_mux_enum_get, \
1829                 .put = alc_mux_enum_put, \
1830         }
1831
1832 #define DEFINE_CAPMIX(num) \
1833 static const struct snd_kcontrol_new alc_capture_mixer ## num[] = { \
1834         _DEFINE_CAPMIX(num),                                  \
1835         _DEFINE_CAPSRC(num),                                  \
1836         { } /* end */                                         \
1837 }
1838
1839 #define DEFINE_CAPMIX_NOSRC(num) \
1840 static const struct snd_kcontrol_new alc_capture_mixer_nosrc ## num[] = { \
1841         _DEFINE_CAPMIX(num),                                        \
1842         { } /* end */                                               \
1843 }
1844
1845 /* up to three ADCs */
1846 DEFINE_CAPMIX(1);
1847 DEFINE_CAPMIX(2);
1848 DEFINE_CAPMIX(3);
1849 DEFINE_CAPMIX_NOSRC(1);
1850 DEFINE_CAPMIX_NOSRC(2);
1851 DEFINE_CAPMIX_NOSRC(3);
1852
1853 /*
1854  * virtual master controls
1855  */
1856
1857 /*
1858  * slave controls for virtual master
1859  */
1860 static const char * const alc_slave_vols[] = {
1861         "Front Playback Volume",
1862         "Surround Playback Volume",
1863         "Center Playback Volume",
1864         "LFE Playback Volume",
1865         "Side Playback Volume",
1866         "Headphone Playback Volume",
1867         "Speaker Playback Volume",
1868         "Mono Playback Volume",
1869         "Line-Out Playback Volume",
1870         "PCM Playback Volume",
1871         NULL,
1872 };
1873
1874 static const char * const alc_slave_sws[] = {
1875         "Front Playback Switch",
1876         "Surround Playback Switch",
1877         "Center Playback Switch",
1878         "LFE Playback Switch",
1879         "Side Playback Switch",
1880         "Headphone Playback Switch",
1881         "Speaker Playback Switch",
1882         "Mono Playback Switch",
1883         "IEC958 Playback Switch",
1884         "Line-Out Playback Switch",
1885         "PCM Playback Switch",
1886         NULL,
1887 };
1888
1889 /*
1890  * build control elements
1891  */
1892
1893 #define NID_MAPPING             (-1)
1894
1895 #define SUBDEV_SPEAKER_         (0 << 6)
1896 #define SUBDEV_HP_              (1 << 6)
1897 #define SUBDEV_LINE_            (2 << 6)
1898 #define SUBDEV_SPEAKER(x)       (SUBDEV_SPEAKER_ | ((x) & 0x3f))
1899 #define SUBDEV_HP(x)            (SUBDEV_HP_ | ((x) & 0x3f))
1900 #define SUBDEV_LINE(x)          (SUBDEV_LINE_ | ((x) & 0x3f))
1901
1902 static void alc_free_kctls(struct hda_codec *codec);
1903
1904 #ifdef CONFIG_SND_HDA_INPUT_BEEP
1905 /* additional beep mixers; the actual parameters are overwritten at build */
1906 static const struct snd_kcontrol_new alc_beep_mixer[] = {
1907         HDA_CODEC_VOLUME("Beep Playback Volume", 0, 0, HDA_INPUT),
1908         HDA_CODEC_MUTE_BEEP("Beep Playback Switch", 0, 0, HDA_INPUT),
1909         { } /* end */
1910 };
1911 #endif
1912
1913 static int alc_build_controls(struct hda_codec *codec)
1914 {
1915         struct alc_spec *spec = codec->spec;
1916         struct snd_kcontrol *kctl = NULL;
1917         const struct snd_kcontrol_new *knew;
1918         int i, j, err;
1919         unsigned int u;
1920         hda_nid_t nid;
1921
1922         for (i = 0; i < spec->num_mixers; i++) {
1923                 err = snd_hda_add_new_ctls(codec, spec->mixers[i]);
1924                 if (err < 0)
1925                         return err;
1926         }
1927         if (spec->cap_mixer) {
1928                 err = snd_hda_add_new_ctls(codec, spec->cap_mixer);
1929                 if (err < 0)
1930                         return err;
1931         }
1932         if (spec->multiout.dig_out_nid) {
1933                 err = snd_hda_create_spdif_out_ctls(codec,
1934                                                     spec->multiout.dig_out_nid,
1935                                                     spec->multiout.dig_out_nid);
1936                 if (err < 0)
1937                         return err;
1938                 if (!spec->no_analog) {
1939                         err = snd_hda_create_spdif_share_sw(codec,
1940                                                             &spec->multiout);
1941                         if (err < 0)
1942                                 return err;
1943                         spec->multiout.share_spdif = 1;
1944                 }
1945         }
1946         if (spec->dig_in_nid) {
1947                 err = snd_hda_create_spdif_in_ctls(codec, spec->dig_in_nid);
1948                 if (err < 0)
1949                         return err;
1950         }
1951
1952 #ifdef CONFIG_SND_HDA_INPUT_BEEP
1953         /* create beep controls if needed */
1954         if (spec->beep_amp) {
1955                 const struct snd_kcontrol_new *knew;
1956                 for (knew = alc_beep_mixer; knew->name; knew++) {
1957                         struct snd_kcontrol *kctl;
1958                         kctl = snd_ctl_new1(knew, codec);
1959                         if (!kctl)
1960                                 return -ENOMEM;
1961                         kctl->private_value = spec->beep_amp;
1962                         err = snd_hda_ctl_add(codec, 0, kctl);
1963                         if (err < 0)
1964                                 return err;
1965                 }
1966         }
1967 #endif
1968
1969         /* if we have no master control, let's create it */
1970         if (!spec->no_analog &&
1971             !snd_hda_find_mixer_ctl(codec, "Master Playback Volume")) {
1972                 unsigned int vmaster_tlv[4];
1973                 snd_hda_set_vmaster_tlv(codec, spec->vmaster_nid,
1974                                         HDA_OUTPUT, vmaster_tlv);
1975                 err = snd_hda_add_vmaster(codec, "Master Playback Volume",
1976                                           vmaster_tlv, alc_slave_vols);
1977                 if (err < 0)
1978                         return err;
1979         }
1980         if (!spec->no_analog &&
1981             !snd_hda_find_mixer_ctl(codec, "Master Playback Switch")) {
1982                 err = snd_hda_add_vmaster(codec, "Master Playback Switch",
1983                                           NULL, alc_slave_sws);
1984                 if (err < 0)
1985                         return err;
1986         }
1987
1988         /* assign Capture Source enums to NID */
1989         if (spec->capsrc_nids || spec->adc_nids) {
1990                 kctl = snd_hda_find_mixer_ctl(codec, "Capture Source");
1991                 if (!kctl)
1992                         kctl = snd_hda_find_mixer_ctl(codec, "Input Source");
1993                 for (i = 0; kctl && i < kctl->count; i++) {
1994                         err = snd_hda_add_nid(codec, kctl, i,
1995                                               get_capsrc(spec, i));
1996                         if (err < 0)
1997                                 return err;
1998                 }
1999         }
2000         if (spec->cap_mixer && spec->adc_nids) {
2001                 const char *kname = kctl ? kctl->id.name : NULL;
2002                 for (knew = spec->cap_mixer; knew->name; knew++) {
2003                         if (kname && strcmp(knew->name, kname) == 0)
2004                                 continue;
2005                         kctl = snd_hda_find_mixer_ctl(codec, knew->name);
2006                         for (i = 0; kctl && i < kctl->count; i++) {
2007                                 err = snd_hda_add_nid(codec, kctl, i,
2008                                                       spec->adc_nids[i]);
2009                                 if (err < 0)
2010                                         return err;
2011                         }
2012                 }
2013         }
2014
2015         /* other nid->control mapping */
2016         for (i = 0; i < spec->num_mixers; i++) {
2017                 for (knew = spec->mixers[i]; knew->name; knew++) {
2018                         if (knew->iface != NID_MAPPING)
2019                                 continue;
2020                         kctl = snd_hda_find_mixer_ctl(codec, knew->name);
2021                         if (kctl == NULL)
2022                                 continue;
2023                         u = knew->subdevice;
2024                         for (j = 0; j < 4; j++, u >>= 8) {
2025                                 nid = u & 0x3f;
2026                                 if (nid == 0)
2027                                         continue;
2028                                 switch (u & 0xc0) {
2029                                 case SUBDEV_SPEAKER_:
2030                                         nid = spec->autocfg.speaker_pins[nid];
2031                                         break;
2032                                 case SUBDEV_LINE_:
2033                                         nid = spec->autocfg.line_out_pins[nid];
2034                                         break;
2035                                 case SUBDEV_HP_:
2036                                         nid = spec->autocfg.hp_pins[nid];
2037                                         break;
2038                                 default:
2039                                         continue;
2040                                 }
2041                                 err = snd_hda_add_nid(codec, kctl, 0, nid);
2042                                 if (err < 0)
2043                                         return err;
2044                         }
2045                         u = knew->private_value;
2046                         for (j = 0; j < 4; j++, u >>= 8) {
2047                                 nid = u & 0xff;
2048                                 if (nid == 0)
2049                                         continue;
2050                                 err = snd_hda_add_nid(codec, kctl, 0, nid);
2051                                 if (err < 0)
2052                                         return err;
2053                         }
2054                 }
2055         }
2056
2057         alc_free_kctls(codec); /* no longer needed */
2058
2059         return 0;
2060 }
2061
2062
2063 /*
2064  * Common callbacks
2065  */
2066
2067 static void alc_init_special_input_src(struct hda_codec *codec);
2068 static int alc269_fill_coef(struct hda_codec *codec);
2069
2070 static int alc_init(struct hda_codec *codec)
2071 {
2072         struct alc_spec *spec = codec->spec;
2073         unsigned int i;
2074
2075         if (codec->vendor_id == 0x10ec0269)
2076                 alc269_fill_coef(codec);
2077
2078         alc_fix_pll(codec);
2079         alc_auto_init_amp(codec, spec->init_amp);
2080
2081         for (i = 0; i < spec->num_init_verbs; i++)
2082                 snd_hda_sequence_write(codec, spec->init_verbs[i]);
2083         alc_init_special_input_src(codec);
2084
2085         if (spec->init_hook)
2086                 spec->init_hook(codec);
2087
2088         alc_apply_fixup(codec, ALC_FIXUP_ACT_INIT);
2089
2090         hda_call_check_power_status(codec, 0x01);
2091         return 0;
2092 }
2093
2094 static void alc_unsol_event(struct hda_codec *codec, unsigned int res)
2095 {
2096         struct alc_spec *spec = codec->spec;
2097
2098         if (spec->unsol_event)
2099                 spec->unsol_event(codec, res);
2100 }
2101
2102 #ifdef CONFIG_SND_HDA_POWER_SAVE
2103 static int alc_check_power_status(struct hda_codec *codec, hda_nid_t nid)
2104 {
2105         struct alc_spec *spec = codec->spec;
2106         return snd_hda_check_amp_list_power(codec, &spec->loopback, nid);
2107 }
2108 #endif
2109
2110 /*
2111  * Analog playback callbacks
2112  */
2113 static int alc_playback_pcm_open(struct hda_pcm_stream *hinfo,
2114                                     struct hda_codec *codec,
2115                                     struct snd_pcm_substream *substream)
2116 {
2117         struct alc_spec *spec = codec->spec;
2118         return snd_hda_multi_out_analog_open(codec, &spec->multiout, substream,
2119                                              hinfo);
2120 }
2121
2122 static int alc_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
2123                                        struct hda_codec *codec,
2124                                        unsigned int stream_tag,
2125                                        unsigned int format,
2126                                        struct snd_pcm_substream *substream)
2127 {
2128         struct alc_spec *spec = codec->spec;
2129         return snd_hda_multi_out_analog_prepare(codec, &spec->multiout,
2130                                                 stream_tag, format, substream);
2131 }
2132
2133 static int alc_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
2134                                        struct hda_codec *codec,
2135                                        struct snd_pcm_substream *substream)
2136 {
2137         struct alc_spec *spec = codec->spec;
2138         return snd_hda_multi_out_analog_cleanup(codec, &spec->multiout);
2139 }
2140
2141 /*
2142  * Digital out
2143  */
2144 static int alc_dig_playback_pcm_open(struct hda_pcm_stream *hinfo,
2145                                         struct hda_codec *codec,
2146                                         struct snd_pcm_substream *substream)
2147 {
2148         struct alc_spec *spec = codec->spec;
2149         return snd_hda_multi_out_dig_open(codec, &spec->multiout);
2150 }
2151
2152 static int alc_dig_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
2153                                            struct hda_codec *codec,
2154                                            unsigned int stream_tag,
2155                                            unsigned int format,
2156                                            struct snd_pcm_substream *substream)
2157 {
2158         struct alc_spec *spec = codec->spec;
2159         return snd_hda_multi_out_dig_prepare(codec, &spec->multiout,
2160                                              stream_tag, format, substream);
2161 }
2162
2163 static int alc_dig_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
2164                                            struct hda_codec *codec,
2165                                            struct snd_pcm_substream *substream)
2166 {
2167         struct alc_spec *spec = codec->spec;
2168         return snd_hda_multi_out_dig_cleanup(codec, &spec->multiout);
2169 }
2170
2171 static int alc_dig_playback_pcm_close(struct hda_pcm_stream *hinfo,
2172                                          struct hda_codec *codec,
2173                                          struct snd_pcm_substream *substream)
2174 {
2175         struct alc_spec *spec = codec->spec;
2176         return snd_hda_multi_out_dig_close(codec, &spec->multiout);
2177 }
2178
2179 /*
2180  * Analog capture
2181  */
2182 static int alc_alt_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
2183                                       struct hda_codec *codec,
2184                                       unsigned int stream_tag,
2185                                       unsigned int format,
2186                                       struct snd_pcm_substream *substream)
2187 {
2188         struct alc_spec *spec = codec->spec;
2189
2190         snd_hda_codec_setup_stream(codec, spec->adc_nids[substream->number + 1],
2191                                    stream_tag, 0, format);
2192         return 0;
2193 }
2194
2195 static int alc_alt_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
2196                                       struct hda_codec *codec,
2197                                       struct snd_pcm_substream *substream)
2198 {
2199         struct alc_spec *spec = codec->spec;
2200
2201         snd_hda_codec_cleanup_stream(codec,
2202                                      spec->adc_nids[substream->number + 1]);
2203         return 0;
2204 }
2205
2206 /* analog capture with dynamic dual-adc changes */
2207 static int dyn_adc_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
2208                                        struct hda_codec *codec,
2209                                        unsigned int stream_tag,
2210                                        unsigned int format,
2211                                        struct snd_pcm_substream *substream)
2212 {
2213         struct alc_spec *spec = codec->spec;
2214         spec->cur_adc = spec->adc_nids[spec->dyn_adc_idx[spec->cur_mux[0]]];
2215         spec->cur_adc_stream_tag = stream_tag;
2216         spec->cur_adc_format = format;
2217         snd_hda_codec_setup_stream(codec, spec->cur_adc, stream_tag, 0, format);
2218         return 0;
2219 }
2220
2221 static int dyn_adc_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
2222                                        struct hda_codec *codec,
2223                                        struct snd_pcm_substream *substream)
2224 {
2225         struct alc_spec *spec = codec->spec;
2226         snd_hda_codec_cleanup_stream(codec, spec->cur_adc);
2227         spec->cur_adc = 0;
2228         return 0;
2229 }
2230
2231 static const struct hda_pcm_stream dyn_adc_pcm_analog_capture = {
2232         .substreams = 1,
2233         .channels_min = 2,
2234         .channels_max = 2,
2235         .nid = 0, /* fill later */
2236         .ops = {
2237                 .prepare = dyn_adc_capture_pcm_prepare,
2238                 .cleanup = dyn_adc_capture_pcm_cleanup
2239         },
2240 };
2241
2242 /*
2243  */
2244 static const struct hda_pcm_stream alc_pcm_analog_playback = {
2245         .substreams = 1,
2246         .channels_min = 2,
2247         .channels_max = 8,
2248         /* NID is set in alc_build_pcms */
2249         .ops = {
2250                 .open = alc_playback_pcm_open,
2251                 .prepare = alc_playback_pcm_prepare,
2252                 .cleanup = alc_playback_pcm_cleanup
2253         },
2254 };
2255
2256 static const struct hda_pcm_stream alc_pcm_analog_capture = {
2257         .substreams = 1,
2258         .channels_min = 2,
2259         .channels_max = 2,
2260         /* NID is set in alc_build_pcms */
2261 };
2262
2263 static const struct hda_pcm_stream alc_pcm_analog_alt_playback = {
2264         .substreams = 1,
2265         .channels_min = 2,
2266         .channels_max = 2,
2267         /* NID is set in alc_build_pcms */
2268 };
2269
2270 static const struct hda_pcm_stream alc_pcm_analog_alt_capture = {
2271         .substreams = 2, /* can be overridden */
2272         .channels_min = 2,
2273         .channels_max = 2,
2274         /* NID is set in alc_build_pcms */
2275         .ops = {
2276                 .prepare = alc_alt_capture_pcm_prepare,
2277                 .cleanup = alc_alt_capture_pcm_cleanup
2278         },
2279 };
2280
2281 static const struct hda_pcm_stream alc_pcm_digital_playback = {
2282         .substreams = 1,
2283         .channels_min = 2,
2284         .channels_max = 2,
2285         /* NID is set in alc_build_pcms */
2286         .ops = {
2287                 .open = alc_dig_playback_pcm_open,
2288                 .close = alc_dig_playback_pcm_close,
2289                 .prepare = alc_dig_playback_pcm_prepare,
2290                 .cleanup = alc_dig_playback_pcm_cleanup
2291         },
2292 };
2293
2294 static const struct hda_pcm_stream alc_pcm_digital_capture = {
2295         .substreams = 1,
2296         .channels_min = 2,
2297         .channels_max = 2,
2298         /* NID is set in alc_build_pcms */
2299 };
2300
2301 /* Used by alc_build_pcms to flag that a PCM has no playback stream */
2302 static const struct hda_pcm_stream alc_pcm_null_stream = {
2303         .substreams = 0,
2304         .channels_min = 0,
2305         .channels_max = 0,
2306 };
2307
2308 static int alc_build_pcms(struct hda_codec *codec)
2309 {
2310         struct alc_spec *spec = codec->spec;
2311         struct hda_pcm *info = spec->pcm_rec;
2312         const struct hda_pcm_stream *p;
2313         bool have_multi_adcs;
2314         int i;
2315
2316         codec->num_pcms = 1;
2317         codec->pcm_info = info;
2318
2319         if (spec->no_analog)
2320                 goto skip_analog;
2321
2322         snprintf(spec->stream_name_analog, sizeof(spec->stream_name_analog),
2323                  "%s Analog", codec->chip_name);
2324         info->name = spec->stream_name_analog;
2325
2326         if (spec->multiout.dac_nids > 0) {
2327                 p = spec->stream_analog_playback;
2328                 if (!p)
2329                         p = &alc_pcm_analog_playback;
2330                 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *p;
2331                 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dac_nids[0];
2332         }
2333         if (spec->adc_nids) {
2334                 p = spec->stream_analog_capture;
2335                 if (!p) {
2336                         if (spec->dyn_adc_switch)
2337                                 p = &dyn_adc_pcm_analog_capture;
2338                         else
2339                                 p = &alc_pcm_analog_capture;
2340                 }
2341                 info->stream[SNDRV_PCM_STREAM_CAPTURE] = *p;
2342                 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adc_nids[0];
2343         }
2344
2345         if (spec->channel_mode) {
2346                 info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max = 0;
2347                 for (i = 0; i < spec->num_channel_mode; i++) {
2348                         if (spec->channel_mode[i].channels > info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max) {
2349                                 info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max = spec->channel_mode[i].channels;
2350                         }
2351                 }
2352         }
2353
2354  skip_analog:
2355         /* SPDIF for stream index #1 */
2356         if (spec->multiout.dig_out_nid || spec->dig_in_nid) {
2357                 snprintf(spec->stream_name_digital,
2358                          sizeof(spec->stream_name_digital),
2359                          "%s Digital", codec->chip_name);
2360                 codec->num_pcms = 2;
2361                 codec->slave_dig_outs = spec->multiout.slave_dig_outs;
2362                 info = spec->pcm_rec + 1;
2363                 info->name = spec->stream_name_digital;
2364                 if (spec->dig_out_type)
2365                         info->pcm_type = spec->dig_out_type;
2366                 else
2367                         info->pcm_type = HDA_PCM_TYPE_SPDIF;
2368                 if (spec->multiout.dig_out_nid) {
2369                         p = spec->stream_digital_playback;
2370                         if (!p)
2371                                 p = &alc_pcm_digital_playback;
2372                         info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *p;
2373                         info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dig_out_nid;
2374                 }
2375                 if (spec->dig_in_nid) {
2376                         p = spec->stream_digital_capture;
2377                         if (!p)
2378                                 p = &alc_pcm_digital_capture;
2379                         info->stream[SNDRV_PCM_STREAM_CAPTURE] = *p;
2380                         info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->dig_in_nid;
2381                 }
2382                 /* FIXME: do we need this for all Realtek codec models? */
2383                 codec->spdif_status_reset = 1;
2384         }
2385
2386         if (spec->no_analog)
2387                 return 0;
2388
2389         /* If the use of more than one ADC is requested for the current
2390          * model, configure a second analog capture-only PCM.
2391          */
2392         have_multi_adcs = (spec->num_adc_nids > 1) &&
2393                 !spec->dyn_adc_switch && !spec->auto_mic &&
2394                 (!spec->input_mux || spec->input_mux->num_items > 1);
2395         /* Additional Analaog capture for index #2 */
2396         if (spec->alt_dac_nid || have_multi_adcs) {
2397                 codec->num_pcms = 3;
2398                 info = spec->pcm_rec + 2;
2399                 info->name = spec->stream_name_analog;
2400                 if (spec->alt_dac_nid) {
2401                         p = spec->stream_analog_alt_playback;
2402                         if (!p)
2403                                 p = &alc_pcm_analog_alt_playback;
2404                         info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *p;
2405                         info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid =
2406                                 spec->alt_dac_nid;
2407                 } else {
2408                         info->stream[SNDRV_PCM_STREAM_PLAYBACK] =
2409                                 alc_pcm_null_stream;
2410                         info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = 0;
2411                 }
2412                 if (have_multi_adcs) {
2413                         p = spec->stream_analog_alt_capture;
2414                         if (!p)
2415                                 p = &alc_pcm_analog_alt_capture;
2416                         info->stream[SNDRV_PCM_STREAM_CAPTURE] = *p;
2417                         info->stream[SNDRV_PCM_STREAM_CAPTURE].nid =
2418                                 spec->adc_nids[1];
2419                         info->stream[SNDRV_PCM_STREAM_CAPTURE].substreams =
2420                                 spec->num_adc_nids - 1;
2421                 } else {
2422                         info->stream[SNDRV_PCM_STREAM_CAPTURE] =
2423                                 alc_pcm_null_stream;
2424                         info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = 0;
2425                 }
2426         }
2427
2428         return 0;
2429 }
2430
2431 static inline void alc_shutup(struct hda_codec *codec)
2432 {
2433         struct alc_spec *spec = codec->spec;
2434
2435         if (spec && spec->shutup)
2436                 spec->shutup(codec);
2437         snd_hda_shutup_pins(codec);
2438 }
2439
2440 static void alc_free_kctls(struct hda_codec *codec)
2441 {
2442         struct alc_spec *spec = codec->spec;
2443
2444         if (spec->kctls.list) {
2445                 struct snd_kcontrol_new *kctl = spec->kctls.list;
2446                 int i;
2447                 for (i = 0; i < spec->kctls.used; i++)
2448                         kfree(kctl[i].name);
2449         }
2450         snd_array_free(&spec->kctls);
2451 }
2452
2453 static void alc_free_bind_ctls(struct hda_codec *codec)
2454 {
2455         struct alc_spec *spec = codec->spec;
2456         if (spec->bind_ctls.list) {
2457                 struct hda_bind_ctls **ctl = spec->bind_ctls.list;
2458                 int i;
2459                 for (i = 0; i < spec->bind_ctls.used; i++)
2460                         kfree(ctl[i]);
2461         }
2462         snd_array_free(&spec->bind_ctls);
2463 }
2464
2465 static void alc_free(struct hda_codec *codec)
2466 {
2467         struct alc_spec *spec = codec->spec;
2468
2469         if (!spec)
2470                 return;
2471
2472         alc_shutup(codec);
2473         snd_hda_input_jack_free(codec);
2474         alc_free_kctls(codec);
2475         alc_free_bind_ctls(codec);
2476         kfree(spec);
2477         snd_hda_detach_beep_device(codec);
2478 }
2479
2480 #ifdef CONFIG_SND_HDA_POWER_SAVE
2481 static void alc_power_eapd(struct hda_codec *codec)
2482 {
2483         alc_auto_setup_eapd(codec, false);
2484 }
2485
2486 static int alc_suspend(struct hda_codec *codec, pm_message_t state)
2487 {
2488         struct alc_spec *spec = codec->spec;
2489         alc_shutup(codec);
2490         if (spec && spec->power_hook)
2491                 spec->power_hook(codec);
2492         return 0;
2493 }
2494 #endif
2495
2496 #ifdef CONFIG_PM
2497 static int alc_resume(struct hda_codec *codec)
2498 {
2499         msleep(150); /* to avoid pop noise */
2500         codec->patch_ops.init(codec);
2501         snd_hda_codec_resume_amp(codec);
2502         snd_hda_codec_resume_cache(codec);
2503         hda_call_check_power_status(codec, 0x01);
2504         return 0;
2505 }
2506 #endif
2507
2508 /*
2509  */
2510 static const struct hda_codec_ops alc_patch_ops = {
2511         .build_controls = alc_build_controls,
2512         .build_pcms = alc_build_pcms,
2513         .init = alc_init,
2514         .free = alc_free,
2515         .unsol_event = alc_unsol_event,
2516 #ifdef CONFIG_PM
2517         .resume = alc_resume,
2518 #endif
2519 #ifdef CONFIG_SND_HDA_POWER_SAVE
2520         .suspend = alc_suspend,
2521         .check_power_status = alc_check_power_status,
2522 #endif
2523         .reboot_notify = alc_shutup,
2524 };
2525
2526 /* replace the codec chip_name with the given string */
2527 static int alc_codec_rename(struct hda_codec *codec, const char *name)
2528 {
2529         kfree(codec->chip_name);
2530         codec->chip_name = kstrdup(name, GFP_KERNEL);
2531         if (!codec->chip_name) {
2532                 alc_free(codec);
2533                 return -ENOMEM;
2534         }
2535         return 0;
2536 }
2537
2538 /*
2539  * Rename codecs appropriately from COEF value
2540  */
2541 struct alc_codec_rename_table {
2542         unsigned int vendor_id;
2543         unsigned short coef_mask;
2544         unsigned short coef_bits;
2545         const char *name;
2546 };
2547
2548 static struct alc_codec_rename_table rename_tbl[] = {
2549         { 0x10ec0269, 0xfff0, 0x3010, "ALC277" },
2550         { 0x10ec0269, 0xf0f0, 0x2010, "ALC259" },
2551         { 0x10ec0269, 0xf0f0, 0x3010, "ALC258" },
2552         { 0x10ec0269, 0x00f0, 0x0010, "ALC269VB" },
2553         { 0x10ec0269, 0xffff, 0xa023, "ALC259" },
2554         { 0x10ec0269, 0xffff, 0x6023, "ALC281X" },
2555         { 0x10ec0269, 0x00f0, 0x0020, "ALC269VC" },
2556         { 0x10ec0887, 0x00f0, 0x0030, "ALC887-VD" },
2557         { 0x10ec0888, 0x00f0, 0x0030, "ALC888-VD" },
2558         { 0x10ec0888, 0xf0f0, 0x3020, "ALC886" },
2559         { 0x10ec0899, 0x2000, 0x2000, "ALC899" },
2560         { 0x10ec0892, 0xffff, 0x8020, "ALC661" },
2561         { 0x10ec0892, 0xffff, 0x8011, "ALC661" },
2562         { 0x10ec0892, 0xffff, 0x4011, "ALC656" },
2563         { } /* terminator */
2564 };
2565
2566 static int alc_codec_rename_from_preset(struct hda_codec *codec)
2567 {
2568         const struct alc_codec_rename_table *p;
2569
2570         for (p = rename_tbl; p->vendor_id; p++) {
2571                 if (p->vendor_id != codec->vendor_id)
2572                         continue;
2573                 if ((alc_get_coef0(codec) & p->coef_mask) == p->coef_bits)
2574                         return alc_codec_rename(codec, p->name);
2575         }
2576         return 0;
2577 }
2578
2579 /*
2580  * Automatic parse of I/O pins from the BIOS configuration
2581  */
2582
2583 enum {
2584         ALC_CTL_WIDGET_VOL,
2585         ALC_CTL_WIDGET_MUTE,
2586         ALC_CTL_BIND_MUTE,
2587         ALC_CTL_BIND_VOL,
2588         ALC_CTL_BIND_SW,
2589 };
2590 static const struct snd_kcontrol_new alc_control_templates[] = {
2591         HDA_CODEC_VOLUME(NULL, 0, 0, 0),
2592         HDA_CODEC_MUTE(NULL, 0, 0, 0),
2593         HDA_BIND_MUTE(NULL, 0, 0, 0),
2594         HDA_BIND_VOL(NULL, 0),
2595         HDA_BIND_SW(NULL, 0),
2596 };
2597
2598 /* add dynamic controls */
2599 static int add_control(struct alc_spec *spec, int type, const char *name,
2600                        int cidx, unsigned long val)
2601 {
2602         struct snd_kcontrol_new *knew;
2603
2604         knew = alc_kcontrol_new(spec);
2605         if (!knew)
2606                 return -ENOMEM;
2607         *knew = alc_control_templates[type];
2608         knew->name = kstrdup(name, GFP_KERNEL);
2609         if (!knew->name)
2610                 return -ENOMEM;
2611         knew->index = cidx;
2612         if (get_amp_nid_(val))
2613                 knew->subdevice = HDA_SUBDEV_AMP_FLAG;
2614         knew->private_value = val;
2615         return 0;
2616 }
2617
2618 static int add_control_with_pfx(struct alc_spec *spec, int type,
2619                                 const char *pfx, const char *dir,
2620                                 const char *sfx, int cidx, unsigned long val)
2621 {
2622         char name[32];
2623         snprintf(name, sizeof(name), "%s %s %s", pfx, dir, sfx);
2624         return add_control(spec, type, name, cidx, val);
2625 }
2626
2627 #define add_pb_vol_ctrl(spec, type, pfx, val)                   \
2628         add_control_with_pfx(spec, type, pfx, "Playback", "Volume", 0, val)
2629 #define add_pb_sw_ctrl(spec, type, pfx, val)                    \
2630         add_control_with_pfx(spec, type, pfx, "Playback", "Switch", 0, val)
2631 #define __add_pb_vol_ctrl(spec, type, pfx, cidx, val)                   \
2632         add_control_with_pfx(spec, type, pfx, "Playback", "Volume", cidx, val)
2633 #define __add_pb_sw_ctrl(spec, type, pfx, cidx, val)                    \
2634         add_control_with_pfx(spec, type, pfx, "Playback", "Switch", cidx, val)
2635
2636 static const char * const channel_name[4] = {
2637         "Front", "Surround", "CLFE", "Side"
2638 };
2639
2640 static const char *alc_get_line_out_pfx(struct alc_spec *spec, int ch,
2641                                         bool can_be_master, int *index)
2642 {
2643         struct auto_pin_cfg *cfg = &spec->autocfg;
2644
2645         *index = 0;
2646         if (cfg->line_outs == 1 && !spec->multi_ios &&
2647             !cfg->hp_outs && !cfg->speaker_outs && can_be_master)
2648                 return "Master";
2649
2650         switch (cfg->line_out_type) {
2651         case AUTO_PIN_SPEAKER_OUT:
2652                 if (cfg->line_outs == 1)
2653                         return "Speaker";
2654                 if (cfg->line_outs == 2)
2655                         return ch ? "Bass Speaker" : "Speaker";
2656                 break;
2657         case AUTO_PIN_HP_OUT:
2658                 /* for multi-io case, only the primary out */
2659                 if (ch && spec->multi_ios)
2660                         break;
2661                 *index = ch;
2662                 return "Headphone";
2663         default:
2664                 if (cfg->line_outs == 1 && !spec->multi_ios)
2665                         return "PCM";
2666                 break;
2667         }
2668         if (snd_BUG_ON(ch >= ARRAY_SIZE(channel_name)))
2669                 return "PCM";
2670
2671         return channel_name[ch];
2672 }
2673
2674 /* create input playback/capture controls for the given pin */
2675 static int new_analog_input(struct alc_spec *spec, hda_nid_t pin,
2676                             const char *ctlname, int ctlidx,
2677                             int idx, hda_nid_t mix_nid)
2678 {
2679         int err;
2680
2681         err = __add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, ctlname, ctlidx,
2682                           HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT));
2683         if (err < 0)
2684                 return err;
2685         err = __add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, ctlname, ctlidx,
2686                           HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT));
2687         if (err < 0)
2688                 return err;
2689         return 0;
2690 }
2691
2692 static int alc_is_input_pin(struct hda_codec *codec, hda_nid_t nid)
2693 {
2694         unsigned int pincap = snd_hda_query_pin_caps(codec, nid);
2695         return (pincap & AC_PINCAP_IN) != 0;
2696 }
2697
2698 /* Parse the codec tree and retrieve ADCs and corresponding capsrc MUXs */
2699 static int alc_auto_fill_adc_caps(struct hda_codec *codec)
2700 {
2701         struct alc_spec *spec = codec->spec;
2702         hda_nid_t nid;
2703         hda_nid_t *adc_nids = spec->private_adc_nids;
2704         hda_nid_t *cap_nids = spec->private_capsrc_nids;
2705         int max_nums = ARRAY_SIZE(spec->private_adc_nids);
2706         int i, nums = 0;
2707
2708         nid = codec->start_nid;
2709         for (i = 0; i < codec->num_nodes; i++, nid++) {
2710                 hda_nid_t src;
2711                 const hda_nid_t *list;
2712                 unsigned int caps = get_wcaps(codec, nid);
2713                 int type = get_wcaps_type(caps);
2714
2715                 if (type != AC_WID_AUD_IN || (caps & AC_WCAP_DIGITAL))
2716                         continue;
2717                 adc_nids[nums] = nid;
2718                 cap_nids[nums] = nid;
2719                 src = nid;
2720                 for (;;) {
2721                         int n;
2722                         type = get_wcaps_type(get_wcaps(codec, src));
2723                         if (type == AC_WID_PIN)
2724                                 break;
2725                         if (type == AC_WID_AUD_SEL) {
2726                                 cap_nids[nums] = src;
2727                                 break;
2728                         }
2729                         n = snd_hda_get_conn_list(codec, src, &list);
2730                         if (n > 1) {
2731                                 cap_nids[nums] = src;
2732                                 break;
2733                         } else if (n != 1)
2734                                 break;
2735                         src = *list;
2736                 }
2737                 if (++nums >= max_nums)
2738                         break;
2739         }
2740         spec->adc_nids = spec->private_adc_nids;
2741         spec->capsrc_nids = spec->private_capsrc_nids;
2742         spec->num_adc_nids = nums;
2743         return nums;
2744 }
2745
2746 /* create playback/capture controls for input pins */
2747 static int alc_auto_create_input_ctls(struct hda_codec *codec)
2748 {
2749         struct alc_spec *spec = codec->spec;
2750         const struct auto_pin_cfg *cfg = &spec->autocfg;
2751         hda_nid_t mixer = spec->mixer_nid;
2752         struct hda_input_mux *imux = &spec->private_imux[0];
2753         int num_adcs;
2754         int i, c, err, idx, type_idx = 0;
2755         const char *prev_label = NULL;
2756
2757         num_adcs = alc_auto_fill_adc_caps(codec);
2758         if (num_adcs < 0)
2759                 return 0;
2760
2761         for (i = 0; i < cfg->num_inputs; i++) {
2762                 hda_nid_t pin;
2763                 const char *label;
2764
2765                 pin = cfg->inputs[i].pin;
2766                 if (!alc_is_input_pin(codec, pin))
2767                         continue;
2768
2769                 label = hda_get_autocfg_input_label(codec, cfg, i);
2770                 if (prev_label && !strcmp(label, prev_label))
2771                         type_idx++;
2772                 else
2773                         type_idx = 0;
2774                 prev_label = label;
2775
2776                 if (mixer) {
2777                         idx = get_connection_index(codec, mixer, pin);
2778                         if (idx >= 0) {
2779                                 err = new_analog_input(spec, pin,
2780                                                        label, type_idx,
2781                                                        idx, mixer);
2782                                 if (err < 0)
2783                                         return err;
2784                         }
2785                 }
2786
2787                 for (c = 0; c < num_adcs; c++) {
2788                         hda_nid_t cap = get_capsrc(spec, c);
2789                         idx = get_connection_index(codec, cap, pin);
2790                         if (idx >= 0) {
2791                                 spec->imux_pins[imux->num_items] = pin;
2792                                 snd_hda_add_imux_item(imux, label, idx, NULL);
2793                                 break;
2794                         }
2795                 }
2796         }
2797
2798         spec->num_mux_defs = 1;
2799         spec->input_mux = imux;
2800
2801         return 0;
2802 }
2803
2804 static void alc_set_pin_output(struct hda_codec *codec, hda_nid_t nid,
2805                                unsigned int pin_type)
2806 {
2807         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
2808                             pin_type);
2809         /* unmute pin */
2810         if (nid_has_mute(codec, nid, HDA_OUTPUT))
2811                 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE,
2812                             AMP_OUT_UNMUTE);
2813 }
2814
2815 static int get_pin_type(int line_out_type)
2816 {
2817         if (line_out_type == AUTO_PIN_HP_OUT)
2818                 return PIN_HP;
2819         else
2820                 return PIN_OUT;
2821 }
2822
2823 static void alc_auto_init_analog_input(struct hda_codec *codec)
2824 {
2825         struct alc_spec *spec = codec->spec;
2826         struct auto_pin_cfg *cfg = &spec->autocfg;
2827         int i;
2828
2829         for (i = 0; i < cfg->num_inputs; i++) {
2830                 hda_nid_t nid = cfg->inputs[i].pin;
2831                 if (alc_is_input_pin(codec, nid)) {
2832                         alc_set_input_pin(codec, nid, cfg->inputs[i].type);
2833                         if (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP)
2834                                 snd_hda_codec_write(codec, nid, 0,
2835                                                     AC_VERB_SET_AMP_GAIN_MUTE,
2836                                                     AMP_OUT_MUTE);
2837                 }
2838         }
2839
2840         /* mute all loopback inputs */
2841         if (spec->mixer_nid) {
2842                 int nums = snd_hda_get_conn_list(codec, spec->mixer_nid, NULL);
2843                 for (i = 0; i < nums; i++)
2844                         snd_hda_codec_write(codec, spec->mixer_nid, 0,
2845                                             AC_VERB_SET_AMP_GAIN_MUTE,
2846                                             AMP_IN_MUTE(i));
2847         }
2848 }
2849
2850 /* convert from MIX nid to DAC */
2851 static hda_nid_t alc_auto_mix_to_dac(struct hda_codec *codec, hda_nid_t nid)
2852 {
2853         hda_nid_t list[5];
2854         int i, num;
2855
2856         if (get_wcaps_type(get_wcaps(codec, nid)) == AC_WID_AUD_OUT)
2857                 return nid;
2858         num = snd_hda_get_connections(codec, nid, list, ARRAY_SIZE(list));
2859         for (i = 0; i < num; i++) {
2860                 if (get_wcaps_type(get_wcaps(codec, list[i])) == AC_WID_AUD_OUT)
2861                         return list[i];
2862         }
2863         return 0;
2864 }
2865
2866 /* go down to the selector widget before the mixer */
2867 static hda_nid_t alc_go_down_to_selector(struct hda_codec *codec, hda_nid_t pin)
2868 {
2869         hda_nid_t srcs[5];
2870         int num = snd_hda_get_connections(codec, pin, srcs,
2871                                           ARRAY_SIZE(srcs));
2872         if (num != 1 ||
2873             get_wcaps_type(get_wcaps(codec, srcs[0])) != AC_WID_AUD_SEL)
2874                 return pin;
2875         return srcs[0];
2876 }
2877
2878 /* get MIX nid connected to the given pin targeted to DAC */
2879 static hda_nid_t alc_auto_dac_to_mix(struct hda_codec *codec, hda_nid_t pin,
2880                                    hda_nid_t dac)
2881 {
2882         hda_nid_t mix[5];
2883         int i, num;
2884
2885         pin = alc_go_down_to_selector(codec, pin);
2886         num = snd_hda_get_connections(codec, pin, mix, ARRAY_SIZE(mix));
2887         for (i = 0; i < num; i++) {
2888                 if (alc_auto_mix_to_dac(codec, mix[i]) == dac)
2889                         return mix[i];
2890         }
2891         return 0;
2892 }
2893
2894 /* select the connection from pin to DAC if needed */
2895 static int alc_auto_select_dac(struct hda_codec *codec, hda_nid_t pin,
2896                                hda_nid_t dac)
2897 {
2898         hda_nid_t mix[5];
2899         int i, num;
2900
2901         pin = alc_go_down_to_selector(codec, pin);
2902         num = snd_hda_get_connections(codec, pin, mix, ARRAY_SIZE(mix));
2903         if (num < 2)
2904                 return 0;
2905         for (i = 0; i < num; i++) {
2906                 if (alc_auto_mix_to_dac(codec, mix[i]) == dac) {
2907                         snd_hda_codec_update_cache(codec, pin, 0,
2908                                                    AC_VERB_SET_CONNECT_SEL, i);
2909                         return 0;
2910                 }
2911         }
2912         return 0;
2913 }
2914
2915 /* look for an empty DAC slot */
2916 static hda_nid_t alc_auto_look_for_dac(struct hda_codec *codec, hda_nid_t pin)
2917 {
2918         struct alc_spec *spec = codec->spec;
2919         hda_nid_t srcs[5];
2920         int i, num;
2921
2922         pin = alc_go_down_to_selector(codec, pin);
2923         num = snd_hda_get_connections(codec, pin, srcs, ARRAY_SIZE(srcs));
2924         for (i = 0; i < num; i++) {
2925                 hda_nid_t nid = alc_auto_mix_to_dac(codec, srcs[i]);
2926                 if (!nid)
2927                         continue;
2928                 if (found_in_nid_list(nid, spec->multiout.dac_nids,
2929                                       ARRAY_SIZE(spec->private_dac_nids)))
2930                         continue;
2931                 if (found_in_nid_list(nid, spec->multiout.hp_out_nid,
2932                                       ARRAY_SIZE(spec->multiout.hp_out_nid)))
2933                     continue;
2934                 if (found_in_nid_list(nid, spec->multiout.extra_out_nid,
2935                                       ARRAY_SIZE(spec->multiout.extra_out_nid)))
2936                     continue;
2937                 return nid;
2938         }
2939         return 0;
2940 }
2941
2942 static hda_nid_t get_dac_if_single(struct hda_codec *codec, hda_nid_t pin)
2943 {
2944         hda_nid_t sel = alc_go_down_to_selector(codec, pin);
2945         if (snd_hda_get_conn_list(codec, sel, NULL) == 1)
2946                 return alc_auto_look_for_dac(codec, pin);
2947         return 0;
2948 }
2949
2950 /* return 0 if no possible DAC is found, 1 if one or more found */
2951 static int alc_auto_fill_extra_dacs(struct hda_codec *codec, int num_outs,
2952                                     const hda_nid_t *pins, hda_nid_t *dacs)
2953 {
2954         int i;
2955
2956         if (num_outs && !dacs[0]) {
2957                 dacs[0] = alc_auto_look_for_dac(codec, pins[0]);
2958                 if (!dacs[0])
2959                         return 0;
2960         }
2961
2962         for (i = 1; i < num_outs; i++)
2963                 dacs[i] = get_dac_if_single(codec, pins[i]);
2964         for (i = 1; i < num_outs; i++) {
2965                 if (!dacs[i])
2966                         dacs[i] = alc_auto_look_for_dac(codec, pins[i]);
2967         }
2968         return 1;
2969 }
2970
2971 static int alc_auto_fill_multi_ios(struct hda_codec *codec,
2972                                    unsigned int location);
2973
2974 /* fill in the dac_nids table from the parsed pin configuration */
2975 static int alc_auto_fill_dac_nids(struct hda_codec *codec)
2976 {
2977         struct alc_spec *spec = codec->spec;
2978         struct auto_pin_cfg *cfg = &spec->autocfg;
2979         bool redone = false;
2980         int i;
2981
2982  again:
2983         /* set num_dacs once to full for alc_auto_look_for_dac() */
2984         spec->multiout.num_dacs = cfg->line_outs;
2985         spec->multiout.hp_out_nid[0] = 0;
2986         spec->multiout.extra_out_nid[0] = 0;
2987         memset(spec->private_dac_nids, 0, sizeof(spec->private_dac_nids));
2988         spec->multiout.dac_nids = spec->private_dac_nids;
2989         spec->multi_ios = 0;
2990
2991         /* fill hard-wired DACs first */
2992         if (!redone) {
2993                 for (i = 0; i < cfg->line_outs; i++)
2994                         spec->private_dac_nids[i] =
2995                                 get_dac_if_single(codec, cfg->line_out_pins[i]);
2996                 if (cfg->hp_outs)
2997                         spec->multiout.hp_out_nid[0] =
2998                                 get_dac_if_single(codec, cfg->hp_pins[0]);
2999                 if (cfg->speaker_outs)
3000                         spec->multiout.extra_out_nid[0] =
3001                                 get_dac_if_single(codec, cfg->speaker_pins[0]);
3002         }
3003
3004         for (i = 0; i < cfg->line_outs; i++) {
3005                 hda_nid_t pin = cfg->line_out_pins[i];
3006                 if (spec->private_dac_nids[i])
3007                         continue;
3008                 spec->private_dac_nids[i] = alc_auto_look_for_dac(codec, pin);
3009                 if (!spec->private_dac_nids[i] && !redone) {
3010                         /* if we can't find primary DACs, re-probe without
3011                          * checking the hard-wired DACs
3012                          */
3013                         redone = true;
3014                         goto again;
3015                 }
3016         }
3017
3018         /* re-count num_dacs and squash invalid entries */
3019         spec->multiout.num_dacs = 0;
3020         for (i = 0; i < cfg->line_outs; i++) {
3021                 if (spec->private_dac_nids[i])
3022                         spec->multiout.num_dacs++;
3023                 else {
3024                         memmove(spec->private_dac_nids + i,
3025                                 spec->private_dac_nids + i + 1,
3026                                 sizeof(hda_nid_t) * (cfg->line_outs - i - 1));
3027                         spec->private_dac_nids[cfg->line_outs - 1] = 0;
3028                 }
3029         }
3030
3031         if (cfg->line_outs == 1 && cfg->line_out_type != AUTO_PIN_SPEAKER_OUT) {
3032                 /* try to fill multi-io first */
3033                 unsigned int location, defcfg;
3034                 int num_pins;
3035
3036                 defcfg = snd_hda_codec_get_pincfg(codec, cfg->line_out_pins[0]);
3037                 location = get_defcfg_location(defcfg);
3038
3039                 num_pins = alc_auto_fill_multi_ios(codec, location);
3040                 if (num_pins > 0) {
3041                         spec->multi_ios = num_pins;
3042                         spec->ext_channel_count = 2;
3043                         spec->multiout.num_dacs = num_pins + 1;
3044                 }
3045         }
3046
3047         if (cfg->line_out_type != AUTO_PIN_HP_OUT)
3048                 alc_auto_fill_extra_dacs(codec, cfg->hp_outs, cfg->hp_pins,
3049                                  spec->multiout.hp_out_nid);
3050         if (cfg->line_out_type != AUTO_PIN_SPEAKER_OUT) {
3051                 int err = alc_auto_fill_extra_dacs(codec, cfg->speaker_outs,
3052                                         cfg->speaker_pins,
3053                                         spec->multiout.extra_out_nid);
3054                 /* if no speaker volume is assigned, try again as the primary
3055                  * output
3056                  */
3057                 if (!err && cfg->speaker_outs > 0 &&
3058                     cfg->line_out_type == AUTO_PIN_HP_OUT) {
3059                         cfg->hp_outs = cfg->line_outs;
3060                         memcpy(cfg->hp_pins, cfg->line_out_pins,
3061                                sizeof(cfg->hp_pins));
3062                         cfg->line_outs = cfg->speaker_outs;
3063                         memcpy(cfg->line_out_pins, cfg->speaker_pins,
3064                                sizeof(cfg->speaker_pins));
3065                         cfg->speaker_outs = 0;
3066                         memset(cfg->speaker_pins, 0, sizeof(cfg->speaker_pins));
3067                         cfg->line_out_type = AUTO_PIN_SPEAKER_OUT;
3068                         redone = false;
3069                         goto again;
3070                 }
3071         }
3072
3073         return 0;
3074 }
3075
3076 static inline unsigned int get_ctl_pos(unsigned int data)
3077 {
3078         hda_nid_t nid = get_amp_nid_(data);
3079         unsigned int dir;
3080         if (snd_BUG_ON(nid >= MAX_VOL_NIDS))
3081                 return 0;
3082         dir = get_amp_direction_(data);
3083         return (nid << 1) | dir;
3084 }
3085
3086 #define is_ctl_used(bits, data) \
3087         test_bit(get_ctl_pos(data), bits)
3088 #define mark_ctl_usage(bits, data) \
3089         set_bit(get_ctl_pos(data), bits)
3090
3091 static int alc_auto_add_vol_ctl(struct hda_codec *codec,
3092                               const char *pfx, int cidx,
3093                               hda_nid_t nid, unsigned int chs)
3094 {
3095         struct alc_spec *spec = codec->spec;
3096         unsigned int val;
3097         if (!nid)
3098                 return 0;
3099         val = HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_OUTPUT);
3100         if (is_ctl_used(spec->vol_ctls, val) && chs != 2) /* exclude LFE */
3101                 return 0;
3102         mark_ctl_usage(spec->vol_ctls, val);
3103         return __add_pb_vol_ctrl(codec->spec, ALC_CTL_WIDGET_VOL, pfx, cidx,
3104                                  val);
3105 }
3106
3107 #define alc_auto_add_stereo_vol(codec, pfx, cidx, nid)  \
3108         alc_auto_add_vol_ctl(codec, pfx, cidx, nid, 3)
3109
3110 /* create a mute-switch for the given mixer widget;
3111  * if it has multiple sources (e.g. DAC and loopback), create a bind-mute
3112  */
3113 static int alc_auto_add_sw_ctl(struct hda_codec *codec,
3114                              const char *pfx, int cidx,
3115                              hda_nid_t nid, unsigned int chs)
3116 {
3117         struct alc_spec *spec = codec->spec;
3118         int wid_type;
3119         int type;
3120         unsigned long val;
3121         if (!nid)
3122                 return 0;
3123         wid_type = get_wcaps_type(get_wcaps(codec, nid));
3124         if (wid_type == AC_WID_PIN || wid_type == AC_WID_AUD_OUT) {
3125                 type = ALC_CTL_WIDGET_MUTE;
3126                 val = HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_OUTPUT);
3127         } else if (snd_hda_get_conn_list(codec, nid, NULL) == 1) {
3128                 type = ALC_CTL_WIDGET_MUTE;
3129                 val = HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_INPUT);
3130         } else {
3131                 type = ALC_CTL_BIND_MUTE;
3132                 val = HDA_COMPOSE_AMP_VAL(nid, chs, 2, HDA_INPUT);
3133         }
3134         if (is_ctl_used(spec->sw_ctls, val) && chs != 2) /* exclude LFE */
3135                 return 0;
3136         mark_ctl_usage(spec->sw_ctls, val);
3137         return __add_pb_sw_ctrl(codec->spec, type, pfx, cidx, val);
3138 }
3139
3140 #define alc_auto_add_stereo_sw(codec, pfx, cidx, nid)   \
3141         alc_auto_add_sw_ctl(codec, pfx, cidx, nid, 3)
3142
3143 static hda_nid_t alc_look_for_out_mute_nid(struct hda_codec *codec,
3144                                            hda_nid_t pin, hda_nid_t dac)
3145 {
3146         hda_nid_t mix = alc_auto_dac_to_mix(codec, pin, dac);
3147         if (nid_has_mute(codec, pin, HDA_OUTPUT))
3148                 return pin;
3149         else if (mix && nid_has_mute(codec, mix, HDA_INPUT))
3150                 return mix;
3151         else if (nid_has_mute(codec, dac, HDA_OUTPUT))
3152                 return dac;
3153         return 0;
3154 }
3155
3156 static hda_nid_t alc_look_for_out_vol_nid(struct hda_codec *codec,
3157                                           hda_nid_t pin, hda_nid_t dac)
3158 {
3159         hda_nid_t mix = alc_auto_dac_to_mix(codec, pin, dac);
3160         if (nid_has_volume(codec, dac, HDA_OUTPUT))
3161                 return dac;
3162         else if (nid_has_volume(codec, mix, HDA_OUTPUT))
3163                 return mix;
3164         else if (nid_has_volume(codec, pin, HDA_OUTPUT))
3165                 return pin;
3166         return 0;
3167 }
3168
3169 /* add playback controls from the parsed DAC table */
3170 static int alc_auto_create_multi_out_ctls(struct hda_codec *codec,
3171                                              const struct auto_pin_cfg *cfg)
3172 {
3173         struct alc_spec *spec = codec->spec;
3174         int i, err, noutputs;
3175
3176         noutputs = cfg->line_outs;
3177         if (spec->multi_ios > 0)
3178                 noutputs += spec->multi_ios;
3179
3180         for (i = 0; i < noutputs; i++) {
3181                 const char *name;
3182                 int index;
3183                 hda_nid_t dac, pin;
3184                 hda_nid_t sw, vol;
3185
3186                 dac = spec->multiout.dac_nids[i];
3187                 if (!dac)
3188                         continue;
3189                 if (i >= cfg->line_outs)
3190                         pin = spec->multi_io[i - 1].pin;
3191                 else
3192                         pin = cfg->line_out_pins[i];
3193
3194                 sw = alc_look_for_out_mute_nid(codec, pin, dac);
3195                 vol = alc_look_for_out_vol_nid(codec, pin, dac);
3196                 name = alc_get_line_out_pfx(spec, i, true, &index);
3197                 if (!name || !strcmp(name, "CLFE")) {
3198                         /* Center/LFE */
3199                         err = alc_auto_add_vol_ctl(codec, "Center", 0, vol, 1);
3200                         if (err < 0)
3201                                 return err;
3202                         err = alc_auto_add_vol_ctl(codec, "LFE", 0, vol, 2);
3203                         if (err < 0)
3204                                 return err;
3205                         err = alc_auto_add_sw_ctl(codec, "Center", 0, sw, 1);
3206                         if (err < 0)
3207                                 return err;
3208                         err = alc_auto_add_sw_ctl(codec, "LFE", 0, sw, 2);
3209                         if (err < 0)
3210                                 return err;
3211                 } else {
3212                         err = alc_auto_add_stereo_vol(codec, name, index, vol);
3213                         if (err < 0)
3214                                 return err;
3215                         err = alc_auto_add_stereo_sw(codec, name, index, sw);
3216                         if (err < 0)
3217                                 return err;
3218                 }
3219         }
3220         return 0;
3221 }
3222
3223 static int alc_auto_create_extra_out(struct hda_codec *codec, hda_nid_t pin,
3224                                      hda_nid_t dac, const char *pfx,
3225                                      int cidx)
3226 {
3227         struct alc_spec *spec = codec->spec;
3228         hda_nid_t sw, vol;
3229         int err;
3230
3231         if (!dac) {
3232                 unsigned int val;
3233                 /* the corresponding DAC is already occupied */
3234                 if (!(get_wcaps(codec, pin) & AC_WCAP_OUT_AMP))
3235                         return 0; /* no way */
3236                 /* create a switch only */
3237                 val = HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT);
3238                 if (is_ctl_used(spec->sw_ctls, val))
3239                         return 0; /* already created */
3240                 mark_ctl_usage(spec->sw_ctls, val);
3241                 return __add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, pfx, cidx, val);
3242         }
3243
3244         sw = alc_look_for_out_mute_nid(codec, pin, dac);
3245         vol = alc_look_for_out_vol_nid(codec, pin, dac);
3246         err = alc_auto_add_stereo_vol(codec, pfx, cidx, vol);
3247         if (err < 0)
3248                 return err;
3249         err = alc_auto_add_stereo_sw(codec, pfx, cidx, sw);
3250         if (err < 0)
3251                 return err;
3252         return 0;
3253 }
3254
3255 static struct hda_bind_ctls *new_bind_ctl(struct hda_codec *codec,
3256                                           unsigned int nums,
3257                                           struct hda_ctl_ops *ops)
3258 {
3259         struct alc_spec *spec = codec->spec;
3260         struct hda_bind_ctls **ctlp, *ctl;
3261         snd_array_init(&spec->bind_ctls, sizeof(ctl), 8);
3262         ctlp = snd_array_new(&spec->bind_ctls);
3263         if (!ctlp)
3264                 return NULL;
3265         ctl = kzalloc(sizeof(*ctl) + sizeof(long) * (nums + 1), GFP_KERNEL);
3266         *ctlp = ctl;
3267         if (ctl)
3268                 ctl->ops = ops;
3269         return ctl;
3270 }
3271
3272 /* add playback controls for speaker and HP outputs */
3273 static int alc_auto_create_extra_outs(struct hda_codec *codec, int num_pins,
3274                                       const hda_nid_t *pins,
3275                                       const hda_nid_t *dacs,
3276                                       const char *pfx)
3277 {
3278         struct alc_spec *spec = codec->spec;
3279         struct hda_bind_ctls *ctl;
3280         char name[32];
3281         int i, n, err;
3282
3283         if (!num_pins || !pins[0])
3284                 return 0;
3285
3286         if (num_pins == 1) {
3287                 hda_nid_t dac = *dacs;
3288                 if (!dac)
3289                         dac = spec->multiout.dac_nids[0];
3290                 return alc_auto_create_extra_out(codec, *pins, dac, pfx, 0);
3291         }
3292
3293         if (dacs[num_pins - 1]) {
3294                 /* OK, we have a multi-output system with individual volumes */
3295                 for (i = 0; i < num_pins; i++) {
3296                         if (num_pins >= 3) {
3297                                 snprintf(name, sizeof(name), "%s %s",
3298                                          pfx, channel_name[i]);
3299                                 err = alc_auto_create_extra_out(codec, pins[i], dacs[i],
3300                                                                 name, 0);
3301                         } else {
3302                                 err = alc_auto_create_extra_out(codec, pins[i], dacs[i],
3303                                                                 pfx, i);
3304                         }
3305                         if (err < 0)
3306                                 return err;
3307                 }
3308                 return 0;
3309         }
3310
3311         /* Let's create a bind-controls */
3312         ctl = new_bind_ctl(codec, num_pins, &snd_hda_bind_sw);
3313         if (!ctl)
3314                 return -ENOMEM;
3315         n = 0;
3316         for (i = 0; i < num_pins; i++) {
3317                 if (get_wcaps(codec, pins[i]) & AC_WCAP_OUT_AMP)
3318                         ctl->values[n++] =
3319                                 HDA_COMPOSE_AMP_VAL(pins[i], 3, 0, HDA_OUTPUT);
3320         }
3321         if (n) {
3322                 snprintf(name, sizeof(name), "%s Playback Switch", pfx);
3323                 err = add_control(spec, ALC_CTL_BIND_SW, name, 0, (long)ctl);
3324                 if (err < 0)
3325                         return err;
3326         }
3327
3328         ctl = new_bind_ctl(codec, num_pins, &snd_hda_bind_vol);
3329         if (!ctl)
3330                 return -ENOMEM;
3331         n = 0;
3332         for (i = 0; i < num_pins; i++) {
3333                 hda_nid_t vol;
3334                 if (!pins[i] || !dacs[i])
3335                         continue;
3336                 vol = alc_look_for_out_vol_nid(codec, pins[i], dacs[i]);
3337                 if (vol)
3338                         ctl->values[n++] =
3339                                 HDA_COMPOSE_AMP_VAL(vol, 3, 0, HDA_OUTPUT);
3340         }
3341         if (n) {
3342                 snprintf(name, sizeof(name), "%s Playback Volume", pfx);
3343                 err = add_control(spec, ALC_CTL_BIND_VOL, name, 0, (long)ctl);
3344                 if (err < 0)
3345                         return err;
3346         }
3347         return 0;
3348 }
3349
3350 static int alc_auto_create_hp_out(struct hda_codec *codec)
3351 {
3352         struct alc_spec *spec = codec->spec;
3353         return alc_auto_create_extra_outs(codec, spec->autocfg.hp_outs,
3354                                           spec->autocfg.hp_pins,
3355                                           spec->multiout.hp_out_nid,
3356                                           "Headphone");
3357 }
3358
3359 static int alc_auto_create_speaker_out(struct hda_codec *codec)
3360 {
3361         struct alc_spec *spec = codec->spec;
3362         return alc_auto_create_extra_outs(codec, spec->autocfg.speaker_outs,
3363                                           spec->autocfg.speaker_pins,
3364                                           spec->multiout.extra_out_nid,
3365                                           "Speaker");
3366 }
3367
3368 static void alc_auto_set_output_and_unmute(struct hda_codec *codec,
3369                                               hda_nid_t pin, int pin_type,
3370                                               hda_nid_t dac)
3371 {
3372         int i, num;
3373         hda_nid_t nid, mix = 0;
3374         hda_nid_t srcs[HDA_MAX_CONNECTIONS];
3375
3376         alc_set_pin_output(codec, pin, pin_type);
3377         nid = alc_go_down_to_selector(codec, pin);
3378         num = snd_hda_get_connections(codec, nid, srcs, ARRAY_SIZE(srcs));
3379         for (i = 0; i < num; i++) {
3380                 if (alc_auto_mix_to_dac(codec, srcs[i]) != dac)
3381                         continue;
3382                 mix = srcs[i];
3383                 break;
3384         }
3385         if (!mix)
3386                 return;
3387
3388         /* need the manual connection? */
3389         if (num > 1)
3390                 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CONNECT_SEL, i);
3391         /* unmute mixer widget inputs */
3392         if (nid_has_mute(codec, mix, HDA_INPUT)) {
3393                 snd_hda_codec_write(codec, mix, 0, AC_VERB_SET_AMP_GAIN_MUTE,
3394                             AMP_IN_UNMUTE(0));
3395                 snd_hda_codec_write(codec, mix, 0, AC_VERB_SET_AMP_GAIN_MUTE,
3396                             AMP_IN_UNMUTE(1));
3397         }
3398         /* initialize volume */
3399         nid = alc_look_for_out_vol_nid(codec, pin, dac);
3400         if (nid)
3401                 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE,
3402                                     AMP_OUT_ZERO);
3403
3404         /* unmute DAC if it's not assigned to a mixer */
3405         nid = alc_look_for_out_mute_nid(codec, pin, dac);
3406         if (nid == mix && nid_has_mute(codec, dac, HDA_OUTPUT))
3407                 snd_hda_codec_write(codec, dac, 0, AC_VERB_SET_AMP_GAIN_MUTE,
3408                                     AMP_OUT_ZERO);
3409 }
3410
3411 static void alc_auto_init_multi_out(struct hda_codec *codec)
3412 {
3413         struct alc_spec *spec = codec->spec;
3414         int pin_type = get_pin_type(spec->autocfg.line_out_type);
3415         int i;
3416
3417         for (i = 0; i <= HDA_SIDE; i++) {
3418                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
3419                 if (nid)
3420                         alc_auto_set_output_and_unmute(codec, nid, pin_type,
3421                                         spec->multiout.dac_nids[i]);
3422         }
3423 }
3424
3425 static void alc_auto_init_extra_out(struct hda_codec *codec)
3426 {
3427         struct alc_spec *spec = codec->spec;
3428         int i;
3429         hda_nid_t pin, dac;
3430
3431         for (i = 0; i < spec->autocfg.hp_outs; i++) {
3432                 if (spec->autocfg.line_out_type == AUTO_PIN_HP_OUT)
3433                         break;
3434                 pin = spec->autocfg.hp_pins[i];
3435                 if (!pin)
3436                         break;
3437                 dac = spec->multiout.hp_out_nid[i];
3438                 if (!dac) {
3439                         if (i > 0 && spec->multiout.hp_out_nid[0])
3440                                 dac = spec->multiout.hp_out_nid[0];
3441                         else
3442                                 dac = spec->multiout.dac_nids[0];
3443                 }
3444                 alc_auto_set_output_and_unmute(codec, pin, PIN_HP, dac);
3445         }
3446         for (i = 0; i < spec->autocfg.speaker_outs; i++) {
3447                 if (spec->autocfg.line_out_type == AUTO_PIN_SPEAKER_OUT)
3448                         break;
3449                 pin = spec->autocfg.speaker_pins[i];
3450                 if (!pin)
3451                         break;
3452                 dac = spec->multiout.extra_out_nid[i];
3453                 if (!dac) {
3454                         if (i > 0 && spec->multiout.extra_out_nid[0])
3455                                 dac = spec->multiout.extra_out_nid[0];
3456                         else
3457                                 dac = spec->multiout.dac_nids[0];
3458                 }
3459                 alc_auto_set_output_and_unmute(codec, pin, PIN_OUT, dac);
3460         }
3461 }
3462
3463 /*
3464  * multi-io helper
3465  */
3466 static int alc_auto_fill_multi_ios(struct hda_codec *codec,
3467                                    unsigned int location)
3468 {
3469         struct alc_spec *spec = codec->spec;
3470         struct auto_pin_cfg *cfg = &spec->autocfg;
3471         hda_nid_t prime_dac = spec->private_dac_nids[0];
3472         int type, i, num_pins = 0;
3473
3474         for (type = AUTO_PIN_LINE_IN; type >= AUTO_PIN_MIC; type--) {
3475                 for (i = 0; i < cfg->num_inputs; i++) {
3476                         hda_nid_t nid = cfg->inputs[i].pin;
3477                         hda_nid_t dac;
3478                         unsigned int defcfg, caps;
3479                         if (cfg->inputs[i].type != type)
3480                                 continue;
3481                         defcfg = snd_hda_codec_get_pincfg(codec, nid);
3482                         if (get_defcfg_connect(defcfg) != AC_JACK_PORT_COMPLEX)
3483                                 continue;
3484                         if (location && get_defcfg_location(defcfg) != location)
3485                                 continue;
3486                         caps = snd_hda_query_pin_caps(codec, nid);
3487                         if (!(caps & AC_PINCAP_OUT))
3488                                 continue;
3489                         dac = alc_auto_look_for_dac(codec, nid);
3490                         if (!dac)
3491                                 continue;
3492                         spec->multi_io[num_pins].pin = nid;
3493                         spec->multi_io[num_pins].dac = dac;
3494                         num_pins++;
3495                         spec->private_dac_nids[spec->multiout.num_dacs++] = dac;
3496                 }
3497         }
3498         spec->multiout.num_dacs = 1;
3499         if (num_pins < 2) {
3500                 /* clear up again */
3501                 memset(spec->private_dac_nids, 0,
3502                        sizeof(spec->private_dac_nids));
3503                 spec->private_dac_nids[0] = prime_dac;
3504                 return 0;
3505         }
3506         return num_pins;
3507 }
3508
3509 static int alc_auto_ch_mode_info(struct snd_kcontrol *kcontrol,
3510                                  struct snd_ctl_elem_info *uinfo)
3511 {
3512         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3513         struct alc_spec *spec = codec->spec;
3514
3515         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
3516         uinfo->count = 1;
3517         uinfo->value.enumerated.items = spec->multi_ios + 1;
3518         if (uinfo->value.enumerated.item > spec->multi_ios)
3519                 uinfo->value.enumerated.item = spec->multi_ios;
3520         sprintf(uinfo->value.enumerated.name, "%dch",
3521                 (uinfo->value.enumerated.item + 1) * 2);
3522         return 0;
3523 }
3524
3525 static int alc_auto_ch_mode_get(struct snd_kcontrol *kcontrol,
3526                                 struct snd_ctl_elem_value *ucontrol)
3527 {
3528         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3529         struct alc_spec *spec = codec->spec;
3530         ucontrol->value.enumerated.item[0] = (spec->ext_channel_count - 1) / 2;
3531         return 0;
3532 }
3533
3534 static int alc_set_multi_io(struct hda_codec *codec, int idx, bool output)
3535 {
3536         struct alc_spec *spec = codec->spec;
3537         hda_nid_t nid = spec->multi_io[idx].pin;
3538
3539         if (!spec->multi_io[idx].ctl_in)
3540                 spec->multi_io[idx].ctl_in =
3541                         snd_hda_codec_read(codec, nid, 0,
3542                                            AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
3543         if (output) {
3544                 snd_hda_codec_update_cache(codec, nid, 0,
3545                                            AC_VERB_SET_PIN_WIDGET_CONTROL,
3546                                            PIN_OUT);
3547                 if (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP)
3548                         snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
3549                                                  HDA_AMP_MUTE, 0);
3550                 alc_auto_select_dac(codec, nid, spec->multi_io[idx].dac);
3551         } else {
3552                 if (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP)
3553                         snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
3554                                                  HDA_AMP_MUTE, HDA_AMP_MUTE);
3555                 snd_hda_codec_update_cache(codec, nid, 0,
3556                                            AC_VERB_SET_PIN_WIDGET_CONTROL,
3557                                            spec->multi_io[idx].ctl_in);
3558         }
3559         return 0;
3560 }
3561
3562 static int alc_auto_ch_mode_put(struct snd_kcontrol *kcontrol,
3563                                 struct snd_ctl_elem_value *ucontrol)
3564 {
3565         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3566         struct alc_spec *spec = codec->spec;
3567         int i, ch;
3568
3569         ch = ucontrol->value.enumerated.item[0];
3570         if (ch < 0 || ch > spec->multi_ios)
3571                 return -EINVAL;
3572         if (ch == (spec->ext_channel_count - 1) / 2)
3573                 return 0;
3574         spec->ext_channel_count = (ch + 1) * 2;
3575         for (i = 0; i < spec->multi_ios; i++)
3576                 alc_set_multi_io(codec, i, i < ch);
3577         spec->multiout.max_channels = spec->ext_channel_count;
3578         if (spec->need_dac_fix && !spec->const_channel_count)
3579                 spec->multiout.num_dacs = spec->multiout.max_channels / 2;
3580         return 1;
3581 }
3582
3583 static const struct snd_kcontrol_new alc_auto_channel_mode_enum = {
3584         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3585         .name = "Channel Mode",
3586         .info = alc_auto_ch_mode_info,
3587         .get = alc_auto_ch_mode_get,
3588         .put = alc_auto_ch_mode_put,
3589 };
3590
3591 static int alc_auto_add_multi_channel_mode(struct hda_codec *codec)
3592 {
3593         struct alc_spec *spec = codec->spec;
3594
3595         if (spec->multi_ios > 0) {
3596                 struct snd_kcontrol_new *knew;
3597
3598                 knew = alc_kcontrol_new(spec);
3599                 if (!knew)
3600                         return -ENOMEM;
3601                 *knew = alc_auto_channel_mode_enum;
3602                 knew->name = kstrdup("Channel Mode", GFP_KERNEL);
3603                 if (!knew->name)
3604                         return -ENOMEM;
3605         }
3606         return 0;
3607 }
3608
3609 /* filter out invalid adc_nids (and capsrc_nids) that don't give all
3610  * active input pins
3611  */
3612 static void alc_remove_invalid_adc_nids(struct hda_codec *codec)
3613 {
3614         struct alc_spec *spec = codec->spec;
3615         const struct hda_input_mux *imux;
3616         hda_nid_t adc_nids[ARRAY_SIZE(spec->private_adc_nids)];
3617         hda_nid_t capsrc_nids[ARRAY_SIZE(spec->private_adc_nids)];
3618         int i, n, nums;
3619
3620         imux = spec->input_mux;
3621         if (!imux)
3622                 return;
3623         if (spec->dyn_adc_switch)
3624                 return;
3625
3626         nums = 0;
3627         for (n = 0; n < spec->num_adc_nids; n++) {
3628                 hda_nid_t cap = spec->private_capsrc_nids[n];
3629                 int num_conns = snd_hda_get_conn_list(codec, cap, NULL);
3630                 for (i = 0; i < imux->num_items; i++) {
3631                         hda_nid_t pin = spec->imux_pins[i];
3632                         if (pin) {
3633                                 if (get_connection_index(codec, cap, pin) < 0)
3634                                         break;
3635                         } else if (num_conns <= imux->items[i].index)
3636                                 break;
3637                 }
3638                 if (i >= imux->num_items) {
3639                         adc_nids[nums] = spec->private_adc_nids[n];
3640                         capsrc_nids[nums++] = cap;
3641                 }
3642         }
3643         if (!nums) {
3644                 /* check whether ADC-switch is possible */
3645                 if (!alc_check_dyn_adc_switch(codec)) {
3646                         printk(KERN_WARNING "hda_codec: %s: no valid ADC found;"
3647                                " using fallback 0x%x\n",
3648                                codec->chip_name, spec->private_adc_nids[0]);
3649                         spec->num_adc_nids = 1;
3650                         spec->auto_mic = 0;
3651                         return;
3652                 }
3653         } else if (nums != spec->num_adc_nids) {
3654                 memcpy(spec->private_adc_nids, adc_nids,
3655                        nums * sizeof(hda_nid_t));
3656                 memcpy(spec->private_capsrc_nids, capsrc_nids,
3657                        nums * sizeof(hda_nid_t));
3658                 spec->num_adc_nids = nums;
3659         }
3660
3661         if (spec->auto_mic)
3662                 alc_auto_mic_check_imux(codec); /* check auto-mic setups */
3663         else if (spec->input_mux->num_items == 1)
3664                 spec->num_adc_nids = 1; /* reduce to a single ADC */
3665 }
3666
3667 /*
3668  * initialize ADC paths
3669  */
3670 static void alc_auto_init_adc(struct hda_codec *codec, int adc_idx)
3671 {
3672         struct alc_spec *spec = codec->spec;
3673         hda_nid_t nid;
3674
3675         nid = spec->adc_nids[adc_idx];
3676         /* mute ADC */
3677         if (nid_has_mute(codec, nid, HDA_INPUT)) {
3678                 snd_hda_codec_write(codec, nid, 0,
3679                                     AC_VERB_SET_AMP_GAIN_MUTE,
3680                                     AMP_IN_MUTE(0));
3681                 return;
3682         }
3683         if (!spec->capsrc_nids)
3684                 return;
3685         nid = spec->capsrc_nids[adc_idx];
3686         if (nid_has_mute(codec, nid, HDA_OUTPUT))
3687                 snd_hda_codec_write(codec, nid, 0,
3688                                     AC_VERB_SET_AMP_GAIN_MUTE,
3689                                     AMP_OUT_MUTE);
3690 }
3691
3692 static void alc_auto_init_input_src(struct hda_codec *codec)
3693 {
3694         struct alc_spec *spec = codec->spec;
3695         int c, nums;
3696
3697         for (c = 0; c < spec->num_adc_nids; c++)
3698                 alc_auto_init_adc(codec, c);
3699         if (spec->dyn_adc_switch)
3700                 nums = 1;
3701         else
3702                 nums = spec->num_adc_nids;
3703         for (c = 0; c < nums; c++)
3704                 alc_mux_select(codec, c, spec->cur_mux[c], true);
3705 }
3706
3707 /* add mic boosts if needed */
3708 static int alc_auto_add_mic_boost(struct hda_codec *codec)
3709 {
3710         struct alc_spec *spec = codec->spec;
3711         struct auto_pin_cfg *cfg = &spec->autocfg;
3712         int i, err;
3713         int type_idx = 0;
3714         hda_nid_t nid;
3715         const char *prev_label = NULL;
3716
3717         for (i = 0; i < cfg->num_inputs; i++) {
3718                 if (cfg->inputs[i].type > AUTO_PIN_MIC)
3719                         break;
3720                 nid = cfg->inputs[i].pin;
3721                 if (get_wcaps(codec, nid) & AC_WCAP_IN_AMP) {
3722                         const char *label;
3723                         char boost_label[32];
3724
3725                         label = hda_get_autocfg_input_label(codec, cfg, i);
3726                         if (prev_label && !strcmp(label, prev_label))
3727                                 type_idx++;
3728                         else
3729                                 type_idx = 0;
3730                         prev_label = label;
3731
3732                         snprintf(boost_label, sizeof(boost_label),
3733                                  "%s Boost Volume", label);
3734                         err = add_control(spec, ALC_CTL_WIDGET_VOL,
3735                                           boost_label, type_idx,
3736                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT));
3737                         if (err < 0)
3738                                 return err;
3739                 }
3740         }
3741         return 0;
3742 }
3743
3744 /* select or unmute the given capsrc route */
3745 static void select_or_unmute_capsrc(struct hda_codec *codec, hda_nid_t cap,
3746                                     int idx)
3747 {
3748         if (get_wcaps_type(get_wcaps(codec, cap)) == AC_WID_AUD_MIX) {
3749                 snd_hda_codec_amp_stereo(codec, cap, HDA_INPUT, idx,
3750                                          HDA_AMP_MUTE, 0);
3751         } else if (snd_hda_get_conn_list(codec, cap, NULL) > 1) {
3752                 snd_hda_codec_write_cache(codec, cap, 0,
3753                                           AC_VERB_SET_CONNECT_SEL, idx);
3754         }
3755 }
3756
3757 /* set the default connection to that pin */
3758 static int init_capsrc_for_pin(struct hda_codec *codec, hda_nid_t pin)
3759 {
3760         struct alc_spec *spec = codec->spec;
3761         int i;
3762
3763         if (!pin)
3764                 return 0;
3765         for (i = 0; i < spec->num_adc_nids; i++) {
3766                 hda_nid_t cap = get_capsrc(spec, i);
3767                 int idx;
3768
3769                 idx = get_connection_index(codec, cap, pin);
3770                 if (idx < 0)
3771                         continue;
3772                 select_or_unmute_capsrc(codec, cap, idx);
3773                 return i; /* return the found index */
3774         }
3775         return -1; /* not found */
3776 }
3777
3778 /* initialize some special cases for input sources */
3779 static void alc_init_special_input_src(struct hda_codec *codec)
3780 {
3781         struct alc_spec *spec = codec->spec;
3782         int i;
3783
3784         for (i = 0; i < spec->autocfg.num_inputs; i++)
3785                 init_capsrc_for_pin(codec, spec->autocfg.inputs[i].pin);
3786 }
3787
3788 /* assign appropriate capture mixers */
3789 static void set_capture_mixer(struct hda_codec *codec)
3790 {
3791         struct alc_spec *spec = codec->spec;
3792         static const struct snd_kcontrol_new *caps[2][3] = {
3793                 { alc_capture_mixer_nosrc1,
3794                   alc_capture_mixer_nosrc2,
3795                   alc_capture_mixer_nosrc3 },
3796                 { alc_capture_mixer1,
3797                   alc_capture_mixer2,
3798                   alc_capture_mixer3 },
3799         };
3800
3801         /* check whether either of ADC or MUX has a volume control */
3802         if (!nid_has_volume(codec, spec->adc_nids[0], HDA_INPUT)) {
3803                 if (!spec->capsrc_nids)
3804                         return; /* no volume */
3805                 if (!nid_has_volume(codec, spec->capsrc_nids[0], HDA_OUTPUT))
3806                         return; /* no volume in capsrc, too */
3807                 spec->vol_in_capsrc = 1;
3808         }
3809
3810         if (spec->num_adc_nids > 0) {
3811                 int mux = 0;
3812                 int num_adcs = 0;
3813
3814                 if (spec->input_mux && spec->input_mux->num_items > 1)
3815                         mux = 1;
3816                 if (spec->auto_mic) {
3817                         num_adcs = 1;
3818                         mux = 0;
3819                 } else if (spec->dyn_adc_switch)
3820                         num_adcs = 1;
3821                 if (!num_adcs) {
3822                         if (spec->num_adc_nids > 3)
3823                                 spec->num_adc_nids = 3;
3824                         else if (!spec->num_adc_nids)
3825                                 return;
3826                         num_adcs = spec->num_adc_nids;
3827                 }
3828                 spec->cap_mixer = caps[mux][num_adcs - 1];
3829         }
3830 }
3831
3832 /*
3833  * standard auto-parser initializations
3834  */
3835 static void alc_auto_init_std(struct hda_codec *codec)
3836 {
3837         struct alc_spec *spec = codec->spec;
3838         alc_auto_init_multi_out(codec);
3839         alc_auto_init_extra_out(codec);
3840         alc_auto_init_analog_input(codec);
3841         alc_auto_init_input_src(codec);
3842         alc_auto_init_digital(codec);
3843         if (spec->unsol_event)
3844                 alc_inithook(codec);
3845 }
3846
3847 /*
3848  * Digital-beep handlers
3849  */
3850 #ifdef CONFIG_SND_HDA_INPUT_BEEP
3851 #define set_beep_amp(spec, nid, idx, dir) \
3852         ((spec)->beep_amp = HDA_COMPOSE_AMP_VAL(nid, 3, idx, dir))
3853
3854 static const struct snd_pci_quirk beep_white_list[] = {
3855         SND_PCI_QUIRK(0x1043, 0x829f, "ASUS", 1),
3856         SND_PCI_QUIRK(0x1043, 0x83ce, "EeePC", 1),
3857         SND_PCI_QUIRK(0x1043, 0x831a, "EeePC", 1),
3858         SND_PCI_QUIRK(0x1043, 0x834a, "EeePC", 1),
3859         SND_PCI_QUIRK(0x8086, 0xd613, "Intel", 1),
3860         {}
3861 };
3862
3863 static inline int has_cdefine_beep(struct hda_codec *codec)
3864 {
3865         struct alc_spec *spec = codec->spec;
3866         const struct snd_pci_quirk *q;
3867         q = snd_pci_quirk_lookup(codec->bus->pci, beep_white_list);
3868         if (q)
3869                 return q->value;
3870         return spec->cdefine.enable_pcbeep;
3871 }
3872 #else
3873 #define set_beep_amp(spec, nid, idx, dir) /* NOP */
3874 #define has_cdefine_beep(codec)         0
3875 #endif
3876
3877 /* parse the BIOS configuration and set up the alc_spec */
3878 /* return 1 if successful, 0 if the proper config is not found,
3879  * or a negative error code
3880  */
3881 static int alc_parse_auto_config(struct hda_codec *codec,
3882                                  const hda_nid_t *ignore_nids,
3883                                  const hda_nid_t *ssid_nids)
3884 {
3885         struct alc_spec *spec = codec->spec;
3886         struct auto_pin_cfg *cfg = &spec->autocfg;
3887         int err;
3888
3889         err = snd_hda_parse_pin_defcfg(codec, cfg, ignore_nids,
3890                                        spec->parse_flags);
3891         if (err < 0)
3892                 return err;
3893         if (!cfg->line_outs) {
3894                 if (cfg->dig_outs || cfg->dig_in_pin) {
3895                         spec->multiout.max_channels = 2;
3896                         spec->no_analog = 1;
3897                         goto dig_only;
3898                 }
3899                 return 0; /* can't find valid BIOS pin config */
3900         }
3901
3902         if (cfg->line_out_type == AUTO_PIN_SPEAKER_OUT &&
3903             cfg->line_outs <= cfg->hp_outs) {
3904                 /* use HP as primary out */
3905                 cfg->speaker_outs = cfg->line_outs;
3906                 memcpy(cfg->speaker_pins, cfg->line_out_pins,
3907                        sizeof(cfg->speaker_pins));
3908                 cfg->line_outs = cfg->hp_outs;
3909                 memcpy(cfg->line_out_pins, cfg->hp_pins, sizeof(cfg->hp_pins));
3910                 cfg->hp_outs = 0;
3911                 memset(cfg->hp_pins, 0, sizeof(cfg->hp_pins));
3912                 cfg->line_out_type = AUTO_PIN_HP_OUT;
3913         }
3914
3915         err = alc_auto_fill_dac_nids(codec);
3916         if (err < 0)
3917                 return err;
3918         err = alc_auto_add_multi_channel_mode(codec);
3919         if (err < 0)
3920                 return err;
3921         err = alc_auto_create_multi_out_ctls(codec, cfg);
3922         if (err < 0)
3923                 return err;
3924         err = alc_auto_create_hp_out(codec);
3925         if (err < 0)
3926                 return err;
3927         err = alc_auto_create_speaker_out(codec);
3928         if (err < 0)
3929                 return err;
3930         err = alc_auto_create_input_ctls(codec);
3931         if (err < 0)
3932                 return err;
3933
3934         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
3935
3936  dig_only:
3937         alc_auto_parse_digital(codec);
3938
3939         if (!spec->no_analog)
3940                 alc_remove_invalid_adc_nids(codec);
3941
3942         if (ssid_nids)
3943                 alc_ssid_check(codec, ssid_nids);
3944
3945         if (!spec->no_analog) {
3946                 alc_auto_check_switches(codec);
3947                 err = alc_auto_add_mic_boost(codec);
3948                 if (err < 0)
3949                         return err;
3950         }
3951
3952         if (spec->kctls.list)
3953                 add_mixer(spec, spec->kctls.list);
3954
3955         return 1;
3956 }
3957
3958 static int alc880_parse_auto_config(struct hda_codec *codec)
3959 {
3960         static const hda_nid_t alc880_ignore[] = { 0x1d, 0 };
3961         static const hda_nid_t alc880_ssids[] = { 0x15, 0x1b, 0x14, 0 };
3962         return alc_parse_auto_config(codec, alc880_ignore, alc880_ssids);
3963 }
3964
3965 #ifdef CONFIG_SND_HDA_POWER_SAVE
3966 static const struct hda_amp_list alc880_loopbacks[] = {
3967         { 0x0b, HDA_INPUT, 0 },
3968         { 0x0b, HDA_INPUT, 1 },
3969         { 0x0b, HDA_INPUT, 2 },
3970         { 0x0b, HDA_INPUT, 3 },
3971         { 0x0b, HDA_INPUT, 4 },
3972         { } /* end */
3973 };
3974 #endif
3975
3976 /*
3977  * board setups
3978  */
3979 #ifdef CONFIG_SND_HDA_ENABLE_REALTEK_QUIRKS
3980 #define alc_board_config \
3981         snd_hda_check_board_config
3982 #define alc_board_codec_sid_config \
3983         snd_hda_check_board_codec_sid_config
3984 #include "alc_quirks.c"
3985 #else
3986 #define alc_board_config(codec, nums, models, tbl)      -1
3987 #define alc_board_codec_sid_config(codec, nums, models, tbl)    -1
3988 #define setup_preset(codec, x)  /* NOP */
3989 #endif
3990
3991 /*
3992  * OK, here we have finally the patch for ALC880
3993  */
3994 #ifdef CONFIG_SND_HDA_ENABLE_REALTEK_QUIRKS
3995 #include "alc880_quirks.c"
3996 #endif
3997
3998 static int patch_alc880(struct hda_codec *codec)
3999 {
4000         struct alc_spec *spec;
4001         int board_config;
4002         int err;
4003
4004         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
4005         if (spec == NULL)
4006                 return -ENOMEM;
4007
4008         codec->spec = spec;
4009
4010         spec->mixer_nid = 0x0b;
4011         spec->need_dac_fix = 1;
4012
4013         board_config = alc_board_config(codec, ALC880_MODEL_LAST,
4014                                         alc880_models, alc880_cfg_tbl);
4015         if (board_config < 0) {
4016                 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
4017                        codec->chip_name);
4018                 board_config = ALC_MODEL_AUTO;
4019         }
4020
4021         if (board_config == ALC_MODEL_AUTO) {
4022                 /* automatic parse from the BIOS config */
4023                 err = alc880_parse_auto_config(codec);
4024                 if (err < 0)
4025                         goto error;
4026 #ifdef CONFIG_SND_HDA_ENABLE_REALTEK_QUIRKS
4027                 else if (!err) {
4028                         printk(KERN_INFO
4029                                "hda_codec: Cannot set up configuration "
4030                                "from BIOS.  Using 3-stack mode...\n");
4031                         board_config = ALC880_3ST;
4032                 }
4033 #endif
4034         }
4035
4036         if (board_config != ALC_MODEL_AUTO)
4037                 setup_preset(codec, &alc880_presets[board_config]);
4038
4039         if (!spec->no_analog && !spec->adc_nids) {
4040                 alc_auto_fill_adc_caps(codec);
4041                 alc_rebuild_imux_for_auto_mic(codec);
4042                 alc_remove_invalid_adc_nids(codec);
4043         }
4044
4045         if (!spec->no_analog && !spec->cap_mixer)
4046                 set_capture_mixer(codec);
4047
4048         if (!spec->no_analog) {
4049                 err = snd_hda_attach_beep_device(codec, 0x1);
4050                 if (err < 0)
4051                         goto error;
4052                 set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
4053         }
4054
4055         spec->vmaster_nid = 0x0c;
4056
4057         codec->patch_ops = alc_patch_ops;
4058         if (board_config == ALC_MODEL_AUTO)
4059                 spec->init_hook = alc_auto_init_std;
4060 #ifdef CONFIG_SND_HDA_POWER_SAVE
4061         if (!spec->loopback.amplist)
4062                 spec->loopback.amplist = alc880_loopbacks;
4063 #endif
4064
4065         return 0;
4066
4067  error:
4068         alc_free(codec);
4069         return err;
4070 }
4071
4072
4073 /*
4074  * ALC260 support
4075  */
4076 static int alc260_parse_auto_config(struct hda_codec *codec)
4077 {
4078         static const hda_nid_t alc260_ignore[] = { 0x17, 0 };
4079         static const hda_nid_t alc260_ssids[] = { 0x10, 0x15, 0x0f, 0 };
4080         return alc_parse_auto_config(codec, alc260_ignore, alc260_ssids);
4081 }
4082
4083 #ifdef CONFIG_SND_HDA_POWER_SAVE
4084 static const struct hda_amp_list alc260_loopbacks[] = {
4085         { 0x07, HDA_INPUT, 0 },
4086         { 0x07, HDA_INPUT, 1 },
4087         { 0x07, HDA_INPUT, 2 },
4088         { 0x07, HDA_INPUT, 3 },
4089         { 0x07, HDA_INPUT, 4 },
4090         { } /* end */
4091 };
4092 #endif
4093
4094 /*
4095  * Pin config fixes
4096  */
4097 enum {
4098         PINFIX_HP_DC5750,
4099 };
4100
4101 static const struct alc_fixup alc260_fixups[] = {
4102         [PINFIX_HP_DC5750] = {
4103                 .type = ALC_FIXUP_PINS,
4104                 .v.pins = (const struct alc_pincfg[]) {
4105                         { 0x11, 0x90130110 }, /* speaker */
4106                         { }
4107                 }
4108         },
4109 };
4110
4111 static const struct snd_pci_quirk alc260_fixup_tbl[] = {
4112         SND_PCI_QUIRK(0x103c, 0x280a, "HP dc5750", PINFIX_HP_DC5750),
4113         {}
4114 };
4115
4116 /*
4117  */
4118 #ifdef CONFIG_SND_HDA_ENABLE_REALTEK_QUIRKS
4119 #include "alc260_quirks.c"
4120 #endif
4121
4122 static int patch_alc260(struct hda_codec *codec)
4123 {
4124         struct alc_spec *spec;
4125         int err, board_config;
4126
4127         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
4128         if (spec == NULL)
4129                 return -ENOMEM;
4130
4131         codec->spec = spec;
4132
4133         spec->mixer_nid = 0x07;
4134
4135         board_config = alc_board_config(codec, ALC260_MODEL_LAST,
4136                                         alc260_models, alc260_cfg_tbl);
4137         if (board_config < 0) {
4138                 snd_printd(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
4139                            codec->chip_name);
4140                 board_config = ALC_MODEL_AUTO;
4141         }
4142
4143         if (board_config == ALC_MODEL_AUTO) {
4144                 alc_pick_fixup(codec, NULL, alc260_fixup_tbl, alc260_fixups);
4145                 alc_apply_fixup(codec, ALC_FIXUP_ACT_PRE_PROBE);
4146         }
4147
4148         if (board_config == ALC_MODEL_AUTO) {
4149                 /* automatic parse from the BIOS config */
4150                 err = alc260_parse_auto_config(codec);
4151                 if (err < 0)
4152                         goto error;
4153 #ifdef CONFIG_SND_HDA_ENABLE_REALTEK_QUIRKS
4154                 else if (!err) {
4155                         printk(KERN_INFO
4156                                "hda_codec: Cannot set up configuration "
4157                                "from BIOS.  Using base mode...\n");
4158                         board_config = ALC260_BASIC;
4159                 }
4160 #endif
4161         }
4162
4163         if (board_config != ALC_MODEL_AUTO)
4164                 setup_preset(codec, &alc260_presets[board_config]);
4165
4166         if (!spec->no_analog && !spec->adc_nids) {
4167                 alc_auto_fill_adc_caps(codec);
4168                 alc_rebuild_imux_for_auto_mic(codec);
4169                 alc_remove_invalid_adc_nids(codec);
4170         }
4171
4172         if (!spec->no_analog && !spec->cap_mixer)
4173                 set_capture_mixer(codec);
4174
4175         if (!spec->no_analog) {
4176                 err = snd_hda_attach_beep_device(codec, 0x1);
4177                 if (err < 0)
4178                         goto error;
4179                 set_beep_amp(spec, 0x07, 0x05, HDA_INPUT);
4180         }
4181
4182         alc_apply_fixup(codec, ALC_FIXUP_ACT_PROBE);
4183
4184         spec->vmaster_nid = 0x08;
4185
4186         codec->patch_ops = alc_patch_ops;
4187         if (board_config == ALC_MODEL_AUTO)
4188                 spec->init_hook = alc_auto_init_std;
4189         spec->shutup = alc_eapd_shutup;
4190 #ifdef CONFIG_SND_HDA_POWER_SAVE
4191         if (!spec->loopback.amplist)
4192                 spec->loopback.amplist = alc260_loopbacks;
4193 #endif
4194
4195         return 0;
4196
4197  error:
4198         alc_free(codec);
4199         return err;
4200 }
4201
4202
4203 /*
4204  * ALC882/883/885/888/889 support
4205  *
4206  * ALC882 is almost identical with ALC880 but has cleaner and more flexible
4207  * configuration.  Each pin widget can choose any input DACs and a mixer.
4208  * Each ADC is connected from a mixer of all inputs.  This makes possible
4209  * 6-channel independent captures.
4210  *
4211  * In addition, an independent DAC for the multi-playback (not used in this
4212  * driver yet).
4213  */
4214 #ifdef CONFIG_SND_HDA_POWER_SAVE
4215 #define alc882_loopbacks        alc880_loopbacks
4216 #endif
4217
4218 /*
4219  * Pin config fixes
4220  */
4221 enum {
4222         PINFIX_ABIT_AW9D_MAX,
4223         PINFIX_LENOVO_Y530,
4224         PINFIX_PB_M5210,
4225         PINFIX_ACER_ASPIRE_7736,
4226         PINFIX_ASUS_W90V,
4227         ALC889_FIXUP_DAC_ROUTE,
4228 };
4229
4230 /* Fix the connection of some pins for ALC889:
4231  * At least, Acer Aspire 5935 shows the connections to DAC3/4 don't
4232  * work correctly (bko#42740)
4233  */
4234 static void alc889_fixup_dac_route(struct hda_codec *codec,
4235                                    const struct alc_fixup *fix, int action)
4236 {
4237         if (action == ALC_FIXUP_ACT_PRE_PROBE) {
4238                 /* fake the connections during parsing the tree */
4239                 hda_nid_t conn1[2] = { 0x0c, 0x0d };
4240                 hda_nid_t conn2[2] = { 0x0e, 0x0f };
4241                 snd_hda_override_conn_list(codec, 0x14, 2, conn1);
4242                 snd_hda_override_conn_list(codec, 0x15, 2, conn1);
4243                 snd_hda_override_conn_list(codec, 0x18, 2, conn2);
4244                 snd_hda_override_conn_list(codec, 0x1a, 2, conn2);
4245         } else if (action == ALC_FIXUP_ACT_PROBE) {
4246                 /* restore the connections */
4247                 hda_nid_t conn[5] = { 0x0c, 0x0d, 0x0e, 0x0f, 0x26 };
4248                 snd_hda_override_conn_list(codec, 0x14, 5, conn);
4249                 snd_hda_override_conn_list(codec, 0x15, 5, conn);
4250                 snd_hda_override_conn_list(codec, 0x18, 5, conn);
4251                 snd_hda_override_conn_list(codec, 0x1a, 5, conn);
4252         }
4253 }
4254
4255 static const struct alc_fixup alc882_fixups[] = {
4256         [PINFIX_ABIT_AW9D_MAX] = {
4257                 .type = ALC_FIXUP_PINS,
4258                 .v.pins = (const struct alc_pincfg[]) {
4259                         { 0x15, 0x01080104 }, /* side */
4260                         { 0x16, 0x01011012 }, /* rear */
4261                         { 0x17, 0x01016011 }, /* clfe */
4262                         { }
4263                 }
4264         },
4265         [PINFIX_LENOVO_Y530] = {
4266                 .type = ALC_FIXUP_PINS,
4267                 .v.pins = (const struct alc_pincfg[]) {
4268                         { 0x15, 0x99130112 }, /* rear int speakers */
4269                         { 0x16, 0x99130111 }, /* subwoofer */
4270                         { }
4271                 }
4272         },
4273         [PINFIX_PB_M5210] = {
4274                 .type = ALC_FIXUP_VERBS,
4275                 .v.verbs = (const struct hda_verb[]) {
4276                         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50 },
4277                         {}
4278                 }
4279         },
4280         [PINFIX_ACER_ASPIRE_7736] = {
4281                 .type = ALC_FIXUP_SKU,
4282                 .v.sku = ALC_FIXUP_SKU_IGNORE,
4283         },
4284         [PINFIX_ASUS_W90V] = {
4285                 .type = ALC_FIXUP_PINS,
4286                 .v.pins = (const struct alc_pincfg[]) {
4287                         { 0x16, 0x99130110 }, /* fix sequence for CLFE */
4288                         { }
4289                 }
4290         },
4291         [ALC889_FIXUP_DAC_ROUTE] = {
4292                 .type = ALC_FIXUP_FUNC,
4293                 .v.func = alc889_fixup_dac_route,
4294         },
4295 };
4296
4297 static const struct snd_pci_quirk alc882_fixup_tbl[] = {
4298         SND_PCI_QUIRK(0x1025, 0x0155, "Packard-Bell M5120", PINFIX_PB_M5210),
4299         SND_PCI_QUIRK(0x1025, 0x0259, "Acer Aspire 5935", ALC889_FIXUP_DAC_ROUTE),
4300         SND_PCI_QUIRK(0x1043, 0x1873, "ASUS W90V", PINFIX_ASUS_W90V),
4301         SND_PCI_QUIRK(0x17aa, 0x3a0d, "Lenovo Y530", PINFIX_LENOVO_Y530),
4302         SND_PCI_QUIRK(0x147b, 0x107a, "Abit AW9D-MAX", PINFIX_ABIT_AW9D_MAX),
4303         SND_PCI_QUIRK(0x1025, 0x0296, "Acer Aspire 7736z", PINFIX_ACER_ASPIRE_7736),
4304         {}
4305 };
4306
4307 /*
4308  * BIOS auto configuration
4309  */
4310 /* almost identical with ALC880 parser... */
4311 static int alc882_parse_auto_config(struct hda_codec *codec)
4312 {
4313         static const hda_nid_t alc882_ignore[] = { 0x1d, 0 };
4314         static const hda_nid_t alc882_ssids[] = { 0x15, 0x1b, 0x14, 0 };
4315         return alc_parse_auto_config(codec, alc882_ignore, alc882_ssids);
4316 }
4317
4318 /*
4319  */
4320 #ifdef CONFIG_SND_HDA_ENABLE_REALTEK_QUIRKS
4321 #include "alc882_quirks.c"
4322 #endif
4323
4324 static int patch_alc882(struct hda_codec *codec)
4325 {
4326         struct alc_spec *spec;
4327         int err, board_config;
4328
4329         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
4330         if (spec == NULL)
4331                 return -ENOMEM;
4332
4333         codec->spec = spec;
4334
4335         spec->mixer_nid = 0x0b;
4336
4337         switch (codec->vendor_id) {
4338         case 0x10ec0882:
4339         case 0x10ec0885:
4340                 break;
4341         default:
4342                 /* ALC883 and variants */
4343                 alc_fix_pll_init(codec, 0x20, 0x0a, 10);
4344                 break;
4345         }
4346
4347         err = alc_codec_rename_from_preset(codec);
4348         if (err < 0)
4349                 goto error;
4350
4351         board_config = alc_board_config(codec, ALC882_MODEL_LAST,
4352                                         alc882_models, alc882_cfg_tbl);
4353
4354         if (board_config < 0)
4355                 board_config = alc_board_codec_sid_config(codec,
4356                         ALC882_MODEL_LAST, alc882_models, alc882_ssid_cfg_tbl);
4357
4358         if (board_config < 0) {
4359                 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
4360                        codec->chip_name);
4361                 board_config = ALC_MODEL_AUTO;
4362         }
4363
4364         if (board_config == ALC_MODEL_AUTO) {
4365                 alc_pick_fixup(codec, NULL, alc882_fixup_tbl, alc882_fixups);
4366                 alc_apply_fixup(codec, ALC_FIXUP_ACT_PRE_PROBE);
4367         }
4368
4369         alc_auto_parse_customize_define(codec);
4370
4371         if (board_config == ALC_MODEL_AUTO) {
4372                 /* automatic parse from the BIOS config */
4373                 err = alc882_parse_auto_config(codec);
4374                 if (err < 0)
4375                         goto error;
4376 #ifdef CONFIG_SND_HDA_ENABLE_REALTEK_QUIRKS
4377                 else if (!err) {
4378                         printk(KERN_INFO
4379                                "hda_codec: Cannot set up configuration "
4380                                "from BIOS.  Using base mode...\n");
4381                         board_config = ALC882_3ST_DIG;
4382                 }
4383 #endif
4384         }
4385
4386         if (board_config != ALC_MODEL_AUTO)
4387                 setup_preset(codec, &alc882_presets[board_config]);
4388
4389         if (!spec->no_analog && !spec->adc_nids) {
4390                 alc_auto_fill_adc_caps(codec);
4391                 alc_rebuild_imux_for_auto_mic(codec);
4392                 alc_remove_invalid_adc_nids(codec);
4393         }
4394
4395         if (!spec->no_analog && !spec->cap_mixer)
4396                 set_capture_mixer(codec);
4397
4398         if (!spec->no_analog && has_cdefine_beep(codec)) {
4399                 err = snd_hda_attach_beep_device(codec, 0x1);
4400                 if (err < 0)
4401                         goto error;
4402                 set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
4403         }
4404
4405         alc_apply_fixup(codec, ALC_FIXUP_ACT_PROBE);
4406
4407         spec->vmaster_nid = 0x0c;
4408
4409         codec->patch_ops = alc_patch_ops;
4410         if (board_config == ALC_MODEL_AUTO)
4411                 spec->init_hook = alc_auto_init_std;
4412
4413         alc_init_jacks(codec);
4414 #ifdef CONFIG_SND_HDA_POWER_SAVE
4415         if (!spec->loopback.amplist)
4416                 spec->loopback.amplist = alc882_loopbacks;
4417 #endif
4418
4419         return 0;
4420
4421  error:
4422         alc_free(codec);
4423         return err;
4424 }
4425
4426
4427 /*
4428  * ALC262 support
4429  */
4430 static int alc262_parse_auto_config(struct hda_codec *codec)
4431 {
4432         static const hda_nid_t alc262_ignore[] = { 0x1d, 0 };
4433         static const hda_nid_t alc262_ssids[] = { 0x15, 0x1b, 0x14, 0 };
4434         return alc_parse_auto_config(codec, alc262_ignore, alc262_ssids);
4435 }
4436
4437 /*
4438  * Pin config fixes
4439  */
4440 enum {
4441         PINFIX_FSC_H270,
4442         PINFIX_HP_Z200,
4443 };
4444
4445 static const struct alc_fixup alc262_fixups[] = {
4446         [PINFIX_FSC_H270] = {
4447                 .type = ALC_FIXUP_PINS,
4448                 .v.pins = (const struct alc_pincfg[]) {
4449                         { 0x14, 0x99130110 }, /* speaker */
4450                         { 0x15, 0x0221142f }, /* front HP */
4451                         { 0x1b, 0x0121141f }, /* rear HP */
4452                         { }
4453                 }
4454         },
4455         [PINFIX_HP_Z200] = {
4456                 .type = ALC_FIXUP_PINS,
4457                 .v.pins = (const struct alc_pincfg[]) {
4458                         { 0x16, 0x99130120 }, /* internal speaker */
4459                         { }
4460                 }
4461         },
4462 };
4463
4464 static const struct snd_pci_quirk alc262_fixup_tbl[] = {
4465         SND_PCI_QUIRK(0x103c, 0x170b, "HP Z200", PINFIX_HP_Z200),
4466         SND_PCI_QUIRK(0x1734, 0x1147, "FSC Celsius H270", PINFIX_FSC_H270),
4467         {}
4468 };
4469
4470
4471 #ifdef CONFIG_SND_HDA_POWER_SAVE
4472 #define alc262_loopbacks        alc880_loopbacks
4473 #endif
4474
4475 /*
4476  */
4477 #ifdef CONFIG_SND_HDA_ENABLE_REALTEK_QUIRKS
4478 #include "alc262_quirks.c"
4479 #endif
4480
4481 static int patch_alc262(struct hda_codec *codec)
4482 {
4483         struct alc_spec *spec;
4484         int board_config;
4485         int err;
4486
4487         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
4488         if (spec == NULL)
4489                 return -ENOMEM;
4490
4491         codec->spec = spec;
4492
4493         spec->mixer_nid = 0x0b;
4494
4495 #if 0
4496         /* pshou 07/11/05  set a zero PCM sample to DAC when FIFO is
4497          * under-run
4498          */
4499         {
4500         int tmp;
4501         snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_COEF_INDEX, 7);
4502         tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0);
4503         snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_COEF_INDEX, 7);
4504         snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_PROC_COEF, tmp | 0x80);
4505         }
4506 #endif
4507         alc_auto_parse_customize_define(codec);
4508
4509         alc_fix_pll_init(codec, 0x20, 0x0a, 10);
4510
4511         board_config = alc_board_config(codec, ALC262_MODEL_LAST,
4512                                         alc262_models, alc262_cfg_tbl);
4513
4514         if (board_config < 0) {
4515                 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
4516                        codec->chip_name);
4517                 board_config = ALC_MODEL_AUTO;
4518         }
4519
4520         if (board_config == ALC_MODEL_AUTO) {
4521                 alc_pick_fixup(codec, NULL, alc262_fixup_tbl, alc262_fixups);
4522                 alc_apply_fixup(codec, ALC_FIXUP_ACT_PRE_PROBE);
4523         }
4524
4525         if (board_config == ALC_MODEL_AUTO) {
4526                 /* automatic parse from the BIOS config */
4527                 err = alc262_parse_auto_config(codec);
4528                 if (err < 0)
4529                         goto error;
4530 #ifdef CONFIG_SND_HDA_ENABLE_REALTEK_QUIRKS
4531                 else if (!err) {
4532                         printk(KERN_INFO
4533                                "hda_codec: Cannot set up configuration "
4534                                "from BIOS.  Using base mode...\n");
4535                         board_config = ALC262_BASIC;
4536                 }
4537 #endif
4538         }
4539
4540         if (board_config != ALC_MODEL_AUTO)
4541                 setup_preset(codec, &alc262_presets[board_config]);
4542
4543         if (!spec->no_analog && !spec->adc_nids) {
4544                 alc_auto_fill_adc_caps(codec);
4545                 alc_rebuild_imux_for_auto_mic(codec);
4546                 alc_remove_invalid_adc_nids(codec);
4547         }
4548
4549         if (!spec->no_analog && !spec->cap_mixer)
4550                 set_capture_mixer(codec);
4551
4552         if (!spec->no_analog && has_cdefine_beep(codec)) {
4553                 err = snd_hda_attach_beep_device(codec, 0x1);
4554                 if (err < 0)
4555                         goto error;
4556                 set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
4557         }
4558
4559         alc_apply_fixup(codec, ALC_FIXUP_ACT_PROBE);
4560
4561         spec->vmaster_nid = 0x0c;
4562
4563         codec->patch_ops = alc_patch_ops;
4564         if (board_config == ALC_MODEL_AUTO)
4565                 spec->init_hook = alc_auto_init_std;
4566         spec->shutup = alc_eapd_shutup;
4567
4568         alc_init_jacks(codec);
4569 #ifdef CONFIG_SND_HDA_POWER_SAVE
4570         if (!spec->loopback.amplist)
4571                 spec->loopback.amplist = alc262_loopbacks;
4572 #endif
4573
4574         return 0;
4575
4576  error:
4577         alc_free(codec);
4578         return err;
4579 }
4580
4581 /*
4582  *  ALC268
4583  */
4584 /* bind Beep switches of both NID 0x0f and 0x10 */
4585 static const struct hda_bind_ctls alc268_bind_beep_sw = {
4586         .ops = &snd_hda_bind_sw,
4587         .values = {
4588                 HDA_COMPOSE_AMP_VAL(0x0f, 3, 1, HDA_INPUT),
4589                 HDA_COMPOSE_AMP_VAL(0x10, 3, 1, HDA_INPUT),
4590                 0
4591         },
4592 };
4593
4594 static const struct snd_kcontrol_new alc268_beep_mixer[] = {
4595         HDA_CODEC_VOLUME("Beep Playback Volume", 0x1d, 0x0, HDA_INPUT),
4596         HDA_BIND_SW("Beep Playback Switch", &alc268_bind_beep_sw),
4597         { }
4598 };
4599
4600 /* set PCBEEP vol = 0, mute connections */
4601 static const struct hda_verb alc268_beep_init_verbs[] = {
4602         {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4603         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4604         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4605         { }
4606 };
4607
4608 /*
4609  * BIOS auto configuration
4610  */
4611 static int alc268_parse_auto_config(struct hda_codec *codec)
4612 {
4613         static const hda_nid_t alc268_ssids[] = { 0x15, 0x1b, 0x14, 0 };
4614         struct alc_spec *spec = codec->spec;
4615         int err = alc_parse_auto_config(codec, NULL, alc268_ssids);
4616         if (err > 0) {
4617                 if (!spec->no_analog && spec->autocfg.speaker_pins[0] != 0x1d) {
4618                         add_mixer(spec, alc268_beep_mixer);
4619                         add_verb(spec, alc268_beep_init_verbs);
4620                 }
4621         }
4622         return err;
4623 }
4624
4625 /*
4626  */
4627 static int patch_alc268(struct hda_codec *codec)
4628 {
4629         struct alc_spec *spec;
4630         int i, has_beep, err;
4631
4632         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
4633         if (spec == NULL)
4634                 return -ENOMEM;
4635
4636         codec->spec = spec;
4637
4638         /* ALC268 has no aa-loopback mixer */
4639
4640         /* automatic parse from the BIOS config */
4641         err = alc268_parse_auto_config(codec);
4642         if (err < 0)
4643                 goto error;
4644
4645         has_beep = 0;
4646         for (i = 0; i < spec->num_mixers; i++) {
4647                 if (spec->mixers[i] == alc268_beep_mixer) {
4648                         has_beep = 1;
4649                         break;
4650                 }
4651         }
4652
4653         if (has_beep) {
4654                 err = snd_hda_attach_beep_device(codec, 0x1);
4655                 if (err < 0)
4656                         goto error;
4657                 if (!query_amp_caps(codec, 0x1d, HDA_INPUT))
4658                         /* override the amp caps for beep generator */
4659                         snd_hda_override_amp_caps(codec, 0x1d, HDA_INPUT,
4660                                           (0x0c << AC_AMPCAP_OFFSET_SHIFT) |
4661                                           (0x0c << AC_AMPCAP_NUM_STEPS_SHIFT) |
4662                                           (0x07 << AC_AMPCAP_STEP_SIZE_SHIFT) |
4663                                           (0 << AC_AMPCAP_MUTE_SHIFT));
4664         }
4665
4666         if (!spec->no_analog && !spec->adc_nids) {
4667                 alc_auto_fill_adc_caps(codec);
4668                 alc_rebuild_imux_for_auto_mic(codec);
4669                 alc_remove_invalid_adc_nids(codec);
4670         }
4671
4672         if (!spec->no_analog && !spec->cap_mixer)
4673                 set_capture_mixer(codec);
4674
4675         spec->vmaster_nid = 0x02;
4676
4677         codec->patch_ops = alc_patch_ops;
4678         spec->init_hook = alc_auto_init_std;
4679         spec->shutup = alc_eapd_shutup;
4680
4681         alc_init_jacks(codec);
4682
4683         return 0;
4684
4685  error:
4686         alc_free(codec);
4687         return err;
4688 }
4689
4690 /*
4691  * ALC269
4692  */
4693 #ifdef CONFIG_SND_HDA_POWER_SAVE
4694 #define alc269_loopbacks        alc880_loopbacks
4695 #endif
4696
4697 static const struct hda_pcm_stream alc269_44k_pcm_analog_playback = {
4698         .substreams = 1,
4699         .channels_min = 2,
4700         .channels_max = 8,
4701         .rates = SNDRV_PCM_RATE_44100, /* fixed rate */
4702         /* NID is set in alc_build_pcms */
4703         .ops = {
4704                 .open = alc_playback_pcm_open,
4705                 .prepare = alc_playback_pcm_prepare,
4706                 .cleanup = alc_playback_pcm_cleanup
4707         },
4708 };
4709
4710 static const struct hda_pcm_stream alc269_44k_pcm_analog_capture = {
4711         .substreams = 1,
4712         .channels_min = 2,
4713         .channels_max = 2,
4714         .rates = SNDRV_PCM_RATE_44100, /* fixed rate */
4715         /* NID is set in alc_build_pcms */
4716 };
4717
4718 #ifdef CONFIG_SND_HDA_POWER_SAVE
4719 static int alc269_mic2_for_mute_led(struct hda_codec *codec)
4720 {
4721         switch (codec->subsystem_id) {
4722         case 0x103c1586:
4723                 return 1;
4724         }
4725         return 0;
4726 }
4727
4728 static int alc269_mic2_mute_check_ps(struct hda_codec *codec, hda_nid_t nid)
4729 {
4730         /* update mute-LED according to the speaker mute state */
4731         if (nid == 0x01 || nid == 0x14) {
4732                 int pinval;
4733                 if (snd_hda_codec_amp_read(codec, 0x14, 0, HDA_OUTPUT, 0) &
4734                     HDA_AMP_MUTE)
4735                         pinval = 0x24;
4736                 else
4737                         pinval = 0x20;
4738                 /* mic2 vref pin is used for mute LED control */
4739                 snd_hda_codec_update_cache(codec, 0x19, 0,
4740                                            AC_VERB_SET_PIN_WIDGET_CONTROL,
4741                                            pinval);
4742         }
4743         return alc_check_power_status(codec, nid);
4744 }
4745 #endif /* CONFIG_SND_HDA_POWER_SAVE */
4746
4747 /* different alc269-variants */
4748 enum {
4749         ALC269_TYPE_ALC269VA,
4750         ALC269_TYPE_ALC269VB,
4751         ALC269_TYPE_ALC269VC,
4752 };
4753
4754 /*
4755  * BIOS auto configuration
4756  */
4757 static int alc269_parse_auto_config(struct hda_codec *codec)
4758 {
4759         static const hda_nid_t alc269_ignore[] = { 0x1d, 0 };
4760         static const hda_nid_t alc269_ssids[] = { 0, 0x1b, 0x14, 0x21 };
4761         static const hda_nid_t alc269va_ssids[] = { 0x15, 0x1b, 0x14, 0 };
4762         struct alc_spec *spec = codec->spec;
4763         const hda_nid_t *ssids = spec->codec_variant == ALC269_TYPE_ALC269VA ?
4764                 alc269va_ssids : alc269_ssids;
4765
4766         return alc_parse_auto_config(codec, alc269_ignore, ssids);
4767 }
4768
4769 static void alc269_toggle_power_output(struct hda_codec *codec, int power_up)
4770 {
4771         int val = alc_read_coef_idx(codec, 0x04);
4772         if (power_up)
4773                 val |= 1 << 11;
4774         else
4775                 val &= ~(1 << 11);
4776         alc_write_coef_idx(codec, 0x04, val);
4777 }
4778
4779 static void alc269_shutup(struct hda_codec *codec)
4780 {
4781         if ((alc_get_coef0(codec) & 0x00ff) == 0x017)
4782                 alc269_toggle_power_output(codec, 0);
4783         if ((alc_get_coef0(codec) & 0x00ff) == 0x018) {
4784                 alc269_toggle_power_output(codec, 0);
4785                 msleep(150);
4786         }
4787 }
4788
4789 #ifdef CONFIG_PM
4790 static int alc269_resume(struct hda_codec *codec)
4791 {
4792         if ((alc_get_coef0(codec) & 0x00ff) == 0x018) {
4793                 alc269_toggle_power_output(codec, 0);
4794                 msleep(150);
4795         }
4796
4797         codec->patch_ops.init(codec);
4798
4799         if ((alc_get_coef0(codec) & 0x00ff) == 0x017) {
4800                 alc269_toggle_power_output(codec, 1);
4801                 msleep(200);
4802         }
4803
4804         if ((alc_get_coef0(codec) & 0x00ff) == 0x018)
4805                 alc269_toggle_power_output(codec, 1);
4806
4807         snd_hda_codec_resume_amp(codec);
4808         snd_hda_codec_resume_cache(codec);
4809         hda_call_check_power_status(codec, 0x01);
4810         return 0;
4811 }
4812 #endif /* CONFIG_PM */
4813
4814 static void alc269_fixup_pincfg_no_hp_to_lineout(struct hda_codec *codec,
4815                                                  const struct alc_fixup *fix, int action)
4816 {
4817         struct alc_spec *spec = codec->spec;
4818
4819         if (action == ALC_FIXUP_ACT_PRE_PROBE)
4820                 spec->parse_flags = HDA_PINCFG_NO_HP_FIXUP;
4821 }
4822
4823 static void alc269_fixup_hweq(struct hda_codec *codec,
4824                                const struct alc_fixup *fix, int action)
4825 {
4826         int coef;
4827
4828         if (action != ALC_FIXUP_ACT_INIT)
4829                 return;
4830         coef = alc_read_coef_idx(codec, 0x1e);
4831         alc_write_coef_idx(codec, 0x1e, coef | 0x80);
4832 }
4833
4834 static void alc271_fixup_dmic(struct hda_codec *codec,
4835                               const struct alc_fixup *fix, int action)
4836 {
4837         static const struct hda_verb verbs[] = {
4838                 {0x20, AC_VERB_SET_COEF_INDEX, 0x0d},
4839                 {0x20, AC_VERB_SET_PROC_COEF, 0x4000},
4840                 {}
4841         };
4842         unsigned int cfg;
4843
4844         if (strcmp(codec->chip_name, "ALC271X"))
4845                 return;
4846         cfg = snd_hda_codec_get_pincfg(codec, 0x12);
4847         if (get_defcfg_connect(cfg) == AC_JACK_PORT_FIXED)
4848                 snd_hda_sequence_write(codec, verbs);
4849 }
4850
4851 static void alc269_fixup_pcm_44k(struct hda_codec *codec,
4852                                  const struct alc_fixup *fix, int action)
4853 {
4854         struct alc_spec *spec = codec->spec;
4855
4856         if (action != ALC_FIXUP_ACT_PROBE)
4857                 return;
4858
4859         /* Due to a hardware problem on Lenovo Ideadpad, we need to
4860          * fix the sample rate of analog I/O to 44.1kHz
4861          */
4862         spec->stream_analog_playback = &alc269_44k_pcm_analog_playback;
4863         spec->stream_analog_capture = &alc269_44k_pcm_analog_capture;
4864 }
4865
4866 static void alc269_fixup_stereo_dmic(struct hda_codec *codec,
4867                                      const struct alc_fixup *fix, int action)
4868 {
4869         int coef;
4870
4871         if (action != ALC_FIXUP_ACT_INIT)
4872                 return;
4873         /* The digital-mic unit sends PDM (differential signal) instead of
4874          * the standard PCM, thus you can't record a valid mono stream as is.
4875          * Below is a workaround specific to ALC269 to control the dmic
4876          * signal source as mono.
4877          */
4878         coef = alc_read_coef_idx(codec, 0x07);
4879         alc_write_coef_idx(codec, 0x07, coef | 0x80);
4880 }
4881
4882 static void alc269_quanta_automute(struct hda_codec *codec)
4883 {
4884         update_outputs(codec);
4885
4886         snd_hda_codec_write(codec, 0x20, 0,
4887                         AC_VERB_SET_COEF_INDEX, 0x0c);
4888         snd_hda_codec_write(codec, 0x20, 0,
4889                         AC_VERB_SET_PROC_COEF, 0x680);
4890
4891         snd_hda_codec_write(codec, 0x20, 0,
4892                         AC_VERB_SET_COEF_INDEX, 0x0c);
4893         snd_hda_codec_write(codec, 0x20, 0,
4894                         AC_VERB_SET_PROC_COEF, 0x480);
4895 }
4896
4897 static void alc269_fixup_quanta_mute(struct hda_codec *codec,
4898                                      const struct alc_fixup *fix, int action)
4899 {
4900         struct alc_spec *spec = codec->spec;
4901         if (action != ALC_FIXUP_ACT_PROBE)
4902                 return;
4903         spec->automute_hook = alc269_quanta_automute;
4904 }
4905
4906 enum {
4907         ALC269_FIXUP_SONY_VAIO,
4908         ALC275_FIXUP_SONY_VAIO_GPIO2,
4909         ALC269_FIXUP_DELL_M101Z,
4910         ALC269_FIXUP_SKU_IGNORE,
4911         ALC269_FIXUP_ASUS_G73JW,
4912         ALC269_FIXUP_LENOVO_EAPD,
4913         ALC275_FIXUP_SONY_HWEQ,
4914         ALC271_FIXUP_DMIC,
4915         ALC269_FIXUP_PCM_44K,
4916         ALC269_FIXUP_STEREO_DMIC,
4917         ALC269_FIXUP_QUANTA_MUTE,
4918         ALC269_FIXUP_LIFEBOOK,
4919         ALC269_FIXUP_AMIC,
4920         ALC269_FIXUP_DMIC,
4921         ALC269VB_FIXUP_AMIC,
4922         ALC269VB_FIXUP_DMIC,
4923         ALC269_FIXUP_LENOVO_DOCK,
4924         ALC269_FIXUP_PINCFG_NO_HP_TO_LINEOUT,
4925 };
4926
4927 static const struct alc_fixup alc269_fixups[] = {
4928         [ALC269_FIXUP_SONY_VAIO] = {
4929                 .type = ALC_FIXUP_VERBS,
4930                 .v.verbs = (const struct hda_verb[]) {
4931                         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREFGRD},
4932                         {}
4933                 }
4934         },
4935         [ALC275_FIXUP_SONY_VAIO_GPIO2] = {
4936                 .type = ALC_FIXUP_VERBS,
4937                 .v.verbs = (const struct hda_verb[]) {
4938                         {0x01, AC_VERB_SET_GPIO_MASK, 0x04},
4939                         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x04},
4940                         {0x01, AC_VERB_SET_GPIO_DATA, 0x00},
4941                         { }
4942                 },
4943                 .chained = true,
4944                 .chain_id = ALC269_FIXUP_SONY_VAIO
4945         },
4946         [ALC269_FIXUP_DELL_M101Z] = {
4947                 .type = ALC_FIXUP_VERBS,
4948                 .v.verbs = (const struct hda_verb[]) {
4949                         /* Enables internal speaker */
4950                         {0x20, AC_VERB_SET_COEF_INDEX, 13},
4951                         {0x20, AC_VERB_SET_PROC_COEF, 0x4040},
4952                         {}
4953                 }
4954         },
4955         [ALC269_FIXUP_SKU_IGNORE] = {
4956                 .type = ALC_FIXUP_SKU,
4957                 .v.sku = ALC_FIXUP_SKU_IGNORE,
4958         },
4959         [ALC269_FIXUP_ASUS_G73JW] = {
4960                 .type = ALC_FIXUP_PINS,
4961                 .v.pins = (const struct alc_pincfg[]) {
4962                         { 0x17, 0x99130111 }, /* subwoofer */
4963                         { }
4964                 }
4965         },
4966         [ALC269_FIXUP_LENOVO_EAPD] = {
4967                 .type = ALC_FIXUP_VERBS,
4968                 .v.verbs = (const struct hda_verb[]) {
4969                         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 0},
4970                         {}
4971                 }
4972         },
4973         [ALC275_FIXUP_SONY_HWEQ] = {
4974                 .type = ALC_FIXUP_FUNC,
4975                 .v.func = alc269_fixup_hweq,
4976                 .chained = true,
4977                 .chain_id = ALC275_FIXUP_SONY_VAIO_GPIO2
4978         },
4979         [ALC271_FIXUP_DMIC] = {
4980                 .type = ALC_FIXUP_FUNC,
4981                 .v.func = alc271_fixup_dmic,
4982         },
4983         [ALC269_FIXUP_PCM_44K] = {
4984                 .type = ALC_FIXUP_FUNC,
4985                 .v.func = alc269_fixup_pcm_44k,
4986                 .chained = true,
4987                 .chain_id = ALC269_FIXUP_QUANTA_MUTE
4988         },
4989         [ALC269_FIXUP_STEREO_DMIC] = {
4990                 .type = ALC_FIXUP_FUNC,
4991                 .v.func = alc269_fixup_stereo_dmic,
4992         },
4993         [ALC269_FIXUP_QUANTA_MUTE] = {
4994                 .type = ALC_FIXUP_FUNC,
4995                 .v.func = alc269_fixup_quanta_mute,
4996         },
4997         [ALC269_FIXUP_LIFEBOOK] = {
4998                 .type = ALC_FIXUP_PINS,
4999                 .v.pins = (const struct alc_pincfg[]) {
5000                         { 0x1a, 0x2101103f }, /* dock line-out */
5001                         { 0x1b, 0x23a11040 }, /* dock mic-in */
5002                         { }
5003                 },
5004                 .chained = true,
5005                 .chain_id = ALC269_FIXUP_QUANTA_MUTE
5006         },
5007         [ALC269_FIXUP_AMIC] = {
5008                 .type = ALC_FIXUP_PINS,
5009                 .v.pins = (const struct alc_pincfg[]) {
5010                         { 0x14, 0x99130110 }, /* speaker */
5011                         { 0x15, 0x0121401f }, /* HP out */
5012                         { 0x18, 0x01a19c20 }, /* mic */
5013                         { 0x19, 0x99a3092f }, /* int-mic */
5014                         { }
5015                 },
5016         },
5017         [ALC269_FIXUP_DMIC] = {
5018                 .type = ALC_FIXUP_PINS,
5019                 .v.pins = (const struct alc_pincfg[]) {
5020                         { 0x12, 0x99a3092f }, /* int-mic */
5021                         { 0x14, 0x99130110 }, /* speaker */
5022                         { 0x15, 0x0121401f }, /* HP out */
5023                         { 0x18, 0x01a19c20 }, /* mic */
5024                         { }
5025                 },
5026         },
5027         [ALC269VB_FIXUP_AMIC] = {
5028                 .type = ALC_FIXUP_PINS,
5029                 .v.pins = (const struct alc_pincfg[]) {
5030                         { 0x14, 0x99130110 }, /* speaker */
5031                         { 0x18, 0x01a19c20 }, /* mic */
5032                         { 0x19, 0x99a3092f }, /* int-mic */
5033                         { 0x21, 0x0121401f }, /* HP out */
5034                         { }
5035                 },
5036         },
5037         [ALC269_FIXUP_DMIC] = {
5038                 .type = ALC_FIXUP_PINS,
5039                 .v.pins = (const struct alc_pincfg[]) {
5040                         { 0x12, 0x99a3092f }, /* int-mic */
5041                         { 0x14, 0x99130110 }, /* speaker */
5042                         { 0x18, 0x01a19c20 }, /* mic */
5043                         { 0x21, 0x0121401f }, /* HP out */
5044                         { }
5045                 },
5046         },
5047         [ALC269_FIXUP_LENOVO_DOCK] = {
5048                 .type = ALC_FIXUP_PINS,
5049                 .v.pins = (const struct alc_pincfg[]) {
5050                         { 0x19, 0x23a11040 }, /* dock mic */
5051                         { 0x1b, 0x2121103f }, /* dock headphone */
5052                         { }
5053                 },
5054                 .chained = true,
5055                 .chain_id = ALC269_FIXUP_PINCFG_NO_HP_TO_LINEOUT
5056         },
5057         [ALC269_FIXUP_PINCFG_NO_HP_TO_LINEOUT] = {
5058                 .type = ALC_FIXUP_FUNC,
5059                 .v.func = alc269_fixup_pincfg_no_hp_to_lineout,
5060         },
5061 };
5062
5063 static const struct snd_pci_quirk alc269_fixup_tbl[] = {
5064         SND_PCI_QUIRK(0x1043, 0x1427, "Asus Zenbook UX31E", ALC269VB_FIXUP_DMIC),
5065         SND_PCI_QUIRK(0x1043, 0x1a13, "Asus G73Jw", ALC269_FIXUP_ASUS_G73JW),
5066         SND_PCI_QUIRK(0x1043, 0x16e3, "ASUS UX50", ALC269_FIXUP_STEREO_DMIC),
5067         SND_PCI_QUIRK(0x1043, 0x831a, "ASUS P901", ALC269_FIXUP_STEREO_DMIC),
5068         SND_PCI_QUIRK(0x1043, 0x834a, "ASUS S101", ALC269_FIXUP_STEREO_DMIC),
5069         SND_PCI_QUIRK(0x1043, 0x8398, "ASUS P1005", ALC269_FIXUP_STEREO_DMIC),
5070         SND_PCI_QUIRK(0x1043, 0x83ce, "ASUS P1005", ALC269_FIXUP_STEREO_DMIC),
5071         SND_PCI_QUIRK(0x104d, 0x9073, "Sony VAIO", ALC275_FIXUP_SONY_VAIO_GPIO2),
5072         SND_PCI_QUIRK(0x104d, 0x907b, "Sony VAIO", ALC275_FIXUP_SONY_HWEQ),
5073         SND_PCI_QUIRK(0x104d, 0x9084, "Sony VAIO", ALC275_FIXUP_SONY_HWEQ),
5074         SND_PCI_QUIRK_VENDOR(0x104d, "Sony VAIO", ALC269_FIXUP_SONY_VAIO),
5075         SND_PCI_QUIRK(0x1028, 0x0470, "Dell M101z", ALC269_FIXUP_DELL_M101Z),
5076         SND_PCI_QUIRK_VENDOR(0x1025, "Acer Aspire", ALC271_FIXUP_DMIC),
5077         SND_PCI_QUIRK(0x10cf, 0x1475, "Lifebook", ALC269_FIXUP_LIFEBOOK),
5078         SND_PCI_QUIRK(0x17aa, 0x20f2, "Thinkpad SL410/510", ALC269_FIXUP_SKU_IGNORE),
5079         SND_PCI_QUIRK(0x17aa, 0x215e, "Thinkpad L512", ALC269_FIXUP_SKU_IGNORE),
5080         SND_PCI_QUIRK(0x17aa, 0x21b8, "Thinkpad Edge 14", ALC269_FIXUP_SKU_IGNORE),
5081         SND_PCI_QUIRK(0x17aa, 0x21ca, "Thinkpad L412", ALC269_FIXUP_SKU_IGNORE),
5082         SND_PCI_QUIRK(0x17aa, 0x21e9, "Thinkpad Edge 15", ALC269_FIXUP_SKU_IGNORE),
5083         SND_PCI_QUIRK(0x17aa, 0x21f6, "Thinkpad T530", ALC269_FIXUP_LENOVO_DOCK),
5084         SND_PCI_QUIRK(0x17aa, 0x21fa, "Thinkpad X230", ALC269_FIXUP_LENOVO_DOCK),
5085         SND_PCI_QUIRK(0x17aa, 0x21fb, "Thinkpad T430s", ALC269_FIXUP_LENOVO_DOCK),
5086         SND_PCI_QUIRK(0x17aa, 0x2203, "Thinkpad X230 Tablet", ALC269_FIXUP_LENOVO_DOCK),
5087         SND_PCI_QUIRK(0x17aa, 0x3bf8, "Quanta FL1", ALC269_FIXUP_PCM_44K),
5088         SND_PCI_QUIRK(0x17aa, 0x9e54, "LENOVO NB", ALC269_FIXUP_LENOVO_EAPD),
5089
5090 #if 1
5091         /* Below is a quirk table taken from the old code.
5092          * Basically the device should work as is without the fixup table.
5093          * If BIOS doesn't give a proper info, enable the corresponding
5094          * fixup entry.
5095          */
5096         SND_PCI_QUIRK(0x1043, 0x8330, "ASUS Eeepc P703 P900A",
5097                       ALC269_FIXUP_AMIC),
5098         SND_PCI_QUIRK(0x1043, 0x1013, "ASUS N61Da", ALC269_FIXUP_AMIC),
5099         SND_PCI_QUIRK(0x1043, 0x1143, "ASUS B53f", ALC269_FIXUP_AMIC),
5100         SND_PCI_QUIRK(0x1043, 0x1133, "ASUS UJ20ft", ALC269_FIXUP_AMIC),
5101         SND_PCI_QUIRK(0x1043, 0x1183, "ASUS K72DR", ALC269_FIXUP_AMIC),
5102         SND_PCI_QUIRK(0x1043, 0x11b3, "ASUS K52DR", ALC269_FIXUP_AMIC),
5103         SND_PCI_QUIRK(0x1043, 0x11e3, "ASUS U33Jc", ALC269_FIXUP_AMIC),
5104         SND_PCI_QUIRK(0x1043, 0x1273, "ASUS UL80Jt", ALC269_FIXUP_AMIC),
5105         SND_PCI_QUIRK(0x1043, 0x1283, "ASUS U53Jc", ALC269_FIXUP_AMIC),
5106         SND_PCI_QUIRK(0x1043, 0x12b3, "ASUS N82JV", ALC269_FIXUP_AMIC),
5107         SND_PCI_QUIRK(0x1043, 0x12d3, "ASUS N61Jv", ALC269_FIXUP_AMIC),
5108         SND_PCI_QUIRK(0x1043, 0x13a3, "ASUS UL30Vt", ALC269_FIXUP_AMIC),
5109         SND_PCI_QUIRK(0x1043, 0x1373, "ASUS G73JX", ALC269_FIXUP_AMIC),
5110         SND_PCI_QUIRK(0x1043, 0x1383, "ASUS UJ30Jc", ALC269_FIXUP_AMIC),
5111         SND_PCI_QUIRK(0x1043, 0x13d3, "ASUS N61JA", ALC269_FIXUP_AMIC),
5112         SND_PCI_QUIRK(0x1043, 0x1413, "ASUS UL50", ALC269_FIXUP_AMIC),
5113         SND_PCI_QUIRK(0x1043, 0x1443, "ASUS UL30", ALC269_FIXUP_AMIC),
5114         SND_PCI_QUIRK(0x1043, 0x1453, "ASUS M60Jv", ALC269_FIXUP_AMIC),
5115         SND_PCI_QUIRK(0x1043, 0x1483, "ASUS UL80", ALC269_FIXUP_AMIC),
5116         SND_PCI_QUIRK(0x1043, 0x14f3, "ASUS F83Vf", ALC269_FIXUP_AMIC),
5117         SND_PCI_QUIRK(0x1043, 0x14e3, "ASUS UL20", ALC269_FIXUP_AMIC),
5118         SND_PCI_QUIRK(0x1043, 0x1513, "ASUS UX30", ALC269_FIXUP_AMIC),
5119         SND_PCI_QUIRK(0x1043, 0x1593, "ASUS N51Vn", ALC269_FIXUP_AMIC),
5120         SND_PCI_QUIRK(0x1043, 0x15a3, "ASUS N60Jv", ALC269_FIXUP_AMIC),
5121         SND_PCI_QUIRK(0x1043, 0x15b3, "ASUS N60Dp", ALC269_FIXUP_AMIC),
5122         SND_PCI_QUIRK(0x1043, 0x15c3, "ASUS N70De", ALC269_FIXUP_AMIC),
5123         SND_PCI_QUIRK(0x1043, 0x15e3, "ASUS F83T", ALC269_FIXUP_AMIC),
5124         SND_PCI_QUIRK(0x1043, 0x1643, "ASUS M60J", ALC269_FIXUP_AMIC),
5125         SND_PCI_QUIRK(0x1043, 0x1653, "ASUS U50", ALC269_FIXUP_AMIC),
5126         SND_PCI_QUIRK(0x1043, 0x1693, "ASUS F50N", ALC269_FIXUP_AMIC),
5127         SND_PCI_QUIRK(0x1043, 0x16a3, "ASUS F5Q", ALC269_FIXUP_AMIC),
5128         SND_PCI_QUIRK(0x1043, 0x1723, "ASUS P80", ALC269_FIXUP_AMIC),
5129         SND_PCI_QUIRK(0x1043, 0x1743, "ASUS U80", ALC269_FIXUP_AMIC),
5130         SND_PCI_QUIRK(0x1043, 0x1773, "ASUS U20A", ALC269_FIXUP_AMIC),
5131         SND_PCI_QUIRK(0x1043, 0x1883, "ASUS F81Se", ALC269_FIXUP_AMIC),
5132         SND_PCI_QUIRK(0x152d, 0x1778, "Quanta ON1", ALC269_FIXUP_DMIC),
5133         SND_PCI_QUIRK(0x17aa, 0x3be9, "Quanta Wistron", ALC269_FIXUP_AMIC),
5134         SND_PCI_QUIRK(0x17aa, 0x3bf8, "Quanta FL1", ALC269_FIXUP_AMIC),
5135         SND_PCI_QUIRK(0x17ff, 0x059a, "Quanta EL3", ALC269_FIXUP_DMIC),
5136         SND_PCI_QUIRK(0x17ff, 0x059b, "Quanta JR1", ALC269_FIXUP_DMIC),
5137 #endif
5138         {}
5139 };
5140
5141 static const struct alc_model_fixup alc269_fixup_models[] = {
5142         {.id = ALC269_FIXUP_AMIC, .name = "laptop-amic"},
5143         {.id = ALC269_FIXUP_DMIC, .name = "laptop-dmic"},
5144         {.id = ALC269_FIXUP_LENOVO_DOCK, .name = "lenovo-dock"},
5145         {}
5146 };
5147
5148
5149 static int alc269_fill_coef(struct hda_codec *codec)
5150 {
5151         struct alc_spec *spec = codec->spec;
5152         int val;
5153
5154         if (spec->codec_variant != ALC269_TYPE_ALC269VB)
5155                 return 0;
5156
5157         if ((alc_get_coef0(codec) & 0x00ff) < 0x015) {
5158                 alc_write_coef_idx(codec, 0xf, 0x960b);
5159                 alc_write_coef_idx(codec, 0xe, 0x8817);
5160         }
5161
5162         if ((alc_get_coef0(codec) & 0x00ff) == 0x016) {
5163                 alc_write_coef_idx(codec, 0xf, 0x960b);
5164                 alc_write_coef_idx(codec, 0xe, 0x8814);
5165         }
5166
5167         if ((alc_get_coef0(codec) & 0x00ff) == 0x017) {
5168                 val = alc_read_coef_idx(codec, 0x04);
5169                 /* Power up output pin */
5170                 alc_write_coef_idx(codec, 0x04, val | (1<<11));
5171         }
5172
5173         if ((alc_get_coef0(codec) & 0x00ff) == 0x018) {
5174                 val = alc_read_coef_idx(codec, 0xd);
5175                 if ((val & 0x0c00) >> 10 != 0x1) {
5176                         /* Capless ramp up clock control */
5177                         alc_write_coef_idx(codec, 0xd, val | (1<<10));
5178                 }
5179                 val = alc_read_coef_idx(codec, 0x17);
5180                 if ((val & 0x01c0) >> 6 != 0x4) {
5181                         /* Class D power on reset */
5182                         alc_write_coef_idx(codec, 0x17, val | (1<<7));
5183                 }
5184         }
5185
5186         val = alc_read_coef_idx(codec, 0xd); /* Class D */
5187         alc_write_coef_idx(codec, 0xd, val | (1<<14));
5188
5189         val = alc_read_coef_idx(codec, 0x4); /* HP */
5190         alc_write_coef_idx(codec, 0x4, val | (1<<11));
5191
5192         return 0;
5193 }
5194
5195 /*
5196  */
5197 static int patch_alc269(struct hda_codec *codec)
5198 {
5199         struct alc_spec *spec;
5200         int err = 0;
5201
5202         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
5203         if (spec == NULL)
5204                 return -ENOMEM;
5205
5206         codec->spec = spec;
5207
5208         spec->mixer_nid = 0x0b;
5209
5210         alc_auto_parse_customize_define(codec);
5211
5212         err = alc_codec_rename_from_preset(codec);
5213         if (err < 0)
5214                 goto error;
5215
5216         if (codec->vendor_id == 0x10ec0269) {
5217                 spec->codec_variant = ALC269_TYPE_ALC269VA;
5218                 switch (alc_get_coef0(codec) & 0x00f0) {
5219                 case 0x0010:
5220                         if (codec->bus->pci->subsystem_vendor == 0x1025 &&
5221                             spec->cdefine.platform_type == 1)
5222                                 err = alc_codec_rename(codec, "ALC271X");
5223                         spec->codec_variant = ALC269_TYPE_ALC269VB;
5224                         break;
5225                 case 0x0020:
5226                         if (codec->bus->pci->subsystem_vendor == 0x17aa &&
5227                             codec->bus->pci->subsystem_device == 0x21f3)
5228                                 err = alc_codec_rename(codec, "ALC3202");
5229                         spec->codec_variant = ALC269_TYPE_ALC269VC;
5230                         break;
5231                 default:
5232                         alc_fix_pll_init(codec, 0x20, 0x04, 15);
5233                 }
5234                 if (err < 0)
5235                         goto error;
5236                 alc269_fill_coef(codec);
5237         }
5238
5239         alc_pick_fixup(codec, alc269_fixup_models,
5240                        alc269_fixup_tbl, alc269_fixups);
5241         alc_apply_fixup(codec, ALC_FIXUP_ACT_PRE_PROBE);
5242
5243         /* automatic parse from the BIOS config */
5244         err = alc269_parse_auto_config(codec);
5245         if (err < 0)
5246                 goto error;
5247
5248         if (!spec->no_analog && !spec->adc_nids) {
5249                 alc_auto_fill_adc_caps(codec);
5250                 alc_rebuild_imux_for_auto_mic(codec);
5251                 alc_remove_invalid_adc_nids(codec);
5252         }
5253
5254         if (!spec->no_analog && !spec->cap_mixer)
5255                 set_capture_mixer(codec);
5256
5257         if (!spec->no_analog && has_cdefine_beep(codec)) {
5258                 err = snd_hda_attach_beep_device(codec, 0x1);
5259                 if (err < 0)
5260                         goto error;
5261                 set_beep_amp(spec, 0x0b, 0x04, HDA_INPUT);
5262         }
5263
5264         alc_apply_fixup(codec, ALC_FIXUP_ACT_PROBE);
5265
5266         spec->vmaster_nid = 0x02;
5267
5268         codec->patch_ops = alc_patch_ops;
5269 #ifdef CONFIG_PM
5270         codec->patch_ops.resume = alc269_resume;
5271 #endif
5272         spec->init_hook = alc_auto_init_std;
5273         spec->shutup = alc269_shutup;
5274
5275         alc_init_jacks(codec);
5276 #ifdef CONFIG_SND_HDA_POWER_SAVE
5277         if (!spec->loopback.amplist)
5278                 spec->loopback.amplist = alc269_loopbacks;
5279         if (alc269_mic2_for_mute_led(codec))
5280                 codec->patch_ops.check_power_status = alc269_mic2_mute_check_ps;
5281 #endif
5282
5283         return 0;
5284
5285  error:
5286         alc_free(codec);
5287         return err;
5288 }
5289
5290 /*
5291  * ALC861
5292  */
5293
5294 static int alc861_parse_auto_config(struct hda_codec *codec)
5295 {
5296         static const hda_nid_t alc861_ignore[] = { 0x1d, 0 };
5297         static const hda_nid_t alc861_ssids[] = { 0x0e, 0x0f, 0x0b, 0 };
5298         return alc_parse_auto_config(codec, alc861_ignore, alc861_ssids);
5299 }
5300
5301 #ifdef CONFIG_SND_HDA_POWER_SAVE
5302 static const struct hda_amp_list alc861_loopbacks[] = {
5303         { 0x15, HDA_INPUT, 0 },
5304         { 0x15, HDA_INPUT, 1 },
5305         { 0x15, HDA_INPUT, 2 },
5306         { 0x15, HDA_INPUT, 3 },
5307         { } /* end */
5308 };
5309 #endif
5310
5311
5312 /* Pin config fixes */
5313 enum {
5314         ALC861_FIXUP_FSC_AMILO_PI1505,
5315         ALC861_FIXUP_AMP_VREF_0F,
5316         ALC861_FIXUP_NO_JACK_DETECT,
5317         ALC861_FIXUP_ASUS_A6RP,
5318 };
5319
5320 /* On some laptops, VREF of pin 0x0f is abused for controlling the main amp */
5321 static void alc861_fixup_asus_amp_vref_0f(struct hda_codec *codec,
5322                         const struct alc_fixup *fix, int action)
5323 {
5324         struct alc_spec *spec = codec->spec;
5325         unsigned int val;
5326
5327         if (action != ALC_FIXUP_ACT_INIT)
5328                 return;
5329         val = snd_hda_codec_read(codec, 0x0f, 0,
5330                                  AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
5331         if (!(val & (AC_PINCTL_IN_EN | AC_PINCTL_OUT_EN)))
5332                 val |= AC_PINCTL_IN_EN;
5333         val |= AC_PINCTL_VREF_50;
5334         snd_hda_codec_write(codec, 0x0f, 0,
5335                             AC_VERB_SET_PIN_WIDGET_CONTROL, val);
5336         spec->keep_vref_in_automute = 1;
5337 }
5338
5339 /* suppress the jack-detection */
5340 static void alc_fixup_no_jack_detect(struct hda_codec *codec,
5341                                      const struct alc_fixup *fix, int action)
5342 {
5343         if (action == ALC_FIXUP_ACT_PRE_PROBE)
5344                 codec->no_jack_detect = 1;
5345 }
5346
5347 static const struct alc_fixup alc861_fixups[] = {
5348         [ALC861_FIXUP_FSC_AMILO_PI1505] = {
5349                 .type = ALC_FIXUP_PINS,
5350                 .v.pins = (const struct alc_pincfg[]) {
5351                         { 0x0b, 0x0221101f }, /* HP */
5352                         { 0x0f, 0x90170310 }, /* speaker */
5353                         { }
5354                 }
5355         },
5356         [ALC861_FIXUP_AMP_VREF_0F] = {
5357                 .type = ALC_FIXUP_FUNC,
5358                 .v.func = alc861_fixup_asus_amp_vref_0f,
5359         },
5360         [ALC861_FIXUP_NO_JACK_DETECT] = {
5361                 .type = ALC_FIXUP_FUNC,
5362                 .v.func = alc_fixup_no_jack_detect,
5363         },
5364         [ALC861_FIXUP_ASUS_A6RP] = {
5365                 .type = ALC_FIXUP_FUNC,
5366                 .v.func = alc861_fixup_asus_amp_vref_0f,
5367                 .chained = true,
5368                 .chain_id = ALC861_FIXUP_NO_JACK_DETECT,
5369         }
5370 };
5371
5372 static const struct snd_pci_quirk alc861_fixup_tbl[] = {
5373         SND_PCI_QUIRK(0x1043, 0x1393, "ASUS A6Rp", ALC861_FIXUP_ASUS_A6RP),
5374         SND_PCI_QUIRK_VENDOR(0x1043, "ASUS laptop", ALC861_FIXUP_AMP_VREF_0F),
5375         SND_PCI_QUIRK(0x1462, 0x7254, "HP DX2200", ALC861_FIXUP_NO_JACK_DETECT),
5376         SND_PCI_QUIRK(0x1584, 0x2b01, "Haier W18", ALC861_FIXUP_AMP_VREF_0F),
5377         SND_PCI_QUIRK(0x1584, 0x0000, "Uniwill ECS M31EI", ALC861_FIXUP_AMP_VREF_0F),
5378         SND_PCI_QUIRK(0x1734, 0x10c7, "FSC Amilo Pi1505", ALC861_FIXUP_FSC_AMILO_PI1505),
5379         {}
5380 };
5381
5382 /*
5383  */
5384 static int patch_alc861(struct hda_codec *codec)
5385 {
5386         struct alc_spec *spec;
5387         int err;
5388
5389         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
5390         if (spec == NULL)
5391                 return -ENOMEM;
5392
5393         codec->spec = spec;
5394
5395         spec->mixer_nid = 0x15;
5396
5397         alc_pick_fixup(codec, NULL, alc861_fixup_tbl, alc861_fixups);
5398         alc_apply_fixup(codec, ALC_FIXUP_ACT_PRE_PROBE);
5399
5400         /* automatic parse from the BIOS config */
5401         err = alc861_parse_auto_config(codec);
5402         if (err < 0)
5403                 goto error;
5404
5405         if (!spec->no_analog && !spec->adc_nids) {
5406                 alc_auto_fill_adc_caps(codec);
5407                 alc_rebuild_imux_for_auto_mic(codec);
5408                 alc_remove_invalid_adc_nids(codec);
5409         }
5410
5411         if (!spec->no_analog && !spec->cap_mixer)
5412                 set_capture_mixer(codec);
5413
5414         if (!spec->no_analog) {
5415                 err = snd_hda_attach_beep_device(codec, 0x23);
5416                 if (err < 0)
5417                         goto error;
5418                 set_beep_amp(spec, 0x23, 0, HDA_OUTPUT);
5419         }
5420
5421         spec->vmaster_nid = 0x03;
5422
5423         alc_apply_fixup(codec, ALC_FIXUP_ACT_PROBE);
5424
5425         codec->patch_ops = alc_patch_ops;
5426         spec->init_hook = alc_auto_init_std;
5427 #ifdef CONFIG_SND_HDA_POWER_SAVE
5428         spec->power_hook = alc_power_eapd;
5429         if (!spec->loopback.amplist)
5430                 spec->loopback.amplist = alc861_loopbacks;
5431 #endif
5432
5433         return 0;
5434
5435  error:
5436         alc_free(codec);
5437         return err;
5438 }
5439
5440 /*
5441  * ALC861-VD support
5442  *
5443  * Based on ALC882
5444  *
5445  * In addition, an independent DAC
5446  */
5447 #ifdef CONFIG_SND_HDA_POWER_SAVE
5448 #define alc861vd_loopbacks      alc880_loopbacks
5449 #endif
5450
5451 static int alc861vd_parse_auto_config(struct hda_codec *codec)
5452 {
5453         static const hda_nid_t alc861vd_ignore[] = { 0x1d, 0 };
5454         static const hda_nid_t alc861vd_ssids[] = { 0x15, 0x1b, 0x14, 0 };
5455         return alc_parse_auto_config(codec, alc861vd_ignore, alc861vd_ssids);
5456 }
5457
5458 enum {
5459         ALC660VD_FIX_ASUS_GPIO1,
5460         ALC861VD_FIX_DALLAS,
5461 };
5462
5463 /* exclude VREF80 */
5464 static void alc861vd_fixup_dallas(struct hda_codec *codec,
5465                                   const struct alc_fixup *fix, int action)
5466 {
5467         if (action == ALC_FIXUP_ACT_PRE_PROBE) {
5468                 snd_hda_override_pin_caps(codec, 0x18, 0x00001714);
5469                 snd_hda_override_pin_caps(codec, 0x19, 0x0000171c);
5470         }
5471 }
5472
5473 static const struct alc_fixup alc861vd_fixups[] = {
5474         [ALC660VD_FIX_ASUS_GPIO1] = {
5475                 .type = ALC_FIXUP_VERBS,
5476                 .v.verbs = (const struct hda_verb[]) {
5477                         /* reset GPIO1 */
5478                         {0x01, AC_VERB_SET_GPIO_MASK, 0x03},
5479                         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
5480                         {0x01, AC_VERB_SET_GPIO_DATA, 0x01},
5481                         { }
5482                 }
5483         },
5484         [ALC861VD_FIX_DALLAS] = {
5485                 .type = ALC_FIXUP_FUNC,
5486                 .v.func = alc861vd_fixup_dallas,
5487         },
5488 };
5489
5490 static const struct snd_pci_quirk alc861vd_fixup_tbl[] = {
5491         SND_PCI_QUIRK(0x103c, 0x30bf, "HP TX1000", ALC861VD_FIX_DALLAS),
5492         SND_PCI_QUIRK(0x1043, 0x1339, "ASUS A7-K", ALC660VD_FIX_ASUS_GPIO1),
5493         SND_PCI_QUIRK(0x1179, 0xff31, "Toshiba L30-149", ALC861VD_FIX_DALLAS),
5494         {}
5495 };
5496
5497 static const struct hda_verb alc660vd_eapd_verbs[] = {
5498         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
5499         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
5500         { }
5501 };
5502
5503 /*
5504  */
5505 static int patch_alc861vd(struct hda_codec *codec)
5506 {
5507         struct alc_spec *spec;
5508         int err;
5509
5510         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
5511         if (spec == NULL)
5512                 return -ENOMEM;
5513
5514         codec->spec = spec;
5515
5516         spec->mixer_nid = 0x0b;
5517
5518         alc_pick_fixup(codec, NULL, alc861vd_fixup_tbl, alc861vd_fixups);
5519         alc_apply_fixup(codec, ALC_FIXUP_ACT_PRE_PROBE);
5520
5521         /* automatic parse from the BIOS config */
5522         err = alc861vd_parse_auto_config(codec);
5523         if (err < 0)
5524                 goto error;
5525
5526         if (codec->vendor_id == 0x10ec0660) {
5527                 /* always turn on EAPD */
5528                 add_verb(spec, alc660vd_eapd_verbs);
5529         }
5530
5531         if (!spec->no_analog && !spec->adc_nids) {
5532                 alc_auto_fill_adc_caps(codec);
5533                 alc_rebuild_imux_for_auto_mic(codec);
5534                 alc_remove_invalid_adc_nids(codec);
5535         }
5536
5537         if (!spec->no_analog && !spec->cap_mixer)
5538                 set_capture_mixer(codec);
5539
5540         if (!spec->no_analog) {
5541                 err = snd_hda_attach_beep_device(codec, 0x23);
5542                 if (err < 0)
5543                         goto error;
5544                 set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
5545         }
5546
5547         spec->vmaster_nid = 0x02;
5548
5549         alc_apply_fixup(codec, ALC_FIXUP_ACT_PROBE);
5550
5551         codec->patch_ops = alc_patch_ops;
5552
5553         spec->init_hook = alc_auto_init_std;
5554         spec->shutup = alc_eapd_shutup;
5555 #ifdef CONFIG_SND_HDA_POWER_SAVE
5556         if (!spec->loopback.amplist)
5557                 spec->loopback.amplist = alc861vd_loopbacks;
5558 #endif
5559
5560         return 0;
5561
5562  error:
5563         alc_free(codec);
5564         return err;
5565 }
5566
5567 /*
5568  * ALC662 support
5569  *
5570  * ALC662 is almost identical with ALC880 but has cleaner and more flexible
5571  * configuration.  Each pin widget can choose any input DACs and a mixer.
5572  * Each ADC is connected from a mixer of all inputs.  This makes possible
5573  * 6-channel independent captures.
5574  *
5575  * In addition, an independent DAC for the multi-playback (not used in this
5576  * driver yet).
5577  */
5578 #ifdef CONFIG_SND_HDA_POWER_SAVE
5579 #define alc662_loopbacks        alc880_loopbacks
5580 #endif
5581
5582 /*
5583  * BIOS auto configuration
5584  */
5585
5586 static int alc662_parse_auto_config(struct hda_codec *codec)
5587 {
5588         static const hda_nid_t alc662_ignore[] = { 0x1d, 0 };
5589         static const hda_nid_t alc663_ssids[] = { 0x15, 0x1b, 0x14, 0x21 };
5590         static const hda_nid_t alc662_ssids[] = { 0x15, 0x1b, 0x14, 0 };
5591         const hda_nid_t *ssids;
5592
5593         if (codec->vendor_id == 0x10ec0272 || codec->vendor_id == 0x10ec0663 ||
5594             codec->vendor_id == 0x10ec0665 || codec->vendor_id == 0x10ec0670)
5595                 ssids = alc663_ssids;
5596         else
5597                 ssids = alc662_ssids;
5598         return alc_parse_auto_config(codec, alc662_ignore, ssids);
5599 }
5600
5601 static void alc272_fixup_mario(struct hda_codec *codec,
5602                                const struct alc_fixup *fix, int action)
5603 {
5604         if (action != ALC_FIXUP_ACT_PROBE)
5605                 return;
5606         if (snd_hda_override_amp_caps(codec, 0x2, HDA_OUTPUT,
5607                                       (0x3b << AC_AMPCAP_OFFSET_SHIFT) |
5608                                       (0x3b << AC_AMPCAP_NUM_STEPS_SHIFT) |
5609                                       (0x03 << AC_AMPCAP_STEP_SIZE_SHIFT) |
5610                                       (0 << AC_AMPCAP_MUTE_SHIFT)))
5611                 printk(KERN_WARNING
5612                        "hda_codec: failed to override amp caps for NID 0x2\n");
5613 }
5614
5615 enum {
5616         ALC662_FIXUP_ASPIRE,
5617         ALC662_FIXUP_IDEAPAD,
5618         ALC272_FIXUP_MARIO,
5619         ALC662_FIXUP_CZC_P10T,
5620         ALC662_FIXUP_SKU_IGNORE,
5621         ALC662_FIXUP_HP_RP5800,
5622         ALC662_FIXUP_ASUS_MODE1,
5623         ALC662_FIXUP_ASUS_MODE2,
5624         ALC662_FIXUP_ASUS_MODE3,
5625         ALC662_FIXUP_ASUS_MODE4,
5626         ALC662_FIXUP_ASUS_MODE5,
5627         ALC662_FIXUP_ASUS_MODE6,
5628         ALC662_FIXUP_ASUS_MODE7,
5629         ALC662_FIXUP_ASUS_MODE8,
5630         ALC662_FIXUP_NO_JACK_DETECT,
5631         ALC662_FIXUP_ZOTAC_Z68,
5632 };
5633
5634 static const struct alc_fixup alc662_fixups[] = {
5635         [ALC662_FIXUP_ASPIRE] = {
5636                 .type = ALC_FIXUP_PINS,
5637                 .v.pins = (const struct alc_pincfg[]) {
5638                         { 0x15, 0x99130112 }, /* subwoofer */
5639                         { }
5640                 }
5641         },
5642         [ALC662_FIXUP_IDEAPAD] = {
5643                 .type = ALC_FIXUP_PINS,
5644                 .v.pins = (const struct alc_pincfg[]) {
5645                         { 0x17, 0x99130112 }, /* subwoofer */
5646                         { }
5647                 }
5648         },
5649         [ALC272_FIXUP_MARIO] = {
5650                 .type = ALC_FIXUP_FUNC,
5651                 .v.func = alc272_fixup_mario,
5652         },
5653         [ALC662_FIXUP_CZC_P10T] = {
5654                 .type = ALC_FIXUP_VERBS,
5655                 .v.verbs = (const struct hda_verb[]) {
5656                         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 0},
5657                         {}
5658                 }
5659         },
5660         [ALC662_FIXUP_SKU_IGNORE] = {
5661                 .type = ALC_FIXUP_SKU,
5662                 .v.sku = ALC_FIXUP_SKU_IGNORE,
5663         },
5664         [ALC662_FIXUP_HP_RP5800] = {
5665                 .type = ALC_FIXUP_PINS,
5666                 .v.pins = (const struct alc_pincfg[]) {
5667                         { 0x14, 0x0221201f }, /* HP out */
5668                         { }
5669                 },
5670                 .chained = true,
5671                 .chain_id = ALC662_FIXUP_SKU_IGNORE
5672         },
5673         [ALC662_FIXUP_ASUS_MODE1] = {
5674                 .type = ALC_FIXUP_PINS,
5675                 .v.pins = (const struct alc_pincfg[]) {
5676                         { 0x14, 0x99130110 }, /* speaker */
5677                         { 0x18, 0x01a19c20 }, /* mic */
5678                         { 0x19, 0x99a3092f }, /* int-mic */
5679                         { 0x21, 0x0121401f }, /* HP out */
5680                         { }
5681                 },
5682                 .chained = true,
5683                 .chain_id = ALC662_FIXUP_SKU_IGNORE
5684         },
5685         [ALC662_FIXUP_ASUS_MODE2] = {
5686                 .type = ALC_FIXUP_PINS,
5687                 .v.pins = (const struct alc_pincfg[]) {
5688                         { 0x14, 0x99130110 }, /* speaker */
5689                         { 0x18, 0x01a19820 }, /* mic */
5690                         { 0x19, 0x99a3092f }, /* int-mic */
5691                         { 0x1b, 0x0121401f }, /* HP out */
5692                         { }
5693                 },
5694                 .chained = true,
5695                 .chain_id = ALC662_FIXUP_SKU_IGNORE
5696         },
5697         [ALC662_FIXUP_ASUS_MODE3] = {
5698                 .type = ALC_FIXUP_PINS,
5699                 .v.pins = (const struct alc_pincfg[]) {
5700                         { 0x14, 0x99130110 }, /* speaker */
5701                         { 0x15, 0x0121441f }, /* HP */
5702                         { 0x18, 0x01a19840 }, /* mic */
5703                         { 0x19, 0x99a3094f }, /* int-mic */
5704                         { 0x21, 0x01211420 }, /* HP2 */
5705                         { }
5706                 },
5707                 .chained = true,
5708                 .chain_id = ALC662_FIXUP_SKU_IGNORE
5709         },
5710         [ALC662_FIXUP_ASUS_MODE4] = {
5711                 .type = ALC_FIXUP_PINS,
5712                 .v.pins = (const struct alc_pincfg[]) {
5713                         { 0x14, 0x99130110 }, /* speaker */
5714                         { 0x16, 0x99130111 }, /* speaker */
5715                         { 0x18, 0x01a19840 }, /* mic */
5716                         { 0x19, 0x99a3094f }, /* int-mic */
5717                         { 0x21, 0x0121441f }, /* HP */
5718                         { }
5719                 },
5720                 .chained = true,
5721                 .chain_id = ALC662_FIXUP_SKU_IGNORE
5722         },
5723         [ALC662_FIXUP_ASUS_MODE5] = {
5724                 .type = ALC_FIXUP_PINS,
5725                 .v.pins = (const struct alc_pincfg[]) {
5726                         { 0x14, 0x99130110 }, /* speaker */
5727                         { 0x15, 0x0121441f }, /* HP */
5728                         { 0x16, 0x99130111 }, /* speaker */
5729                         { 0x18, 0x01a19840 }, /* mic */
5730                         { 0x19, 0x99a3094f }, /* int-mic */
5731                         { }
5732                 },
5733                 .chained = true,
5734                 .chain_id = ALC662_FIXUP_SKU_IGNORE
5735         },
5736         [ALC662_FIXUP_ASUS_MODE6] = {
5737                 .type = ALC_FIXUP_PINS,
5738                 .v.pins = (const struct alc_pincfg[]) {
5739                         { 0x14, 0x99130110 }, /* speaker */
5740                         { 0x15, 0x01211420 }, /* HP2 */
5741                         { 0x18, 0x01a19840 }, /* mic */
5742                         { 0x19, 0x99a3094f }, /* int-mic */
5743                         { 0x1b, 0x0121441f }, /* HP */
5744                         { }
5745                 },
5746                 .chained = true,
5747                 .chain_id = ALC662_FIXUP_SKU_IGNORE
5748         },
5749         [ALC662_FIXUP_ASUS_MODE7] = {
5750                 .type = ALC_FIXUP_PINS,
5751                 .v.pins = (const struct alc_pincfg[]) {
5752                         { 0x14, 0x99130110 }, /* speaker */
5753                         { 0x17, 0x99130111 }, /* speaker */
5754                         { 0x18, 0x01a19840 }, /* mic */
5755                         { 0x19, 0x99a3094f }, /* int-mic */
5756                         { 0x1b, 0x01214020 }, /* HP */
5757                         { 0x21, 0x0121401f }, /* HP */
5758                         { }
5759                 },
5760                 .chained = true,
5761                 .chain_id = ALC662_FIXUP_SKU_IGNORE
5762         },
5763         [ALC662_FIXUP_ASUS_MODE8] = {
5764                 .type = ALC_FIXUP_PINS,
5765                 .v.pins = (const struct alc_pincfg[]) {
5766                         { 0x14, 0x99130110 }, /* speaker */
5767                         { 0x12, 0x99a30970 }, /* int-mic */
5768                         { 0x15, 0x01214020 }, /* HP */
5769                         { 0x17, 0x99130111 }, /* speaker */
5770                         { 0x18, 0x01a19840 }, /* mic */
5771                         { 0x21, 0x0121401f }, /* HP */
5772                         { }
5773                 },
5774                 .chained = true,
5775                 .chain_id = ALC662_FIXUP_SKU_IGNORE
5776         },
5777         [ALC662_FIXUP_NO_JACK_DETECT] = {
5778                 .type = ALC_FIXUP_FUNC,
5779                 .v.func = alc_fixup_no_jack_detect,
5780         },
5781         [ALC662_FIXUP_ZOTAC_Z68] = {
5782                 .type = ALC_FIXUP_PINS,
5783                 .v.pins = (const struct alc_pincfg[]) {
5784                         { 0x1b, 0x02214020 }, /* Front HP */
5785                         { }
5786                 }
5787         },
5788 };
5789
5790 static const struct snd_pci_quirk alc662_fixup_tbl[] = {
5791         SND_PCI_QUIRK(0x1019, 0x9087, "ECS", ALC662_FIXUP_ASUS_MODE2),
5792         SND_PCI_QUIRK(0x1025, 0x0308, "Acer Aspire 8942G", ALC662_FIXUP_ASPIRE),
5793         SND_PCI_QUIRK(0x1025, 0x031c, "Gateway NV79", ALC662_FIXUP_SKU_IGNORE),
5794         SND_PCI_QUIRK(0x1025, 0x038b, "Acer Aspire 8943G", ALC662_FIXUP_ASPIRE),
5795         SND_PCI_QUIRK(0x103c, 0x1632, "HP RP5800", ALC662_FIXUP_HP_RP5800),
5796         SND_PCI_QUIRK(0x1043, 0x8469, "ASUS mobo", ALC662_FIXUP_NO_JACK_DETECT),
5797         SND_PCI_QUIRK(0x105b, 0x0cd6, "Foxconn", ALC662_FIXUP_ASUS_MODE2),
5798         SND_PCI_QUIRK(0x144d, 0xc051, "Samsung R720", ALC662_FIXUP_IDEAPAD),
5799         SND_PCI_QUIRK(0x17aa, 0x38af, "Lenovo Ideapad Y550P", ALC662_FIXUP_IDEAPAD),
5800         SND_PCI_QUIRK(0x17aa, 0x3a0d, "Lenovo Ideapad Y550", ALC662_FIXUP_IDEAPAD),
5801         SND_PCI_QUIRK(0x19da, 0xa130, "Zotac Z68", ALC662_FIXUP_ZOTAC_Z68),
5802         SND_PCI_QUIRK(0x1b35, 0x2206, "CZC P10T", ALC662_FIXUP_CZC_P10T),
5803
5804 #if 0
5805         /* Below is a quirk table taken from the old code.
5806          * Basically the device should work as is without the fixup table.
5807          * If BIOS doesn't give a proper info, enable the corresponding
5808          * fixup entry.
5809          */
5810         SND_PCI_QUIRK(0x1043, 0x1000, "ASUS N50Vm", ALC662_FIXUP_ASUS_MODE1),
5811         SND_PCI_QUIRK(0x1043, 0x1092, "ASUS NB", ALC662_FIXUP_ASUS_MODE3),
5812         SND_PCI_QUIRK(0x1043, 0x1173, "ASUS K73Jn", ALC662_FIXUP_ASUS_MODE1),
5813         SND_PCI_QUIRK(0x1043, 0x11c3, "ASUS M70V", ALC662_FIXUP_ASUS_MODE3),
5814         SND_PCI_QUIRK(0x1043, 0x11d3, "ASUS NB", ALC662_FIXUP_ASUS_MODE1),
5815         SND_PCI_QUIRK(0x1043, 0x11f3, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
5816         SND_PCI_QUIRK(0x1043, 0x1203, "ASUS NB", ALC662_FIXUP_ASUS_MODE1),
5817         SND_PCI_QUIRK(0x1043, 0x1303, "ASUS G60J", ALC662_FIXUP_ASUS_MODE1),
5818         SND_PCI_QUIRK(0x1043, 0x1333, "ASUS G60Jx", ALC662_FIXUP_ASUS_MODE1),
5819         SND_PCI_QUIRK(0x1043, 0x1339, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
5820         SND_PCI_QUIRK(0x1043, 0x13e3, "ASUS N71JA", ALC662_FIXUP_ASUS_MODE7),
5821         SND_PCI_QUIRK(0x1043, 0x1463, "ASUS N71", ALC662_FIXUP_ASUS_MODE7),
5822         SND_PCI_QUIRK(0x1043, 0x14d3, "ASUS G72", ALC662_FIXUP_ASUS_MODE8),
5823         SND_PCI_QUIRK(0x1043, 0x1563, "ASUS N90", ALC662_FIXUP_ASUS_MODE3),
5824         SND_PCI_QUIRK(0x1043, 0x15d3, "ASUS N50SF F50SF", ALC662_FIXUP_ASUS_MODE1),
5825         SND_PCI_QUIRK(0x1043, 0x16c3, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
5826         SND_PCI_QUIRK(0x1043, 0x16f3, "ASUS K40C K50C", ALC662_FIXUP_ASUS_MODE2),
5827         SND_PCI_QUIRK(0x1043, 0x1733, "ASUS N81De", ALC662_FIXUP_ASUS_MODE1),
5828         SND_PCI_QUIRK(0x1043, 0x1753, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
5829         SND_PCI_QUIRK(0x1043, 0x1763, "ASUS NB", ALC662_FIXUP_ASUS_MODE6),
5830         SND_PCI_QUIRK(0x1043, 0x1765, "ASUS NB", ALC662_FIXUP_ASUS_MODE6),
5831         SND_PCI_QUIRK(0x1043, 0x1783, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
5832         SND_PCI_QUIRK(0x1043, 0x1793, "ASUS F50GX", ALC662_FIXUP_ASUS_MODE1),
5833         SND_PCI_QUIRK(0x1043, 0x17b3, "ASUS F70SL", ALC662_FIXUP_ASUS_MODE3),
5834         SND_PCI_QUIRK(0x1043, 0x17f3, "ASUS X58LE", ALC662_FIXUP_ASUS_MODE2),
5835         SND_PCI_QUIRK(0x1043, 0x1813, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
5836         SND_PCI_QUIRK(0x1043, 0x1823, "ASUS NB", ALC662_FIXUP_ASUS_MODE5),
5837         SND_PCI_QUIRK(0x1043, 0x1833, "ASUS NB", ALC662_FIXUP_ASUS_MODE6),
5838         SND_PCI_QUIRK(0x1043, 0x1843, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
5839         SND_PCI_QUIRK(0x1043, 0x1853, "ASUS F50Z", ALC662_FIXUP_ASUS_MODE1),
5840         SND_PCI_QUIRK(0x1043, 0x1864, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
5841         SND_PCI_QUIRK(0x1043, 0x1876, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
5842         SND_PCI_QUIRK(0x1043, 0x1893, "ASUS M50Vm", ALC662_FIXUP_ASUS_MODE3),
5843         SND_PCI_QUIRK(0x1043, 0x1894, "ASUS X55", ALC662_FIXUP_ASUS_MODE3),
5844         SND_PCI_QUIRK(0x1043, 0x18b3, "ASUS N80Vc", ALC662_FIXUP_ASUS_MODE1),
5845         SND_PCI_QUIRK(0x1043, 0x18c3, "ASUS VX5", ALC662_FIXUP_ASUS_MODE1),
5846         SND_PCI_QUIRK(0x1043, 0x18d3, "ASUS N81Te", ALC662_FIXUP_ASUS_MODE1),
5847         SND_PCI_QUIRK(0x1043, 0x18f3, "ASUS N505Tp", ALC662_FIXUP_ASUS_MODE1),
5848         SND_PCI_QUIRK(0x1043, 0x1903, "ASUS F5GL", ALC662_FIXUP_ASUS_MODE1),
5849         SND_PCI_QUIRK(0x1043, 0x1913, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
5850         SND_PCI_QUIRK(0x1043, 0x1933, "ASUS F80Q", ALC662_FIXUP_ASUS_MODE2),
5851         SND_PCI_QUIRK(0x1043, 0x1943, "ASUS Vx3V", ALC662_FIXUP_ASUS_MODE1),
5852         SND_PCI_QUIRK(0x1043, 0x1953, "ASUS NB", ALC662_FIXUP_ASUS_MODE1),
5853         SND_PCI_QUIRK(0x1043, 0x1963, "ASUS X71C", ALC662_FIXUP_ASUS_MODE3),
5854         SND_PCI_QUIRK(0x1043, 0x1983, "ASUS N5051A", ALC662_FIXUP_ASUS_MODE1),
5855         SND_PCI_QUIRK(0x1043, 0x1993, "ASUS N20", ALC662_FIXUP_ASUS_MODE1),
5856         SND_PCI_QUIRK(0x1043, 0x19b3, "ASUS F7Z", ALC662_FIXUP_ASUS_MODE1),
5857         SND_PCI_QUIRK(0x1043, 0x19c3, "ASUS F5Z/F6x", ALC662_FIXUP_ASUS_MODE2),
5858         SND_PCI_QUIRK(0x1043, 0x19e3, "ASUS NB", ALC662_FIXUP_ASUS_MODE1),
5859         SND_PCI_QUIRK(0x1043, 0x19f3, "ASUS NB", ALC662_FIXUP_ASUS_MODE4),
5860 #endif
5861         {}
5862 };
5863
5864 static const struct alc_model_fixup alc662_fixup_models[] = {
5865         {.id = ALC272_FIXUP_MARIO, .name = "mario"},
5866         {.id = ALC662_FIXUP_ASUS_MODE1, .name = "asus-mode1"},
5867         {.id = ALC662_FIXUP_ASUS_MODE2, .name = "asus-mode2"},
5868         {.id = ALC662_FIXUP_ASUS_MODE3, .name = "asus-mode3"},
5869         {.id = ALC662_FIXUP_ASUS_MODE4, .name = "asus-mode4"},
5870         {.id = ALC662_FIXUP_ASUS_MODE5, .name = "asus-mode5"},
5871         {.id = ALC662_FIXUP_ASUS_MODE6, .name = "asus-mode6"},
5872         {.id = ALC662_FIXUP_ASUS_MODE7, .name = "asus-mode7"},
5873         {.id = ALC662_FIXUP_ASUS_MODE8, .name = "asus-mode8"},
5874         {}
5875 };
5876
5877
5878 /*
5879  */
5880 static int patch_alc662(struct hda_codec *codec)
5881 {
5882         struct alc_spec *spec;
5883         int err = 0;
5884
5885         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
5886         if (!spec)
5887                 return -ENOMEM;
5888
5889         codec->spec = spec;
5890
5891         spec->mixer_nid = 0x0b;
5892
5893         /* handle multiple HPs as is */
5894         spec->parse_flags = HDA_PINCFG_NO_HP_FIXUP;
5895
5896         alc_auto_parse_customize_define(codec);
5897
5898         alc_fix_pll_init(codec, 0x20, 0x04, 15);
5899
5900         err = alc_codec_rename_from_preset(codec);
5901         if (err < 0)
5902                 goto error;
5903
5904         if ((alc_get_coef0(codec) & (1 << 14)) &&
5905             codec->bus->pci->subsystem_vendor == 0x1025 &&
5906             spec->cdefine.platform_type == 1) {
5907                 if (alc_codec_rename(codec, "ALC272X") < 0)
5908                         goto error;
5909         }
5910
5911         alc_pick_fixup(codec, alc662_fixup_models,
5912                        alc662_fixup_tbl, alc662_fixups);
5913         alc_apply_fixup(codec, ALC_FIXUP_ACT_PRE_PROBE);
5914         /* automatic parse from the BIOS config */
5915         err = alc662_parse_auto_config(codec);
5916         if (err < 0)
5917                 goto error;
5918
5919         if (!spec->no_analog && !spec->adc_nids) {
5920                 alc_auto_fill_adc_caps(codec);
5921                 alc_rebuild_imux_for_auto_mic(codec);
5922                 alc_remove_invalid_adc_nids(codec);
5923         }
5924
5925         if (!spec->no_analog && !spec->cap_mixer)
5926                 set_capture_mixer(codec);
5927
5928         if (!spec->no_analog && has_cdefine_beep(codec)) {
5929                 err = snd_hda_attach_beep_device(codec, 0x1);
5930                 if (err < 0)
5931                         goto error;
5932                 switch (codec->vendor_id) {
5933                 case 0x10ec0662:
5934                         set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
5935                         break;
5936                 case 0x10ec0272:
5937                 case 0x10ec0663:
5938                 case 0x10ec0665:
5939                         set_beep_amp(spec, 0x0b, 0x04, HDA_INPUT);
5940                         break;
5941                 case 0x10ec0273:
5942                         set_beep_amp(spec, 0x0b, 0x03, HDA_INPUT);
5943                         break;
5944                 }
5945         }
5946         spec->vmaster_nid = 0x02;
5947
5948         alc_apply_fixup(codec, ALC_FIXUP_ACT_PROBE);
5949
5950         codec->patch_ops = alc_patch_ops;
5951         spec->init_hook = alc_auto_init_std;
5952         spec->shutup = alc_eapd_shutup;
5953
5954         alc_init_jacks(codec);
5955
5956 #ifdef CONFIG_SND_HDA_POWER_SAVE
5957         if (!spec->loopback.amplist)
5958                 spec->loopback.amplist = alc662_loopbacks;
5959 #endif
5960
5961         return 0;
5962
5963  error:
5964         alc_free(codec);
5965         return err;
5966 }
5967
5968 /*
5969  * ALC680 support
5970  */
5971
5972 static int alc680_parse_auto_config(struct hda_codec *codec)
5973 {
5974         return alc_parse_auto_config(codec, NULL, NULL);
5975 }
5976
5977 /*
5978  */
5979 static int patch_alc680(struct hda_codec *codec)
5980 {
5981         struct alc_spec *spec;
5982         int err;
5983
5984         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
5985         if (spec == NULL)
5986                 return -ENOMEM;
5987
5988         codec->spec = spec;
5989
5990         /* ALC680 has no aa-loopback mixer */
5991
5992         /* automatic parse from the BIOS config */
5993         err = alc680_parse_auto_config(codec);
5994         if (err < 0) {
5995                 alc_free(codec);
5996                 return err;
5997         }
5998
5999         if (!spec->no_analog && !spec->cap_mixer)
6000                 set_capture_mixer(codec);
6001
6002         spec->vmaster_nid = 0x02;
6003
6004         codec->patch_ops = alc_patch_ops;
6005         spec->init_hook = alc_auto_init_std;
6006
6007         return 0;
6008 }
6009
6010 /*
6011  * patch entries
6012  */
6013 static const struct hda_codec_preset snd_hda_preset_realtek[] = {
6014         { .id = 0x10ec0221, .name = "ALC221", .patch = patch_alc269 },
6015         { .id = 0x10ec0260, .name = "ALC260", .patch = patch_alc260 },
6016         { .id = 0x10ec0262, .name = "ALC262", .patch = patch_alc262 },
6017         { .id = 0x10ec0267, .name = "ALC267", .patch = patch_alc268 },
6018         { .id = 0x10ec0268, .name = "ALC268", .patch = patch_alc268 },
6019         { .id = 0x10ec0269, .name = "ALC269", .patch = patch_alc269 },
6020         { .id = 0x10ec0270, .name = "ALC270", .patch = patch_alc269 },
6021         { .id = 0x10ec0272, .name = "ALC272", .patch = patch_alc662 },
6022         { .id = 0x10ec0275, .name = "ALC275", .patch = patch_alc269 },
6023         { .id = 0x10ec0276, .name = "ALC276", .patch = patch_alc269 },
6024         { .id = 0x10ec0280, .name = "ALC280", .patch = patch_alc269 },
6025         { .id = 0x10ec0282, .name = "ALC282", .patch = patch_alc269 },
6026         { .id = 0x10ec0861, .rev = 0x100340, .name = "ALC660",
6027           .patch = patch_alc861 },
6028         { .id = 0x10ec0660, .name = "ALC660-VD", .patch = patch_alc861vd },
6029         { .id = 0x10ec0861, .name = "ALC861", .patch = patch_alc861 },
6030         { .id = 0x10ec0862, .name = "ALC861-VD", .patch = patch_alc861vd },
6031         { .id = 0x10ec0662, .rev = 0x100002, .name = "ALC662 rev2",
6032           .patch = patch_alc882 },
6033         { .id = 0x10ec0662, .rev = 0x100101, .name = "ALC662 rev1",
6034           .patch = patch_alc662 },
6035         { .id = 0x10ec0662, .rev = 0x100300, .name = "ALC662 rev3",
6036           .patch = patch_alc662 },
6037         { .id = 0x10ec0663, .name = "ALC663", .patch = patch_alc662 },
6038         { .id = 0x10ec0665, .name = "ALC665", .patch = patch_alc662 },
6039         { .id = 0x10ec0670, .name = "ALC670", .patch = patch_alc662 },
6040         { .id = 0x10ec0680, .name = "ALC680", .patch = patch_alc680 },
6041         { .id = 0x10ec0880, .name = "ALC880", .patch = patch_alc880 },
6042         { .id = 0x10ec0882, .name = "ALC882", .patch = patch_alc882 },
6043         { .id = 0x10ec0883, .name = "ALC883", .patch = patch_alc882 },
6044         { .id = 0x10ec0885, .rev = 0x100101, .name = "ALC889A",
6045           .patch = patch_alc882 },
6046         { .id = 0x10ec0885, .rev = 0x100103, .name = "ALC889A",
6047           .patch = patch_alc882 },
6048         { .id = 0x10ec0885, .name = "ALC885", .patch = patch_alc882 },
6049         { .id = 0x10ec0887, .name = "ALC887", .patch = patch_alc882 },
6050         { .id = 0x10ec0888, .rev = 0x100101, .name = "ALC1200",
6051           .patch = patch_alc882 },
6052         { .id = 0x10ec0888, .name = "ALC888", .patch = patch_alc882 },
6053         { .id = 0x10ec0889, .name = "ALC889", .patch = patch_alc882 },
6054         { .id = 0x10ec0892, .name = "ALC892", .patch = patch_alc662 },
6055         { .id = 0x10ec0899, .name = "ALC898", .patch = patch_alc882 },
6056         {} /* terminator */
6057 };
6058
6059 MODULE_ALIAS("snd-hda-codec-id:10ec*");
6060
6061 MODULE_LICENSE("GPL");
6062 MODULE_DESCRIPTION("Realtek HD-audio codec");
6063
6064 static struct hda_codec_preset_list realtek_list = {
6065         .preset = snd_hda_preset_realtek,
6066         .owner = THIS_MODULE,
6067 };
6068
6069 static int __init patch_realtek_init(void)
6070 {
6071         return snd_hda_add_codec_preset(&realtek_list);
6072 }
6073
6074 static void __exit patch_realtek_exit(void)
6075 {
6076         snd_hda_delete_codec_preset(&realtek_list);
6077 }
6078
6079 module_init(patch_realtek_init)
6080 module_exit(patch_realtek_exit)