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