sound/pci/hda/patch_realtek.c

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