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                 if (cfg->line_outs == 2)
2635                         return ch ? "Bass Speaker" : "Speaker";
2636                 break;
2637         case AUTO_PIN_HP_OUT:
2638                 /* for multi-io case, only the primary out */
2639                 if (ch && spec->multi_ios)
2640                         break;
2641                 *index = ch;
2642                 return "Headphone";
2643         default:
2644                 if (cfg->line_outs == 1 && !spec->multi_ios)
2645                         return "PCM";
2646                 break;
2647         }
2648         if (snd_BUG_ON(ch >= ARRAY_SIZE(channel_name)))
2649                 return "PCM";
2650
2651         return channel_name[ch];
2652 }
2653
2654 /* create input playback/capture controls for the given pin */
2655 static int new_analog_input(struct alc_spec *spec, hda_nid_t pin,
2656                             const char *ctlname, int ctlidx,
2657                             int idx, hda_nid_t mix_nid)
2658 {
2659         int err;
2660
2661         err = __add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, ctlname, ctlidx,
2662                           HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT));
2663         if (err < 0)
2664                 return err;
2665         err = __add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, ctlname, ctlidx,
2666                           HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT));
2667         if (err < 0)
2668                 return err;
2669         return 0;
2670 }
2671
2672 static int alc_is_input_pin(struct hda_codec *codec, hda_nid_t nid)
2673 {
2674         unsigned int pincap = snd_hda_query_pin_caps(codec, nid);
2675         return (pincap & AC_PINCAP_IN) != 0;
2676 }
2677
2678 /* Parse the codec tree and retrieve ADCs and corresponding capsrc MUXs */
2679 static int alc_auto_fill_adc_caps(struct hda_codec *codec)
2680 {
2681         struct alc_spec *spec = codec->spec;
2682         hda_nid_t nid;
2683         hda_nid_t *adc_nids = spec->private_adc_nids;
2684         hda_nid_t *cap_nids = spec->private_capsrc_nids;
2685         int max_nums = ARRAY_SIZE(spec->private_adc_nids);
2686         int i, nums = 0;
2687
2688         nid = codec->start_nid;
2689         for (i = 0; i < codec->num_nodes; i++, nid++) {
2690                 hda_nid_t src;
2691                 const hda_nid_t *list;
2692                 unsigned int caps = get_wcaps(codec, nid);
2693                 int type = get_wcaps_type(caps);
2694
2695                 if (type != AC_WID_AUD_IN || (caps & AC_WCAP_DIGITAL))
2696                         continue;
2697                 adc_nids[nums] = nid;
2698                 cap_nids[nums] = nid;
2699                 src = nid;
2700                 for (;;) {
2701                         int n;
2702                         type = get_wcaps_type(get_wcaps(codec, src));
2703                         if (type == AC_WID_PIN)
2704                                 break;
2705                         if (type == AC_WID_AUD_SEL) {
2706                                 cap_nids[nums] = src;
2707                                 break;
2708                         }
2709                         n = snd_hda_get_conn_list(codec, src, &list);
2710                         if (n > 1) {
2711                                 cap_nids[nums] = src;
2712                                 break;
2713                         } else if (n != 1)
2714                                 break;
2715                         src = *list;
2716                 }
2717                 if (++nums >= max_nums)
2718                         break;
2719         }
2720         spec->adc_nids = spec->private_adc_nids;
2721         spec->capsrc_nids = spec->private_capsrc_nids;
2722         spec->num_adc_nids = nums;
2723         return nums;
2724 }
2725
2726 /* create playback/capture controls for input pins */
2727 static int alc_auto_create_input_ctls(struct hda_codec *codec)
2728 {
2729         struct alc_spec *spec = codec->spec;
2730         const struct auto_pin_cfg *cfg = &spec->autocfg;
2731         hda_nid_t mixer = spec->mixer_nid;
2732         struct hda_input_mux *imux = &spec->private_imux[0];
2733         int num_adcs;
2734         int i, c, err, idx, type_idx = 0;
2735         const char *prev_label = NULL;
2736
2737         num_adcs = alc_auto_fill_adc_caps(codec);
2738         if (num_adcs < 0)
2739                 return 0;
2740
2741         for (i = 0; i < cfg->num_inputs; i++) {
2742                 hda_nid_t pin;
2743                 const char *label;
2744
2745                 pin = cfg->inputs[i].pin;
2746                 if (!alc_is_input_pin(codec, pin))
2747                         continue;
2748
2749                 label = hda_get_autocfg_input_label(codec, cfg, i);
2750                 if (prev_label && !strcmp(label, prev_label))
2751                         type_idx++;
2752                 else
2753                         type_idx = 0;
2754                 prev_label = label;
2755
2756                 if (mixer) {
2757                         idx = get_connection_index(codec, mixer, pin);
2758                         if (idx >= 0) {
2759                                 err = new_analog_input(spec, pin,
2760                                                        label, type_idx,
2761                                                        idx, mixer);
2762                                 if (err < 0)
2763                                         return err;
2764                         }
2765                 }
2766
2767                 for (c = 0; c < num_adcs; c++) {
2768                         hda_nid_t cap = get_capsrc(spec, c);
2769                         idx = get_connection_index(codec, cap, pin);
2770                         if (idx >= 0) {
2771                                 spec->imux_pins[imux->num_items] = pin;
2772                                 snd_hda_add_imux_item(imux, label, idx, NULL);
2773                                 break;
2774                         }
2775                 }
2776         }
2777
2778         spec->num_mux_defs = 1;
2779         spec->input_mux = imux;
2780
2781         return 0;
2782 }
2783
2784 static void alc_set_pin_output(struct hda_codec *codec, hda_nid_t nid,
2785                                unsigned int pin_type)
2786 {
2787         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
2788                             pin_type);
2789         /* unmute pin */
2790         if (nid_has_mute(codec, nid, HDA_OUTPUT))
2791                 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE,
2792                             AMP_OUT_UNMUTE);
2793 }
2794
2795 static int get_pin_type(int line_out_type)
2796 {
2797         if (line_out_type == AUTO_PIN_HP_OUT)
2798                 return PIN_HP;
2799         else
2800                 return PIN_OUT;
2801 }
2802
2803 static void alc_auto_init_analog_input(struct hda_codec *codec)
2804 {
2805         struct alc_spec *spec = codec->spec;
2806         struct auto_pin_cfg *cfg = &spec->autocfg;
2807         int i;
2808
2809         for (i = 0; i < cfg->num_inputs; i++) {
2810                 hda_nid_t nid = cfg->inputs[i].pin;
2811                 if (alc_is_input_pin(codec, nid)) {
2812                         alc_set_input_pin(codec, nid, cfg->inputs[i].type);
2813                         if (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP)
2814                                 snd_hda_codec_write(codec, nid, 0,
2815                                                     AC_VERB_SET_AMP_GAIN_MUTE,
2816                                                     AMP_OUT_MUTE);
2817                 }
2818         }
2819
2820         /* mute all loopback inputs */
2821         if (spec->mixer_nid) {
2822                 int nums = snd_hda_get_conn_list(codec, spec->mixer_nid, NULL);
2823                 for (i = 0; i < nums; i++)
2824                         snd_hda_codec_write(codec, spec->mixer_nid, 0,
2825                                             AC_VERB_SET_AMP_GAIN_MUTE,
2826                                             AMP_IN_MUTE(i));
2827         }
2828 }
2829
2830 /* convert from MIX nid to DAC */
2831 static hda_nid_t alc_auto_mix_to_dac(struct hda_codec *codec, hda_nid_t nid)
2832 {
2833         hda_nid_t list[5];
2834         int i, num;
2835
2836         if (get_wcaps_type(get_wcaps(codec, nid)) == AC_WID_AUD_OUT)
2837                 return nid;
2838         num = snd_hda_get_connections(codec, nid, list, ARRAY_SIZE(list));
2839         for (i = 0; i < num; i++) {
2840                 if (get_wcaps_type(get_wcaps(codec, list[i])) == AC_WID_AUD_OUT)
2841                         return list[i];
2842         }
2843         return 0;
2844 }
2845
2846 /* go down to the selector widget before the mixer */
2847 static hda_nid_t alc_go_down_to_selector(struct hda_codec *codec, hda_nid_t pin)
2848 {
2849         hda_nid_t srcs[5];
2850         int num = snd_hda_get_connections(codec, pin, srcs,
2851                                           ARRAY_SIZE(srcs));
2852         if (num != 1 ||
2853             get_wcaps_type(get_wcaps(codec, srcs[0])) != AC_WID_AUD_SEL)
2854                 return pin;
2855         return srcs[0];
2856 }
2857
2858 /* get MIX nid connected to the given pin targeted to DAC */
2859 static hda_nid_t alc_auto_dac_to_mix(struct hda_codec *codec, hda_nid_t pin,
2860                                    hda_nid_t dac)
2861 {
2862         hda_nid_t mix[5];
2863         int i, num;
2864
2865         pin = alc_go_down_to_selector(codec, pin);
2866         num = snd_hda_get_connections(codec, pin, mix, ARRAY_SIZE(mix));
2867         for (i = 0; i < num; i++) {
2868                 if (alc_auto_mix_to_dac(codec, mix[i]) == dac)
2869                         return mix[i];
2870         }
2871         return 0;
2872 }
2873
2874 /* select the connection from pin to DAC if needed */
2875 static int alc_auto_select_dac(struct hda_codec *codec, hda_nid_t pin,
2876                                hda_nid_t dac)
2877 {
2878         hda_nid_t mix[5];
2879         int i, num;
2880
2881         pin = alc_go_down_to_selector(codec, pin);
2882         num = snd_hda_get_connections(codec, pin, mix, ARRAY_SIZE(mix));
2883         if (num < 2)
2884                 return 0;
2885         for (i = 0; i < num; i++) {
2886                 if (alc_auto_mix_to_dac(codec, mix[i]) == dac) {
2887                         snd_hda_codec_update_cache(codec, pin, 0,
2888                                                    AC_VERB_SET_CONNECT_SEL, i);
2889                         return 0;
2890                 }
2891         }
2892         return 0;
2893 }
2894
2895 /* look for an empty DAC slot */
2896 static hda_nid_t alc_auto_look_for_dac(struct hda_codec *codec, hda_nid_t pin)
2897 {
2898         struct alc_spec *spec = codec->spec;
2899         hda_nid_t srcs[5];
2900         int i, num;
2901
2902         pin = alc_go_down_to_selector(codec, pin);
2903         num = snd_hda_get_connections(codec, pin, srcs, ARRAY_SIZE(srcs));
2904         for (i = 0; i < num; i++) {
2905                 hda_nid_t nid = alc_auto_mix_to_dac(codec, srcs[i]);
2906                 if (!nid)
2907                         continue;
2908                 if (found_in_nid_list(nid, spec->multiout.dac_nids,
2909                                       spec->multiout.num_dacs))
2910                         continue;
2911                 if (found_in_nid_list(nid, spec->multiout.hp_out_nid,
2912                                       ARRAY_SIZE(spec->multiout.hp_out_nid)))
2913                     continue;
2914                 if (found_in_nid_list(nid, spec->multiout.extra_out_nid,
2915                                       ARRAY_SIZE(spec->multiout.extra_out_nid)))
2916                     continue;
2917                 return nid;
2918         }
2919         return 0;
2920 }
2921
2922 static hda_nid_t get_dac_if_single(struct hda_codec *codec, hda_nid_t pin)
2923 {
2924         hda_nid_t sel = alc_go_down_to_selector(codec, pin);
2925         if (snd_hda_get_conn_list(codec, sel, NULL) == 1)
2926                 return alc_auto_look_for_dac(codec, pin);
2927         return 0;
2928 }
2929
2930 static int alc_auto_fill_extra_dacs(struct hda_codec *codec, int num_outs,
2931                                     const hda_nid_t *pins, hda_nid_t *dacs)
2932 {
2933         int i;
2934
2935         if (num_outs && !dacs[0]) {
2936                 dacs[0] = alc_auto_look_for_dac(codec, pins[0]);
2937                 if (!dacs[0])
2938                         return 0;
2939         }
2940
2941         for (i = 1; i < num_outs; i++)
2942                 dacs[i] = get_dac_if_single(codec, pins[i]);
2943         for (i = 1; i < num_outs; i++) {
2944                 if (!dacs[i])
2945                         dacs[i] = alc_auto_look_for_dac(codec, pins[i]);
2946         }
2947         return 0;
2948 }
2949
2950 static int alc_auto_fill_multi_ios(struct hda_codec *codec,
2951                                    unsigned int location);
2952
2953 /* fill in the dac_nids table from the parsed pin configuration */
2954 static int alc_auto_fill_dac_nids(struct hda_codec *codec)
2955 {
2956         struct alc_spec *spec = codec->spec;
2957         const struct auto_pin_cfg *cfg = &spec->autocfg;
2958         bool redone = false;
2959         int i;
2960
2961  again:
2962         /* set num_dacs once to full for alc_auto_look_for_dac() */
2963         spec->multiout.num_dacs = cfg->line_outs;
2964         spec->multiout.hp_out_nid[0] = 0;
2965         spec->multiout.extra_out_nid[0] = 0;
2966         memset(spec->private_dac_nids, 0, sizeof(spec->private_dac_nids));
2967         spec->multiout.dac_nids = spec->private_dac_nids;
2968
2969         /* fill hard-wired DACs first */
2970         if (!redone) {
2971                 for (i = 0; i < cfg->line_outs; i++)
2972                         spec->private_dac_nids[i] =
2973                                 get_dac_if_single(codec, cfg->line_out_pins[i]);
2974                 if (cfg->hp_outs)
2975                         spec->multiout.hp_out_nid[0] =
2976                                 get_dac_if_single(codec, cfg->hp_pins[0]);
2977                 if (cfg->speaker_outs)
2978                         spec->multiout.extra_out_nid[0] =
2979                                 get_dac_if_single(codec, cfg->speaker_pins[0]);
2980         }
2981
2982         for (i = 0; i < cfg->line_outs; i++) {
2983                 hda_nid_t pin = cfg->line_out_pins[i];
2984                 if (spec->private_dac_nids[i])
2985                         continue;
2986                 spec->private_dac_nids[i] = alc_auto_look_for_dac(codec, pin);
2987                 if (!spec->private_dac_nids[i] && !redone) {
2988                         /* if we can't find primary DACs, re-probe without
2989                          * checking the hard-wired DACs
2990                          */
2991                         redone = true;
2992                         goto again;
2993                 }
2994         }
2995
2996         /* re-count num_dacs and squash invalid entries */
2997         spec->multiout.num_dacs = 0;
2998         for (i = 0; i < cfg->line_outs; i++) {
2999                 if (spec->private_dac_nids[i])
3000                         spec->multiout.num_dacs++;
3001                 else
3002                         memmove(spec->private_dac_nids + i,
3003                                 spec->private_dac_nids + i + 1,
3004                                 sizeof(hda_nid_t) * (cfg->line_outs - i - 1));
3005         }
3006
3007         if (cfg->line_outs == 1 && cfg->line_out_type != AUTO_PIN_SPEAKER_OUT) {
3008                 /* try to fill multi-io first */
3009                 unsigned int location, defcfg;
3010                 int num_pins;
3011
3012                 defcfg = snd_hda_codec_get_pincfg(codec, cfg->line_out_pins[0]);
3013                 location = get_defcfg_location(defcfg);
3014
3015                 num_pins = alc_auto_fill_multi_ios(codec, location);
3016                 if (num_pins > 0) {
3017                         spec->multi_ios = num_pins;
3018                         spec->ext_channel_count = 2;
3019                         spec->multiout.num_dacs = num_pins + 1;
3020                 }
3021         }
3022
3023         if (cfg->line_out_type != AUTO_PIN_HP_OUT)
3024                 alc_auto_fill_extra_dacs(codec, cfg->hp_outs, cfg->hp_pins,
3025                                  spec->multiout.hp_out_nid);
3026         if (cfg->line_out_type != AUTO_PIN_SPEAKER_OUT)
3027                 alc_auto_fill_extra_dacs(codec, cfg->speaker_outs, cfg->speaker_pins,
3028                                  spec->multiout.extra_out_nid);
3029
3030         return 0;
3031 }
3032
3033 static inline unsigned int get_ctl_pos(unsigned int data)
3034 {
3035         hda_nid_t nid = get_amp_nid_(data);
3036         unsigned int dir = get_amp_direction_(data);
3037         return (nid << 1) | dir;
3038 }
3039
3040 #define is_ctl_used(bits, data) \
3041         test_bit(get_ctl_pos(data), bits)
3042 #define mark_ctl_usage(bits, data) \
3043         set_bit(get_ctl_pos(data), bits)
3044
3045 static int alc_auto_add_vol_ctl(struct hda_codec *codec,
3046                               const char *pfx, int cidx,
3047                               hda_nid_t nid, unsigned int chs)
3048 {
3049         struct alc_spec *spec = codec->spec;
3050         unsigned int val;
3051         if (!nid)
3052                 return 0;
3053         val = HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_OUTPUT);
3054         if (is_ctl_used(spec->vol_ctls, val) && chs != 2) /* exclude LFE */
3055                 return 0;
3056         mark_ctl_usage(spec->vol_ctls, val);
3057         return __add_pb_vol_ctrl(codec->spec, ALC_CTL_WIDGET_VOL, pfx, cidx,
3058                                  val);
3059 }
3060
3061 #define alc_auto_add_stereo_vol(codec, pfx, cidx, nid)  \
3062         alc_auto_add_vol_ctl(codec, pfx, cidx, nid, 3)
3063
3064 /* create a mute-switch for the given mixer widget;
3065  * if it has multiple sources (e.g. DAC and loopback), create a bind-mute
3066  */
3067 static int alc_auto_add_sw_ctl(struct hda_codec *codec,
3068                              const char *pfx, int cidx,
3069                              hda_nid_t nid, unsigned int chs)
3070 {
3071         struct alc_spec *spec = codec->spec;
3072         int wid_type;
3073         int type;
3074         unsigned long val;
3075         if (!nid)
3076                 return 0;
3077         wid_type = get_wcaps_type(get_wcaps(codec, nid));
3078         if (wid_type == AC_WID_PIN || wid_type == AC_WID_AUD_OUT) {
3079                 type = ALC_CTL_WIDGET_MUTE;
3080                 val = HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_OUTPUT);
3081         } else if (snd_hda_get_conn_list(codec, nid, NULL) == 1) {
3082                 type = ALC_CTL_WIDGET_MUTE;
3083                 val = HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_INPUT);
3084         } else {
3085                 type = ALC_CTL_BIND_MUTE;
3086                 val = HDA_COMPOSE_AMP_VAL(nid, chs, 2, HDA_INPUT);
3087         }
3088         if (is_ctl_used(spec->sw_ctls, val) && chs != 2) /* exclude LFE */
3089                 return 0;
3090         mark_ctl_usage(spec->sw_ctls, val);
3091         return __add_pb_sw_ctrl(codec->spec, type, pfx, cidx, val);
3092 }
3093
3094 #define alc_auto_add_stereo_sw(codec, pfx, cidx, nid)   \
3095         alc_auto_add_sw_ctl(codec, pfx, cidx, nid, 3)
3096
3097 static hda_nid_t alc_look_for_out_mute_nid(struct hda_codec *codec,
3098                                            hda_nid_t pin, hda_nid_t dac)
3099 {
3100         hda_nid_t mix = alc_auto_dac_to_mix(codec, pin, dac);
3101         if (nid_has_mute(codec, pin, HDA_OUTPUT))
3102                 return pin;
3103         else if (mix && nid_has_mute(codec, mix, HDA_INPUT))
3104                 return mix;
3105         else if (nid_has_mute(codec, dac, HDA_OUTPUT))
3106                 return dac;
3107         return 0;
3108 }
3109
3110 static hda_nid_t alc_look_for_out_vol_nid(struct hda_codec *codec,
3111                                           hda_nid_t pin, hda_nid_t dac)
3112 {
3113         hda_nid_t mix = alc_auto_dac_to_mix(codec, pin, dac);
3114         if (nid_has_volume(codec, dac, HDA_OUTPUT))
3115                 return dac;
3116         else if (nid_has_volume(codec, mix, HDA_OUTPUT))
3117                 return mix;
3118         else if (nid_has_volume(codec, pin, HDA_OUTPUT))
3119                 return pin;
3120         return 0;
3121 }
3122
3123 /* add playback controls from the parsed DAC table */
3124 static int alc_auto_create_multi_out_ctls(struct hda_codec *codec,
3125                                              const struct auto_pin_cfg *cfg)
3126 {
3127         struct alc_spec *spec = codec->spec;
3128         int i, err, noutputs;
3129
3130         noutputs = cfg->line_outs;
3131         if (spec->multi_ios > 0)
3132                 noutputs += spec->multi_ios;
3133
3134         for (i = 0; i < noutputs; i++) {
3135                 const char *name;
3136                 int index;
3137                 hda_nid_t dac, pin;
3138                 hda_nid_t sw, vol;
3139
3140                 dac = spec->multiout.dac_nids[i];
3141                 if (!dac)
3142                         continue;
3143                 if (i >= cfg->line_outs)
3144                         pin = spec->multi_io[i - 1].pin;
3145                 else
3146                         pin = cfg->line_out_pins[i];
3147
3148                 sw = alc_look_for_out_mute_nid(codec, pin, dac);
3149                 vol = alc_look_for_out_vol_nid(codec, pin, dac);
3150                 name = alc_get_line_out_pfx(spec, i, true, &index);
3151                 if (!name || !strcmp(name, "CLFE")) {
3152                         /* Center/LFE */
3153                         err = alc_auto_add_vol_ctl(codec, "Center", 0, vol, 1);
3154                         if (err < 0)
3155                                 return err;
3156                         err = alc_auto_add_vol_ctl(codec, "LFE", 0, vol, 2);
3157                         if (err < 0)
3158                                 return err;
3159                         err = alc_auto_add_sw_ctl(codec, "Center", 0, sw, 1);
3160                         if (err < 0)
3161                                 return err;
3162                         err = alc_auto_add_sw_ctl(codec, "LFE", 0, sw, 2);
3163                         if (err < 0)
3164                                 return err;
3165                 } else {
3166                         err = alc_auto_add_stereo_vol(codec, name, index, vol);
3167                         if (err < 0)
3168                                 return err;
3169                         err = alc_auto_add_stereo_sw(codec, name, index, sw);
3170                         if (err < 0)
3171                                 return err;
3172                 }
3173         }
3174         return 0;
3175 }
3176
3177 static int alc_auto_create_extra_out(struct hda_codec *codec, hda_nid_t pin,
3178                                      hda_nid_t dac, const char *pfx,
3179                                      int cidx)
3180 {
3181         struct alc_spec *spec = codec->spec;
3182         hda_nid_t sw, vol;
3183         int err;
3184
3185         if (!dac) {
3186                 unsigned int val;
3187                 /* the corresponding DAC is already occupied */
3188                 if (!(get_wcaps(codec, pin) & AC_WCAP_OUT_AMP))
3189                         return 0; /* no way */
3190                 /* create a switch only */
3191                 val = HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT);
3192                 if (is_ctl_used(spec->sw_ctls, val))
3193                         return 0; /* already created */
3194                 mark_ctl_usage(spec->sw_ctls, val);
3195                 return __add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, pfx, cidx, val);
3196         }
3197
3198         sw = alc_look_for_out_mute_nid(codec, pin, dac);
3199         vol = alc_look_for_out_vol_nid(codec, pin, dac);
3200         err = alc_auto_add_stereo_vol(codec, pfx, cidx, vol);
3201         if (err < 0)
3202                 return err;
3203         err = alc_auto_add_stereo_sw(codec, pfx, cidx, sw);
3204         if (err < 0)
3205                 return err;
3206         return 0;
3207 }
3208
3209 static struct hda_bind_ctls *new_bind_ctl(struct hda_codec *codec,
3210                                           unsigned int nums,
3211                                           struct hda_ctl_ops *ops)
3212 {
3213         struct alc_spec *spec = codec->spec;
3214         struct hda_bind_ctls **ctlp, *ctl;
3215         snd_array_init(&spec->bind_ctls, sizeof(ctl), 8);
3216         ctlp = snd_array_new(&spec->bind_ctls);
3217         if (!ctlp)
3218                 return NULL;
3219         ctl = kzalloc(sizeof(*ctl) + sizeof(long) * (nums + 1), GFP_KERNEL);
3220         *ctlp = ctl;
3221         if (ctl)
3222                 ctl->ops = ops;
3223         return ctl;
3224 }
3225
3226 /* add playback controls for speaker and HP outputs */
3227 static int alc_auto_create_extra_outs(struct hda_codec *codec, int num_pins,
3228                                       const hda_nid_t *pins,
3229                                       const hda_nid_t *dacs,
3230                                       const char *pfx)
3231 {
3232         struct alc_spec *spec = codec->spec;
3233         struct hda_bind_ctls *ctl;
3234         char name[32];
3235         int i, n, err;
3236
3237         if (!num_pins || !pins[0])
3238                 return 0;
3239
3240         if (num_pins == 1) {
3241                 hda_nid_t dac = *dacs;
3242                 if (!dac)
3243                         dac = spec->multiout.dac_nids[0];
3244                 return alc_auto_create_extra_out(codec, *pins, dac, pfx, 0);
3245         }
3246
3247         if (dacs[num_pins - 1]) {
3248                 /* OK, we have a multi-output system with individual volumes */
3249                 for (i = 0; i < num_pins; i++) {
3250                         if (num_pins >= 3) {
3251                                 snprintf(name, sizeof(name), "%s %s",
3252                                          pfx, channel_name[i]);
3253                                 err = alc_auto_create_extra_out(codec, pins[i], dacs[i],
3254                                                                 name, 0);
3255                         } else {
3256                                 err = alc_auto_create_extra_out(codec, pins[i], dacs[i],
3257                                                                 pfx, i);
3258                         }
3259                         if (err < 0)
3260                                 return err;
3261                 }
3262                 return 0;
3263         }
3264
3265         /* Let's create a bind-controls */
3266         ctl = new_bind_ctl(codec, num_pins, &snd_hda_bind_sw);
3267         if (!ctl)
3268                 return -ENOMEM;
3269         n = 0;
3270         for (i = 0; i < num_pins; i++) {
3271                 if (get_wcaps(codec, pins[i]) & AC_WCAP_OUT_AMP)
3272                         ctl->values[n++] =
3273                                 HDA_COMPOSE_AMP_VAL(pins[i], 3, 0, HDA_OUTPUT);
3274         }
3275         if (n) {
3276                 snprintf(name, sizeof(name), "%s Playback Switch", pfx);
3277                 err = add_control(spec, ALC_CTL_BIND_SW, name, 0, (long)ctl);
3278                 if (err < 0)
3279                         return err;
3280         }
3281
3282         ctl = new_bind_ctl(codec, num_pins, &snd_hda_bind_vol);
3283         if (!ctl)
3284                 return -ENOMEM;
3285         n = 0;
3286         for (i = 0; i < num_pins; i++) {
3287                 hda_nid_t vol;
3288                 if (!pins[i] || !dacs[i])
3289                         continue;
3290                 vol = alc_look_for_out_vol_nid(codec, pins[i], dacs[i]);
3291                 if (vol)
3292                         ctl->values[n++] =
3293                                 HDA_COMPOSE_AMP_VAL(vol, 3, 0, HDA_OUTPUT);
3294         }
3295         if (n) {
3296                 snprintf(name, sizeof(name), "%s Playback Volume", pfx);
3297                 err = add_control(spec, ALC_CTL_BIND_VOL, name, 0, (long)ctl);
3298                 if (err < 0)
3299                         return err;
3300         }
3301         return 0;
3302 }
3303
3304 static int alc_auto_create_hp_out(struct hda_codec *codec)
3305 {
3306         struct alc_spec *spec = codec->spec;
3307         return alc_auto_create_extra_outs(codec, spec->autocfg.hp_outs,
3308                                           spec->autocfg.hp_pins,
3309                                           spec->multiout.hp_out_nid,
3310                                           "Headphone");
3311 }
3312
3313 static int alc_auto_create_speaker_out(struct hda_codec *codec)
3314 {
3315         struct alc_spec *spec = codec->spec;
3316         return alc_auto_create_extra_outs(codec, spec->autocfg.speaker_outs,
3317                                           spec->autocfg.speaker_pins,
3318                                           spec->multiout.extra_out_nid,
3319                                           "Speaker");
3320 }
3321
3322 static void alc_auto_set_output_and_unmute(struct hda_codec *codec,
3323                                               hda_nid_t pin, int pin_type,
3324                                               hda_nid_t dac)
3325 {
3326         int i, num;
3327         hda_nid_t nid, mix = 0;
3328         hda_nid_t srcs[HDA_MAX_CONNECTIONS];
3329
3330         alc_set_pin_output(codec, pin, pin_type);
3331         nid = alc_go_down_to_selector(codec, pin);
3332         num = snd_hda_get_connections(codec, nid, srcs, ARRAY_SIZE(srcs));
3333         for (i = 0; i < num; i++) {
3334                 if (alc_auto_mix_to_dac(codec, srcs[i]) != dac)
3335                         continue;
3336                 mix = srcs[i];
3337                 break;
3338         }
3339         if (!mix)
3340                 return;
3341
3342         /* need the manual connection? */
3343         if (num > 1)
3344                 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CONNECT_SEL, i);
3345         /* unmute mixer widget inputs */
3346         if (nid_has_mute(codec, mix, HDA_INPUT)) {
3347                 snd_hda_codec_write(codec, mix, 0, AC_VERB_SET_AMP_GAIN_MUTE,
3348                             AMP_IN_UNMUTE(0));
3349                 snd_hda_codec_write(codec, mix, 0, AC_VERB_SET_AMP_GAIN_MUTE,
3350                             AMP_IN_UNMUTE(1));
3351         }
3352         /* initialize volume */
3353         nid = alc_look_for_out_vol_nid(codec, pin, dac);
3354         if (nid)
3355                 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE,
3356                                     AMP_OUT_ZERO);
3357
3358         /* unmute DAC if it's not assigned to a mixer */
3359         nid = alc_look_for_out_mute_nid(codec, pin, dac);
3360         if (nid == mix && nid_has_mute(codec, dac, HDA_OUTPUT))
3361                 snd_hda_codec_write(codec, dac, 0, AC_VERB_SET_AMP_GAIN_MUTE,
3362                                     AMP_OUT_ZERO);
3363 }
3364
3365 static void alc_auto_init_multi_out(struct hda_codec *codec)
3366 {
3367         struct alc_spec *spec = codec->spec;
3368         int pin_type = get_pin_type(spec->autocfg.line_out_type);
3369         int i;
3370
3371         for (i = 0; i <= HDA_SIDE; i++) {
3372                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
3373                 if (nid)
3374                         alc_auto_set_output_and_unmute(codec, nid, pin_type,
3375                                         spec->multiout.dac_nids[i]);
3376         }
3377 }
3378
3379 static void alc_auto_init_extra_out(struct hda_codec *codec)
3380 {
3381         struct alc_spec *spec = codec->spec;
3382         int i;
3383         hda_nid_t pin, dac;
3384
3385         for (i = 0; i < spec->autocfg.hp_outs; i++) {
3386                 if (spec->autocfg.line_out_type == AUTO_PIN_HP_OUT)
3387                         break;
3388                 pin = spec->autocfg.hp_pins[i];
3389                 if (!pin)
3390                         break;
3391                 dac = spec->multiout.hp_out_nid[i];
3392                 if (!dac) {
3393                         if (i > 0 && spec->multiout.hp_out_nid[0])
3394                                 dac = spec->multiout.hp_out_nid[0];
3395                         else
3396                                 dac = spec->multiout.dac_nids[0];
3397                 }
3398                 alc_auto_set_output_and_unmute(codec, pin, PIN_HP, dac);
3399         }
3400         for (i = 0; i < spec->autocfg.speaker_outs; i++) {
3401                 if (spec->autocfg.line_out_type == AUTO_PIN_SPEAKER_OUT)
3402                         break;
3403                 pin = spec->autocfg.speaker_pins[i];
3404                 if (!pin)
3405                         break;
3406                 dac = spec->multiout.extra_out_nid[i];
3407                 if (!dac) {
3408                         if (i > 0 && spec->multiout.extra_out_nid[0])
3409                                 dac = spec->multiout.extra_out_nid[0];
3410                         else
3411                                 dac = spec->multiout.dac_nids[0];
3412                 }
3413                 alc_auto_set_output_and_unmute(codec, pin, PIN_OUT, dac);
3414         }
3415 }
3416
3417 /*
3418  * multi-io helper
3419  */
3420 static int alc_auto_fill_multi_ios(struct hda_codec *codec,
3421                                    unsigned int location)
3422 {
3423         struct alc_spec *spec = codec->spec;
3424         struct auto_pin_cfg *cfg = &spec->autocfg;
3425         hda_nid_t prime_dac = spec->private_dac_nids[0];
3426         int type, i, num_pins = 0;
3427
3428         for (type = AUTO_PIN_LINE_IN; type >= AUTO_PIN_MIC; type--) {
3429                 for (i = 0; i < cfg->num_inputs; i++) {
3430                         hda_nid_t nid = cfg->inputs[i].pin;
3431                         hda_nid_t dac;
3432                         unsigned int defcfg, caps;
3433                         if (cfg->inputs[i].type != type)
3434                                 continue;
3435                         defcfg = snd_hda_codec_get_pincfg(codec, nid);
3436                         if (get_defcfg_connect(defcfg) != AC_JACK_PORT_COMPLEX)
3437                                 continue;
3438                         if (location && get_defcfg_location(defcfg) != location)
3439                                 continue;
3440                         caps = snd_hda_query_pin_caps(codec, nid);
3441                         if (!(caps & AC_PINCAP_OUT))
3442                                 continue;
3443                         dac = alc_auto_look_for_dac(codec, nid);
3444                         if (!dac)
3445                                 continue;
3446                         spec->multi_io[num_pins].pin = nid;
3447                         spec->multi_io[num_pins].dac = dac;
3448                         num_pins++;
3449                         spec->private_dac_nids[spec->multiout.num_dacs++] = dac;
3450                 }
3451         }
3452         spec->multiout.num_dacs = 1;
3453         if (num_pins < 2) {
3454                 /* clear up again */
3455                 memset(spec->private_dac_nids, 0,
3456                        sizeof(spec->private_dac_nids));
3457                 spec->private_dac_nids[0] = prime_dac;
3458                 return 0;
3459         }
3460         return num_pins;
3461 }
3462
3463 static int alc_auto_ch_mode_info(struct snd_kcontrol *kcontrol,
3464                                  struct snd_ctl_elem_info *uinfo)
3465 {
3466         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3467         struct alc_spec *spec = codec->spec;
3468
3469         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
3470         uinfo->count = 1;
3471         uinfo->value.enumerated.items = spec->multi_ios + 1;
3472         if (uinfo->value.enumerated.item > spec->multi_ios)
3473                 uinfo->value.enumerated.item = spec->multi_ios;
3474         sprintf(uinfo->value.enumerated.name, "%dch",
3475                 (uinfo->value.enumerated.item + 1) * 2);
3476         return 0;
3477 }
3478
3479 static int alc_auto_ch_mode_get(struct snd_kcontrol *kcontrol,
3480                                 struct snd_ctl_elem_value *ucontrol)
3481 {
3482         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3483         struct alc_spec *spec = codec->spec;
3484         ucontrol->value.enumerated.item[0] = (spec->ext_channel_count - 1) / 2;
3485         return 0;
3486 }
3487
3488 static int alc_set_multi_io(struct hda_codec *codec, int idx, bool output)
3489 {
3490         struct alc_spec *spec = codec->spec;
3491         hda_nid_t nid = spec->multi_io[idx].pin;
3492
3493         if (!spec->multi_io[idx].ctl_in)
3494                 spec->multi_io[idx].ctl_in =
3495                         snd_hda_codec_read(codec, nid, 0,
3496                                            AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
3497         if (output) {
3498                 snd_hda_codec_update_cache(codec, nid, 0,
3499                                            AC_VERB_SET_PIN_WIDGET_CONTROL,
3500                                            PIN_OUT);
3501                 if (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP)
3502                         snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
3503                                                  HDA_AMP_MUTE, 0);
3504                 alc_auto_select_dac(codec, nid, spec->multi_io[idx].dac);
3505         } else {
3506                 if (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP)
3507                         snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
3508                                                  HDA_AMP_MUTE, HDA_AMP_MUTE);
3509                 snd_hda_codec_update_cache(codec, nid, 0,
3510                                            AC_VERB_SET_PIN_WIDGET_CONTROL,
3511                                            spec->multi_io[idx].ctl_in);
3512         }
3513         return 0;
3514 }
3515
3516 static int alc_auto_ch_mode_put(struct snd_kcontrol *kcontrol,
3517                                 struct snd_ctl_elem_value *ucontrol)
3518 {
3519         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3520         struct alc_spec *spec = codec->spec;
3521         int i, ch;
3522
3523         ch = ucontrol->value.enumerated.item[0];
3524         if (ch < 0 || ch > spec->multi_ios)
3525                 return -EINVAL;
3526         if (ch == (spec->ext_channel_count - 1) / 2)
3527                 return 0;
3528         spec->ext_channel_count = (ch + 1) * 2;
3529         for (i = 0; i < spec->multi_ios; i++)
3530                 alc_set_multi_io(codec, i, i < ch);
3531         spec->multiout.max_channels = spec->ext_channel_count;
3532         if (spec->need_dac_fix && !spec->const_channel_count)
3533                 spec->multiout.num_dacs = spec->multiout.max_channels / 2;
3534         return 1;
3535 }
3536
3537 static const struct snd_kcontrol_new alc_auto_channel_mode_enum = {
3538         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3539         .name = "Channel Mode",
3540         .info = alc_auto_ch_mode_info,
3541         .get = alc_auto_ch_mode_get,
3542         .put = alc_auto_ch_mode_put,
3543 };
3544
3545 static int alc_auto_add_multi_channel_mode(struct hda_codec *codec)
3546 {
3547         struct alc_spec *spec = codec->spec;
3548
3549         if (spec->multi_ios > 0) {
3550                 struct snd_kcontrol_new *knew;
3551
3552                 knew = alc_kcontrol_new(spec);
3553                 if (!knew)
3554                         return -ENOMEM;
3555                 *knew = alc_auto_channel_mode_enum;
3556                 knew->name = kstrdup("Channel Mode", GFP_KERNEL);
3557                 if (!knew->name)
3558                         return -ENOMEM;
3559         }
3560         return 0;
3561 }
3562
3563 /* filter out invalid adc_nids (and capsrc_nids) that don't give all
3564  * active input pins
3565  */
3566 static void alc_remove_invalid_adc_nids(struct hda_codec *codec)
3567 {
3568         struct alc_spec *spec = codec->spec;
3569         const struct hda_input_mux *imux;
3570         hda_nid_t adc_nids[ARRAY_SIZE(spec->private_adc_nids)];
3571         hda_nid_t capsrc_nids[ARRAY_SIZE(spec->private_adc_nids)];
3572         int i, n, nums;
3573
3574         imux = spec->input_mux;
3575         if (!imux)
3576                 return;
3577         if (spec->dyn_adc_switch)
3578                 return;
3579
3580         nums = 0;
3581         for (n = 0; n < spec->num_adc_nids; n++) {
3582                 hda_nid_t cap = spec->private_capsrc_nids[n];
3583                 int num_conns = snd_hda_get_conn_list(codec, cap, NULL);
3584                 for (i = 0; i < imux->num_items; i++) {
3585                         hda_nid_t pin = spec->imux_pins[i];
3586                         if (pin) {
3587                                 if (get_connection_index(codec, cap, pin) < 0)
3588                                         break;
3589                         } else if (num_conns <= imux->items[i].index)
3590                                 break;
3591                 }
3592                 if (i >= imux->num_items) {
3593                         adc_nids[nums] = spec->private_adc_nids[n];
3594                         capsrc_nids[nums++] = cap;
3595                 }
3596         }
3597         if (!nums) {
3598                 /* check whether ADC-switch is possible */
3599                 if (!alc_check_dyn_adc_switch(codec)) {
3600                         printk(KERN_WARNING "hda_codec: %s: no valid ADC found;"
3601                                " using fallback 0x%x\n",
3602                                codec->chip_name, spec->private_adc_nids[0]);
3603                         spec->num_adc_nids = 1;
3604                         spec->auto_mic = 0;
3605                         return;
3606                 }
3607         } else if (nums != spec->num_adc_nids) {
3608                 memcpy(spec->private_adc_nids, adc_nids,
3609                        nums * sizeof(hda_nid_t));
3610                 memcpy(spec->private_capsrc_nids, capsrc_nids,
3611                        nums * sizeof(hda_nid_t));
3612                 spec->num_adc_nids = nums;
3613         }
3614
3615         if (spec->auto_mic)
3616                 alc_auto_mic_check_imux(codec); /* check auto-mic setups */
3617         else if (spec->input_mux->num_items == 1)
3618                 spec->num_adc_nids = 1; /* reduce to a single ADC */
3619 }
3620
3621 /*
3622  * initialize ADC paths
3623  */
3624 static void alc_auto_init_adc(struct hda_codec *codec, int adc_idx)
3625 {
3626         struct alc_spec *spec = codec->spec;
3627         hda_nid_t nid;
3628
3629         nid = spec->adc_nids[adc_idx];
3630         /* mute ADC */
3631         if (nid_has_mute(codec, nid, HDA_INPUT)) {
3632                 snd_hda_codec_write(codec, nid, 0,
3633                                     AC_VERB_SET_AMP_GAIN_MUTE,
3634                                     AMP_IN_MUTE(0));
3635                 return;
3636         }
3637         if (!spec->capsrc_nids)
3638                 return;
3639         nid = spec->capsrc_nids[adc_idx];
3640         if (nid_has_mute(codec, nid, HDA_OUTPUT))
3641                 snd_hda_codec_write(codec, nid, 0,
3642                                     AC_VERB_SET_AMP_GAIN_MUTE,
3643                                     AMP_OUT_MUTE);
3644 }
3645
3646 static void alc_auto_init_input_src(struct hda_codec *codec)
3647 {
3648         struct alc_spec *spec = codec->spec;
3649         int c, nums;
3650
3651         for (c = 0; c < spec->num_adc_nids; c++)
3652                 alc_auto_init_adc(codec, c);
3653         if (spec->dyn_adc_switch)
3654                 nums = 1;
3655         else
3656                 nums = spec->num_adc_nids;
3657         for (c = 0; c < nums; c++)
3658                 alc_mux_select(codec, 0, spec->cur_mux[c], true);
3659 }
3660
3661 /* add mic boosts if needed */
3662 static int alc_auto_add_mic_boost(struct hda_codec *codec)
3663 {
3664         struct alc_spec *spec = codec->spec;
3665         struct auto_pin_cfg *cfg = &spec->autocfg;
3666         int i, err;
3667         int type_idx = 0;
3668         hda_nid_t nid;
3669         const char *prev_label = NULL;
3670
3671         for (i = 0; i < cfg->num_inputs; i++) {
3672                 if (cfg->inputs[i].type > AUTO_PIN_MIC)
3673                         break;
3674                 nid = cfg->inputs[i].pin;
3675                 if (get_wcaps(codec, nid) & AC_WCAP_IN_AMP) {
3676                         const char *label;
3677                         char boost_label[32];
3678
3679                         label = hda_get_autocfg_input_label(codec, cfg, i);
3680                         if (prev_label && !strcmp(label, prev_label))
3681                                 type_idx++;
3682                         else
3683                                 type_idx = 0;
3684                         prev_label = label;
3685
3686                         snprintf(boost_label, sizeof(boost_label),
3687                                  "%s Boost Volume", label);
3688                         err = add_control(spec, ALC_CTL_WIDGET_VOL,
3689                                           boost_label, type_idx,
3690                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT));
3691                         if (err < 0)
3692                                 return err;
3693                 }
3694         }
3695         return 0;
3696 }
3697
3698 /* select or unmute the given capsrc route */
3699 static void select_or_unmute_capsrc(struct hda_codec *codec, hda_nid_t cap,
3700                                     int idx)
3701 {
3702         if (get_wcaps_type(get_wcaps(codec, cap)) == AC_WID_AUD_MIX) {
3703                 snd_hda_codec_amp_stereo(codec, cap, HDA_INPUT, idx,
3704                                          HDA_AMP_MUTE, 0);
3705         } else if (snd_hda_get_conn_list(codec, cap, NULL) > 1) {
3706                 snd_hda_codec_write_cache(codec, cap, 0,
3707                                           AC_VERB_SET_CONNECT_SEL, idx);
3708         }
3709 }
3710
3711 /* set the default connection to that pin */
3712 static int init_capsrc_for_pin(struct hda_codec *codec, hda_nid_t pin)
3713 {
3714         struct alc_spec *spec = codec->spec;
3715         int i;
3716
3717         if (!pin)
3718                 return 0;
3719         for (i = 0; i < spec->num_adc_nids; i++) {
3720                 hda_nid_t cap = get_capsrc(spec, i);
3721                 int idx;
3722
3723                 idx = get_connection_index(codec, cap, pin);
3724                 if (idx < 0)
3725                         continue;
3726                 select_or_unmute_capsrc(codec, cap, idx);
3727                 return i; /* return the found index */
3728         }
3729         return -1; /* not found */
3730 }
3731
3732 /* initialize some special cases for input sources */
3733 static void alc_init_special_input_src(struct hda_codec *codec)
3734 {
3735         struct alc_spec *spec = codec->spec;
3736         int i;
3737
3738         for (i = 0; i < spec->autocfg.num_inputs; i++)
3739                 init_capsrc_for_pin(codec, spec->autocfg.inputs[i].pin);
3740 }
3741
3742 /* assign appropriate capture mixers */
3743 static void set_capture_mixer(struct hda_codec *codec)
3744 {
3745         struct alc_spec *spec = codec->spec;
3746         static const struct snd_kcontrol_new *caps[2][3] = {
3747                 { alc_capture_mixer_nosrc1,
3748                   alc_capture_mixer_nosrc2,
3749                   alc_capture_mixer_nosrc3 },
3750                 { alc_capture_mixer1,
3751                   alc_capture_mixer2,
3752                   alc_capture_mixer3 },
3753         };
3754
3755         /* check whether either of ADC or MUX has a volume control */
3756         if (!nid_has_volume(codec, spec->adc_nids[0], HDA_INPUT)) {
3757                 if (!spec->capsrc_nids)
3758                         return; /* no volume */
3759                 if (!nid_has_volume(codec, spec->capsrc_nids[0], HDA_OUTPUT))
3760                         return; /* no volume in capsrc, too */
3761                 spec->vol_in_capsrc = 1;
3762         }
3763
3764         if (spec->num_adc_nids > 0) {
3765                 int mux = 0;
3766                 int num_adcs = 0;
3767
3768                 if (spec->input_mux && spec->input_mux->num_items > 1)
3769                         mux = 1;
3770                 if (spec->auto_mic) {
3771                         num_adcs = 1;
3772                         mux = 0;
3773                 } else if (spec->dyn_adc_switch)
3774                         num_adcs = 1;
3775                 if (!num_adcs) {
3776                         if (spec->num_adc_nids > 3)
3777                                 spec->num_adc_nids = 3;
3778                         else if (!spec->num_adc_nids)
3779                                 return;
3780                         num_adcs = spec->num_adc_nids;
3781                 }
3782                 spec->cap_mixer = caps[mux][num_adcs - 1];
3783         }
3784 }
3785
3786 /*
3787  * standard auto-parser initializations
3788  */
3789 static void alc_auto_init_std(struct hda_codec *codec)
3790 {
3791         struct alc_spec *spec = codec->spec;
3792         alc_auto_init_multi_out(codec);
3793         alc_auto_init_extra_out(codec);
3794         alc_auto_init_analog_input(codec);
3795         alc_auto_init_input_src(codec);
3796         alc_auto_init_digital(codec);
3797         if (spec->unsol_event)
3798                 alc_inithook(codec);
3799 }
3800
3801 /*
3802  * Digital-beep handlers
3803  */
3804 #ifdef CONFIG_SND_HDA_INPUT_BEEP
3805 #define set_beep_amp(spec, nid, idx, dir) \
3806         ((spec)->beep_amp = HDA_COMPOSE_AMP_VAL(nid, 3, idx, dir))
3807
3808 static const struct snd_pci_quirk beep_white_list[] = {
3809         SND_PCI_QUIRK(0x1043, 0x829f, "ASUS", 1),
3810         SND_PCI_QUIRK(0x1043, 0x83ce, "EeePC", 1),
3811         SND_PCI_QUIRK(0x1043, 0x831a, "EeePC", 1),
3812         SND_PCI_QUIRK(0x1043, 0x834a, "EeePC", 1),
3813         SND_PCI_QUIRK(0x8086, 0xd613, "Intel", 1),
3814         {}
3815 };
3816
3817 static inline int has_cdefine_beep(struct hda_codec *codec)
3818 {
3819         struct alc_spec *spec = codec->spec;
3820         const struct snd_pci_quirk *q;
3821         q = snd_pci_quirk_lookup(codec->bus->pci, beep_white_list);
3822         if (q)
3823                 return q->value;
3824         return spec->cdefine.enable_pcbeep;
3825 }
3826 #else
3827 #define set_beep_amp(spec, nid, idx, dir) /* NOP */
3828 #define has_cdefine_beep(codec)         0
3829 #endif
3830
3831 /* parse the BIOS configuration and set up the alc_spec */
3832 /* return 1 if successful, 0 if the proper config is not found,
3833  * or a negative error code
3834  */
3835 static int alc_parse_auto_config(struct hda_codec *codec,
3836                                  const hda_nid_t *ignore_nids,
3837                                  const hda_nid_t *ssid_nids)
3838 {
3839         struct alc_spec *spec = codec->spec;
3840         struct auto_pin_cfg *cfg = &spec->autocfg;
3841         int err;
3842
3843         err = snd_hda_parse_pin_defcfg(codec, cfg, ignore_nids,
3844                                        spec->parse_flags);
3845         if (err < 0)
3846                 return err;
3847         if (!cfg->line_outs) {
3848                 if (cfg->dig_outs || cfg->dig_in_pin) {
3849                         spec->multiout.max_channels = 2;
3850                         spec->no_analog = 1;
3851                         goto dig_only;
3852                 }
3853                 return 0; /* can't find valid BIOS pin config */
3854         }
3855
3856         if (cfg->line_out_type == AUTO_PIN_SPEAKER_OUT &&
3857             cfg->line_outs <= cfg->hp_outs) {
3858                 /* use HP as primary out */
3859                 cfg->speaker_outs = cfg->line_outs;
3860                 memcpy(cfg->speaker_pins, cfg->line_out_pins,
3861                        sizeof(cfg->speaker_pins));
3862                 cfg->line_outs = cfg->hp_outs;
3863                 memcpy(cfg->line_out_pins, cfg->hp_pins, sizeof(cfg->hp_pins));
3864                 cfg->hp_outs = 0;
3865                 memset(cfg->hp_pins, 0, sizeof(cfg->hp_pins));
3866                 cfg->line_out_type = AUTO_PIN_HP_OUT;
3867         }
3868
3869         err = alc_auto_fill_dac_nids(codec);
3870         if (err < 0)
3871                 return err;
3872         err = alc_auto_add_multi_channel_mode(codec);
3873         if (err < 0)
3874                 return err;
3875         err = alc_auto_create_multi_out_ctls(codec, cfg);
3876         if (err < 0)
3877                 return err;
3878         err = alc_auto_create_hp_out(codec);
3879         if (err < 0)
3880                 return err;
3881         err = alc_auto_create_speaker_out(codec);
3882         if (err < 0)
3883                 return err;
3884         err = alc_auto_create_input_ctls(codec);
3885         if (err < 0)
3886                 return err;
3887
3888         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
3889
3890  dig_only:
3891         alc_auto_parse_digital(codec);
3892
3893         if (!spec->no_analog)
3894                 alc_remove_invalid_adc_nids(codec);
3895
3896         if (ssid_nids)
3897                 alc_ssid_check(codec, ssid_nids);
3898
3899         if (!spec->no_analog) {
3900                 alc_auto_check_switches(codec);
3901                 err = alc_auto_add_mic_boost(codec);
3902                 if (err < 0)
3903                         return err;
3904         }
3905
3906         if (spec->kctls.list)
3907                 add_mixer(spec, spec->kctls.list);
3908
3909         return 1;
3910 }
3911
3912 static int alc880_parse_auto_config(struct hda_codec *codec)
3913 {
3914         static const hda_nid_t alc880_ignore[] = { 0x1d, 0 };
3915         static const hda_nid_t alc880_ssids[] = { 0x15, 0x1b, 0x14, 0 };
3916         return alc_parse_auto_config(codec, alc880_ignore, alc880_ssids);
3917 }
3918
3919 #ifdef CONFIG_SND_HDA_POWER_SAVE
3920 static const struct hda_amp_list alc880_loopbacks[] = {
3921         { 0x0b, HDA_INPUT, 0 },
3922         { 0x0b, HDA_INPUT, 1 },
3923         { 0x0b, HDA_INPUT, 2 },
3924         { 0x0b, HDA_INPUT, 3 },
3925         { 0x0b, HDA_INPUT, 4 },
3926         { } /* end */
3927 };
3928 #endif
3929
3930 /*
3931  * board setups
3932  */
3933 #ifdef CONFIG_SND_HDA_ENABLE_REALTEK_QUIRKS
3934 #define alc_board_config \
3935         snd_hda_check_board_config
3936 #define alc_board_codec_sid_config \
3937         snd_hda_check_board_codec_sid_config
3938 #include "alc_quirks.c"
3939 #else
3940 #define alc_board_config(codec, nums, models, tbl)      -1
3941 #define alc_board_codec_sid_config(codec, nums, models, tbl)    -1
3942 #define setup_preset(codec, x)  /* NOP */
3943 #endif
3944
3945 /*
3946  * OK, here we have finally the patch for ALC880
3947  */
3948 #ifdef CONFIG_SND_HDA_ENABLE_REALTEK_QUIRKS
3949 #include "alc880_quirks.c"
3950 #endif
3951
3952 static int patch_alc880(struct hda_codec *codec)
3953 {
3954         struct alc_spec *spec;
3955         int board_config;
3956         int err;
3957
3958         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
3959         if (spec == NULL)
3960                 return -ENOMEM;
3961
3962         codec->spec = spec;
3963
3964         spec->mixer_nid = 0x0b;
3965         spec->need_dac_fix = 1;
3966
3967         board_config = alc_board_config(codec, ALC880_MODEL_LAST,
3968                                         alc880_models, alc880_cfg_tbl);
3969         if (board_config < 0) {
3970                 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
3971                        codec->chip_name);
3972                 board_config = ALC_MODEL_AUTO;
3973         }
3974
3975         if (board_config == ALC_MODEL_AUTO) {
3976                 /* automatic parse from the BIOS config */
3977                 err = alc880_parse_auto_config(codec);
3978                 if (err < 0)
3979                         goto error;
3980 #ifdef CONFIG_SND_HDA_ENABLE_REALTEK_QUIRKS
3981                 else if (!err) {
3982                         printk(KERN_INFO
3983                                "hda_codec: Cannot set up configuration "
3984                                "from BIOS.  Using 3-stack mode...\n");
3985                         board_config = ALC880_3ST;
3986                 }
3987 #endif
3988         }
3989
3990         if (board_config != ALC_MODEL_AUTO)
3991                 setup_preset(codec, &alc880_presets[board_config]);
3992
3993         if (!spec->no_analog && !spec->adc_nids) {
3994                 alc_auto_fill_adc_caps(codec);
3995                 alc_rebuild_imux_for_auto_mic(codec);
3996                 alc_remove_invalid_adc_nids(codec);
3997         }
3998
3999         if (!spec->no_analog && !spec->cap_mixer)
4000                 set_capture_mixer(codec);
4001
4002         if (!spec->no_analog) {
4003                 err = snd_hda_attach_beep_device(codec, 0x1);
4004                 if (err < 0)
4005                         goto error;
4006                 set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
4007         }
4008
4009         spec->vmaster_nid = 0x0c;
4010
4011         codec->patch_ops = alc_patch_ops;
4012         if (board_config == ALC_MODEL_AUTO)
4013                 spec->init_hook = alc_auto_init_std;
4014 #ifdef CONFIG_SND_HDA_POWER_SAVE
4015         if (!spec->loopback.amplist)
4016                 spec->loopback.amplist = alc880_loopbacks;
4017 #endif
4018
4019         return 0;
4020
4021  error:
4022         alc_free(codec);
4023         return err;
4024 }
4025
4026
4027 /*
4028  * ALC260 support
4029  */
4030 static int alc260_parse_auto_config(struct hda_codec *codec)
4031 {
4032         static const hda_nid_t alc260_ignore[] = { 0x17, 0 };
4033         static const hda_nid_t alc260_ssids[] = { 0x10, 0x15, 0x0f, 0 };
4034         return alc_parse_auto_config(codec, alc260_ignore, alc260_ssids);
4035 }
4036
4037 #ifdef CONFIG_SND_HDA_POWER_SAVE
4038 static const struct hda_amp_list alc260_loopbacks[] = {
4039         { 0x07, HDA_INPUT, 0 },
4040         { 0x07, HDA_INPUT, 1 },
4041         { 0x07, HDA_INPUT, 2 },
4042         { 0x07, HDA_INPUT, 3 },
4043         { 0x07, HDA_INPUT, 4 },
4044         { } /* end */
4045 };
4046 #endif
4047
4048 /*
4049  * Pin config fixes
4050  */
4051 enum {
4052         PINFIX_HP_DC5750,
4053 };
4054
4055 static const struct alc_fixup alc260_fixups[] = {
4056         [PINFIX_HP_DC5750] = {
4057                 .type = ALC_FIXUP_PINS,
4058                 .v.pins = (const struct alc_pincfg[]) {
4059                         { 0x11, 0x90130110 }, /* speaker */
4060                         { }
4061                 }
4062         },
4063 };
4064
4065 static const struct snd_pci_quirk alc260_fixup_tbl[] = {
4066         SND_PCI_QUIRK(0x103c, 0x280a, "HP dc5750", PINFIX_HP_DC5750),
4067         {}
4068 };
4069
4070 /*
4071  */
4072 #ifdef CONFIG_SND_HDA_ENABLE_REALTEK_QUIRKS
4073 #include "alc260_quirks.c"
4074 #endif
4075
4076 static int patch_alc260(struct hda_codec *codec)
4077 {
4078         struct alc_spec *spec;
4079         int err, board_config;
4080
4081         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
4082         if (spec == NULL)
4083                 return -ENOMEM;
4084
4085         codec->spec = spec;
4086
4087         spec->mixer_nid = 0x07;
4088
4089         board_config = alc_board_config(codec, ALC260_MODEL_LAST,
4090                                         alc260_models, alc260_cfg_tbl);
4091         if (board_config < 0) {
4092                 snd_printd(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
4093                            codec->chip_name);
4094                 board_config = ALC_MODEL_AUTO;
4095         }
4096
4097         if (board_config == ALC_MODEL_AUTO) {
4098                 alc_pick_fixup(codec, NULL, alc260_fixup_tbl, alc260_fixups);
4099                 alc_apply_fixup(codec, ALC_FIXUP_ACT_PRE_PROBE);
4100         }
4101
4102         if (board_config == ALC_MODEL_AUTO) {
4103                 /* automatic parse from the BIOS config */
4104                 err = alc260_parse_auto_config(codec);
4105                 if (err < 0)
4106                         goto error;
4107 #ifdef CONFIG_SND_HDA_ENABLE_REALTEK_QUIRKS
4108                 else if (!err) {
4109                         printk(KERN_INFO
4110                                "hda_codec: Cannot set up configuration "
4111                                "from BIOS.  Using base mode...\n");
4112                         board_config = ALC260_BASIC;
4113                 }
4114 #endif
4115         }
4116
4117         if (board_config != ALC_MODEL_AUTO)
4118                 setup_preset(codec, &alc260_presets[board_config]);
4119
4120         if (!spec->no_analog && !spec->adc_nids) {
4121                 alc_auto_fill_adc_caps(codec);
4122                 alc_rebuild_imux_for_auto_mic(codec);
4123                 alc_remove_invalid_adc_nids(codec);
4124         }
4125
4126         if (!spec->no_analog && !spec->cap_mixer)
4127                 set_capture_mixer(codec);
4128
4129         if (!spec->no_analog) {
4130                 err = snd_hda_attach_beep_device(codec, 0x1);
4131                 if (err < 0)
4132                         goto error;
4133                 set_beep_amp(spec, 0x07, 0x05, HDA_INPUT);
4134         }
4135
4136         alc_apply_fixup(codec, ALC_FIXUP_ACT_PROBE);
4137
4138         spec->vmaster_nid = 0x08;
4139
4140         codec->patch_ops = alc_patch_ops;
4141         if (board_config == ALC_MODEL_AUTO)
4142                 spec->init_hook = alc_auto_init_std;
4143         spec->shutup = alc_eapd_shutup;
4144 #ifdef CONFIG_SND_HDA_POWER_SAVE
4145         if (!spec->loopback.amplist)
4146                 spec->loopback.amplist = alc260_loopbacks;
4147 #endif
4148
4149         return 0;
4150
4151  error:
4152         alc_free(codec);
4153         return err;
4154 }
4155
4156
4157 /*
4158  * ALC882/883/885/888/889 support
4159  *
4160  * ALC882 is almost identical with ALC880 but has cleaner and more flexible
4161  * configuration.  Each pin widget can choose any input DACs and a mixer.
4162  * Each ADC is connected from a mixer of all inputs.  This makes possible
4163  * 6-channel independent captures.
4164  *
4165  * In addition, an independent DAC for the multi-playback (not used in this
4166  * driver yet).
4167  */
4168 #ifdef CONFIG_SND_HDA_POWER_SAVE
4169 #define alc882_loopbacks        alc880_loopbacks
4170 #endif
4171
4172 /*
4173  * Pin config fixes
4174  */
4175 enum {
4176         PINFIX_ABIT_AW9D_MAX,
4177         PINFIX_LENOVO_Y530,
4178         PINFIX_PB_M5210,
4179         PINFIX_ACER_ASPIRE_7736,
4180         PINFIX_ASUS_W90V,
4181 };
4182
4183 static const struct alc_fixup alc882_fixups[] = {
4184         [PINFIX_ABIT_AW9D_MAX] = {
4185                 .type = ALC_FIXUP_PINS,
4186                 .v.pins = (const struct alc_pincfg[]) {
4187                         { 0x15, 0x01080104 }, /* side */
4188                         { 0x16, 0x01011012 }, /* rear */
4189                         { 0x17, 0x01016011 }, /* clfe */
4190                         { }
4191                 }
4192         },
4193         [PINFIX_LENOVO_Y530] = {
4194                 .type = ALC_FIXUP_PINS,
4195                 .v.pins = (const struct alc_pincfg[]) {
4196                         { 0x15, 0x99130112 }, /* rear int speakers */
4197                         { 0x16, 0x99130111 }, /* subwoofer */
4198                         { }
4199                 }
4200         },
4201         [PINFIX_PB_M5210] = {
4202                 .type = ALC_FIXUP_VERBS,
4203                 .v.verbs = (const struct hda_verb[]) {
4204                         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50 },
4205                         {}
4206                 }
4207         },
4208         [PINFIX_ACER_ASPIRE_7736] = {
4209                 .type = ALC_FIXUP_SKU,
4210                 .v.sku = ALC_FIXUP_SKU_IGNORE,
4211         },
4212         [PINFIX_ASUS_W90V] = {
4213                 .type = ALC_FIXUP_PINS,
4214                 .v.pins = (const struct alc_pincfg[]) {
4215                         { 0x16, 0x99130110 }, /* fix sequence for CLFE */
4216                         { }
4217                 }
4218         },
4219 };
4220
4221 static const struct snd_pci_quirk alc882_fixup_tbl[] = {
4222         SND_PCI_QUIRK(0x1025, 0x0155, "Packard-Bell M5120", PINFIX_PB_M5210),
4223         SND_PCI_QUIRK(0x1043, 0x1873, "ASUS W90V", PINFIX_ASUS_W90V),
4224         SND_PCI_QUIRK(0x17aa, 0x3a0d, "Lenovo Y530", PINFIX_LENOVO_Y530),
4225         SND_PCI_QUIRK(0x147b, 0x107a, "Abit AW9D-MAX", PINFIX_ABIT_AW9D_MAX),
4226         SND_PCI_QUIRK(0x1025, 0x0296, "Acer Aspire 7736z", PINFIX_ACER_ASPIRE_7736),
4227         {}
4228 };
4229
4230 /*
4231  * BIOS auto configuration
4232  */
4233 /* almost identical with ALC880 parser... */
4234 static int alc882_parse_auto_config(struct hda_codec *codec)
4235 {
4236         static const hda_nid_t alc882_ignore[] = { 0x1d, 0 };
4237         static const hda_nid_t alc882_ssids[] = { 0x15, 0x1b, 0x14, 0 };
4238         return alc_parse_auto_config(codec, alc882_ignore, alc882_ssids);
4239 }
4240
4241 /*
4242  */
4243 #ifdef CONFIG_SND_HDA_ENABLE_REALTEK_QUIRKS
4244 #include "alc882_quirks.c"
4245 #endif
4246
4247 static int patch_alc882(struct hda_codec *codec)
4248 {
4249         struct alc_spec *spec;
4250         int err, board_config;
4251
4252         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
4253         if (spec == NULL)
4254                 return -ENOMEM;
4255
4256         codec->spec = spec;
4257
4258         spec->mixer_nid = 0x0b;
4259
4260         switch (codec->vendor_id) {
4261         case 0x10ec0882:
4262         case 0x10ec0885:
4263                 break;
4264         default:
4265                 /* ALC883 and variants */
4266                 alc_fix_pll_init(codec, 0x20, 0x0a, 10);
4267                 break;
4268         }
4269
4270         err = alc_codec_rename_from_preset(codec);
4271         if (err < 0)
4272                 goto error;
4273
4274         board_config = alc_board_config(codec, ALC882_MODEL_LAST,
4275                                         alc882_models, alc882_cfg_tbl);
4276
4277         if (board_config < 0)
4278                 board_config = alc_board_codec_sid_config(codec,
4279                         ALC882_MODEL_LAST, alc882_models, alc882_ssid_cfg_tbl);
4280
4281         if (board_config < 0) {
4282                 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
4283                        codec->chip_name);
4284                 board_config = ALC_MODEL_AUTO;
4285         }
4286
4287         if (board_config == ALC_MODEL_AUTO) {
4288                 alc_pick_fixup(codec, NULL, alc882_fixup_tbl, alc882_fixups);
4289                 alc_apply_fixup(codec, ALC_FIXUP_ACT_PRE_PROBE);
4290         }
4291
4292         alc_auto_parse_customize_define(codec);
4293
4294         if (board_config == ALC_MODEL_AUTO) {
4295                 /* automatic parse from the BIOS config */
4296                 err = alc882_parse_auto_config(codec);
4297                 if (err < 0)
4298                         goto error;
4299 #ifdef CONFIG_SND_HDA_ENABLE_REALTEK_QUIRKS
4300                 else if (!err) {
4301                         printk(KERN_INFO
4302                                "hda_codec: Cannot set up configuration "
4303                                "from BIOS.  Using base mode...\n");
4304                         board_config = ALC882_3ST_DIG;
4305                 }
4306 #endif
4307         }
4308
4309         if (board_config != ALC_MODEL_AUTO)
4310                 setup_preset(codec, &alc882_presets[board_config]);
4311
4312         if (!spec->no_analog && !spec->adc_nids) {
4313                 alc_auto_fill_adc_caps(codec);
4314                 alc_rebuild_imux_for_auto_mic(codec);
4315                 alc_remove_invalid_adc_nids(codec);
4316         }
4317
4318         if (!spec->no_analog && !spec->cap_mixer)
4319                 set_capture_mixer(codec);
4320
4321         if (!spec->no_analog && has_cdefine_beep(codec)) {
4322                 err = snd_hda_attach_beep_device(codec, 0x1);
4323                 if (err < 0)
4324                         goto error;
4325                 set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
4326         }
4327
4328         alc_apply_fixup(codec, ALC_FIXUP_ACT_PROBE);
4329
4330         spec->vmaster_nid = 0x0c;
4331
4332         codec->patch_ops = alc_patch_ops;
4333         if (board_config == ALC_MODEL_AUTO)
4334                 spec->init_hook = alc_auto_init_std;
4335
4336         alc_init_jacks(codec);
4337 #ifdef CONFIG_SND_HDA_POWER_SAVE
4338         if (!spec->loopback.amplist)
4339                 spec->loopback.amplist = alc882_loopbacks;
4340 #endif
4341
4342         return 0;
4343
4344  error:
4345         alc_free(codec);
4346         return err;
4347 }
4348
4349
4350 /*
4351  * ALC262 support
4352  */
4353 static int alc262_parse_auto_config(struct hda_codec *codec)
4354 {
4355         static const hda_nid_t alc262_ignore[] = { 0x1d, 0 };
4356         static const hda_nid_t alc262_ssids[] = { 0x15, 0x1b, 0x14, 0 };
4357         return alc_parse_auto_config(codec, alc262_ignore, alc262_ssids);
4358 }
4359
4360 /*
4361  * Pin config fixes
4362  */
4363 enum {
4364         PINFIX_FSC_H270,
4365         PINFIX_HP_Z200,
4366 };
4367
4368 static const struct alc_fixup alc262_fixups[] = {
4369         [PINFIX_FSC_H270] = {
4370                 .type = ALC_FIXUP_PINS,
4371                 .v.pins = (const struct alc_pincfg[]) {
4372                         { 0x14, 0x99130110 }, /* speaker */
4373                         { 0x15, 0x0221142f }, /* front HP */
4374                         { 0x1b, 0x0121141f }, /* rear HP */
4375                         { }
4376                 }
4377         },
4378         [PINFIX_HP_Z200] = {
4379                 .type = ALC_FIXUP_PINS,
4380                 .v.pins = (const struct alc_pincfg[]) {
4381                         { 0x16, 0x99130120 }, /* internal speaker */
4382                         { }
4383                 }
4384         },
4385 };
4386
4387 static const struct snd_pci_quirk alc262_fixup_tbl[] = {
4388         SND_PCI_QUIRK(0x103c, 0x170b, "HP Z200", PINFIX_HP_Z200),
4389         SND_PCI_QUIRK(0x1734, 0x1147, "FSC Celsius H270", PINFIX_FSC_H270),
4390         {}
4391 };
4392
4393
4394 #ifdef CONFIG_SND_HDA_POWER_SAVE
4395 #define alc262_loopbacks        alc880_loopbacks
4396 #endif
4397
4398 /*
4399  */
4400 #ifdef CONFIG_SND_HDA_ENABLE_REALTEK_QUIRKS
4401 #include "alc262_quirks.c"
4402 #endif
4403
4404 static int patch_alc262(struct hda_codec *codec)
4405 {
4406         struct alc_spec *spec;
4407         int board_config;
4408         int err;
4409
4410         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
4411         if (spec == NULL)
4412                 return -ENOMEM;
4413
4414         codec->spec = spec;
4415
4416         spec->mixer_nid = 0x0b;
4417
4418 #if 0
4419         /* pshou 07/11/05  set a zero PCM sample to DAC when FIFO is
4420          * under-run
4421          */
4422         {
4423         int tmp;
4424         snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_COEF_INDEX, 7);
4425         tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0);
4426         snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_COEF_INDEX, 7);
4427         snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_PROC_COEF, tmp | 0x80);
4428         }
4429 #endif
4430         alc_auto_parse_customize_define(codec);
4431
4432         alc_fix_pll_init(codec, 0x20, 0x0a, 10);
4433
4434         board_config = alc_board_config(codec, ALC262_MODEL_LAST,
4435                                         alc262_models, alc262_cfg_tbl);
4436
4437         if (board_config < 0) {
4438                 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
4439                        codec->chip_name);
4440                 board_config = ALC_MODEL_AUTO;
4441         }
4442
4443         if (board_config == ALC_MODEL_AUTO) {
4444                 alc_pick_fixup(codec, NULL, alc262_fixup_tbl, alc262_fixups);
4445                 alc_apply_fixup(codec, ALC_FIXUP_ACT_PRE_PROBE);
4446         }
4447
4448         if (board_config == ALC_MODEL_AUTO) {
4449                 /* automatic parse from the BIOS config */
4450                 err = alc262_parse_auto_config(codec);
4451                 if (err < 0)
4452                         goto error;
4453 #ifdef CONFIG_SND_HDA_ENABLE_REALTEK_QUIRKS
4454                 else if (!err) {
4455                         printk(KERN_INFO
4456                                "hda_codec: Cannot set up configuration "
4457                                "from BIOS.  Using base mode...\n");
4458                         board_config = ALC262_BASIC;
4459                 }
4460 #endif
4461         }
4462
4463         if (board_config != ALC_MODEL_AUTO)
4464                 setup_preset(codec, &alc262_presets[board_config]);
4465
4466         if (!spec->no_analog && !spec->adc_nids) {
4467                 alc_auto_fill_adc_caps(codec);
4468                 alc_rebuild_imux_for_auto_mic(codec);
4469                 alc_remove_invalid_adc_nids(codec);
4470         }
4471
4472         if (!spec->no_analog && !spec->cap_mixer)
4473                 set_capture_mixer(codec);
4474
4475         if (!spec->no_analog && has_cdefine_beep(codec)) {
4476                 err = snd_hda_attach_beep_device(codec, 0x1);
4477                 if (err < 0)
4478                         goto error;
4479                 set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
4480         }
4481
4482         alc_apply_fixup(codec, ALC_FIXUP_ACT_PROBE);
4483
4484         spec->vmaster_nid = 0x0c;
4485
4486         codec->patch_ops = alc_patch_ops;
4487         if (board_config == ALC_MODEL_AUTO)
4488                 spec->init_hook = alc_auto_init_std;
4489         spec->shutup = alc_eapd_shutup;
4490
4491         alc_init_jacks(codec);
4492 #ifdef CONFIG_SND_HDA_POWER_SAVE
4493         if (!spec->loopback.amplist)
4494                 spec->loopback.amplist = alc262_loopbacks;
4495 #endif
4496
4497         return 0;
4498
4499  error:
4500         alc_free(codec);
4501         return err;
4502 }
4503
4504 /*
4505  *  ALC268
4506  */
4507 /* bind Beep switches of both NID 0x0f and 0x10 */
4508 static const struct hda_bind_ctls alc268_bind_beep_sw = {
4509         .ops = &snd_hda_bind_sw,
4510         .values = {
4511                 HDA_COMPOSE_AMP_VAL(0x0f, 3, 1, HDA_INPUT),
4512                 HDA_COMPOSE_AMP_VAL(0x10, 3, 1, HDA_INPUT),
4513                 0
4514         },
4515 };
4516
4517 static const struct snd_kcontrol_new alc268_beep_mixer[] = {
4518         HDA_CODEC_VOLUME("Beep Playback Volume", 0x1d, 0x0, HDA_INPUT),
4519         HDA_BIND_SW("Beep Playback Switch", &alc268_bind_beep_sw),
4520         { }
4521 };
4522
4523 /* set PCBEEP vol = 0, mute connections */
4524 static const struct hda_verb alc268_beep_init_verbs[] = {
4525         {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4526         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4527         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4528         { }
4529 };
4530
4531 /*
4532  * BIOS auto configuration
4533  */
4534 static int alc268_parse_auto_config(struct hda_codec *codec)
4535 {
4536         static const hda_nid_t alc268_ssids[] = { 0x15, 0x1b, 0x14, 0 };
4537         struct alc_spec *spec = codec->spec;
4538         int err = alc_parse_auto_config(codec, NULL, alc268_ssids);
4539         if (err > 0) {
4540                 if (!spec->no_analog && spec->autocfg.speaker_pins[0] != 0x1d) {
4541                         add_mixer(spec, alc268_beep_mixer);
4542                         add_verb(spec, alc268_beep_init_verbs);
4543                 }
4544         }
4545         return err;
4546 }
4547
4548 /*
4549  */
4550 static int patch_alc268(struct hda_codec *codec)
4551 {
4552         struct alc_spec *spec;
4553         int i, has_beep, err;
4554
4555         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
4556         if (spec == NULL)
4557                 return -ENOMEM;
4558
4559         codec->spec = spec;
4560
4561         /* ALC268 has no aa-loopback mixer */
4562
4563         /* automatic parse from the BIOS config */
4564         err = alc268_parse_auto_config(codec);
4565         if (err < 0)
4566                 goto error;
4567
4568         has_beep = 0;
4569         for (i = 0; i < spec->num_mixers; i++) {
4570                 if (spec->mixers[i] == alc268_beep_mixer) {
4571                         has_beep = 1;
4572                         break;
4573                 }
4574         }
4575
4576         if (has_beep) {
4577                 err = snd_hda_attach_beep_device(codec, 0x1);
4578                 if (err < 0)
4579                         goto error;
4580                 if (!query_amp_caps(codec, 0x1d, HDA_INPUT))
4581                         /* override the amp caps for beep generator */
4582                         snd_hda_override_amp_caps(codec, 0x1d, HDA_INPUT,
4583                                           (0x0c << AC_AMPCAP_OFFSET_SHIFT) |
4584                                           (0x0c << AC_AMPCAP_NUM_STEPS_SHIFT) |
4585                                           (0x07 << AC_AMPCAP_STEP_SIZE_SHIFT) |
4586                                           (0 << AC_AMPCAP_MUTE_SHIFT));
4587         }
4588
4589         if (!spec->no_analog && !spec->adc_nids) {
4590                 alc_auto_fill_adc_caps(codec);
4591                 alc_rebuild_imux_for_auto_mic(codec);
4592                 alc_remove_invalid_adc_nids(codec);
4593         }
4594
4595         if (!spec->no_analog && !spec->cap_mixer)
4596                 set_capture_mixer(codec);
4597
4598         spec->vmaster_nid = 0x02;
4599
4600         codec->patch_ops = alc_patch_ops;
4601         spec->init_hook = alc_auto_init_std;
4602         spec->shutup = alc_eapd_shutup;
4603
4604         alc_init_jacks(codec);
4605
4606         return 0;
4607
4608  error:
4609         alc_free(codec);
4610         return err;
4611 }
4612
4613 /*
4614  * ALC269
4615  */
4616 #ifdef CONFIG_SND_HDA_POWER_SAVE
4617 #define alc269_loopbacks        alc880_loopbacks
4618 #endif
4619
4620 static const struct hda_pcm_stream alc269_44k_pcm_analog_playback = {
4621         .substreams = 1,
4622         .channels_min = 2,
4623         .channels_max = 8,
4624         .rates = SNDRV_PCM_RATE_44100, /* fixed rate */
4625         /* NID is set in alc_build_pcms */
4626         .ops = {
4627                 .open = alc_playback_pcm_open,
4628                 .prepare = alc_playback_pcm_prepare,
4629                 .cleanup = alc_playback_pcm_cleanup
4630         },
4631 };
4632
4633 static const struct hda_pcm_stream alc269_44k_pcm_analog_capture = {
4634         .substreams = 1,
4635         .channels_min = 2,
4636         .channels_max = 2,
4637         .rates = SNDRV_PCM_RATE_44100, /* fixed rate */
4638         /* NID is set in alc_build_pcms */
4639 };
4640
4641 #ifdef CONFIG_SND_HDA_POWER_SAVE
4642 static int alc269_mic2_for_mute_led(struct hda_codec *codec)
4643 {
4644         switch (codec->subsystem_id) {
4645         case 0x103c1586:
4646                 return 1;
4647         }
4648         return 0;
4649 }
4650
4651 static int alc269_mic2_mute_check_ps(struct hda_codec *codec, hda_nid_t nid)
4652 {
4653         /* update mute-LED according to the speaker mute state */
4654         if (nid == 0x01 || nid == 0x14) {
4655                 int pinval;
4656                 if (snd_hda_codec_amp_read(codec, 0x14, 0, HDA_OUTPUT, 0) &
4657                     HDA_AMP_MUTE)
4658                         pinval = 0x24;
4659                 else
4660                         pinval = 0x20;
4661                 /* mic2 vref pin is used for mute LED control */
4662                 snd_hda_codec_update_cache(codec, 0x19, 0,
4663                                            AC_VERB_SET_PIN_WIDGET_CONTROL,
4664                                            pinval);
4665         }
4666         return alc_check_power_status(codec, nid);
4667 }
4668 #endif /* CONFIG_SND_HDA_POWER_SAVE */
4669
4670 /* different alc269-variants */
4671 enum {
4672         ALC269_TYPE_ALC269VA,
4673         ALC269_TYPE_ALC269VB,
4674         ALC269_TYPE_ALC269VC,
4675 };
4676
4677 /*
4678  * BIOS auto configuration
4679  */
4680 static int alc269_parse_auto_config(struct hda_codec *codec)
4681 {
4682         static const hda_nid_t alc269_ignore[] = { 0x1d, 0 };
4683         static const hda_nid_t alc269_ssids[] = { 0, 0x1b, 0x14, 0x21 };
4684         static const hda_nid_t alc269va_ssids[] = { 0x15, 0x1b, 0x14, 0 };
4685         struct alc_spec *spec = codec->spec;
4686         const hda_nid_t *ssids = spec->codec_variant == ALC269_TYPE_ALC269VA ?
4687                 alc269va_ssids : alc269_ssids;
4688
4689         return alc_parse_auto_config(codec, alc269_ignore, ssids);
4690 }
4691
4692 static void alc269_toggle_power_output(struct hda_codec *codec, int power_up)
4693 {
4694         int val = alc_read_coef_idx(codec, 0x04);
4695         if (power_up)
4696                 val |= 1 << 11;
4697         else
4698                 val &= ~(1 << 11);
4699         alc_write_coef_idx(codec, 0x04, val);
4700 }
4701
4702 static void alc269_shutup(struct hda_codec *codec)
4703 {
4704         if ((alc_get_coef0(codec) & 0x00ff) == 0x017)
4705                 alc269_toggle_power_output(codec, 0);
4706         if ((alc_get_coef0(codec) & 0x00ff) == 0x018) {
4707                 alc269_toggle_power_output(codec, 0);
4708                 msleep(150);
4709         }
4710 }
4711
4712 #ifdef CONFIG_PM
4713 static int alc269_resume(struct hda_codec *codec)
4714 {
4715         if ((alc_get_coef0(codec) & 0x00ff) == 0x018) {
4716                 alc269_toggle_power_output(codec, 0);
4717                 msleep(150);
4718         }
4719
4720         codec->patch_ops.init(codec);
4721
4722         if ((alc_get_coef0(codec) & 0x00ff) == 0x017) {
4723                 alc269_toggle_power_output(codec, 1);
4724                 msleep(200);
4725         }
4726
4727         if ((alc_get_coef0(codec) & 0x00ff) == 0x018)
4728                 alc269_toggle_power_output(codec, 1);
4729
4730         snd_hda_codec_resume_amp(codec);
4731         snd_hda_codec_resume_cache(codec);
4732         hda_call_check_power_status(codec, 0x01);
4733         return 0;
4734 }
4735 #endif /* CONFIG_PM */
4736
4737 static void alc269_fixup_hweq(struct hda_codec *codec,
4738                                const struct alc_fixup *fix, int action)
4739 {
4740         int coef;
4741
4742         if (action != ALC_FIXUP_ACT_INIT)
4743                 return;
4744         coef = alc_read_coef_idx(codec, 0x1e);
4745         alc_write_coef_idx(codec, 0x1e, coef | 0x80);
4746 }
4747
4748 static void alc271_fixup_dmic(struct hda_codec *codec,
4749                               const struct alc_fixup *fix, int action)
4750 {
4751         static const struct hda_verb verbs[] = {
4752                 {0x20, AC_VERB_SET_COEF_INDEX, 0x0d},
4753                 {0x20, AC_VERB_SET_PROC_COEF, 0x4000},
4754                 {}
4755         };
4756         unsigned int cfg;
4757
4758         if (strcmp(codec->chip_name, "ALC271X"))
4759                 return;
4760         cfg = snd_hda_codec_get_pincfg(codec, 0x12);
4761         if (get_defcfg_connect(cfg) == AC_JACK_PORT_FIXED)
4762                 snd_hda_sequence_write(codec, verbs);
4763 }
4764
4765 static void alc269_fixup_pcm_44k(struct hda_codec *codec,
4766                                  const struct alc_fixup *fix, int action)
4767 {
4768         struct alc_spec *spec = codec->spec;
4769
4770         if (action != ALC_FIXUP_ACT_PROBE)
4771                 return;
4772
4773         /* Due to a hardware problem on Lenovo Ideadpad, we need to
4774          * fix the sample rate of analog I/O to 44.1kHz
4775          */
4776         spec->stream_analog_playback = &alc269_44k_pcm_analog_playback;
4777         spec->stream_analog_capture = &alc269_44k_pcm_analog_capture;
4778 }
4779
4780 static void alc269_fixup_stereo_dmic(struct hda_codec *codec,
4781                                      const struct alc_fixup *fix, int action)
4782 {
4783         int coef;
4784
4785         if (action != ALC_FIXUP_ACT_INIT)
4786                 return;
4787         /* The digital-mic unit sends PDM (differential signal) instead of
4788          * the standard PCM, thus you can't record a valid mono stream as is.
4789          * Below is a workaround specific to ALC269 to control the dmic
4790          * signal source as mono.
4791          */
4792         coef = alc_read_coef_idx(codec, 0x07);
4793         alc_write_coef_idx(codec, 0x07, coef | 0x80);
4794 }
4795
4796 static void alc269_quanta_automute(struct hda_codec *codec)
4797 {
4798         update_outputs(codec);
4799
4800         snd_hda_codec_write(codec, 0x20, 0,
4801                         AC_VERB_SET_COEF_INDEX, 0x0c);
4802         snd_hda_codec_write(codec, 0x20, 0,
4803                         AC_VERB_SET_PROC_COEF, 0x680);
4804
4805         snd_hda_codec_write(codec, 0x20, 0,
4806                         AC_VERB_SET_COEF_INDEX, 0x0c);
4807         snd_hda_codec_write(codec, 0x20, 0,
4808                         AC_VERB_SET_PROC_COEF, 0x480);
4809 }
4810
4811 static void alc269_fixup_quanta_mute(struct hda_codec *codec,
4812                                      const struct alc_fixup *fix, int action)
4813 {
4814         struct alc_spec *spec = codec->spec;
4815         if (action != ALC_FIXUP_ACT_PROBE)
4816                 return;
4817         spec->automute_hook = alc269_quanta_automute;
4818 }
4819
4820 enum {
4821         ALC269_FIXUP_SONY_VAIO,
4822         ALC275_FIXUP_SONY_VAIO_GPIO2,
4823         ALC269_FIXUP_DELL_M101Z,
4824         ALC269_FIXUP_SKU_IGNORE,
4825         ALC269_FIXUP_ASUS_G73JW,
4826         ALC269_FIXUP_LENOVO_EAPD,
4827         ALC275_FIXUP_SONY_HWEQ,
4828         ALC271_FIXUP_DMIC,
4829         ALC269_FIXUP_PCM_44K,
4830         ALC269_FIXUP_STEREO_DMIC,
4831         ALC269_FIXUP_QUANTA_MUTE,
4832         ALC269_FIXUP_LIFEBOOK,
4833         ALC269_FIXUP_AMIC,
4834         ALC269_FIXUP_DMIC,
4835         ALC269VB_FIXUP_AMIC,
4836         ALC269VB_FIXUP_DMIC,
4837 };
4838
4839 static const struct alc_fixup alc269_fixups[] = {
4840         [ALC269_FIXUP_SONY_VAIO] = {
4841                 .type = ALC_FIXUP_VERBS,
4842                 .v.verbs = (const struct hda_verb[]) {
4843                         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREFGRD},
4844                         {}
4845                 }
4846         },
4847         [ALC275_FIXUP_SONY_VAIO_GPIO2] = {
4848                 .type = ALC_FIXUP_VERBS,
4849                 .v.verbs = (const struct hda_verb[]) {
4850                         {0x01, AC_VERB_SET_GPIO_MASK, 0x04},
4851                         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x04},
4852                         {0x01, AC_VERB_SET_GPIO_DATA, 0x00},
4853                         { }
4854                 },
4855                 .chained = true,
4856                 .chain_id = ALC269_FIXUP_SONY_VAIO
4857         },
4858         [ALC269_FIXUP_DELL_M101Z] = {
4859                 .type = ALC_FIXUP_VERBS,
4860                 .v.verbs = (const struct hda_verb[]) {
4861                         /* Enables internal speaker */
4862                         {0x20, AC_VERB_SET_COEF_INDEX, 13},
4863                         {0x20, AC_VERB_SET_PROC_COEF, 0x4040},
4864                         {}
4865                 }
4866         },
4867         [ALC269_FIXUP_SKU_IGNORE] = {
4868                 .type = ALC_FIXUP_SKU,
4869                 .v.sku = ALC_FIXUP_SKU_IGNORE,
4870         },
4871         [ALC269_FIXUP_ASUS_G73JW] = {
4872                 .type = ALC_FIXUP_PINS,
4873                 .v.pins = (const struct alc_pincfg[]) {
4874                         { 0x17, 0x99130111 }, /* subwoofer */
4875                         { }
4876                 }
4877         },
4878         [ALC269_FIXUP_LENOVO_EAPD] = {
4879                 .type = ALC_FIXUP_VERBS,
4880                 .v.verbs = (const struct hda_verb[]) {
4881                         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 0},
4882                         {}
4883                 }
4884         },
4885         [ALC275_FIXUP_SONY_HWEQ] = {
4886                 .type = ALC_FIXUP_FUNC,
4887                 .v.func = alc269_fixup_hweq,
4888                 .chained = true,
4889                 .chain_id = ALC275_FIXUP_SONY_VAIO_GPIO2
4890         },
4891         [ALC271_FIXUP_DMIC] = {
4892                 .type = ALC_FIXUP_FUNC,
4893                 .v.func = alc271_fixup_dmic,
4894         },
4895         [ALC269_FIXUP_PCM_44K] = {
4896                 .type = ALC_FIXUP_FUNC,
4897                 .v.func = alc269_fixup_pcm_44k,
4898         },
4899         [ALC269_FIXUP_STEREO_DMIC] = {
4900                 .type = ALC_FIXUP_FUNC,
4901                 .v.func = alc269_fixup_stereo_dmic,
4902         },
4903         [ALC269_FIXUP_QUANTA_MUTE] = {
4904                 .type = ALC_FIXUP_FUNC,
4905                 .v.func = alc269_fixup_quanta_mute,
4906         },
4907         [ALC269_FIXUP_LIFEBOOK] = {
4908                 .type = ALC_FIXUP_PINS,
4909                 .v.pins = (const struct alc_pincfg[]) {
4910                         { 0x1a, 0x2101103f }, /* dock line-out */
4911                         { 0x1b, 0x23a11040 }, /* dock mic-in */
4912                         { }
4913                 },
4914                 .chained = true,
4915                 .chain_id = ALC269_FIXUP_QUANTA_MUTE
4916         },
4917         [ALC269_FIXUP_AMIC] = {
4918                 .type = ALC_FIXUP_PINS,
4919                 .v.pins = (const struct alc_pincfg[]) {
4920                         { 0x14, 0x99130110 }, /* speaker */
4921                         { 0x15, 0x0121401f }, /* HP out */
4922                         { 0x18, 0x01a19c20 }, /* mic */
4923                         { 0x19, 0x99a3092f }, /* int-mic */
4924                         { }
4925                 },
4926         },
4927         [ALC269_FIXUP_DMIC] = {
4928                 .type = ALC_FIXUP_PINS,
4929                 .v.pins = (const struct alc_pincfg[]) {
4930                         { 0x12, 0x99a3092f }, /* int-mic */
4931                         { 0x14, 0x99130110 }, /* speaker */
4932                         { 0x15, 0x0121401f }, /* HP out */
4933                         { 0x18, 0x01a19c20 }, /* mic */
4934                         { }
4935                 },
4936         },
4937         [ALC269VB_FIXUP_AMIC] = {
4938                 .type = ALC_FIXUP_PINS,
4939                 .v.pins = (const struct alc_pincfg[]) {
4940                         { 0x14, 0x99130110 }, /* speaker */
4941                         { 0x18, 0x01a19c20 }, /* mic */
4942                         { 0x19, 0x99a3092f }, /* int-mic */
4943                         { 0x21, 0x0121401f }, /* HP out */
4944                         { }
4945                 },
4946         },
4947         [ALC269_FIXUP_DMIC] = {
4948                 .type = ALC_FIXUP_PINS,
4949                 .v.pins = (const struct alc_pincfg[]) {
4950                         { 0x12, 0x99a3092f }, /* int-mic */
4951                         { 0x14, 0x99130110 }, /* speaker */
4952                         { 0x18, 0x01a19c20 }, /* mic */
4953                         { 0x21, 0x0121401f }, /* HP out */
4954                         { }
4955                 },
4956         },
4957 };
4958
4959 static const struct snd_pci_quirk alc269_fixup_tbl[] = {
4960         SND_PCI_QUIRK(0x1043, 0x1a13, "Asus G73Jw", ALC269_FIXUP_ASUS_G73JW),
4961         SND_PCI_QUIRK(0x1043, 0x16e3, "ASUS UX50", ALC269_FIXUP_STEREO_DMIC),
4962         SND_PCI_QUIRK(0x1043, 0x831a, "ASUS P901", ALC269_FIXUP_STEREO_DMIC),
4963         SND_PCI_QUIRK(0x1043, 0x834a, "ASUS S101", ALC269_FIXUP_STEREO_DMIC),
4964         SND_PCI_QUIRK(0x1043, 0x8398, "ASUS P1005", ALC269_FIXUP_STEREO_DMIC),
4965         SND_PCI_QUIRK(0x1043, 0x83ce, "ASUS P1005", ALC269_FIXUP_STEREO_DMIC),
4966         SND_PCI_QUIRK(0x104d, 0x9073, "Sony VAIO", ALC275_FIXUP_SONY_VAIO_GPIO2),
4967         SND_PCI_QUIRK(0x104d, 0x907b, "Sony VAIO", ALC275_FIXUP_SONY_HWEQ),
4968         SND_PCI_QUIRK(0x104d, 0x9084, "Sony VAIO", ALC275_FIXUP_SONY_HWEQ),
4969         SND_PCI_QUIRK_VENDOR(0x104d, "Sony VAIO", ALC269_FIXUP_SONY_VAIO),
4970         SND_PCI_QUIRK(0x1028, 0x0470, "Dell M101z", ALC269_FIXUP_DELL_M101Z),
4971         SND_PCI_QUIRK_VENDOR(0x1025, "Acer Aspire", ALC271_FIXUP_DMIC),
4972         SND_PCI_QUIRK(0x10cf, 0x1475, "Lifebook", ALC269_FIXUP_LIFEBOOK),
4973         SND_PCI_QUIRK(0x17aa, 0x20f2, "Thinkpad SL410/510", ALC269_FIXUP_SKU_IGNORE),
4974         SND_PCI_QUIRK(0x17aa, 0x215e, "Thinkpad L512", ALC269_FIXUP_SKU_IGNORE),
4975         SND_PCI_QUIRK(0x17aa, 0x21b8, "Thinkpad Edge 14", ALC269_FIXUP_SKU_IGNORE),
4976         SND_PCI_QUIRK(0x17aa, 0x21ca, "Thinkpad L412", ALC269_FIXUP_SKU_IGNORE),
4977         SND_PCI_QUIRK(0x17aa, 0x21e9, "Thinkpad Edge 15", ALC269_FIXUP_SKU_IGNORE),
4978         SND_PCI_QUIRK(0x17aa, 0x3bf8, "Quanta FL1", ALC269_FIXUP_QUANTA_MUTE),
4979         SND_PCI_QUIRK(0x17aa, 0x3bf8, "Lenovo Ideapd", ALC269_FIXUP_PCM_44K),
4980         SND_PCI_QUIRK(0x17aa, 0x9e54, "LENOVO NB", ALC269_FIXUP_LENOVO_EAPD),
4981
4982 #if 1
4983         /* Below is a quirk table taken from the old code.
4984          * Basically the device should work as is without the fixup table.
4985          * If BIOS doesn't give a proper info, enable the corresponding
4986          * fixup entry.
4987          */
4988         SND_PCI_QUIRK(0x1043, 0x8330, "ASUS Eeepc P703 P900A",
4989                       ALC269_FIXUP_AMIC),
4990         SND_PCI_QUIRK(0x1043, 0x1013, "ASUS N61Da", ALC269_FIXUP_AMIC),
4991         SND_PCI_QUIRK(0x1043, 0x1113, "ASUS N63Jn", ALC269_FIXUP_AMIC),
4992         SND_PCI_QUIRK(0x1043, 0x1143, "ASUS B53f", ALC269_FIXUP_AMIC),
4993         SND_PCI_QUIRK(0x1043, 0x1133, "ASUS UJ20ft", ALC269_FIXUP_AMIC),
4994         SND_PCI_QUIRK(0x1043, 0x1183, "ASUS K72DR", ALC269_FIXUP_AMIC),
4995         SND_PCI_QUIRK(0x1043, 0x11b3, "ASUS K52DR", ALC269_FIXUP_AMIC),
4996         SND_PCI_QUIRK(0x1043, 0x11e3, "ASUS U33Jc", ALC269_FIXUP_AMIC),
4997         SND_PCI_QUIRK(0x1043, 0x1273, "ASUS UL80Jt", ALC269_FIXUP_AMIC),
4998         SND_PCI_QUIRK(0x1043, 0x1283, "ASUS U53Jc", ALC269_FIXUP_AMIC),
4999         SND_PCI_QUIRK(0x1043, 0x12b3, "ASUS N82JV", ALC269_FIXUP_AMIC),
5000         SND_PCI_QUIRK(0x1043, 0x12d3, "ASUS N61Jv", ALC269_FIXUP_AMIC),
5001         SND_PCI_QUIRK(0x1043, 0x13a3, "ASUS UL30Vt", ALC269_FIXUP_AMIC),
5002         SND_PCI_QUIRK(0x1043, 0x1373, "ASUS G73JX", ALC269_FIXUP_AMIC),
5003         SND_PCI_QUIRK(0x1043, 0x1383, "ASUS UJ30Jc", ALC269_FIXUP_AMIC),
5004         SND_PCI_QUIRK(0x1043, 0x13d3, "ASUS N61JA", ALC269_FIXUP_AMIC),
5005         SND_PCI_QUIRK(0x1043, 0x1413, "ASUS UL50", ALC269_FIXUP_AMIC),
5006         SND_PCI_QUIRK(0x1043, 0x1443, "ASUS UL30", ALC269_FIXUP_AMIC),
5007         SND_PCI_QUIRK(0x1043, 0x1453, "ASUS M60Jv", ALC269_FIXUP_AMIC),
5008         SND_PCI_QUIRK(0x1043, 0x1483, "ASUS UL80", ALC269_FIXUP_AMIC),
5009         SND_PCI_QUIRK(0x1043, 0x14f3, "ASUS F83Vf", ALC269_FIXUP_AMIC),
5010         SND_PCI_QUIRK(0x1043, 0x14e3, "ASUS UL20", ALC269_FIXUP_AMIC),
5011         SND_PCI_QUIRK(0x1043, 0x1513, "ASUS UX30", ALC269_FIXUP_AMIC),
5012         SND_PCI_QUIRK(0x1043, 0x1593, "ASUS N51Vn", ALC269_FIXUP_AMIC),
5013         SND_PCI_QUIRK(0x1043, 0x15a3, "ASUS N60Jv", ALC269_FIXUP_AMIC),
5014         SND_PCI_QUIRK(0x1043, 0x15b3, "ASUS N60Dp", ALC269_FIXUP_AMIC),
5015         SND_PCI_QUIRK(0x1043, 0x15c3, "ASUS N70De", ALC269_FIXUP_AMIC),
5016         SND_PCI_QUIRK(0x1043, 0x15e3, "ASUS F83T", ALC269_FIXUP_AMIC),
5017         SND_PCI_QUIRK(0x1043, 0x1643, "ASUS M60J", ALC269_FIXUP_AMIC),
5018         SND_PCI_QUIRK(0x1043, 0x1653, "ASUS U50", ALC269_FIXUP_AMIC),
5019         SND_PCI_QUIRK(0x1043, 0x1693, "ASUS F50N", ALC269_FIXUP_AMIC),
5020         SND_PCI_QUIRK(0x1043, 0x16a3, "ASUS F5Q", ALC269_FIXUP_AMIC),
5021         SND_PCI_QUIRK(0x1043, 0x1723, "ASUS P80", ALC269_FIXUP_AMIC),
5022         SND_PCI_QUIRK(0x1043, 0x1743, "ASUS U80", ALC269_FIXUP_AMIC),
5023         SND_PCI_QUIRK(0x1043, 0x1773, "ASUS U20A", ALC269_FIXUP_AMIC),
5024         SND_PCI_QUIRK(0x1043, 0x1883, "ASUS F81Se", ALC269_FIXUP_AMIC),
5025         SND_PCI_QUIRK(0x152d, 0x1778, "Quanta ON1", ALC269_FIXUP_DMIC),
5026         SND_PCI_QUIRK(0x17aa, 0x3be9, "Quanta Wistron", ALC269_FIXUP_AMIC),
5027         SND_PCI_QUIRK(0x17aa, 0x3bf8, "Quanta FL1", ALC269_FIXUP_AMIC),
5028         SND_PCI_QUIRK(0x17ff, 0x059a, "Quanta EL3", ALC269_FIXUP_DMIC),
5029         SND_PCI_QUIRK(0x17ff, 0x059b, "Quanta JR1", ALC269_FIXUP_DMIC),
5030 #endif
5031         {}
5032 };
5033
5034 static const struct alc_model_fixup alc269_fixup_models[] = {
5035         {.id = ALC269_FIXUP_AMIC, .name = "laptop-amic"},
5036         {.id = ALC269_FIXUP_DMIC, .name = "laptop-dmic"},
5037         {}
5038 };
5039
5040
5041 static int alc269_fill_coef(struct hda_codec *codec)
5042 {
5043         int val;
5044
5045         if ((alc_get_coef0(codec) & 0x00ff) < 0x015) {
5046                 alc_write_coef_idx(codec, 0xf, 0x960b);
5047                 alc_write_coef_idx(codec, 0xe, 0x8817);
5048         }
5049
5050         if ((alc_get_coef0(codec) & 0x00ff) == 0x016) {
5051                 alc_write_coef_idx(codec, 0xf, 0x960b);
5052                 alc_write_coef_idx(codec, 0xe, 0x8814);
5053         }
5054
5055         if ((alc_get_coef0(codec) & 0x00ff) == 0x017) {
5056                 val = alc_read_coef_idx(codec, 0x04);
5057                 /* Power up output pin */
5058                 alc_write_coef_idx(codec, 0x04, val | (1<<11));
5059         }
5060
5061         if ((alc_get_coef0(codec) & 0x00ff) == 0x018) {
5062                 val = alc_read_coef_idx(codec, 0xd);
5063                 if ((val & 0x0c00) >> 10 != 0x1) {
5064                         /* Capless ramp up clock control */
5065                         alc_write_coef_idx(codec, 0xd, val | (1<<10));
5066                 }
5067                 val = alc_read_coef_idx(codec, 0x17);
5068                 if ((val & 0x01c0) >> 6 != 0x4) {
5069                         /* Class D power on reset */
5070                         alc_write_coef_idx(codec, 0x17, val | (1<<7));
5071                 }
5072         }
5073
5074         val = alc_read_coef_idx(codec, 0xd); /* Class D */
5075         alc_write_coef_idx(codec, 0xd, val | (1<<14));
5076
5077         val = alc_read_coef_idx(codec, 0x4); /* HP */
5078         alc_write_coef_idx(codec, 0x4, val | (1<<11));
5079
5080         return 0;
5081 }
5082
5083 /*
5084  */
5085 static int patch_alc269(struct hda_codec *codec)
5086 {
5087         struct alc_spec *spec;
5088         int err = 0;
5089
5090         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
5091         if (spec == NULL)
5092                 return -ENOMEM;
5093
5094         codec->spec = spec;
5095
5096         spec->mixer_nid = 0x0b;
5097
5098         alc_auto_parse_customize_define(codec);
5099
5100         err = alc_codec_rename_from_preset(codec);
5101         if (err < 0)
5102                 goto error;
5103
5104         if (codec->vendor_id == 0x10ec0269) {
5105                 spec->codec_variant = ALC269_TYPE_ALC269VA;
5106                 switch (alc_get_coef0(codec) & 0x00f0) {
5107                 case 0x0010:
5108                         if (codec->bus->pci->subsystem_vendor == 0x1025 &&
5109                             spec->cdefine.platform_type == 1)
5110                                 err = alc_codec_rename(codec, "ALC271X");
5111                         spec->codec_variant = ALC269_TYPE_ALC269VB;
5112                         break;
5113                 case 0x0020:
5114                         if (codec->bus->pci->subsystem_vendor == 0x17aa &&
5115                             codec->bus->pci->subsystem_device == 0x21f3)
5116                                 err = alc_codec_rename(codec, "ALC3202");
5117                         spec->codec_variant = ALC269_TYPE_ALC269VC;
5118                         break;
5119                 default:
5120                         alc_fix_pll_init(codec, 0x20, 0x04, 15);
5121                 }
5122                 if (err < 0)
5123                         goto error;
5124                 alc269_fill_coef(codec);
5125         }
5126
5127         alc_pick_fixup(codec, alc269_fixup_models,
5128                        alc269_fixup_tbl, alc269_fixups);
5129         alc_apply_fixup(codec, ALC_FIXUP_ACT_PRE_PROBE);
5130
5131         /* automatic parse from the BIOS config */
5132         err = alc269_parse_auto_config(codec);
5133         if (err < 0)
5134                 goto error;
5135
5136         if (!spec->no_analog && !spec->adc_nids) {
5137                 alc_auto_fill_adc_caps(codec);
5138                 alc_rebuild_imux_for_auto_mic(codec);
5139                 alc_remove_invalid_adc_nids(codec);
5140         }
5141
5142         if (!spec->no_analog && !spec->cap_mixer)
5143                 set_capture_mixer(codec);
5144
5145         if (!spec->no_analog && has_cdefine_beep(codec)) {
5146                 err = snd_hda_attach_beep_device(codec, 0x1);
5147                 if (err < 0)
5148                         goto error;
5149                 set_beep_amp(spec, 0x0b, 0x04, HDA_INPUT);
5150         }
5151
5152         alc_apply_fixup(codec, ALC_FIXUP_ACT_PROBE);
5153
5154         spec->vmaster_nid = 0x02;
5155
5156         codec->patch_ops = alc_patch_ops;
5157 #ifdef CONFIG_PM
5158         codec->patch_ops.resume = alc269_resume;
5159 #endif
5160         spec->init_hook = alc_auto_init_std;
5161         spec->shutup = alc269_shutup;
5162
5163         alc_init_jacks(codec);
5164 #ifdef CONFIG_SND_HDA_POWER_SAVE
5165         if (!spec->loopback.amplist)
5166                 spec->loopback.amplist = alc269_loopbacks;
5167         if (alc269_mic2_for_mute_led(codec))
5168                 codec->patch_ops.check_power_status = alc269_mic2_mute_check_ps;
5169 #endif
5170
5171         return 0;
5172
5173  error:
5174         alc_free(codec);
5175         return err;
5176 }
5177
5178 /*
5179  * ALC861
5180  */
5181
5182 static int alc861_parse_auto_config(struct hda_codec *codec)
5183 {
5184         static const hda_nid_t alc861_ignore[] = { 0x1d, 0 };
5185         static const hda_nid_t alc861_ssids[] = { 0x0e, 0x0f, 0x0b, 0 };
5186         return alc_parse_auto_config(codec, alc861_ignore, alc861_ssids);
5187 }
5188
5189 #ifdef CONFIG_SND_HDA_POWER_SAVE
5190 static const struct hda_amp_list alc861_loopbacks[] = {
5191         { 0x15, HDA_INPUT, 0 },
5192         { 0x15, HDA_INPUT, 1 },
5193         { 0x15, HDA_INPUT, 2 },
5194         { 0x15, HDA_INPUT, 3 },
5195         { } /* end */
5196 };
5197 #endif
5198
5199
5200 /* Pin config fixes */
5201 enum {
5202         PINFIX_FSC_AMILO_PI1505,
5203 };
5204
5205 static const struct alc_fixup alc861_fixups[] = {
5206         [PINFIX_FSC_AMILO_PI1505] = {
5207                 .type = ALC_FIXUP_PINS,
5208                 .v.pins = (const struct alc_pincfg[]) {
5209                         { 0x0b, 0x0221101f }, /* HP */
5210                         { 0x0f, 0x90170310 }, /* speaker */
5211                         { }
5212                 }
5213         },
5214 };
5215
5216 static const struct snd_pci_quirk alc861_fixup_tbl[] = {
5217         SND_PCI_QUIRK(0x1734, 0x10c7, "FSC Amilo Pi1505", PINFIX_FSC_AMILO_PI1505),
5218         {}
5219 };
5220
5221 /*
5222  */
5223 static int patch_alc861(struct hda_codec *codec)
5224 {
5225         struct alc_spec *spec;
5226         int err;
5227
5228         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
5229         if (spec == NULL)
5230                 return -ENOMEM;
5231
5232         codec->spec = spec;
5233
5234         spec->mixer_nid = 0x15;
5235
5236         alc_pick_fixup(codec, NULL, alc861_fixup_tbl, alc861_fixups);
5237         alc_apply_fixup(codec, ALC_FIXUP_ACT_PRE_PROBE);
5238
5239         /* automatic parse from the BIOS config */
5240         err = alc861_parse_auto_config(codec);
5241         if (err < 0)
5242                 goto error;
5243
5244         if (!spec->no_analog && !spec->adc_nids) {
5245                 alc_auto_fill_adc_caps(codec);
5246                 alc_rebuild_imux_for_auto_mic(codec);
5247                 alc_remove_invalid_adc_nids(codec);
5248         }
5249
5250         if (!spec->no_analog && !spec->cap_mixer)
5251                 set_capture_mixer(codec);
5252
5253         if (!spec->no_analog) {
5254                 err = snd_hda_attach_beep_device(codec, 0x23);
5255                 if (err < 0)
5256                         goto error;
5257                 set_beep_amp(spec, 0x23, 0, HDA_OUTPUT);
5258         }
5259
5260         spec->vmaster_nid = 0x03;
5261
5262         alc_apply_fixup(codec, ALC_FIXUP_ACT_PROBE);
5263
5264         codec->patch_ops = alc_patch_ops;
5265         spec->init_hook = alc_auto_init_std;
5266 #ifdef CONFIG_SND_HDA_POWER_SAVE
5267         spec->power_hook = alc_power_eapd;
5268         if (!spec->loopback.amplist)
5269                 spec->loopback.amplist = alc861_loopbacks;
5270 #endif
5271
5272         return 0;
5273
5274  error:
5275         alc_free(codec);
5276         return err;
5277 }
5278
5279 /*
5280  * ALC861-VD support
5281  *
5282  * Based on ALC882
5283  *
5284  * In addition, an independent DAC
5285  */
5286 #ifdef CONFIG_SND_HDA_POWER_SAVE
5287 #define alc861vd_loopbacks      alc880_loopbacks
5288 #endif
5289
5290 static int alc861vd_parse_auto_config(struct hda_codec *codec)
5291 {
5292         static const hda_nid_t alc861vd_ignore[] = { 0x1d, 0 };
5293         static const hda_nid_t alc861vd_ssids[] = { 0x15, 0x1b, 0x14, 0 };
5294         return alc_parse_auto_config(codec, alc861vd_ignore, alc861vd_ssids);
5295 }
5296
5297 enum {
5298         ALC660VD_FIX_ASUS_GPIO1,
5299         ALC861VD_FIX_DALLAS,
5300 };
5301
5302 /* exclude VREF80 */
5303 static void alc861vd_fixup_dallas(struct hda_codec *codec,
5304                                   const struct alc_fixup *fix, int action)
5305 {
5306         if (action == ALC_FIXUP_ACT_PRE_PROBE) {
5307                 snd_hda_override_pin_caps(codec, 0x18, 0x00001714);
5308                 snd_hda_override_pin_caps(codec, 0x19, 0x0000171c);
5309         }
5310 }
5311
5312 static const struct alc_fixup alc861vd_fixups[] = {
5313         [ALC660VD_FIX_ASUS_GPIO1] = {
5314                 .type = ALC_FIXUP_VERBS,
5315                 .v.verbs = (const struct hda_verb[]) {
5316                         /* reset GPIO1 */
5317                         {0x01, AC_VERB_SET_GPIO_MASK, 0x03},
5318                         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
5319                         {0x01, AC_VERB_SET_GPIO_DATA, 0x01},
5320                         { }
5321                 }
5322         },
5323         [ALC861VD_FIX_DALLAS] = {
5324                 .type = ALC_FIXUP_FUNC,
5325                 .v.func = alc861vd_fixup_dallas,
5326         },
5327 };
5328
5329 static const struct snd_pci_quirk alc861vd_fixup_tbl[] = {
5330         SND_PCI_QUIRK(0x103c, 0x30bf, "HP TX1000", ALC861VD_FIX_DALLAS),
5331         SND_PCI_QUIRK(0x1043, 0x1339, "ASUS A7-K", ALC660VD_FIX_ASUS_GPIO1),
5332         SND_PCI_QUIRK(0x1179, 0xff31, "Toshiba L30-149", ALC861VD_FIX_DALLAS),
5333         {}
5334 };
5335
5336 static const struct hda_verb alc660vd_eapd_verbs[] = {
5337         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
5338         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
5339         { }
5340 };
5341
5342 /*
5343  */
5344 static int patch_alc861vd(struct hda_codec *codec)
5345 {
5346         struct alc_spec *spec;
5347         int err;
5348
5349         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
5350         if (spec == NULL)
5351                 return -ENOMEM;
5352
5353         codec->spec = spec;
5354
5355         spec->mixer_nid = 0x0b;
5356
5357         alc_pick_fixup(codec, NULL, alc861vd_fixup_tbl, alc861vd_fixups);
5358         alc_apply_fixup(codec, ALC_FIXUP_ACT_PRE_PROBE);
5359
5360         /* automatic parse from the BIOS config */
5361         err = alc861vd_parse_auto_config(codec);
5362         if (err < 0)
5363                 goto error;
5364
5365         if (codec->vendor_id == 0x10ec0660) {
5366                 /* always turn on EAPD */
5367                 add_verb(spec, alc660vd_eapd_verbs);
5368         }
5369
5370         if (!spec->no_analog && !spec->adc_nids) {
5371                 alc_auto_fill_adc_caps(codec);
5372                 alc_rebuild_imux_for_auto_mic(codec);
5373                 alc_remove_invalid_adc_nids(codec);
5374         }
5375
5376         if (!spec->no_analog && !spec->cap_mixer)
5377                 set_capture_mixer(codec);
5378
5379         if (!spec->no_analog) {
5380                 err = snd_hda_attach_beep_device(codec, 0x23);
5381                 if (err < 0)
5382                         goto error;
5383                 set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
5384         }
5385
5386         spec->vmaster_nid = 0x02;
5387
5388         alc_apply_fixup(codec, ALC_FIXUP_ACT_PROBE);
5389
5390         codec->patch_ops = alc_patch_ops;
5391
5392         spec->init_hook = alc_auto_init_std;
5393         spec->shutup = alc_eapd_shutup;
5394 #ifdef CONFIG_SND_HDA_POWER_SAVE
5395         if (!spec->loopback.amplist)
5396                 spec->loopback.amplist = alc861vd_loopbacks;
5397 #endif
5398
5399         return 0;
5400
5401  error:
5402         alc_free(codec);
5403         return err;
5404 }
5405
5406 /*
5407  * ALC662 support
5408  *
5409  * ALC662 is almost identical with ALC880 but has cleaner and more flexible
5410  * configuration.  Each pin widget can choose any input DACs and a mixer.
5411  * Each ADC is connected from a mixer of all inputs.  This makes possible
5412  * 6-channel independent captures.
5413  *
5414  * In addition, an independent DAC for the multi-playback (not used in this
5415  * driver yet).
5416  */
5417 #ifdef CONFIG_SND_HDA_POWER_SAVE
5418 #define alc662_loopbacks        alc880_loopbacks
5419 #endif
5420
5421 /*
5422  * BIOS auto configuration
5423  */
5424
5425 static int alc662_parse_auto_config(struct hda_codec *codec)
5426 {
5427         static const hda_nid_t alc662_ignore[] = { 0x1d, 0 };
5428         static const hda_nid_t alc663_ssids[] = { 0x15, 0x1b, 0x14, 0x21 };
5429         static const hda_nid_t alc662_ssids[] = { 0x15, 0x1b, 0x14, 0 };
5430         const hda_nid_t *ssids;
5431
5432         if (codec->vendor_id == 0x10ec0272 || codec->vendor_id == 0x10ec0663 ||
5433             codec->vendor_id == 0x10ec0665 || codec->vendor_id == 0x10ec0670)
5434                 ssids = alc663_ssids;
5435         else
5436                 ssids = alc662_ssids;
5437         return alc_parse_auto_config(codec, alc662_ignore, ssids);
5438 }
5439
5440 static void alc272_fixup_mario(struct hda_codec *codec,
5441                                const struct alc_fixup *fix, int action)
5442 {
5443         if (action != ALC_FIXUP_ACT_PROBE)
5444                 return;
5445         if (snd_hda_override_amp_caps(codec, 0x2, HDA_OUTPUT,
5446                                       (0x3b << AC_AMPCAP_OFFSET_SHIFT) |
5447                                       (0x3b << AC_AMPCAP_NUM_STEPS_SHIFT) |
5448                                       (0x03 << AC_AMPCAP_STEP_SIZE_SHIFT) |
5449                                       (0 << AC_AMPCAP_MUTE_SHIFT)))
5450                 printk(KERN_WARNING
5451                        "hda_codec: failed to override amp caps for NID 0x2\n");
5452 }
5453
5454 enum {
5455         ALC662_FIXUP_ASPIRE,
5456         ALC662_FIXUP_IDEAPAD,
5457         ALC272_FIXUP_MARIO,
5458         ALC662_FIXUP_CZC_P10T,
5459         ALC662_FIXUP_SKU_IGNORE,
5460         ALC662_FIXUP_HP_RP5800,
5461         ALC662_FIXUP_ASUS_MODE1,
5462         ALC662_FIXUP_ASUS_MODE2,
5463         ALC662_FIXUP_ASUS_MODE3,
5464         ALC662_FIXUP_ASUS_MODE4,
5465         ALC662_FIXUP_ASUS_MODE5,
5466         ALC662_FIXUP_ASUS_MODE6,
5467         ALC662_FIXUP_ASUS_MODE7,
5468         ALC662_FIXUP_ASUS_MODE8,
5469 };
5470
5471 static const struct alc_fixup alc662_fixups[] = {
5472         [ALC662_FIXUP_ASPIRE] = {
5473                 .type = ALC_FIXUP_PINS,
5474                 .v.pins = (const struct alc_pincfg[]) {
5475                         { 0x15, 0x99130112 }, /* subwoofer */
5476                         { }
5477                 }
5478         },
5479         [ALC662_FIXUP_IDEAPAD] = {
5480                 .type = ALC_FIXUP_PINS,
5481                 .v.pins = (const struct alc_pincfg[]) {
5482                         { 0x17, 0x99130112 }, /* subwoofer */
5483                         { }
5484                 }
5485         },
5486         [ALC272_FIXUP_MARIO] = {
5487                 .type = ALC_FIXUP_FUNC,
5488                 .v.func = alc272_fixup_mario,
5489         },
5490         [ALC662_FIXUP_CZC_P10T] = {
5491                 .type = ALC_FIXUP_VERBS,
5492                 .v.verbs = (const struct hda_verb[]) {
5493                         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 0},
5494                         {}
5495                 }
5496         },
5497         [ALC662_FIXUP_SKU_IGNORE] = {
5498                 .type = ALC_FIXUP_SKU,
5499                 .v.sku = ALC_FIXUP_SKU_IGNORE,
5500         },
5501         [ALC662_FIXUP_HP_RP5800] = {
5502                 .type = ALC_FIXUP_PINS,
5503                 .v.pins = (const struct alc_pincfg[]) {
5504                         { 0x14, 0x0221201f }, /* HP out */
5505                         { }
5506                 },
5507                 .chained = true,
5508                 .chain_id = ALC662_FIXUP_SKU_IGNORE
5509         },
5510         [ALC662_FIXUP_ASUS_MODE1] = {
5511                 .type = ALC_FIXUP_PINS,
5512                 .v.pins = (const struct alc_pincfg[]) {
5513                         { 0x14, 0x99130110 }, /* speaker */
5514                         { 0x18, 0x01a19c20 }, /* mic */
5515                         { 0x19, 0x99a3092f }, /* int-mic */
5516                         { 0x21, 0x0121401f }, /* HP out */
5517                         { }
5518                 },
5519                 .chained = true,
5520                 .chain_id = ALC662_FIXUP_SKU_IGNORE
5521         },
5522         [ALC662_FIXUP_ASUS_MODE2] = {
5523                 .type = ALC_FIXUP_PINS,
5524                 .v.pins = (const struct alc_pincfg[]) {
5525                         { 0x14, 0x99130110 }, /* speaker */
5526                         { 0x18, 0x01a19820 }, /* mic */
5527                         { 0x19, 0x99a3092f }, /* int-mic */
5528                         { 0x1b, 0x0121401f }, /* HP out */
5529                         { }
5530                 },
5531                 .chained = true,
5532                 .chain_id = ALC662_FIXUP_SKU_IGNORE
5533         },
5534         [ALC662_FIXUP_ASUS_MODE3] = {
5535                 .type = ALC_FIXUP_PINS,
5536                 .v.pins = (const struct alc_pincfg[]) {
5537                         { 0x14, 0x99130110 }, /* speaker */
5538                         { 0x15, 0x0121441f }, /* HP */
5539                         { 0x18, 0x01a19840 }, /* mic */
5540                         { 0x19, 0x99a3094f }, /* int-mic */
5541                         { 0x21, 0x01211420 }, /* HP2 */
5542                         { }
5543                 },
5544                 .chained = true,
5545                 .chain_id = ALC662_FIXUP_SKU_IGNORE
5546         },
5547         [ALC662_FIXUP_ASUS_MODE4] = {
5548                 .type = ALC_FIXUP_PINS,
5549                 .v.pins = (const struct alc_pincfg[]) {
5550                         { 0x14, 0x99130110 }, /* speaker */
5551                         { 0x16, 0x99130111 }, /* speaker */
5552                         { 0x18, 0x01a19840 }, /* mic */
5553                         { 0x19, 0x99a3094f }, /* int-mic */
5554                         { 0x21, 0x0121441f }, /* HP */
5555                         { }
5556                 },
5557                 .chained = true,
5558                 .chain_id = ALC662_FIXUP_SKU_IGNORE
5559         },
5560         [ALC662_FIXUP_ASUS_MODE5] = {
5561                 .type = ALC_FIXUP_PINS,
5562                 .v.pins = (const struct alc_pincfg[]) {
5563                         { 0x14, 0x99130110 }, /* speaker */
5564                         { 0x15, 0x0121441f }, /* HP */
5565                         { 0x16, 0x99130111 }, /* speaker */
5566                         { 0x18, 0x01a19840 }, /* mic */
5567                         { 0x19, 0x99a3094f }, /* int-mic */
5568                         { }
5569                 },
5570                 .chained = true,
5571                 .chain_id = ALC662_FIXUP_SKU_IGNORE
5572         },
5573         [ALC662_FIXUP_ASUS_MODE6] = {
5574                 .type = ALC_FIXUP_PINS,
5575                 .v.pins = (const struct alc_pincfg[]) {
5576                         { 0x14, 0x99130110 }, /* speaker */
5577                         { 0x15, 0x01211420 }, /* HP2 */
5578                         { 0x18, 0x01a19840 }, /* mic */
5579                         { 0x19, 0x99a3094f }, /* int-mic */
5580                         { 0x1b, 0x0121441f }, /* HP */
5581                         { }
5582                 },
5583                 .chained = true,
5584                 .chain_id = ALC662_FIXUP_SKU_IGNORE
5585         },
5586         [ALC662_FIXUP_ASUS_MODE7] = {
5587                 .type = ALC_FIXUP_PINS,
5588                 .v.pins = (const struct alc_pincfg[]) {
5589                         { 0x14, 0x99130110 }, /* speaker */
5590                         { 0x17, 0x99130111 }, /* speaker */
5591                         { 0x18, 0x01a19840 }, /* mic */
5592                         { 0x19, 0x99a3094f }, /* int-mic */
5593                         { 0x1b, 0x01214020 }, /* HP */
5594                         { 0x21, 0x0121401f }, /* HP */
5595                         { }
5596                 },
5597                 .chained = true,
5598                 .chain_id = ALC662_FIXUP_SKU_IGNORE
5599         },
5600         [ALC662_FIXUP_ASUS_MODE8] = {
5601                 .type = ALC_FIXUP_PINS,
5602                 .v.pins = (const struct alc_pincfg[]) {
5603                         { 0x14, 0x99130110 }, /* speaker */
5604                         { 0x12, 0x99a30970 }, /* int-mic */
5605                         { 0x15, 0x01214020 }, /* HP */
5606                         { 0x17, 0x99130111 }, /* speaker */
5607                         { 0x18, 0x01a19840 }, /* mic */
5608                         { 0x21, 0x0121401f }, /* HP */
5609                         { }
5610                 },
5611                 .chained = true,
5612                 .chain_id = ALC662_FIXUP_SKU_IGNORE
5613         },
5614 };
5615
5616 static const struct snd_pci_quirk alc662_fixup_tbl[] = {
5617         SND_PCI_QUIRK(0x1019, 0x9087, "ECS", ALC662_FIXUP_ASUS_MODE2),
5618         SND_PCI_QUIRK(0x1025, 0x0308, "Acer Aspire 8942G", ALC662_FIXUP_ASPIRE),
5619         SND_PCI_QUIRK(0x1025, 0x031c, "Gateway NV79", ALC662_FIXUP_SKU_IGNORE),
5620         SND_PCI_QUIRK(0x1025, 0x038b, "Acer Aspire 8943G", ALC662_FIXUP_ASPIRE),
5621         SND_PCI_QUIRK(0x103c, 0x1632, "HP RP5800", ALC662_FIXUP_HP_RP5800),
5622         SND_PCI_QUIRK(0x105b, 0x0cd6, "Foxconn", ALC662_FIXUP_ASUS_MODE2),
5623         SND_PCI_QUIRK(0x144d, 0xc051, "Samsung R720", ALC662_FIXUP_IDEAPAD),
5624         SND_PCI_QUIRK(0x17aa, 0x38af, "Lenovo Ideapad Y550P", ALC662_FIXUP_IDEAPAD),
5625         SND_PCI_QUIRK(0x17aa, 0x3a0d, "Lenovo Ideapad Y550", ALC662_FIXUP_IDEAPAD),
5626         SND_PCI_QUIRK(0x1b35, 0x2206, "CZC P10T", ALC662_FIXUP_CZC_P10T),
5627
5628 #if 0
5629         /* Below is a quirk table taken from the old code.
5630          * Basically the device should work as is without the fixup table.
5631          * If BIOS doesn't give a proper info, enable the corresponding
5632          * fixup entry.
5633          */
5634         SND_PCI_QUIRK(0x1043, 0x1000, "ASUS N50Vm", ALC662_FIXUP_ASUS_MODE1),
5635         SND_PCI_QUIRK(0x1043, 0x1092, "ASUS NB", ALC662_FIXUP_ASUS_MODE3),
5636         SND_PCI_QUIRK(0x1043, 0x1173, "ASUS K73Jn", ALC662_FIXUP_ASUS_MODE1),
5637         SND_PCI_QUIRK(0x1043, 0x11c3, "ASUS M70V", ALC662_FIXUP_ASUS_MODE3),
5638         SND_PCI_QUIRK(0x1043, 0x11d3, "ASUS NB", ALC662_FIXUP_ASUS_MODE1),
5639         SND_PCI_QUIRK(0x1043, 0x11f3, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
5640         SND_PCI_QUIRK(0x1043, 0x1203, "ASUS NB", ALC662_FIXUP_ASUS_MODE1),
5641         SND_PCI_QUIRK(0x1043, 0x1303, "ASUS G60J", ALC662_FIXUP_ASUS_MODE1),
5642         SND_PCI_QUIRK(0x1043, 0x1333, "ASUS G60Jx", ALC662_FIXUP_ASUS_MODE1),
5643         SND_PCI_QUIRK(0x1043, 0x1339, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
5644         SND_PCI_QUIRK(0x1043, 0x13e3, "ASUS N71JA", ALC662_FIXUP_ASUS_MODE7),
5645         SND_PCI_QUIRK(0x1043, 0x1463, "ASUS N71", ALC662_FIXUP_ASUS_MODE7),
5646         SND_PCI_QUIRK(0x1043, 0x14d3, "ASUS G72", ALC662_FIXUP_ASUS_MODE8),
5647         SND_PCI_QUIRK(0x1043, 0x1563, "ASUS N90", ALC662_FIXUP_ASUS_MODE3),
5648         SND_PCI_QUIRK(0x1043, 0x15d3, "ASUS N50SF F50SF", ALC662_FIXUP_ASUS_MODE1),
5649         SND_PCI_QUIRK(0x1043, 0x16c3, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
5650         SND_PCI_QUIRK(0x1043, 0x16f3, "ASUS K40C K50C", ALC662_FIXUP_ASUS_MODE2),
5651         SND_PCI_QUIRK(0x1043, 0x1733, "ASUS N81De", ALC662_FIXUP_ASUS_MODE1),
5652         SND_PCI_QUIRK(0x1043, 0x1753, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
5653         SND_PCI_QUIRK(0x1043, 0x1763, "ASUS NB", ALC662_FIXUP_ASUS_MODE6),
5654         SND_PCI_QUIRK(0x1043, 0x1765, "ASUS NB", ALC662_FIXUP_ASUS_MODE6),
5655         SND_PCI_QUIRK(0x1043, 0x1783, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
5656         SND_PCI_QUIRK(0x1043, 0x1793, "ASUS F50GX", ALC662_FIXUP_ASUS_MODE1),
5657         SND_PCI_QUIRK(0x1043, 0x17b3, "ASUS F70SL", ALC662_FIXUP_ASUS_MODE3),
5658         SND_PCI_QUIRK(0x1043, 0x17f3, "ASUS X58LE", ALC662_FIXUP_ASUS_MODE2),
5659         SND_PCI_QUIRK(0x1043, 0x1813, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
5660         SND_PCI_QUIRK(0x1043, 0x1823, "ASUS NB", ALC662_FIXUP_ASUS_MODE5),
5661         SND_PCI_QUIRK(0x1043, 0x1833, "ASUS NB", ALC662_FIXUP_ASUS_MODE6),
5662         SND_PCI_QUIRK(0x1043, 0x1843, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
5663         SND_PCI_QUIRK(0x1043, 0x1853, "ASUS F50Z", ALC662_FIXUP_ASUS_MODE1),
5664         SND_PCI_QUIRK(0x1043, 0x1864, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
5665         SND_PCI_QUIRK(0x1043, 0x1876, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
5666         SND_PCI_QUIRK(0x1043, 0x1893, "ASUS M50Vm", ALC662_FIXUP_ASUS_MODE3),
5667         SND_PCI_QUIRK(0x1043, 0x1894, "ASUS X55", ALC662_FIXUP_ASUS_MODE3),
5668         SND_PCI_QUIRK(0x1043, 0x18b3, "ASUS N80Vc", ALC662_FIXUP_ASUS_MODE1),
5669         SND_PCI_QUIRK(0x1043, 0x18c3, "ASUS VX5", ALC662_FIXUP_ASUS_MODE1),
5670         SND_PCI_QUIRK(0x1043, 0x18d3, "ASUS N81Te", ALC662_FIXUP_ASUS_MODE1),
5671         SND_PCI_QUIRK(0x1043, 0x18f3, "ASUS N505Tp", ALC662_FIXUP_ASUS_MODE1),
5672         SND_PCI_QUIRK(0x1043, 0x1903, "ASUS F5GL", ALC662_FIXUP_ASUS_MODE1),
5673         SND_PCI_QUIRK(0x1043, 0x1913, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
5674         SND_PCI_QUIRK(0x1043, 0x1933, "ASUS F80Q", ALC662_FIXUP_ASUS_MODE2),
5675         SND_PCI_QUIRK(0x1043, 0x1943, "ASUS Vx3V", ALC662_FIXUP_ASUS_MODE1),
5676         SND_PCI_QUIRK(0x1043, 0x1953, "ASUS NB", ALC662_FIXUP_ASUS_MODE1),
5677         SND_PCI_QUIRK(0x1043, 0x1963, "ASUS X71C", ALC662_FIXUP_ASUS_MODE3),
5678         SND_PCI_QUIRK(0x1043, 0x1983, "ASUS N5051A", ALC662_FIXUP_ASUS_MODE1),
5679         SND_PCI_QUIRK(0x1043, 0x1993, "ASUS N20", ALC662_FIXUP_ASUS_MODE1),
5680         SND_PCI_QUIRK(0x1043, 0x19b3, "ASUS F7Z", ALC662_FIXUP_ASUS_MODE1),
5681         SND_PCI_QUIRK(0x1043, 0x19c3, "ASUS F5Z/F6x", ALC662_FIXUP_ASUS_MODE2),
5682         SND_PCI_QUIRK(0x1043, 0x19e3, "ASUS NB", ALC662_FIXUP_ASUS_MODE1),
5683         SND_PCI_QUIRK(0x1043, 0x19f3, "ASUS NB", ALC662_FIXUP_ASUS_MODE4),
5684 #endif
5685         {}
5686 };
5687
5688 static const struct alc_model_fixup alc662_fixup_models[] = {
5689         {.id = ALC272_FIXUP_MARIO, .name = "mario"},
5690         {.id = ALC662_FIXUP_ASUS_MODE1, .name = "asus-mode1"},
5691         {.id = ALC662_FIXUP_ASUS_MODE2, .name = "asus-mode2"},
5692         {.id = ALC662_FIXUP_ASUS_MODE3, .name = "asus-mode3"},
5693         {.id = ALC662_FIXUP_ASUS_MODE4, .name = "asus-mode4"},
5694         {.id = ALC662_FIXUP_ASUS_MODE5, .name = "asus-mode5"},
5695         {.id = ALC662_FIXUP_ASUS_MODE6, .name = "asus-mode6"},
5696         {.id = ALC662_FIXUP_ASUS_MODE7, .name = "asus-mode7"},
5697         {.id = ALC662_FIXUP_ASUS_MODE8, .name = "asus-mode8"},
5698         {}
5699 };
5700
5701
5702 /*
5703  */
5704 static int patch_alc662(struct hda_codec *codec)
5705 {
5706         struct alc_spec *spec;
5707         int err = 0;
5708
5709         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
5710         if (!spec)
5711                 return -ENOMEM;
5712
5713         codec->spec = spec;
5714
5715         spec->mixer_nid = 0x0b;
5716
5717         /* handle multiple HPs as is */
5718         spec->parse_flags = HDA_PINCFG_NO_HP_FIXUP;
5719
5720         alc_auto_parse_customize_define(codec);
5721
5722         alc_fix_pll_init(codec, 0x20, 0x04, 15);
5723
5724         err = alc_codec_rename_from_preset(codec);
5725         if (err < 0)
5726                 goto error;
5727
5728         if ((alc_get_coef0(codec) & (1 << 14)) &&
5729             codec->bus->pci->subsystem_vendor == 0x1025 &&
5730             spec->cdefine.platform_type == 1) {
5731                 if (alc_codec_rename(codec, "ALC272X") < 0)
5732                         goto error;
5733         }
5734
5735         alc_pick_fixup(codec, alc662_fixup_models,
5736                        alc662_fixup_tbl, alc662_fixups);
5737         alc_apply_fixup(codec, ALC_FIXUP_ACT_PRE_PROBE);
5738         /* automatic parse from the BIOS config */
5739         err = alc662_parse_auto_config(codec);
5740         if (err < 0)
5741                 goto error;
5742
5743         if (!spec->no_analog && !spec->adc_nids) {
5744                 alc_auto_fill_adc_caps(codec);
5745                 alc_rebuild_imux_for_auto_mic(codec);
5746                 alc_remove_invalid_adc_nids(codec);
5747         }
5748
5749         if (!spec->no_analog && !spec->cap_mixer)
5750                 set_capture_mixer(codec);
5751
5752         if (!spec->no_analog && has_cdefine_beep(codec)) {
5753                 err = snd_hda_attach_beep_device(codec, 0x1);
5754                 if (err < 0)
5755                         goto error;
5756                 switch (codec->vendor_id) {
5757                 case 0x10ec0662:
5758                         set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
5759                         break;
5760                 case 0x10ec0272:
5761                 case 0x10ec0663:
5762                 case 0x10ec0665:
5763                         set_beep_amp(spec, 0x0b, 0x04, HDA_INPUT);
5764                         break;
5765                 case 0x10ec0273:
5766                         set_beep_amp(spec, 0x0b, 0x03, HDA_INPUT);
5767                         break;
5768                 }
5769         }
5770         spec->vmaster_nid = 0x02;
5771
5772         alc_apply_fixup(codec, ALC_FIXUP_ACT_PROBE);
5773
5774         codec->patch_ops = alc_patch_ops;
5775         spec->init_hook = alc_auto_init_std;
5776         spec->shutup = alc_eapd_shutup;
5777
5778         alc_init_jacks(codec);
5779
5780 #ifdef CONFIG_SND_HDA_POWER_SAVE
5781         if (!spec->loopback.amplist)
5782                 spec->loopback.amplist = alc662_loopbacks;
5783 #endif
5784
5785         return 0;
5786
5787  error:
5788         alc_free(codec);
5789         return err;
5790 }
5791
5792 /*
5793  * ALC680 support
5794  */
5795
5796 static int alc680_parse_auto_config(struct hda_codec *codec)
5797 {
5798         return alc_parse_auto_config(codec, NULL, NULL);
5799 }
5800
5801 /*
5802  */
5803 static int patch_alc680(struct hda_codec *codec)
5804 {
5805         struct alc_spec *spec;
5806         int err;
5807
5808         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
5809         if (spec == NULL)
5810                 return -ENOMEM;
5811
5812         codec->spec = spec;
5813
5814         /* ALC680 has no aa-loopback mixer */
5815
5816         /* automatic parse from the BIOS config */
5817         err = alc680_parse_auto_config(codec);
5818         if (err < 0) {
5819                 alc_free(codec);
5820                 return err;
5821         }
5822
5823         if (!spec->no_analog && !spec->cap_mixer)
5824                 set_capture_mixer(codec);
5825
5826         spec->vmaster_nid = 0x02;
5827
5828         codec->patch_ops = alc_patch_ops;
5829         spec->init_hook = alc_auto_init_std;
5830
5831         return 0;
5832 }
5833
5834 /*
5835  * patch entries
5836  */
5837 static const struct hda_codec_preset snd_hda_preset_realtek[] = {
5838         { .id = 0x10ec0221, .name = "ALC221", .patch = patch_alc269 },
5839         { .id = 0x10ec0260, .name = "ALC260", .patch = patch_alc260 },
5840         { .id = 0x10ec0262, .name = "ALC262", .patch = patch_alc262 },
5841         { .id = 0x10ec0267, .name = "ALC267", .patch = patch_alc268 },
5842         { .id = 0x10ec0268, .name = "ALC268", .patch = patch_alc268 },
5843         { .id = 0x10ec0269, .name = "ALC269", .patch = patch_alc269 },
5844         { .id = 0x10ec0270, .name = "ALC270", .patch = patch_alc269 },
5845         { .id = 0x10ec0272, .name = "ALC272", .patch = patch_alc662 },
5846         { .id = 0x10ec0275, .name = "ALC275", .patch = patch_alc269 },
5847         { .id = 0x10ec0276, .name = "ALC276", .patch = patch_alc269 },
5848         { .id = 0x10ec0861, .rev = 0x100340, .name = "ALC660",
5849           .patch = patch_alc861 },
5850         { .id = 0x10ec0660, .name = "ALC660-VD", .patch = patch_alc861vd },
5851         { .id = 0x10ec0861, .name = "ALC861", .patch = patch_alc861 },
5852         { .id = 0x10ec0862, .name = "ALC861-VD", .patch = patch_alc861vd },
5853         { .id = 0x10ec0662, .rev = 0x100002, .name = "ALC662 rev2",
5854           .patch = patch_alc882 },
5855         { .id = 0x10ec0662, .rev = 0x100101, .name = "ALC662 rev1",
5856           .patch = patch_alc662 },
5857         { .id = 0x10ec0662, .rev = 0x100300, .name = "ALC662 rev3",
5858           .patch = patch_alc662 },
5859         { .id = 0x10ec0663, .name = "ALC663", .patch = patch_alc662 },
5860         { .id = 0x10ec0665, .name = "ALC665", .patch = patch_alc662 },
5861         { .id = 0x10ec0670, .name = "ALC670", .patch = patch_alc662 },
5862         { .id = 0x10ec0680, .name = "ALC680", .patch = patch_alc680 },
5863         { .id = 0x10ec0880, .name = "ALC880", .patch = patch_alc880 },
5864         { .id = 0x10ec0882, .name = "ALC882", .patch = patch_alc882 },
5865         { .id = 0x10ec0883, .name = "ALC883", .patch = patch_alc882 },
5866         { .id = 0x10ec0885, .rev = 0x100101, .name = "ALC889A",
5867           .patch = patch_alc882 },
5868         { .id = 0x10ec0885, .rev = 0x100103, .name = "ALC889A",
5869           .patch = patch_alc882 },
5870         { .id = 0x10ec0885, .name = "ALC885", .patch = patch_alc882 },
5871         { .id = 0x10ec0887, .name = "ALC887", .patch = patch_alc882 },
5872         { .id = 0x10ec0888, .rev = 0x100101, .name = "ALC1200",
5873           .patch = patch_alc882 },
5874         { .id = 0x10ec0888, .name = "ALC888", .patch = patch_alc882 },
5875         { .id = 0x10ec0889, .name = "ALC889", .patch = patch_alc882 },
5876         { .id = 0x10ec0892, .name = "ALC892", .patch = patch_alc662 },
5877         { .id = 0x10ec0899, .name = "ALC898", .patch = patch_alc882 },
5878         {} /* terminator */
5879 };
5880
5881 MODULE_ALIAS("snd-hda-codec-id:10ec*");
5882
5883 MODULE_LICENSE("GPL");
5884 MODULE_DESCRIPTION("Realtek HD-audio codec");
5885
5886 static struct hda_codec_preset_list realtek_list = {
5887         .preset = snd_hda_preset_realtek,
5888         .owner = THIS_MODULE,
5889 };
5890
5891 static int __init patch_realtek_init(void)
5892 {
5893         return snd_hda_add_codec_preset(&realtek_list);
5894 }
5895
5896 static void __exit patch_realtek_exit(void)
5897 {
5898         snd_hda_delete_codec_preset(&realtek_list);
5899 }
5900
5901 module_init(patch_realtek_init)
5902 module_exit(patch_realtek_exit)