sound/pci/hda/patch_realtek.c

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