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