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