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