sound/pci/hda/patch_realtek.c

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