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