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