sound/pci/hda/patch_realtek.c

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