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