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