sound/pci/hda/patch_realtek.c

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