ALSA: hda - Add a fixup for ASUS N76VZ
[pandora-kernel.git] / sound / pci / hda / patch_realtek.c
1 /*
2  * Universal Interface for Intel High Definition Audio Codec
3  *
4  * HD audio interface patch for Realtek ALC codecs
5  *
6  * Copyright (c) 2004 Kailang Yang <kailang@realtek.com.tw>
7  *                    PeiSen Hou <pshou@realtek.com.tw>
8  *                    Takashi Iwai <tiwai@suse.de>
9  *                    Jonathan Woithe <jwoithe@physics.adelaide.edu.au>
10  *
11  *  This driver is free software; you can redistribute it and/or modify
12  *  it under the terms of the GNU General Public License as published by
13  *  the Free Software Foundation; either version 2 of the License, or
14  *  (at your option) any later version.
15  *
16  *  This driver is distributed in the hope that it will be useful,
17  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
18  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
19  *  GNU General Public License for more details.
20  *
21  *  You should have received a copy of the GNU General Public License
22  *  along with this program; if not, write to the Free Software
23  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
24  */
25
26 #include <linux/init.h>
27 #include <linux/delay.h>
28 #include <linux/slab.h>
29 #include <linux/pci.h>
30 #include <linux/module.h>
31 #include <sound/core.h>
32 #include <sound/jack.h>
33 #include "hda_codec.h"
34 #include "hda_local.h"
35 #include "hda_beep.h"
36
37 /* unsol event tags */
38 #define ALC_FRONT_EVENT         0x01
39 #define ALC_DCVOL_EVENT         0x02
40 #define ALC_HP_EVENT            0x04
41 #define ALC_MIC_EVENT           0x08
42
43 /* for GPIO Poll */
44 #define GPIO_MASK       0x03
45
46 /* extra amp-initialization sequence types */
47 enum {
48         ALC_INIT_NONE,
49         ALC_INIT_DEFAULT,
50         ALC_INIT_GPIO1,
51         ALC_INIT_GPIO2,
52         ALC_INIT_GPIO3,
53 };
54
55 struct alc_customize_define {
56         unsigned int  sku_cfg;
57         unsigned char port_connectivity;
58         unsigned char check_sum;
59         unsigned char customization;
60         unsigned char external_amp;
61         unsigned int  enable_pcbeep:1;
62         unsigned int  platform_type:1;
63         unsigned int  swap:1;
64         unsigned int  override:1;
65         unsigned int  fixup:1; /* Means that this sku is set by driver, not read from hw */
66 };
67
68 struct alc_fixup;
69
70 struct alc_multi_io {
71         hda_nid_t pin;          /* multi-io widget pin NID */
72         hda_nid_t dac;          /* DAC to be connected */
73         unsigned int ctl_in;    /* cached input-pin control value */
74 };
75
76 enum {
77         ALC_AUTOMUTE_PIN,       /* change the pin control */
78         ALC_AUTOMUTE_AMP,       /* mute/unmute the pin AMP */
79         ALC_AUTOMUTE_MIXER,     /* mute/unmute mixer widget AMP */
80 };
81
82 #define MAX_VOL_NIDS    0x40
83
84 struct alc_spec {
85         /* codec parameterization */
86         const struct snd_kcontrol_new *mixers[5];       /* mixer arrays */
87         unsigned int num_mixers;
88         const struct snd_kcontrol_new *cap_mixer;       /* capture mixer */
89         unsigned int beep_amp;  /* beep amp value, set via set_beep_amp() */
90
91         const struct hda_verb *init_verbs[10];  /* initialization verbs
92                                                  * don't forget NULL
93                                                  * termination!
94                                                  */
95         unsigned int num_init_verbs;
96
97         char stream_name_analog[32];    /* analog PCM stream */
98         const struct hda_pcm_stream *stream_analog_playback;
99         const struct hda_pcm_stream *stream_analog_capture;
100         const struct hda_pcm_stream *stream_analog_alt_playback;
101         const struct hda_pcm_stream *stream_analog_alt_capture;
102
103         char stream_name_digital[32];   /* digital PCM stream */
104         const struct hda_pcm_stream *stream_digital_playback;
105         const struct hda_pcm_stream *stream_digital_capture;
106
107         /* playback */
108         struct hda_multi_out multiout;  /* playback set-up
109                                          * max_channels, dacs must be set
110                                          * dig_out_nid and hp_nid are optional
111                                          */
112         hda_nid_t alt_dac_nid;
113         hda_nid_t slave_dig_outs[3];    /* optional - for auto-parsing */
114         int dig_out_type;
115
116         /* capture */
117         unsigned int num_adc_nids;
118         const hda_nid_t *adc_nids;
119         const hda_nid_t *capsrc_nids;
120         hda_nid_t dig_in_nid;           /* digital-in NID; optional */
121         hda_nid_t mixer_nid;            /* analog-mixer NID */
122         DECLARE_BITMAP(vol_ctls, MAX_VOL_NIDS << 1);
123         DECLARE_BITMAP(sw_ctls, MAX_VOL_NIDS << 1);
124
125         /* capture setup for dynamic dual-adc switch */
126         hda_nid_t cur_adc;
127         unsigned int cur_adc_stream_tag;
128         unsigned int cur_adc_format;
129
130         /* capture source */
131         unsigned int num_mux_defs;
132         const struct hda_input_mux *input_mux;
133         unsigned int cur_mux[3];
134         hda_nid_t ext_mic_pin;
135         hda_nid_t dock_mic_pin;
136         hda_nid_t int_mic_pin;
137
138         /* channel model */
139         const struct hda_channel_mode *channel_mode;
140         int num_channel_mode;
141         int need_dac_fix;
142         int const_channel_count;
143         int ext_channel_count;
144
145         /* PCM information */
146         struct hda_pcm pcm_rec[3];      /* used in alc_build_pcms() */
147
148         /* dynamic controls, init_verbs and input_mux */
149         struct auto_pin_cfg autocfg;
150         struct alc_customize_define cdefine;
151         struct snd_array kctls;
152         struct hda_input_mux private_imux[3];
153         hda_nid_t private_dac_nids[AUTO_CFG_MAX_OUTS];
154         hda_nid_t private_adc_nids[AUTO_CFG_MAX_OUTS];
155         hda_nid_t private_capsrc_nids[AUTO_CFG_MAX_OUTS];
156         hda_nid_t imux_pins[HDA_MAX_NUM_INPUTS];
157         unsigned int dyn_adc_idx[HDA_MAX_NUM_INPUTS];
158         int int_mic_idx, ext_mic_idx, dock_mic_idx; /* for auto-mic */
159
160         /* hooks */
161         void (*init_hook)(struct hda_codec *codec);
162         void (*unsol_event)(struct hda_codec *codec, unsigned int res);
163 #ifdef CONFIG_SND_HDA_POWER_SAVE
164         void (*power_hook)(struct hda_codec *codec);
165 #endif
166         void (*shutup)(struct hda_codec *codec);
167         void (*automute_hook)(struct hda_codec *codec);
168
169         /* for pin sensing */
170         unsigned int hp_jack_present:1;
171         unsigned int line_jack_present:1;
172         unsigned int master_mute:1;
173         unsigned int auto_mic:1;
174         unsigned int auto_mic_valid_imux:1;     /* valid imux for auto-mic */
175         unsigned int automute_speaker:1; /* automute speaker outputs */
176         unsigned int automute_lo:1; /* automute LO outputs */
177         unsigned int detect_hp:1;       /* Headphone detection enabled */
178         unsigned int detect_lo:1;       /* Line-out detection enabled */
179         unsigned int automute_speaker_possible:1; /* there are speakers and either LO or HP */
180         unsigned int automute_lo_possible:1;      /* there are line outs and HP */
181         unsigned int keep_vref_in_automute:1; /* Don't clear VREF in automute */
182
183         /* other flags */
184         unsigned int no_analog :1; /* digital I/O only */
185         unsigned int dyn_adc_switch:1; /* switch ADCs (for ALC275) */
186         unsigned int single_input_src:1;
187         unsigned int vol_in_capsrc:1; /* use capsrc volume (ADC has no vol) */
188         unsigned int parse_flags; /* passed to snd_hda_parse_pin_defcfg() */
189
190         /* auto-mute control */
191         int automute_mode;
192         hda_nid_t automute_mixer_nid[AUTO_CFG_MAX_OUTS];
193
194         int init_amp;
195         int codec_variant;      /* flag for other variants */
196
197         /* for virtual master */
198         hda_nid_t vmaster_nid;
199 #ifdef CONFIG_SND_HDA_POWER_SAVE
200         struct hda_loopback_check loopback;
201 #endif
202
203         /* for PLL fix */
204         hda_nid_t pll_nid;
205         unsigned int pll_coef_idx, pll_coef_bit;
206         unsigned int coef0;
207
208         /* fix-up list */
209         int fixup_id;
210         const struct alc_fixup *fixup_list;
211         const char *fixup_name;
212
213         /* multi-io */
214         int multi_ios;
215         struct alc_multi_io multi_io[4];
216
217         /* bind volumes */
218         struct snd_array bind_ctls;
219 };
220
221 #define ALC_MODEL_AUTO          0       /* common for all chips */
222
223 static bool check_amp_caps(struct hda_codec *codec, hda_nid_t nid,
224                            int dir, unsigned int bits)
225 {
226         if (!nid)
227                 return false;
228         if (get_wcaps(codec, nid) & (1 << (dir + 1)))
229                 if (query_amp_caps(codec, nid, dir) & bits)
230                         return true;
231         return false;
232 }
233
234 #define nid_has_mute(codec, nid, dir) \
235         check_amp_caps(codec, nid, dir, AC_AMPCAP_MUTE)
236 #define nid_has_volume(codec, nid, dir) \
237         check_amp_caps(codec, nid, dir, AC_AMPCAP_NUM_STEPS)
238
239 /*
240  * input MUX handling
241  */
242 static int alc_mux_enum_info(struct snd_kcontrol *kcontrol,
243                              struct snd_ctl_elem_info *uinfo)
244 {
245         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
246         struct alc_spec *spec = codec->spec;
247         unsigned int mux_idx = snd_ctl_get_ioffidx(kcontrol, &uinfo->id);
248         if (mux_idx >= spec->num_mux_defs)
249                 mux_idx = 0;
250         if (!spec->input_mux[mux_idx].num_items && mux_idx > 0)
251                 mux_idx = 0;
252         return snd_hda_input_mux_info(&spec->input_mux[mux_idx], uinfo);
253 }
254
255 static int alc_mux_enum_get(struct snd_kcontrol *kcontrol,
256                             struct snd_ctl_elem_value *ucontrol)
257 {
258         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
259         struct alc_spec *spec = codec->spec;
260         unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
261
262         ucontrol->value.enumerated.item[0] = spec->cur_mux[adc_idx];
263         return 0;
264 }
265
266 static bool alc_dyn_adc_pcm_resetup(struct hda_codec *codec, int cur)
267 {
268         struct alc_spec *spec = codec->spec;
269         hda_nid_t new_adc = spec->adc_nids[spec->dyn_adc_idx[cur]];
270
271         if (spec->cur_adc && spec->cur_adc != new_adc) {
272                 /* stream is running, let's swap the current ADC */
273                 __snd_hda_codec_cleanup_stream(codec, spec->cur_adc, 1);
274                 spec->cur_adc = new_adc;
275                 snd_hda_codec_setup_stream(codec, new_adc,
276                                            spec->cur_adc_stream_tag, 0,
277                                            spec->cur_adc_format);
278                 return true;
279         }
280         return false;
281 }
282
283 static inline hda_nid_t get_capsrc(struct alc_spec *spec, int idx)
284 {
285         return spec->capsrc_nids ?
286                 spec->capsrc_nids[idx] : spec->adc_nids[idx];
287 }
288
289 /* select the given imux item; either unmute exclusively or select the route */
290 static int alc_mux_select(struct hda_codec *codec, unsigned int adc_idx,
291                           unsigned int idx, bool force)
292 {
293         struct alc_spec *spec = codec->spec;
294         const struct hda_input_mux *imux;
295         unsigned int mux_idx;
296         int i, type, num_conns;
297         hda_nid_t nid;
298
299         mux_idx = adc_idx >= spec->num_mux_defs ? 0 : adc_idx;
300         imux = &spec->input_mux[mux_idx];
301         if (!imux->num_items && mux_idx > 0)
302                 imux = &spec->input_mux[0];
303         if (!imux->num_items)
304                 return 0;
305
306         if (idx >= imux->num_items)
307                 idx = imux->num_items - 1;
308         if (spec->cur_mux[adc_idx] == idx && !force)
309                 return 0;
310         spec->cur_mux[adc_idx] = idx;
311
312         if (spec->dyn_adc_switch) {
313                 alc_dyn_adc_pcm_resetup(codec, idx);
314                 adc_idx = spec->dyn_adc_idx[idx];
315         }
316
317         nid = get_capsrc(spec, adc_idx);
318
319         /* no selection? */
320         num_conns = snd_hda_get_conn_list(codec, nid, NULL);
321         if (num_conns <= 1)
322                 return 1;
323
324         type = get_wcaps_type(get_wcaps(codec, nid));
325         if (type == AC_WID_AUD_MIX) {
326                 /* Matrix-mixer style (e.g. ALC882) */
327                 int active = imux->items[idx].index;
328                 for (i = 0; i < num_conns; i++) {
329                         unsigned int v = (i == active) ? 0 : HDA_AMP_MUTE;
330                         snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT, i,
331                                                  HDA_AMP_MUTE, v);
332                 }
333         } else {
334                 /* MUX style (e.g. ALC880) */
335                 snd_hda_codec_write_cache(codec, nid, 0,
336                                           AC_VERB_SET_CONNECT_SEL,
337                                           imux->items[idx].index);
338         }
339         return 1;
340 }
341
342 static int alc_mux_enum_put(struct snd_kcontrol *kcontrol,
343                             struct snd_ctl_elem_value *ucontrol)
344 {
345         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
346         unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
347         return alc_mux_select(codec, adc_idx,
348                               ucontrol->value.enumerated.item[0], false);
349 }
350
351 /*
352  * set up the input pin config (depending on the given auto-pin type)
353  */
354 static void alc_set_input_pin(struct hda_codec *codec, hda_nid_t nid,
355                               int auto_pin_type)
356 {
357         unsigned int val = PIN_IN;
358
359         if (auto_pin_type == AUTO_PIN_MIC) {
360                 unsigned int pincap;
361                 unsigned int oldval;
362                 oldval = snd_hda_codec_read(codec, nid, 0,
363                                             AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
364                 pincap = snd_hda_query_pin_caps(codec, nid);
365                 pincap = (pincap & AC_PINCAP_VREF) >> AC_PINCAP_VREF_SHIFT;
366                 /* if the default pin setup is vref50, we give it priority */
367                 if ((pincap & AC_PINCAP_VREF_80) && oldval != PIN_VREF50)
368                         val = PIN_VREF80;
369                 else if (pincap & AC_PINCAP_VREF_50)
370                         val = PIN_VREF50;
371                 else if (pincap & AC_PINCAP_VREF_100)
372                         val = PIN_VREF100;
373                 else if (pincap & AC_PINCAP_VREF_GRD)
374                         val = PIN_VREFGRD;
375         }
376         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, val);
377 }
378
379 /*
380  * Append the given mixer and verb elements for the later use
381  * The mixer array is referred in build_controls(), and init_verbs are
382  * called in init().
383  */
384 static void add_mixer(struct alc_spec *spec, const struct snd_kcontrol_new *mix)
385 {
386         if (snd_BUG_ON(spec->num_mixers >= ARRAY_SIZE(spec->mixers)))
387                 return;
388         spec->mixers[spec->num_mixers++] = mix;
389 }
390
391 static void add_verb(struct alc_spec *spec, const struct hda_verb *verb)
392 {
393         if (snd_BUG_ON(spec->num_init_verbs >= ARRAY_SIZE(spec->init_verbs)))
394                 return;
395         spec->init_verbs[spec->num_init_verbs++] = verb;
396 }
397
398 /*
399  * GPIO setup tables, used in initialization
400  */
401 /* Enable GPIO mask and set output */
402 static const struct hda_verb alc_gpio1_init_verbs[] = {
403         {0x01, AC_VERB_SET_GPIO_MASK, 0x01},
404         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
405         {0x01, AC_VERB_SET_GPIO_DATA, 0x01},
406         { }
407 };
408
409 static const struct hda_verb alc_gpio2_init_verbs[] = {
410         {0x01, AC_VERB_SET_GPIO_MASK, 0x02},
411         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x02},
412         {0x01, AC_VERB_SET_GPIO_DATA, 0x02},
413         { }
414 };
415
416 static const struct hda_verb alc_gpio3_init_verbs[] = {
417         {0x01, AC_VERB_SET_GPIO_MASK, 0x03},
418         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x03},
419         {0x01, AC_VERB_SET_GPIO_DATA, 0x03},
420         { }
421 };
422
423 /*
424  * Fix hardware PLL issue
425  * On some codecs, the analog PLL gating control must be off while
426  * the default value is 1.
427  */
428 static void alc_fix_pll(struct hda_codec *codec)
429 {
430         struct alc_spec *spec = codec->spec;
431         unsigned int val;
432
433         if (!spec->pll_nid)
434                 return;
435         snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_COEF_INDEX,
436                             spec->pll_coef_idx);
437         val = snd_hda_codec_read(codec, spec->pll_nid, 0,
438                                  AC_VERB_GET_PROC_COEF, 0);
439         snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_COEF_INDEX,
440                             spec->pll_coef_idx);
441         snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_PROC_COEF,
442                             val & ~(1 << spec->pll_coef_bit));
443 }
444
445 static void alc_fix_pll_init(struct hda_codec *codec, hda_nid_t nid,
446                              unsigned int coef_idx, unsigned int coef_bit)
447 {
448         struct alc_spec *spec = codec->spec;
449         spec->pll_nid = nid;
450         spec->pll_coef_idx = coef_idx;
451         spec->pll_coef_bit = coef_bit;
452         alc_fix_pll(codec);
453 }
454
455 /*
456  * Jack-reporting via input-jack layer
457  */
458
459 /* initialization of jacks; currently checks only a few known pins */
460 static int alc_init_jacks(struct hda_codec *codec)
461 {
462 #ifdef CONFIG_SND_HDA_INPUT_JACK
463         struct alc_spec *spec = codec->spec;
464         int err;
465         unsigned int hp_nid = spec->autocfg.hp_pins[0];
466         unsigned int mic_nid = spec->ext_mic_pin;
467         unsigned int dock_nid = spec->dock_mic_pin;
468
469         if (hp_nid) {
470                 err = snd_hda_input_jack_add(codec, hp_nid,
471                                              SND_JACK_HEADPHONE, NULL);
472                 if (err < 0)
473                         return err;
474                 snd_hda_input_jack_report(codec, hp_nid);
475         }
476
477         if (mic_nid) {
478                 err = snd_hda_input_jack_add(codec, mic_nid,
479                                              SND_JACK_MICROPHONE, NULL);
480                 if (err < 0)
481                         return err;
482                 snd_hda_input_jack_report(codec, mic_nid);
483         }
484         if (dock_nid) {
485                 err = snd_hda_input_jack_add(codec, dock_nid,
486                                              SND_JACK_MICROPHONE, NULL);
487                 if (err < 0)
488                         return err;
489                 snd_hda_input_jack_report(codec, dock_nid);
490         }
491 #endif /* CONFIG_SND_HDA_INPUT_JACK */
492         return 0;
493 }
494
495 /*
496  * Jack detections for HP auto-mute and mic-switch
497  */
498
499 /* check each pin in the given array; returns true if any of them is plugged */
500 static bool detect_jacks(struct hda_codec *codec, int num_pins, hda_nid_t *pins)
501 {
502         int i, present = 0;
503
504         for (i = 0; i < num_pins; i++) {
505                 hda_nid_t nid = pins[i];
506                 if (!nid)
507                         break;
508                 snd_hda_input_jack_report(codec, nid);
509                 present |= snd_hda_jack_detect(codec, nid);
510         }
511         return present;
512 }
513
514 /* standard HP/line-out auto-mute helper */
515 static void do_automute(struct hda_codec *codec, int num_pins, hda_nid_t *pins,
516                         bool mute, bool hp_out)
517 {
518         struct alc_spec *spec = codec->spec;
519         unsigned int mute_bits = mute ? HDA_AMP_MUTE : 0;
520         unsigned int pin_bits = mute ? 0 : (hp_out ? PIN_HP : PIN_OUT);
521         int i;
522
523         for (i = 0; i < num_pins; i++) {
524                 hda_nid_t nid = pins[i];
525                 unsigned int val;
526                 if (!nid)
527                         break;
528                 switch (spec->automute_mode) {
529                 case ALC_AUTOMUTE_PIN:
530                         /* don't reset VREF value in case it's controlling
531                          * the amp (see alc861_fixup_asus_amp_vref_0f())
532                          */
533                         if (spec->keep_vref_in_automute) {
534                                 val = snd_hda_codec_read(codec, nid, 0,
535                                         AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
536                                 val &= ~PIN_HP;
537                         } else
538                                 val = 0;
539                         val |= pin_bits;
540                         snd_hda_codec_write(codec, nid, 0,
541                                             AC_VERB_SET_PIN_WIDGET_CONTROL,
542                                             val);
543                         break;
544                 case ALC_AUTOMUTE_AMP:
545                         snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
546                                                  HDA_AMP_MUTE, mute_bits);
547                         break;
548                 case ALC_AUTOMUTE_MIXER:
549                         nid = spec->automute_mixer_nid[i];
550                         if (!nid)
551                                 break;
552                         snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT, 0,
553                                                  HDA_AMP_MUTE, mute_bits);
554                         snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT, 1,
555                                                  HDA_AMP_MUTE, mute_bits);
556                         break;
557                 }
558         }
559 }
560
561 /* Toggle outputs muting */
562 static void update_outputs(struct hda_codec *codec)
563 {
564         struct alc_spec *spec = codec->spec;
565         int on;
566
567         /* Control HP pins/amps depending on master_mute state;
568          * in general, HP pins/amps control should be enabled in all cases,
569          * but currently set only for master_mute, just to be safe
570          */
571         do_automute(codec, ARRAY_SIZE(spec->autocfg.hp_pins),
572                     spec->autocfg.hp_pins, spec->master_mute, true);
573
574         if (!spec->automute_speaker)
575                 on = 0;
576         else
577                 on = spec->hp_jack_present | spec->line_jack_present;
578         on |= spec->master_mute;
579         do_automute(codec, ARRAY_SIZE(spec->autocfg.speaker_pins),
580                     spec->autocfg.speaker_pins, on, false);
581
582         /* toggle line-out mutes if needed, too */
583         /* if LO is a copy of either HP or Speaker, don't need to handle it */
584         if (spec->autocfg.line_out_pins[0] == spec->autocfg.hp_pins[0] ||
585             spec->autocfg.line_out_pins[0] == spec->autocfg.speaker_pins[0])
586                 return;
587         if (!spec->automute_lo)
588                 on = 0;
589         else
590                 on = spec->hp_jack_present;
591         on |= spec->master_mute;
592         do_automute(codec, ARRAY_SIZE(spec->autocfg.line_out_pins),
593                     spec->autocfg.line_out_pins, on, false);
594 }
595
596 static void call_update_outputs(struct hda_codec *codec)
597 {
598         struct alc_spec *spec = codec->spec;
599         if (spec->automute_hook)
600                 spec->automute_hook(codec);
601         else
602                 update_outputs(codec);
603 }
604
605 /* standard HP-automute helper */
606 static void alc_hp_automute(struct hda_codec *codec)
607 {
608         struct alc_spec *spec = codec->spec;
609
610         spec->hp_jack_present =
611                 detect_jacks(codec, ARRAY_SIZE(spec->autocfg.hp_pins),
612                              spec->autocfg.hp_pins);
613         if (!spec->detect_hp || (!spec->automute_speaker && !spec->automute_lo))
614                 return;
615         call_update_outputs(codec);
616 }
617
618 /* standard line-out-automute helper */
619 static void alc_line_automute(struct hda_codec *codec)
620 {
621         struct alc_spec *spec = codec->spec;
622
623         if (spec->autocfg.line_out_type == AUTO_PIN_SPEAKER_OUT)
624                 return;
625         /* check LO jack only when it's different from HP */
626         if (spec->autocfg.line_out_pins[0] == spec->autocfg.hp_pins[0])
627                 return;
628
629         spec->line_jack_present =
630                 detect_jacks(codec, ARRAY_SIZE(spec->autocfg.line_out_pins),
631                              spec->autocfg.line_out_pins);
632         if (!spec->automute_speaker || !spec->detect_lo)
633                 return;
634         call_update_outputs(codec);
635 }
636
637 #define get_connection_index(codec, mux, nid) \
638         snd_hda_get_conn_index(codec, mux, nid, 0)
639
640 /* standard mic auto-switch helper */
641 static void alc_mic_automute(struct hda_codec *codec)
642 {
643         struct alc_spec *spec = codec->spec;
644         hda_nid_t *pins = spec->imux_pins;
645
646         if (!spec->auto_mic || !spec->auto_mic_valid_imux)
647                 return;
648         if (snd_BUG_ON(!spec->adc_nids))
649                 return;
650         if (snd_BUG_ON(spec->int_mic_idx < 0 || spec->ext_mic_idx < 0))
651                 return;
652
653         if (snd_hda_jack_detect(codec, pins[spec->ext_mic_idx]))
654                 alc_mux_select(codec, 0, spec->ext_mic_idx, false);
655         else if (spec->dock_mic_idx >= 0 &&
656                    snd_hda_jack_detect(codec, pins[spec->dock_mic_idx]))
657                 alc_mux_select(codec, 0, spec->dock_mic_idx, false);
658         else
659                 alc_mux_select(codec, 0, spec->int_mic_idx, false);
660
661         snd_hda_input_jack_report(codec, pins[spec->ext_mic_idx]);
662         if (spec->dock_mic_idx >= 0)
663                 snd_hda_input_jack_report(codec, pins[spec->dock_mic_idx]);
664 }
665
666 /* unsolicited event for HP jack sensing */
667 static void alc_sku_unsol_event(struct hda_codec *codec, unsigned int res)
668 {
669         if (codec->vendor_id == 0x10ec0880)
670                 res >>= 28;
671         else
672                 res >>= 26;
673         switch (res) {
674         case ALC_HP_EVENT:
675                 alc_hp_automute(codec);
676                 break;
677         case ALC_FRONT_EVENT:
678                 alc_line_automute(codec);
679                 break;
680         case ALC_MIC_EVENT:
681                 alc_mic_automute(codec);
682                 break;
683         }
684 }
685
686 /* call init functions of standard auto-mute helpers */
687 static void alc_inithook(struct hda_codec *codec)
688 {
689         alc_hp_automute(codec);
690         alc_line_automute(codec);
691         alc_mic_automute(codec);
692 }
693
694 /* additional initialization for ALC888 variants */
695 static void alc888_coef_init(struct hda_codec *codec)
696 {
697         unsigned int tmp;
698
699         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 0);
700         tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0);
701         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 7);
702         if ((tmp & 0xf0) == 0x20)
703                 /* alc888S-VC */
704                 snd_hda_codec_read(codec, 0x20, 0,
705                                    AC_VERB_SET_PROC_COEF, 0x830);
706          else
707                  /* alc888-VB */
708                  snd_hda_codec_read(codec, 0x20, 0,
709                                     AC_VERB_SET_PROC_COEF, 0x3030);
710 }
711
712 /* additional initialization for ALC889 variants */
713 static void alc889_coef_init(struct hda_codec *codec)
714 {
715         unsigned int tmp;
716
717         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 7);
718         tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0);
719         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 7);
720         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_PROC_COEF, tmp|0x2010);
721 }
722
723 /* turn on/off EAPD control (only if available) */
724 static void set_eapd(struct hda_codec *codec, hda_nid_t nid, int on)
725 {
726         if (get_wcaps_type(get_wcaps(codec, nid)) != AC_WID_PIN)
727                 return;
728         if (snd_hda_query_pin_caps(codec, nid) & AC_PINCAP_EAPD)
729                 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_EAPD_BTLENABLE,
730                                     on ? 2 : 0);
731 }
732
733 /* turn on/off EAPD controls of the codec */
734 static void alc_auto_setup_eapd(struct hda_codec *codec, bool on)
735 {
736         /* We currently only handle front, HP */
737         static hda_nid_t pins[] = {
738                 0x0f, 0x10, 0x14, 0x15, 0
739         };
740         hda_nid_t *p;
741         for (p = pins; *p; p++)
742                 set_eapd(codec, *p, on);
743 }
744
745 /* generic shutup callback;
746  * just turning off EPAD and a little pause for avoiding pop-noise
747  */
748 static void alc_eapd_shutup(struct hda_codec *codec)
749 {
750         alc_auto_setup_eapd(codec, false);
751         msleep(200);
752 }
753
754 /* generic EAPD initialization */
755 static void alc_auto_init_amp(struct hda_codec *codec, int type)
756 {
757         unsigned int tmp;
758
759         alc_auto_setup_eapd(codec, true);
760         switch (type) {
761         case ALC_INIT_GPIO1:
762                 snd_hda_sequence_write(codec, alc_gpio1_init_verbs);
763                 break;
764         case ALC_INIT_GPIO2:
765                 snd_hda_sequence_write(codec, alc_gpio2_init_verbs);
766                 break;
767         case ALC_INIT_GPIO3:
768                 snd_hda_sequence_write(codec, alc_gpio3_init_verbs);
769                 break;
770         case ALC_INIT_DEFAULT:
771                 switch (codec->vendor_id) {
772                 case 0x10ec0260:
773                         snd_hda_codec_write(codec, 0x1a, 0,
774                                             AC_VERB_SET_COEF_INDEX, 7);
775                         tmp = snd_hda_codec_read(codec, 0x1a, 0,
776                                                  AC_VERB_GET_PROC_COEF, 0);
777                         snd_hda_codec_write(codec, 0x1a, 0,
778                                             AC_VERB_SET_COEF_INDEX, 7);
779                         snd_hda_codec_write(codec, 0x1a, 0,
780                                             AC_VERB_SET_PROC_COEF,
781                                             tmp | 0x2010);
782                         break;
783                 case 0x10ec0262:
784                 case 0x10ec0880:
785                 case 0x10ec0882:
786                 case 0x10ec0883:
787                 case 0x10ec0885:
788                 case 0x10ec0887:
789                 /*case 0x10ec0889:*/ /* this causes an SPDIF problem */
790                         alc889_coef_init(codec);
791                         break;
792                 case 0x10ec0888:
793                         alc888_coef_init(codec);
794                         break;
795 #if 0 /* XXX: This may cause the silent output on speaker on some machines */
796                 case 0x10ec0267:
797                 case 0x10ec0268:
798                         snd_hda_codec_write(codec, 0x20, 0,
799                                             AC_VERB_SET_COEF_INDEX, 7);
800                         tmp = snd_hda_codec_read(codec, 0x20, 0,
801                                                  AC_VERB_GET_PROC_COEF, 0);
802                         snd_hda_codec_write(codec, 0x20, 0,
803                                             AC_VERB_SET_COEF_INDEX, 7);
804                         snd_hda_codec_write(codec, 0x20, 0,
805                                             AC_VERB_SET_PROC_COEF,
806                                             tmp | 0x3000);
807                         break;
808 #endif /* XXX */
809                 }
810                 break;
811         }
812 }
813
814 /*
815  * Auto-Mute mode mixer enum support
816  */
817 static int alc_automute_mode_info(struct snd_kcontrol *kcontrol,
818                                   struct snd_ctl_elem_info *uinfo)
819 {
820         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
821         struct alc_spec *spec = codec->spec;
822         static const char * const texts2[] = {
823                 "Disabled", "Enabled"
824         };
825         static const char * const texts3[] = {
826                 "Disabled", "Speaker Only", "Line-Out+Speaker"
827         };
828         const char * const *texts;
829
830         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
831         uinfo->count = 1;
832         if (spec->automute_speaker_possible && spec->automute_lo_possible) {
833                 uinfo->value.enumerated.items = 3;
834                 texts = texts3;
835         } else {
836                 uinfo->value.enumerated.items = 2;
837                 texts = texts2;
838         }
839         if (uinfo->value.enumerated.item >= uinfo->value.enumerated.items)
840                 uinfo->value.enumerated.item = uinfo->value.enumerated.items - 1;
841         strcpy(uinfo->value.enumerated.name,
842                texts[uinfo->value.enumerated.item]);
843         return 0;
844 }
845
846 static int alc_automute_mode_get(struct snd_kcontrol *kcontrol,
847                                  struct snd_ctl_elem_value *ucontrol)
848 {
849         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
850         struct alc_spec *spec = codec->spec;
851         unsigned int val = 0;
852         if (spec->automute_speaker)
853                 val++;
854         if (spec->automute_lo)
855                 val++;
856
857         ucontrol->value.enumerated.item[0] = val;
858         return 0;
859 }
860
861 static int alc_automute_mode_put(struct snd_kcontrol *kcontrol,
862                                  struct snd_ctl_elem_value *ucontrol)
863 {
864         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
865         struct alc_spec *spec = codec->spec;
866
867         switch (ucontrol->value.enumerated.item[0]) {
868         case 0:
869                 if (!spec->automute_speaker && !spec->automute_lo)
870                         return 0;
871                 spec->automute_speaker = 0;
872                 spec->automute_lo = 0;
873                 break;
874         case 1:
875                 if (spec->automute_speaker_possible) {
876                         if (!spec->automute_lo && spec->automute_speaker)
877                                 return 0;
878                         spec->automute_speaker = 1;
879                         spec->automute_lo = 0;
880                 } else if (spec->automute_lo_possible) {
881                         if (spec->automute_lo)
882                                 return 0;
883                         spec->automute_lo = 1;
884                 } else
885                         return -EINVAL;
886                 break;
887         case 2:
888                 if (!spec->automute_lo_possible || !spec->automute_speaker_possible)
889                         return -EINVAL;
890                 if (spec->automute_speaker && spec->automute_lo)
891                         return 0;
892                 spec->automute_speaker = 1;
893                 spec->automute_lo = 1;
894                 break;
895         default:
896                 return -EINVAL;
897         }
898         call_update_outputs(codec);
899         return 1;
900 }
901
902 static const struct snd_kcontrol_new alc_automute_mode_enum = {
903         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
904         .name = "Auto-Mute Mode",
905         .info = alc_automute_mode_info,
906         .get = alc_automute_mode_get,
907         .put = alc_automute_mode_put,
908 };
909
910 static struct snd_kcontrol_new *alc_kcontrol_new(struct alc_spec *spec)
911 {
912         snd_array_init(&spec->kctls, sizeof(struct snd_kcontrol_new), 32);
913         return snd_array_new(&spec->kctls);
914 }
915
916 static int alc_add_automute_mode_enum(struct hda_codec *codec)
917 {
918         struct alc_spec *spec = codec->spec;
919         struct snd_kcontrol_new *knew;
920
921         knew = alc_kcontrol_new(spec);
922         if (!knew)
923                 return -ENOMEM;
924         *knew = alc_automute_mode_enum;
925         knew->name = kstrdup("Auto-Mute Mode", GFP_KERNEL);
926         if (!knew->name)
927                 return -ENOMEM;
928         return 0;
929 }
930
931 /*
932  * Check the availability of HP/line-out auto-mute;
933  * Set up appropriately if really supported
934  */
935 static void alc_init_automute(struct hda_codec *codec)
936 {
937         struct alc_spec *spec = codec->spec;
938         struct auto_pin_cfg *cfg = &spec->autocfg;
939         int present = 0;
940         int i;
941
942         if (cfg->hp_pins[0])
943                 present++;
944         if (cfg->line_out_pins[0])
945                 present++;
946         if (cfg->speaker_pins[0])
947                 present++;
948         if (present < 2) /* need two different output types */
949                 return;
950
951         if (!cfg->speaker_pins[0] &&
952             cfg->line_out_type == AUTO_PIN_SPEAKER_OUT) {
953                 memcpy(cfg->speaker_pins, cfg->line_out_pins,
954                        sizeof(cfg->speaker_pins));
955                 cfg->speaker_outs = cfg->line_outs;
956         }
957
958         if (!cfg->hp_pins[0] &&
959             cfg->line_out_type == AUTO_PIN_HP_OUT) {
960                 memcpy(cfg->hp_pins, cfg->line_out_pins,
961                        sizeof(cfg->hp_pins));
962                 cfg->hp_outs = cfg->line_outs;
963         }
964
965         spec->automute_mode = ALC_AUTOMUTE_PIN;
966
967         for (i = 0; i < cfg->hp_outs; i++) {
968                 hda_nid_t nid = cfg->hp_pins[i];
969                 if (!is_jack_detectable(codec, nid))
970                         continue;
971                 snd_printdd("realtek: Enable HP auto-muting on NID 0x%x\n",
972                             nid);
973                 snd_hda_codec_write_cache(codec, nid, 0,
974                                   AC_VERB_SET_UNSOLICITED_ENABLE,
975                                   AC_USRSP_EN | ALC_HP_EVENT);
976                 spec->detect_hp = 1;
977         }
978
979         if (cfg->line_out_type == AUTO_PIN_LINE_OUT && cfg->line_outs) {
980                 if (cfg->speaker_outs)
981                         for (i = 0; i < cfg->line_outs; i++) {
982                                 hda_nid_t nid = cfg->line_out_pins[i];
983                                 if (!is_jack_detectable(codec, nid))
984                                         continue;
985                                 snd_printdd("realtek: Enable Line-Out "
986                                             "auto-muting on NID 0x%x\n", nid);
987                                 snd_hda_codec_write_cache(codec, nid, 0,
988                                                 AC_VERB_SET_UNSOLICITED_ENABLE,
989                                                 AC_USRSP_EN | ALC_FRONT_EVENT);
990                                 spec->detect_lo = 1;
991                 }
992                 spec->automute_lo_possible = spec->detect_hp;
993         }
994
995         spec->automute_speaker_possible = cfg->speaker_outs &&
996                 (spec->detect_hp || spec->detect_lo);
997
998         spec->automute_lo = spec->automute_lo_possible;
999         spec->automute_speaker = spec->automute_speaker_possible;
1000
1001         if (spec->automute_speaker_possible || spec->automute_lo_possible) {
1002                 /* create a control for automute mode */
1003                 alc_add_automute_mode_enum(codec);
1004                 spec->unsol_event = alc_sku_unsol_event;
1005         }
1006 }
1007
1008 /* return the position of NID in the list, or -1 if not found */
1009 static int find_idx_in_nid_list(hda_nid_t nid, const hda_nid_t *list, int nums)
1010 {
1011         int i;
1012         for (i = 0; i < nums; i++)
1013                 if (list[i] == nid)
1014                         return i;
1015         return -1;
1016 }
1017
1018 /* check whether dynamic ADC-switching is available */
1019 static bool alc_check_dyn_adc_switch(struct hda_codec *codec)
1020 {
1021         struct alc_spec *spec = codec->spec;
1022         struct hda_input_mux *imux = &spec->private_imux[0];
1023         int i, n, idx;
1024         hda_nid_t cap, pin;
1025
1026         if (imux != spec->input_mux) /* no dynamic imux? */
1027                 return false;
1028
1029         for (n = 0; n < spec->num_adc_nids; n++) {
1030                 cap = spec->private_capsrc_nids[n];
1031                 for (i = 0; i < imux->num_items; i++) {
1032                         pin = spec->imux_pins[i];
1033                         if (!pin)
1034                                 return false;
1035                         if (get_connection_index(codec, cap, pin) < 0)
1036                                 break;
1037                 }
1038                 if (i >= imux->num_items)
1039                         return true; /* no ADC-switch is needed */
1040         }
1041
1042         for (i = 0; i < imux->num_items; i++) {
1043                 pin = spec->imux_pins[i];
1044                 for (n = 0; n < spec->num_adc_nids; n++) {
1045                         cap = spec->private_capsrc_nids[n];
1046                         idx = get_connection_index(codec, cap, pin);
1047                         if (idx >= 0) {
1048                                 imux->items[i].index = idx;
1049                                 spec->dyn_adc_idx[i] = n;
1050                                 break;
1051                         }
1052                 }
1053         }
1054
1055         snd_printdd("realtek: enabling ADC switching\n");
1056         spec->dyn_adc_switch = 1;
1057         return true;
1058 }
1059
1060 /* rebuild imux for matching with the given auto-mic pins (if not yet) */
1061 static bool alc_rebuild_imux_for_auto_mic(struct hda_codec *codec)
1062 {
1063         struct alc_spec *spec = codec->spec;
1064         struct hda_input_mux *imux;
1065         static char * const texts[3] = {
1066                 "Mic", "Internal Mic", "Dock Mic"
1067         };
1068         int i;
1069
1070         if (!spec->auto_mic)
1071                 return false;
1072         imux = &spec->private_imux[0];
1073         if (spec->input_mux == imux)
1074                 return true;
1075         spec->imux_pins[0] = spec->ext_mic_pin;
1076         spec->imux_pins[1] = spec->int_mic_pin;
1077         spec->imux_pins[2] = spec->dock_mic_pin;
1078         for (i = 0; i < 3; i++) {
1079                 strcpy(imux->items[i].label, texts[i]);
1080                 if (spec->imux_pins[i]) {
1081                         hda_nid_t pin = spec->imux_pins[i];
1082                         int c;
1083                         for (c = 0; c < spec->num_adc_nids; c++) {
1084                                 hda_nid_t cap = get_capsrc(spec, c);
1085                                 int idx = get_connection_index(codec, cap, pin);
1086                                 if (idx >= 0) {
1087                                         imux->items[i].index = idx;
1088                                         break;
1089                                 }
1090                         }
1091                         imux->num_items = i + 1;
1092                 }
1093         }
1094         spec->num_mux_defs = 1;
1095         spec->input_mux = imux;
1096         return true;
1097 }
1098
1099 /* check whether all auto-mic pins are valid; setup indices if OK */
1100 static bool alc_auto_mic_check_imux(struct hda_codec *codec)
1101 {
1102         struct alc_spec *spec = codec->spec;
1103         const struct hda_input_mux *imux;
1104
1105         if (!spec->auto_mic)
1106                 return false;
1107         if (spec->auto_mic_valid_imux)
1108                 return true; /* already checked */
1109
1110         /* fill up imux indices */
1111         if (!alc_check_dyn_adc_switch(codec)) {
1112                 spec->auto_mic = 0;
1113                 return false;
1114         }
1115
1116         imux = spec->input_mux;
1117         spec->ext_mic_idx = find_idx_in_nid_list(spec->ext_mic_pin,
1118                                         spec->imux_pins, imux->num_items);
1119         spec->int_mic_idx = find_idx_in_nid_list(spec->int_mic_pin,
1120                                         spec->imux_pins, imux->num_items);
1121         spec->dock_mic_idx = find_idx_in_nid_list(spec->dock_mic_pin,
1122                                         spec->imux_pins, imux->num_items);
1123         if (spec->ext_mic_idx < 0 || spec->int_mic_idx < 0) {
1124                 spec->auto_mic = 0;
1125                 return false; /* no corresponding imux */
1126         }
1127
1128         snd_hda_codec_write_cache(codec, spec->ext_mic_pin, 0,
1129                                   AC_VERB_SET_UNSOLICITED_ENABLE,
1130                                   AC_USRSP_EN | ALC_MIC_EVENT);
1131         if (spec->dock_mic_pin)
1132                 snd_hda_codec_write_cache(codec, spec->dock_mic_pin, 0,
1133                                   AC_VERB_SET_UNSOLICITED_ENABLE,
1134                                   AC_USRSP_EN | ALC_MIC_EVENT);
1135
1136         spec->auto_mic_valid_imux = 1;
1137         spec->auto_mic = 1;
1138         return true;
1139 }
1140
1141 /*
1142  * Check the availability of auto-mic switch;
1143  * Set up if really supported
1144  */
1145 static void alc_init_auto_mic(struct hda_codec *codec)
1146 {
1147         struct alc_spec *spec = codec->spec;
1148         struct auto_pin_cfg *cfg = &spec->autocfg;
1149         hda_nid_t fixed, ext, dock;
1150         int i;
1151
1152         spec->ext_mic_idx = spec->int_mic_idx = spec->dock_mic_idx = -1;
1153
1154         fixed = ext = dock = 0;
1155         for (i = 0; i < cfg->num_inputs; i++) {
1156                 hda_nid_t nid = cfg->inputs[i].pin;
1157                 unsigned int defcfg;
1158                 defcfg = snd_hda_codec_get_pincfg(codec, nid);
1159                 switch (snd_hda_get_input_pin_attr(defcfg)) {
1160                 case INPUT_PIN_ATTR_INT:
1161                         if (fixed)
1162                                 return; /* already occupied */
1163                         if (cfg->inputs[i].type != AUTO_PIN_MIC)
1164                                 return; /* invalid type */
1165                         fixed = nid;
1166                         break;
1167                 case INPUT_PIN_ATTR_UNUSED:
1168                         return; /* invalid entry */
1169                 case INPUT_PIN_ATTR_DOCK:
1170                         if (dock)
1171                                 return; /* already occupied */
1172                         if (cfg->inputs[i].type > AUTO_PIN_LINE_IN)
1173                                 return; /* invalid type */
1174                         dock = nid;
1175                         break;
1176                 default:
1177                         if (ext)
1178                                 return; /* already occupied */
1179                         if (cfg->inputs[i].type != AUTO_PIN_MIC)
1180                                 return; /* invalid type */
1181                         ext = nid;
1182                         break;
1183                 }
1184         }
1185         if (!ext && dock) {
1186                 ext = dock;
1187                 dock = 0;
1188         }
1189         if (!ext || !fixed)
1190                 return;
1191         if (!is_jack_detectable(codec, ext))
1192                 return; /* no unsol support */
1193         if (dock && !is_jack_detectable(codec, dock))
1194                 return; /* no unsol support */
1195
1196         /* check imux indices */
1197         spec->ext_mic_pin = ext;
1198         spec->int_mic_pin = fixed;
1199         spec->dock_mic_pin = dock;
1200
1201         spec->auto_mic = 1;
1202         if (!alc_auto_mic_check_imux(codec))
1203                 return;
1204
1205         snd_printdd("realtek: Enable auto-mic switch on NID 0x%x/0x%x/0x%x\n",
1206                     ext, fixed, dock);
1207         spec->unsol_event = alc_sku_unsol_event;
1208 }
1209
1210 /* check the availabilities of auto-mute and auto-mic switches */
1211 static void alc_auto_check_switches(struct hda_codec *codec)
1212 {
1213         alc_init_automute(codec);
1214         alc_init_auto_mic(codec);
1215 }
1216
1217 /*
1218  * Realtek SSID verification
1219  */
1220
1221 /* Could be any non-zero and even value. When used as fixup, tells
1222  * the driver to ignore any present sku defines.
1223  */
1224 #define ALC_FIXUP_SKU_IGNORE (2)
1225
1226 static int alc_auto_parse_customize_define(struct hda_codec *codec)
1227 {
1228         unsigned int ass, tmp, i;
1229         unsigned nid = 0;
1230         struct alc_spec *spec = codec->spec;
1231
1232         spec->cdefine.enable_pcbeep = 1; /* assume always enabled */
1233
1234         if (spec->cdefine.fixup) {
1235                 ass = spec->cdefine.sku_cfg;
1236                 if (ass == ALC_FIXUP_SKU_IGNORE)
1237                         return -1;
1238                 goto do_sku;
1239         }
1240
1241         ass = codec->subsystem_id & 0xffff;
1242         if (ass != codec->bus->pci->subsystem_device && (ass & 1))
1243                 goto do_sku;
1244
1245         nid = 0x1d;
1246         if (codec->vendor_id == 0x10ec0260)
1247                 nid = 0x17;
1248         ass = snd_hda_codec_get_pincfg(codec, nid);
1249
1250         if (!(ass & 1)) {
1251                 printk(KERN_INFO "hda_codec: %s: SKU not ready 0x%08x\n",
1252                        codec->chip_name, ass);
1253                 return -1;
1254         }
1255
1256         /* check sum */
1257         tmp = 0;
1258         for (i = 1; i < 16; i++) {
1259                 if ((ass >> i) & 1)
1260                         tmp++;
1261         }
1262         if (((ass >> 16) & 0xf) != tmp)
1263                 return -1;
1264
1265         spec->cdefine.port_connectivity = ass >> 30;
1266         spec->cdefine.enable_pcbeep = (ass & 0x100000) >> 20;
1267         spec->cdefine.check_sum = (ass >> 16) & 0xf;
1268         spec->cdefine.customization = ass >> 8;
1269 do_sku:
1270         spec->cdefine.sku_cfg = ass;
1271         spec->cdefine.external_amp = (ass & 0x38) >> 3;
1272         spec->cdefine.platform_type = (ass & 0x4) >> 2;
1273         spec->cdefine.swap = (ass & 0x2) >> 1;
1274         spec->cdefine.override = ass & 0x1;
1275
1276         snd_printd("SKU: Nid=0x%x sku_cfg=0x%08x\n",
1277                    nid, spec->cdefine.sku_cfg);
1278         snd_printd("SKU: port_connectivity=0x%x\n",
1279                    spec->cdefine.port_connectivity);
1280         snd_printd("SKU: enable_pcbeep=0x%x\n", spec->cdefine.enable_pcbeep);
1281         snd_printd("SKU: check_sum=0x%08x\n", spec->cdefine.check_sum);
1282         snd_printd("SKU: customization=0x%08x\n", spec->cdefine.customization);
1283         snd_printd("SKU: external_amp=0x%x\n", spec->cdefine.external_amp);
1284         snd_printd("SKU: platform_type=0x%x\n", spec->cdefine.platform_type);
1285         snd_printd("SKU: swap=0x%x\n", spec->cdefine.swap);
1286         snd_printd("SKU: override=0x%x\n", spec->cdefine.override);
1287
1288         return 0;
1289 }
1290
1291 /* return true if the given NID is found in the list */
1292 static bool found_in_nid_list(hda_nid_t nid, const hda_nid_t *list, int nums)
1293 {
1294         return find_idx_in_nid_list(nid, list, nums) >= 0;
1295 }
1296
1297 /* check subsystem ID and set up device-specific initialization;
1298  * return 1 if initialized, 0 if invalid SSID
1299  */
1300 /* 32-bit subsystem ID for BIOS loading in HD Audio codec.
1301  *      31 ~ 16 :       Manufacture ID
1302  *      15 ~ 8  :       SKU ID
1303  *      7  ~ 0  :       Assembly ID
1304  *      port-A --> pin 39/41, port-E --> pin 14/15, port-D --> pin 35/36
1305  */
1306 static int alc_subsystem_id(struct hda_codec *codec,
1307                             hda_nid_t porta, hda_nid_t porte,
1308                             hda_nid_t portd, hda_nid_t porti)
1309 {
1310         unsigned int ass, tmp, i;
1311         unsigned nid;
1312         struct alc_spec *spec = codec->spec;
1313
1314         if (spec->cdefine.fixup) {
1315                 ass = spec->cdefine.sku_cfg;
1316                 if (ass == ALC_FIXUP_SKU_IGNORE)
1317                         return 0;
1318                 goto do_sku;
1319         }
1320
1321         ass = codec->subsystem_id & 0xffff;
1322         if ((ass != codec->bus->pci->subsystem_device) && (ass & 1))
1323                 goto do_sku;
1324
1325         /* invalid SSID, check the special NID pin defcfg instead */
1326         /*
1327          * 31~30        : port connectivity
1328          * 29~21        : reserve
1329          * 20           : PCBEEP input
1330          * 19~16        : Check sum (15:1)
1331          * 15~1         : Custom
1332          * 0            : override
1333         */
1334         nid = 0x1d;
1335         if (codec->vendor_id == 0x10ec0260)
1336                 nid = 0x17;
1337         ass = snd_hda_codec_get_pincfg(codec, nid);
1338         snd_printd("realtek: No valid SSID, "
1339                    "checking pincfg 0x%08x for NID 0x%x\n",
1340                    ass, nid);
1341         if (!(ass & 1))
1342                 return 0;
1343         if ((ass >> 30) != 1)   /* no physical connection */
1344                 return 0;
1345
1346         /* check sum */
1347         tmp = 0;
1348         for (i = 1; i < 16; i++) {
1349                 if ((ass >> i) & 1)
1350                         tmp++;
1351         }
1352         if (((ass >> 16) & 0xf) != tmp)
1353                 return 0;
1354 do_sku:
1355         snd_printd("realtek: Enabling init ASM_ID=0x%04x CODEC_ID=%08x\n",
1356                    ass & 0xffff, codec->vendor_id);
1357         /*
1358          * 0 : override
1359          * 1 :  Swap Jack
1360          * 2 : 0 --> Desktop, 1 --> Laptop
1361          * 3~5 : External Amplifier control
1362          * 7~6 : Reserved
1363         */
1364         tmp = (ass & 0x38) >> 3;        /* external Amp control */
1365         switch (tmp) {
1366         case 1:
1367                 spec->init_amp = ALC_INIT_GPIO1;
1368                 break;
1369         case 3:
1370                 spec->init_amp = ALC_INIT_GPIO2;
1371                 break;
1372         case 7:
1373                 spec->init_amp = ALC_INIT_GPIO3;
1374                 break;
1375         case 5:
1376         default:
1377                 spec->init_amp = ALC_INIT_DEFAULT;
1378                 break;
1379         }
1380
1381         /* is laptop or Desktop and enable the function "Mute internal speaker
1382          * when the external headphone out jack is plugged"
1383          */
1384         if (!(ass & 0x8000))
1385                 return 1;
1386         /*
1387          * 10~8 : Jack location
1388          * 12~11: Headphone out -> 00: PortA, 01: PortE, 02: PortD, 03: Resvered
1389          * 14~13: Resvered
1390          * 15   : 1 --> enable the function "Mute internal speaker
1391          *              when the external headphone out jack is plugged"
1392          */
1393         if (!spec->autocfg.hp_pins[0] &&
1394             !(spec->autocfg.line_out_pins[0] &&
1395               spec->autocfg.line_out_type == AUTO_PIN_HP_OUT)) {
1396                 hda_nid_t nid;
1397                 tmp = (ass >> 11) & 0x3;        /* HP to chassis */
1398                 if (tmp == 0)
1399                         nid = porta;
1400                 else if (tmp == 1)
1401                         nid = porte;
1402                 else if (tmp == 2)
1403                         nid = portd;
1404                 else if (tmp == 3)
1405                         nid = porti;
1406                 else
1407                         return 1;
1408                 if (found_in_nid_list(nid, spec->autocfg.line_out_pins,
1409                                       spec->autocfg.line_outs))
1410                         return 1;
1411                 spec->autocfg.hp_pins[0] = nid;
1412         }
1413         return 1;
1414 }
1415
1416 /* Check the validity of ALC subsystem-id
1417  * ports contains an array of 4 pin NIDs for port-A, E, D and I */
1418 static void alc_ssid_check(struct hda_codec *codec, const hda_nid_t *ports)
1419 {
1420         if (!alc_subsystem_id(codec, ports[0], ports[1], ports[2], ports[3])) {
1421                 struct alc_spec *spec = codec->spec;
1422                 snd_printd("realtek: "
1423                            "Enable default setup for auto mode as fallback\n");
1424                 spec->init_amp = ALC_INIT_DEFAULT;
1425         }
1426 }
1427
1428 /*
1429  * Fix-up pin default configurations and add default verbs
1430  */
1431
1432 struct alc_pincfg {
1433         hda_nid_t nid;
1434         u32 val;
1435 };
1436
1437 struct alc_model_fixup {
1438         const int id;
1439         const char *name;
1440 };
1441
1442 struct alc_fixup {
1443         int type;
1444         bool chained;
1445         int chain_id;
1446         union {
1447                 unsigned int sku;
1448                 const struct alc_pincfg *pins;
1449                 const struct hda_verb *verbs;
1450                 void (*func)(struct hda_codec *codec,
1451                              const struct alc_fixup *fix,
1452                              int action);
1453         } v;
1454 };
1455
1456 enum {
1457         ALC_FIXUP_INVALID,
1458         ALC_FIXUP_SKU,
1459         ALC_FIXUP_PINS,
1460         ALC_FIXUP_VERBS,
1461         ALC_FIXUP_FUNC,
1462 };
1463
1464 enum {
1465         ALC_FIXUP_ACT_PRE_PROBE,
1466         ALC_FIXUP_ACT_PROBE,
1467         ALC_FIXUP_ACT_INIT,
1468 };
1469
1470 static void alc_apply_fixup(struct hda_codec *codec, int action)
1471 {
1472         struct alc_spec *spec = codec->spec;
1473         int id = spec->fixup_id;
1474 #ifdef CONFIG_SND_DEBUG_VERBOSE
1475         const char *modelname = spec->fixup_name;
1476 #endif
1477         int depth = 0;
1478
1479         if (!spec->fixup_list)
1480                 return;
1481
1482         while (id >= 0) {
1483                 const struct alc_fixup *fix = spec->fixup_list + id;
1484                 const struct alc_pincfg *cfg;
1485
1486                 switch (fix->type) {
1487                 case ALC_FIXUP_SKU:
1488                         if (action != ALC_FIXUP_ACT_PRE_PROBE || !fix->v.sku)
1489                                 break;
1490                         snd_printdd(KERN_INFO "hda_codec: %s: "
1491                                     "Apply sku override for %s\n",
1492                                     codec->chip_name, modelname);
1493                         spec->cdefine.sku_cfg = fix->v.sku;
1494                         spec->cdefine.fixup = 1;
1495                         break;
1496                 case ALC_FIXUP_PINS:
1497                         cfg = fix->v.pins;
1498                         if (action != ALC_FIXUP_ACT_PRE_PROBE || !cfg)
1499                                 break;
1500                         snd_printdd(KERN_INFO "hda_codec: %s: "
1501                                     "Apply pincfg for %s\n",
1502                                     codec->chip_name, modelname);
1503                         for (; cfg->nid; cfg++)
1504                                 snd_hda_codec_set_pincfg(codec, cfg->nid,
1505                                                          cfg->val);
1506                         break;
1507                 case ALC_FIXUP_VERBS:
1508                         if (action != ALC_FIXUP_ACT_PROBE || !fix->v.verbs)
1509                                 break;
1510                         snd_printdd(KERN_INFO "hda_codec: %s: "
1511                                     "Apply fix-verbs for %s\n",
1512                                     codec->chip_name, modelname);
1513                         add_verb(codec->spec, fix->v.verbs);
1514                         break;
1515                 case ALC_FIXUP_FUNC:
1516                         if (!fix->v.func)
1517                                 break;
1518                         snd_printdd(KERN_INFO "hda_codec: %s: "
1519                                     "Apply fix-func for %s\n",
1520                                     codec->chip_name, modelname);
1521                         fix->v.func(codec, fix, action);
1522                         break;
1523                 default:
1524                         snd_printk(KERN_ERR "hda_codec: %s: "
1525                                    "Invalid fixup type %d\n",
1526                                    codec->chip_name, fix->type);
1527                         break;
1528                 }
1529                 if (!fix->chained)
1530                         break;
1531                 if (++depth > 10)
1532                         break;
1533                 id = fix->chain_id;
1534         }
1535 }
1536
1537 static void alc_pick_fixup(struct hda_codec *codec,
1538                            const struct alc_model_fixup *models,
1539                            const struct snd_pci_quirk *quirk,
1540                            const struct alc_fixup *fixlist)
1541 {
1542         struct alc_spec *spec = codec->spec;
1543         int id = -1;
1544         const char *name = NULL;
1545
1546         if (codec->modelname && models) {
1547                 while (models->name) {
1548                         if (!strcmp(codec->modelname, models->name)) {
1549                                 id = models->id;
1550                                 name = models->name;
1551                                 break;
1552                         }
1553                         models++;
1554                 }
1555         }
1556         if (id < 0) {
1557                 quirk = snd_pci_quirk_lookup(codec->bus->pci, quirk);
1558                 if (quirk) {
1559                         id = quirk->value;
1560 #ifdef CONFIG_SND_DEBUG_VERBOSE
1561                         name = quirk->name;
1562 #endif
1563                 }
1564         }
1565
1566         spec->fixup_id = id;
1567         if (id >= 0) {
1568                 spec->fixup_list = fixlist;
1569                 spec->fixup_name = name;
1570         }
1571 }
1572
1573 /*
1574  * COEF access helper functions
1575  */
1576 static int alc_read_coef_idx(struct hda_codec *codec,
1577                         unsigned int coef_idx)
1578 {
1579         unsigned int val;
1580         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX,
1581                                 coef_idx);
1582         val = snd_hda_codec_read(codec, 0x20, 0,
1583                                 AC_VERB_GET_PROC_COEF, 0);
1584         return val;
1585 }
1586
1587 static void alc_write_coef_idx(struct hda_codec *codec, unsigned int coef_idx,
1588                                                         unsigned int coef_val)
1589 {
1590         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX,
1591                             coef_idx);
1592         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_PROC_COEF,
1593                             coef_val);
1594 }
1595
1596 /* a special bypass for COEF 0; read the cached value at the second time */
1597 static unsigned int alc_get_coef0(struct hda_codec *codec)
1598 {
1599         struct alc_spec *spec = codec->spec;
1600         if (!spec->coef0)
1601                 spec->coef0 = alc_read_coef_idx(codec, 0);
1602         return spec->coef0;
1603 }
1604
1605 /*
1606  * Digital I/O handling
1607  */
1608
1609 /* set right pin controls for digital I/O */
1610 static void alc_auto_init_digital(struct hda_codec *codec)
1611 {
1612         struct alc_spec *spec = codec->spec;
1613         int i;
1614         hda_nid_t pin, dac;
1615
1616         for (i = 0; i < spec->autocfg.dig_outs; i++) {
1617                 pin = spec->autocfg.dig_out_pins[i];
1618                 if (!pin)
1619                         continue;
1620                 snd_hda_codec_write(codec, pin, 0,
1621                                     AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
1622                 if (!i)
1623                         dac = spec->multiout.dig_out_nid;
1624                 else
1625                         dac = spec->slave_dig_outs[i - 1];
1626                 if (!dac || !(get_wcaps(codec, dac) & AC_WCAP_OUT_AMP))
1627                         continue;
1628                 snd_hda_codec_write(codec, dac, 0,
1629                                     AC_VERB_SET_AMP_GAIN_MUTE,
1630                                     AMP_OUT_UNMUTE);
1631         }
1632         pin = spec->autocfg.dig_in_pin;
1633         if (pin)
1634                 snd_hda_codec_write(codec, pin, 0,
1635                                     AC_VERB_SET_PIN_WIDGET_CONTROL,
1636                                     PIN_IN);
1637 }
1638
1639 /* parse digital I/Os and set up NIDs in BIOS auto-parse mode */
1640 static void alc_auto_parse_digital(struct hda_codec *codec)
1641 {
1642         struct alc_spec *spec = codec->spec;
1643         int i, err, nums;
1644         hda_nid_t dig_nid;
1645
1646         /* support multiple SPDIFs; the secondary is set up as a slave */
1647         nums = 0;
1648         for (i = 0; i < spec->autocfg.dig_outs; i++) {
1649                 hda_nid_t conn[4];
1650                 err = snd_hda_get_connections(codec,
1651                                               spec->autocfg.dig_out_pins[i],
1652                                               conn, ARRAY_SIZE(conn));
1653                 if (err <= 0)
1654                         continue;
1655                 dig_nid = conn[0]; /* assume the first element is audio-out */
1656                 if (!nums) {
1657                         spec->multiout.dig_out_nid = dig_nid;
1658                         spec->dig_out_type = spec->autocfg.dig_out_type[0];
1659                 } else {
1660                         spec->multiout.slave_dig_outs = spec->slave_dig_outs;
1661                         if (nums >= ARRAY_SIZE(spec->slave_dig_outs) - 1)
1662                                 break;
1663                         spec->slave_dig_outs[nums - 1] = dig_nid;
1664                 }
1665                 nums++;
1666         }
1667
1668         if (spec->autocfg.dig_in_pin) {
1669                 dig_nid = codec->start_nid;
1670                 for (i = 0; i < codec->num_nodes; i++, dig_nid++) {
1671                         unsigned int wcaps = get_wcaps(codec, dig_nid);
1672                         if (get_wcaps_type(wcaps) != AC_WID_AUD_IN)
1673                                 continue;
1674                         if (!(wcaps & AC_WCAP_DIGITAL))
1675                                 continue;
1676                         if (!(wcaps & AC_WCAP_CONN_LIST))
1677                                 continue;
1678                         err = get_connection_index(codec, dig_nid,
1679                                                    spec->autocfg.dig_in_pin);
1680                         if (err >= 0) {
1681                                 spec->dig_in_nid = dig_nid;
1682                                 break;
1683                         }
1684                 }
1685         }
1686 }
1687
1688 /*
1689  * capture mixer elements
1690  */
1691 static int alc_cap_vol_info(struct snd_kcontrol *kcontrol,
1692                             struct snd_ctl_elem_info *uinfo)
1693 {
1694         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1695         struct alc_spec *spec = codec->spec;
1696         unsigned long val;
1697         int err;
1698
1699         mutex_lock(&codec->control_mutex);
1700         if (spec->vol_in_capsrc)
1701                 val = HDA_COMPOSE_AMP_VAL(spec->capsrc_nids[0], 3, 0, HDA_OUTPUT);
1702         else
1703                 val = HDA_COMPOSE_AMP_VAL(spec->adc_nids[0], 3, 0, HDA_INPUT);
1704         kcontrol->private_value = val;
1705         err = snd_hda_mixer_amp_volume_info(kcontrol, uinfo);
1706         mutex_unlock(&codec->control_mutex);
1707         return err;
1708 }
1709
1710 static int alc_cap_vol_tlv(struct snd_kcontrol *kcontrol, int op_flag,
1711                            unsigned int size, unsigned int __user *tlv)
1712 {
1713         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1714         struct alc_spec *spec = codec->spec;
1715         unsigned long val;
1716         int err;
1717
1718         mutex_lock(&codec->control_mutex);
1719         if (spec->vol_in_capsrc)
1720                 val = HDA_COMPOSE_AMP_VAL(spec->capsrc_nids[0], 3, 0, HDA_OUTPUT);
1721         else
1722                 val = HDA_COMPOSE_AMP_VAL(spec->adc_nids[0], 3, 0, HDA_INPUT);
1723         kcontrol->private_value = val;
1724         err = snd_hda_mixer_amp_tlv(kcontrol, op_flag, size, tlv);
1725         mutex_unlock(&codec->control_mutex);
1726         return err;
1727 }
1728
1729 typedef int (*getput_call_t)(struct snd_kcontrol *kcontrol,
1730                              struct snd_ctl_elem_value *ucontrol);
1731
1732 static int alc_cap_getput_caller(struct snd_kcontrol *kcontrol,
1733                                  struct snd_ctl_elem_value *ucontrol,
1734                                  getput_call_t func, bool check_adc_switch)
1735 {
1736         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1737         struct alc_spec *spec = codec->spec;
1738         int i, err = 0;
1739
1740         mutex_lock(&codec->control_mutex);
1741         if (check_adc_switch && spec->dyn_adc_switch) {
1742                 for (i = 0; i < spec->num_adc_nids; i++) {
1743                         kcontrol->private_value =
1744                                 HDA_COMPOSE_AMP_VAL(spec->adc_nids[i],
1745                                                     3, 0, HDA_INPUT);
1746                         err = func(kcontrol, ucontrol);
1747                         if (err < 0)
1748                                 goto error;
1749                 }
1750         } else {
1751                 i = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
1752                 if (spec->vol_in_capsrc)
1753                         kcontrol->private_value =
1754                                 HDA_COMPOSE_AMP_VAL(spec->capsrc_nids[i],
1755                                                     3, 0, HDA_OUTPUT);
1756                 else
1757                         kcontrol->private_value =
1758                                 HDA_COMPOSE_AMP_VAL(spec->adc_nids[i],
1759                                                     3, 0, HDA_INPUT);
1760                 err = func(kcontrol, ucontrol);
1761         }
1762  error:
1763         mutex_unlock(&codec->control_mutex);
1764         return err;
1765 }
1766
1767 static int alc_cap_vol_get(struct snd_kcontrol *kcontrol,
1768                            struct snd_ctl_elem_value *ucontrol)
1769 {
1770         return alc_cap_getput_caller(kcontrol, ucontrol,
1771                                      snd_hda_mixer_amp_volume_get, false);
1772 }
1773
1774 static int alc_cap_vol_put(struct snd_kcontrol *kcontrol,
1775                            struct snd_ctl_elem_value *ucontrol)
1776 {
1777         return alc_cap_getput_caller(kcontrol, ucontrol,
1778                                      snd_hda_mixer_amp_volume_put, true);
1779 }
1780
1781 /* capture mixer elements */
1782 #define alc_cap_sw_info         snd_ctl_boolean_stereo_info
1783
1784 static int alc_cap_sw_get(struct snd_kcontrol *kcontrol,
1785                           struct snd_ctl_elem_value *ucontrol)
1786 {
1787         return alc_cap_getput_caller(kcontrol, ucontrol,
1788                                      snd_hda_mixer_amp_switch_get, false);
1789 }
1790
1791 static int alc_cap_sw_put(struct snd_kcontrol *kcontrol,
1792                           struct snd_ctl_elem_value *ucontrol)
1793 {
1794         return alc_cap_getput_caller(kcontrol, ucontrol,
1795                                      snd_hda_mixer_amp_switch_put, true);
1796 }
1797
1798 #define _DEFINE_CAPMIX(num) \
1799         { \
1800                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
1801                 .name = "Capture Switch", \
1802                 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE, \
1803                 .count = num, \
1804                 .info = alc_cap_sw_info, \
1805                 .get = alc_cap_sw_get, \
1806                 .put = alc_cap_sw_put, \
1807         }, \
1808         { \
1809                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
1810                 .name = "Capture Volume", \
1811                 .access = (SNDRV_CTL_ELEM_ACCESS_READWRITE | \
1812                            SNDRV_CTL_ELEM_ACCESS_TLV_READ | \
1813                            SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK), \
1814                 .count = num, \
1815                 .info = alc_cap_vol_info, \
1816                 .get = alc_cap_vol_get, \
1817                 .put = alc_cap_vol_put, \
1818                 .tlv = { .c = alc_cap_vol_tlv }, \
1819         }
1820
1821 #define _DEFINE_CAPSRC(num) \
1822         { \
1823                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
1824                 /* .name = "Capture Source", */ \
1825                 .name = "Input Source", \
1826                 .count = num, \
1827                 .info = alc_mux_enum_info, \
1828                 .get = alc_mux_enum_get, \
1829                 .put = alc_mux_enum_put, \
1830         }
1831
1832 #define DEFINE_CAPMIX(num) \
1833 static const struct snd_kcontrol_new alc_capture_mixer ## num[] = { \
1834         _DEFINE_CAPMIX(num),                                  \
1835         _DEFINE_CAPSRC(num),                                  \
1836         { } /* end */                                         \
1837 }
1838
1839 #define DEFINE_CAPMIX_NOSRC(num) \
1840 static const struct snd_kcontrol_new alc_capture_mixer_nosrc ## num[] = { \
1841         _DEFINE_CAPMIX(num),                                        \
1842         { } /* end */                                               \
1843 }
1844
1845 /* up to three ADCs */
1846 DEFINE_CAPMIX(1);
1847 DEFINE_CAPMIX(2);
1848 DEFINE_CAPMIX(3);
1849 DEFINE_CAPMIX_NOSRC(1);
1850 DEFINE_CAPMIX_NOSRC(2);
1851 DEFINE_CAPMIX_NOSRC(3);
1852
1853 /*
1854  * virtual master controls
1855  */
1856
1857 /*
1858  * slave controls for virtual master
1859  */
1860 static const char * const alc_slave_vols[] = {
1861         "Front Playback Volume",
1862         "Surround Playback Volume",
1863         "Center Playback Volume",
1864         "LFE Playback Volume",
1865         "Side Playback Volume",
1866         "Headphone Playback Volume",
1867         "Speaker Playback Volume",
1868         "Mono Playback Volume",
1869         "Line-Out Playback Volume",
1870         "PCM Playback Volume",
1871         NULL,
1872 };
1873
1874 static const char * const alc_slave_sws[] = {
1875         "Front Playback Switch",
1876         "Surround Playback Switch",
1877         "Center Playback Switch",
1878         "LFE Playback Switch",
1879         "Side Playback Switch",
1880         "Headphone Playback Switch",
1881         "Speaker Playback Switch",
1882         "Mono Playback Switch",
1883         "IEC958 Playback Switch",
1884         "Line-Out Playback Switch",
1885         "PCM Playback Switch",
1886         NULL,
1887 };
1888
1889 /*
1890  * build control elements
1891  */
1892
1893 #define NID_MAPPING             (-1)
1894
1895 #define SUBDEV_SPEAKER_         (0 << 6)
1896 #define SUBDEV_HP_              (1 << 6)
1897 #define SUBDEV_LINE_            (2 << 6)
1898 #define SUBDEV_SPEAKER(x)       (SUBDEV_SPEAKER_ | ((x) & 0x3f))
1899 #define SUBDEV_HP(x)            (SUBDEV_HP_ | ((x) & 0x3f))
1900 #define SUBDEV_LINE(x)          (SUBDEV_LINE_ | ((x) & 0x3f))
1901
1902 static void alc_free_kctls(struct hda_codec *codec);
1903
1904 #ifdef CONFIG_SND_HDA_INPUT_BEEP
1905 /* additional beep mixers; the actual parameters are overwritten at build */
1906 static const struct snd_kcontrol_new alc_beep_mixer[] = {
1907         HDA_CODEC_VOLUME("Beep Playback Volume", 0, 0, HDA_INPUT),
1908         HDA_CODEC_MUTE_BEEP("Beep Playback Switch", 0, 0, HDA_INPUT),
1909         { } /* end */
1910 };
1911 #endif
1912
1913 static int alc_build_controls(struct hda_codec *codec)
1914 {
1915         struct alc_spec *spec = codec->spec;
1916         struct snd_kcontrol *kctl = NULL;
1917         const struct snd_kcontrol_new *knew;
1918         int i, j, err;
1919         unsigned int u;
1920         hda_nid_t nid;
1921
1922         for (i = 0; i < spec->num_mixers; i++) {
1923                 err = snd_hda_add_new_ctls(codec, spec->mixers[i]);
1924                 if (err < 0)
1925                         return err;
1926         }
1927         if (spec->cap_mixer) {
1928                 err = snd_hda_add_new_ctls(codec, spec->cap_mixer);
1929                 if (err < 0)
1930                         return err;
1931         }
1932         if (spec->multiout.dig_out_nid) {
1933                 err = snd_hda_create_spdif_out_ctls(codec,
1934                                                     spec->multiout.dig_out_nid,
1935                                                     spec->multiout.dig_out_nid);
1936                 if (err < 0)
1937                         return err;
1938                 if (!spec->no_analog) {
1939                         err = snd_hda_create_spdif_share_sw(codec,
1940                                                             &spec->multiout);
1941                         if (err < 0)
1942                                 return err;
1943                         spec->multiout.share_spdif = 1;
1944                 }
1945         }
1946         if (spec->dig_in_nid) {
1947                 err = snd_hda_create_spdif_in_ctls(codec, spec->dig_in_nid);
1948                 if (err < 0)
1949                         return err;
1950         }
1951
1952 #ifdef CONFIG_SND_HDA_INPUT_BEEP
1953         /* create beep controls if needed */
1954         if (spec->beep_amp) {
1955                 const struct snd_kcontrol_new *knew;
1956                 for (knew = alc_beep_mixer; knew->name; knew++) {
1957                         struct snd_kcontrol *kctl;
1958                         kctl = snd_ctl_new1(knew, codec);
1959                         if (!kctl)
1960                                 return -ENOMEM;
1961                         kctl->private_value = spec->beep_amp;
1962                         err = snd_hda_ctl_add(codec, 0, kctl);
1963                         if (err < 0)
1964                                 return err;
1965                 }
1966         }
1967 #endif
1968
1969         /* if we have no master control, let's create it */
1970         if (!spec->no_analog &&
1971             !snd_hda_find_mixer_ctl(codec, "Master Playback Volume")) {
1972                 unsigned int vmaster_tlv[4];
1973                 snd_hda_set_vmaster_tlv(codec, spec->vmaster_nid,
1974                                         HDA_OUTPUT, vmaster_tlv);
1975                 err = snd_hda_add_vmaster(codec, "Master Playback Volume",
1976                                           vmaster_tlv, alc_slave_vols);
1977                 if (err < 0)
1978                         return err;
1979         }
1980         if (!spec->no_analog &&
1981             !snd_hda_find_mixer_ctl(codec, "Master Playback Switch")) {
1982                 err = snd_hda_add_vmaster(codec, "Master Playback Switch",
1983                                           NULL, alc_slave_sws);
1984                 if (err < 0)
1985                         return err;
1986         }
1987
1988         /* assign Capture Source enums to NID */
1989         if (spec->capsrc_nids || spec->adc_nids) {
1990                 kctl = snd_hda_find_mixer_ctl(codec, "Capture Source");
1991                 if (!kctl)
1992                         kctl = snd_hda_find_mixer_ctl(codec, "Input Source");
1993                 for (i = 0; kctl && i < kctl->count; i++) {
1994                         err = snd_hda_add_nid(codec, kctl, i,
1995                                               get_capsrc(spec, i));
1996                         if (err < 0)
1997                                 return err;
1998                 }
1999         }
2000         if (spec->cap_mixer && spec->adc_nids) {
2001                 const char *kname = kctl ? kctl->id.name : NULL;
2002                 for (knew = spec->cap_mixer; knew->name; knew++) {
2003                         if (kname && strcmp(knew->name, kname) == 0)
2004                                 continue;
2005                         kctl = snd_hda_find_mixer_ctl(codec, knew->name);
2006                         for (i = 0; kctl && i < kctl->count; i++) {
2007                                 err = snd_hda_add_nid(codec, kctl, i,
2008                                                       spec->adc_nids[i]);
2009                                 if (err < 0)
2010                                         return err;
2011                         }
2012                 }
2013         }
2014
2015         /* other nid->control mapping */
2016         for (i = 0; i < spec->num_mixers; i++) {
2017                 for (knew = spec->mixers[i]; knew->name; knew++) {
2018                         if (knew->iface != NID_MAPPING)
2019                                 continue;
2020                         kctl = snd_hda_find_mixer_ctl(codec, knew->name);
2021                         if (kctl == NULL)
2022                                 continue;
2023                         u = knew->subdevice;
2024                         for (j = 0; j < 4; j++, u >>= 8) {
2025                                 nid = u & 0x3f;
2026                                 if (nid == 0)
2027                                         continue;
2028                                 switch (u & 0xc0) {
2029                                 case SUBDEV_SPEAKER_:
2030                                         nid = spec->autocfg.speaker_pins[nid];
2031                                         break;
2032                                 case SUBDEV_LINE_:
2033                                         nid = spec->autocfg.line_out_pins[nid];
2034                                         break;
2035                                 case SUBDEV_HP_:
2036                                         nid = spec->autocfg.hp_pins[nid];
2037                                         break;
2038                                 default:
2039                                         continue;
2040                                 }
2041                                 err = snd_hda_add_nid(codec, kctl, 0, nid);
2042                                 if (err < 0)
2043                                         return err;
2044                         }
2045                         u = knew->private_value;
2046                         for (j = 0; j < 4; j++, u >>= 8) {
2047                                 nid = u & 0xff;
2048                                 if (nid == 0)
2049                                         continue;
2050                                 err = snd_hda_add_nid(codec, kctl, 0, nid);
2051                                 if (err < 0)
2052                                         return err;
2053                         }
2054                 }
2055         }
2056
2057         alc_free_kctls(codec); /* no longer needed */
2058
2059         return 0;
2060 }
2061
2062
2063 /*
2064  * Common callbacks
2065  */
2066
2067 static void alc_init_special_input_src(struct hda_codec *codec);
2068 static int alc269_fill_coef(struct hda_codec *codec);
2069
2070 static int alc_init(struct hda_codec *codec)
2071 {
2072         struct alc_spec *spec = codec->spec;
2073         unsigned int i;
2074
2075         if (codec->vendor_id == 0x10ec0269)
2076                 alc269_fill_coef(codec);
2077
2078         alc_fix_pll(codec);
2079         alc_auto_init_amp(codec, spec->init_amp);
2080
2081         for (i = 0; i < spec->num_init_verbs; i++)
2082                 snd_hda_sequence_write(codec, spec->init_verbs[i]);
2083         alc_init_special_input_src(codec);
2084
2085         if (spec->init_hook)
2086                 spec->init_hook(codec);
2087
2088         alc_apply_fixup(codec, ALC_FIXUP_ACT_INIT);
2089
2090         hda_call_check_power_status(codec, 0x01);
2091         return 0;
2092 }
2093
2094 static void alc_unsol_event(struct hda_codec *codec, unsigned int res)
2095 {
2096         struct alc_spec *spec = codec->spec;
2097
2098         if (spec->unsol_event)
2099                 spec->unsol_event(codec, res);
2100 }
2101
2102 #ifdef CONFIG_SND_HDA_POWER_SAVE
2103 static int alc_check_power_status(struct hda_codec *codec, hda_nid_t nid)
2104 {
2105         struct alc_spec *spec = codec->spec;
2106         return snd_hda_check_amp_list_power(codec, &spec->loopback, nid);
2107 }
2108 #endif
2109
2110 /*
2111  * Analog playback callbacks
2112  */
2113 static int alc_playback_pcm_open(struct hda_pcm_stream *hinfo,
2114                                     struct hda_codec *codec,
2115                                     struct snd_pcm_substream *substream)
2116 {
2117         struct alc_spec *spec = codec->spec;
2118         return snd_hda_multi_out_analog_open(codec, &spec->multiout, substream,
2119                                              hinfo);
2120 }
2121
2122 static int alc_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
2123                                        struct hda_codec *codec,
2124                                        unsigned int stream_tag,
2125                                        unsigned int format,
2126                                        struct snd_pcm_substream *substream)
2127 {
2128         struct alc_spec *spec = codec->spec;
2129         return snd_hda_multi_out_analog_prepare(codec, &spec->multiout,
2130                                                 stream_tag, format, substream);
2131 }
2132
2133 static int alc_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
2134                                        struct hda_codec *codec,
2135                                        struct snd_pcm_substream *substream)
2136 {
2137         struct alc_spec *spec = codec->spec;
2138         return snd_hda_multi_out_analog_cleanup(codec, &spec->multiout);
2139 }
2140
2141 /*
2142  * Digital out
2143  */
2144 static int alc_dig_playback_pcm_open(struct hda_pcm_stream *hinfo,
2145                                         struct hda_codec *codec,
2146                                         struct snd_pcm_substream *substream)
2147 {
2148         struct alc_spec *spec = codec->spec;
2149         return snd_hda_multi_out_dig_open(codec, &spec->multiout);
2150 }
2151
2152 static int alc_dig_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
2153                                            struct hda_codec *codec,
2154                                            unsigned int stream_tag,
2155                                            unsigned int format,
2156                                            struct snd_pcm_substream *substream)
2157 {
2158         struct alc_spec *spec = codec->spec;
2159         return snd_hda_multi_out_dig_prepare(codec, &spec->multiout,
2160                                              stream_tag, format, substream);
2161 }
2162
2163 static int alc_dig_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
2164                                            struct hda_codec *codec,
2165                                            struct snd_pcm_substream *substream)
2166 {
2167         struct alc_spec *spec = codec->spec;
2168         return snd_hda_multi_out_dig_cleanup(codec, &spec->multiout);
2169 }
2170
2171 static int alc_dig_playback_pcm_close(struct hda_pcm_stream *hinfo,
2172                                          struct hda_codec *codec,
2173                                          struct snd_pcm_substream *substream)
2174 {
2175         struct alc_spec *spec = codec->spec;
2176         return snd_hda_multi_out_dig_close(codec, &spec->multiout);
2177 }
2178
2179 /*
2180  * Analog capture
2181  */
2182 static int alc_alt_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
2183                                       struct hda_codec *codec,
2184                                       unsigned int stream_tag,
2185                                       unsigned int format,
2186                                       struct snd_pcm_substream *substream)
2187 {
2188         struct alc_spec *spec = codec->spec;
2189
2190         snd_hda_codec_setup_stream(codec, spec->adc_nids[substream->number + 1],
2191                                    stream_tag, 0, format);
2192         return 0;
2193 }
2194
2195 static int alc_alt_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
2196                                       struct hda_codec *codec,
2197                                       struct snd_pcm_substream *substream)
2198 {
2199         struct alc_spec *spec = codec->spec;
2200
2201         snd_hda_codec_cleanup_stream(codec,
2202                                      spec->adc_nids[substream->number + 1]);
2203         return 0;
2204 }
2205
2206 /* analog capture with dynamic dual-adc changes */
2207 static int dyn_adc_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
2208                                        struct hda_codec *codec,
2209                                        unsigned int stream_tag,
2210                                        unsigned int format,
2211                                        struct snd_pcm_substream *substream)
2212 {
2213         struct alc_spec *spec = codec->spec;
2214         spec->cur_adc = spec->adc_nids[spec->dyn_adc_idx[spec->cur_mux[0]]];
2215         spec->cur_adc_stream_tag = stream_tag;
2216         spec->cur_adc_format = format;
2217         snd_hda_codec_setup_stream(codec, spec->cur_adc, stream_tag, 0, format);
2218         return 0;
2219 }
2220
2221 static int dyn_adc_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
2222                                        struct hda_codec *codec,
2223                                        struct snd_pcm_substream *substream)
2224 {
2225         struct alc_spec *spec = codec->spec;
2226         snd_hda_codec_cleanup_stream(codec, spec->cur_adc);
2227         spec->cur_adc = 0;
2228         return 0;
2229 }
2230
2231 static const struct hda_pcm_stream dyn_adc_pcm_analog_capture = {
2232         .substreams = 1,
2233         .channels_min = 2,
2234         .channels_max = 2,
2235         .nid = 0, /* fill later */
2236         .ops = {
2237                 .prepare = dyn_adc_capture_pcm_prepare,
2238                 .cleanup = dyn_adc_capture_pcm_cleanup
2239         },
2240 };
2241
2242 /*
2243  */
2244 static const struct hda_pcm_stream alc_pcm_analog_playback = {
2245         .substreams = 1,
2246         .channels_min = 2,
2247         .channels_max = 8,
2248         /* NID is set in alc_build_pcms */
2249         .ops = {
2250                 .open = alc_playback_pcm_open,
2251                 .prepare = alc_playback_pcm_prepare,
2252                 .cleanup = alc_playback_pcm_cleanup
2253         },
2254 };
2255
2256 static const struct hda_pcm_stream alc_pcm_analog_capture = {
2257         .substreams = 1,
2258         .channels_min = 2,
2259         .channels_max = 2,
2260         /* NID is set in alc_build_pcms */
2261 };
2262
2263 static const struct hda_pcm_stream alc_pcm_analog_alt_playback = {
2264         .substreams = 1,
2265         .channels_min = 2,
2266         .channels_max = 2,
2267         /* NID is set in alc_build_pcms */
2268 };
2269
2270 static const struct hda_pcm_stream alc_pcm_analog_alt_capture = {
2271         .substreams = 2, /* can be overridden */
2272         .channels_min = 2,
2273         .channels_max = 2,
2274         /* NID is set in alc_build_pcms */
2275         .ops = {
2276                 .prepare = alc_alt_capture_pcm_prepare,
2277                 .cleanup = alc_alt_capture_pcm_cleanup
2278         },
2279 };
2280
2281 static const struct hda_pcm_stream alc_pcm_digital_playback = {
2282         .substreams = 1,
2283         .channels_min = 2,
2284         .channels_max = 2,
2285         /* NID is set in alc_build_pcms */
2286         .ops = {
2287                 .open = alc_dig_playback_pcm_open,
2288                 .close = alc_dig_playback_pcm_close,
2289                 .prepare = alc_dig_playback_pcm_prepare,
2290                 .cleanup = alc_dig_playback_pcm_cleanup
2291         },
2292 };
2293
2294 static const struct hda_pcm_stream alc_pcm_digital_capture = {
2295         .substreams = 1,
2296         .channels_min = 2,
2297         .channels_max = 2,
2298         /* NID is set in alc_build_pcms */
2299 };
2300
2301 /* Used by alc_build_pcms to flag that a PCM has no playback stream */
2302 static const struct hda_pcm_stream alc_pcm_null_stream = {
2303         .substreams = 0,
2304         .channels_min = 0,
2305         .channels_max = 0,
2306 };
2307
2308 static int alc_build_pcms(struct hda_codec *codec)
2309 {
2310         struct alc_spec *spec = codec->spec;
2311         struct hda_pcm *info = spec->pcm_rec;
2312         const struct hda_pcm_stream *p;
2313         bool have_multi_adcs;
2314         int i;
2315
2316         codec->num_pcms = 1;
2317         codec->pcm_info = info;
2318
2319         if (spec->no_analog)
2320                 goto skip_analog;
2321
2322         snprintf(spec->stream_name_analog, sizeof(spec->stream_name_analog),
2323                  "%s Analog", codec->chip_name);
2324         info->name = spec->stream_name_analog;
2325
2326         if (spec->multiout.dac_nids > 0) {
2327                 p = spec->stream_analog_playback;
2328                 if (!p)
2329                         p = &alc_pcm_analog_playback;
2330                 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *p;
2331                 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dac_nids[0];
2332         }
2333         if (spec->adc_nids) {
2334                 p = spec->stream_analog_capture;
2335                 if (!p) {
2336                         if (spec->dyn_adc_switch)
2337                                 p = &dyn_adc_pcm_analog_capture;
2338                         else
2339                                 p = &alc_pcm_analog_capture;
2340                 }
2341                 info->stream[SNDRV_PCM_STREAM_CAPTURE] = *p;
2342                 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adc_nids[0];
2343         }
2344
2345         if (spec->channel_mode) {
2346                 info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max = 0;
2347                 for (i = 0; i < spec->num_channel_mode; i++) {
2348                         if (spec->channel_mode[i].channels > info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max) {
2349                                 info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max = spec->channel_mode[i].channels;
2350                         }
2351                 }
2352         }
2353
2354  skip_analog:
2355         /* SPDIF for stream index #1 */
2356         if (spec->multiout.dig_out_nid || spec->dig_in_nid) {
2357                 snprintf(spec->stream_name_digital,
2358                          sizeof(spec->stream_name_digital),
2359                          "%s Digital", codec->chip_name);
2360                 codec->num_pcms = 2;
2361                 codec->slave_dig_outs = spec->multiout.slave_dig_outs;
2362                 info = spec->pcm_rec + 1;
2363                 info->name = spec->stream_name_digital;
2364                 if (spec->dig_out_type)
2365                         info->pcm_type = spec->dig_out_type;
2366                 else
2367                         info->pcm_type = HDA_PCM_TYPE_SPDIF;
2368                 if (spec->multiout.dig_out_nid) {
2369                         p = spec->stream_digital_playback;
2370                         if (!p)
2371                                 p = &alc_pcm_digital_playback;
2372                         info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *p;
2373                         info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dig_out_nid;
2374                 }
2375                 if (spec->dig_in_nid) {
2376                         p = spec->stream_digital_capture;
2377                         if (!p)
2378                                 p = &alc_pcm_digital_capture;
2379                         info->stream[SNDRV_PCM_STREAM_CAPTURE] = *p;
2380                         info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->dig_in_nid;
2381                 }
2382                 /* FIXME: do we need this for all Realtek codec models? */
2383                 codec->spdif_status_reset = 1;
2384         }
2385
2386         if (spec->no_analog)
2387                 return 0;
2388
2389         /* If the use of more than one ADC is requested for the current
2390          * model, configure a second analog capture-only PCM.
2391          */
2392         have_multi_adcs = (spec->num_adc_nids > 1) &&
2393                 !spec->dyn_adc_switch && !spec->auto_mic &&
2394                 (!spec->input_mux || spec->input_mux->num_items > 1);
2395         /* Additional Analaog capture for index #2 */
2396         if (spec->alt_dac_nid || have_multi_adcs) {
2397                 codec->num_pcms = 3;
2398                 info = spec->pcm_rec + 2;
2399                 info->name = spec->stream_name_analog;
2400                 if (spec->alt_dac_nid) {
2401                         p = spec->stream_analog_alt_playback;
2402                         if (!p)
2403                                 p = &alc_pcm_analog_alt_playback;
2404                         info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *p;
2405                         info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid =
2406                                 spec->alt_dac_nid;
2407                 } else {
2408                         info->stream[SNDRV_PCM_STREAM_PLAYBACK] =
2409                                 alc_pcm_null_stream;
2410                         info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = 0;
2411                 }
2412                 if (have_multi_adcs) {
2413                         p = spec->stream_analog_alt_capture;
2414                         if (!p)
2415                                 p = &alc_pcm_analog_alt_capture;
2416                         info->stream[SNDRV_PCM_STREAM_CAPTURE] = *p;
2417                         info->stream[SNDRV_PCM_STREAM_CAPTURE].nid =
2418                                 spec->adc_nids[1];
2419                         info->stream[SNDRV_PCM_STREAM_CAPTURE].substreams =
2420                                 spec->num_adc_nids - 1;
2421                 } else {
2422                         info->stream[SNDRV_PCM_STREAM_CAPTURE] =
2423                                 alc_pcm_null_stream;
2424                         info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = 0;
2425                 }
2426         }
2427
2428         return 0;
2429 }
2430
2431 static inline void alc_shutup(struct hda_codec *codec)
2432 {
2433         struct alc_spec *spec = codec->spec;
2434
2435         if (spec && spec->shutup)
2436                 spec->shutup(codec);
2437         snd_hda_shutup_pins(codec);
2438 }
2439
2440 static void alc_free_kctls(struct hda_codec *codec)
2441 {
2442         struct alc_spec *spec = codec->spec;
2443
2444         if (spec->kctls.list) {
2445                 struct snd_kcontrol_new *kctl = spec->kctls.list;
2446                 int i;
2447                 for (i = 0; i < spec->kctls.used; i++)
2448                         kfree(kctl[i].name);
2449         }
2450         snd_array_free(&spec->kctls);
2451 }
2452
2453 static void alc_free_bind_ctls(struct hda_codec *codec)
2454 {
2455         struct alc_spec *spec = codec->spec;
2456         if (spec->bind_ctls.list) {
2457                 struct hda_bind_ctls **ctl = spec->bind_ctls.list;
2458                 int i;
2459                 for (i = 0; i < spec->bind_ctls.used; i++)
2460                         kfree(ctl[i]);
2461         }
2462         snd_array_free(&spec->bind_ctls);
2463 }
2464
2465 static void alc_free(struct hda_codec *codec)
2466 {
2467         struct alc_spec *spec = codec->spec;
2468
2469         if (!spec)
2470                 return;
2471
2472         alc_shutup(codec);
2473         snd_hda_input_jack_free(codec);
2474         alc_free_kctls(codec);
2475         alc_free_bind_ctls(codec);
2476         kfree(spec);
2477         snd_hda_detach_beep_device(codec);
2478 }
2479
2480 #ifdef CONFIG_SND_HDA_POWER_SAVE
2481 static void alc_power_eapd(struct hda_codec *codec)
2482 {
2483         alc_auto_setup_eapd(codec, false);
2484 }
2485
2486 static int alc_suspend(struct hda_codec *codec, pm_message_t state)
2487 {
2488         struct alc_spec *spec = codec->spec;
2489         alc_shutup(codec);
2490         if (spec && spec->power_hook)
2491                 spec->power_hook(codec);
2492         return 0;
2493 }
2494 #endif
2495
2496 #ifdef CONFIG_PM
2497 static int alc_resume(struct hda_codec *codec)
2498 {
2499         msleep(150); /* to avoid pop noise */
2500         codec->patch_ops.init(codec);
2501         snd_hda_codec_resume_amp(codec);
2502         snd_hda_codec_resume_cache(codec);
2503         hda_call_check_power_status(codec, 0x01);
2504         return 0;
2505 }
2506 #endif
2507
2508 /*
2509  */
2510 static const struct hda_codec_ops alc_patch_ops = {
2511         .build_controls = alc_build_controls,
2512         .build_pcms = alc_build_pcms,
2513         .init = alc_init,
2514         .free = alc_free,
2515         .unsol_event = alc_unsol_event,
2516 #ifdef CONFIG_PM
2517         .resume = alc_resume,
2518 #endif
2519 #ifdef CONFIG_SND_HDA_POWER_SAVE
2520         .suspend = alc_suspend,
2521         .check_power_status = alc_check_power_status,
2522 #endif
2523         .reboot_notify = alc_shutup,
2524 };
2525
2526 /* replace the codec chip_name with the given string */
2527 static int alc_codec_rename(struct hda_codec *codec, const char *name)
2528 {
2529         kfree(codec->chip_name);
2530         codec->chip_name = kstrdup(name, GFP_KERNEL);
2531         if (!codec->chip_name) {
2532                 alc_free(codec);
2533                 return -ENOMEM;
2534         }
2535         return 0;
2536 }
2537
2538 /*
2539  * Rename codecs appropriately from COEF value
2540  */
2541 struct alc_codec_rename_table {
2542         unsigned int vendor_id;
2543         unsigned short coef_mask;
2544         unsigned short coef_bits;
2545         const char *name;
2546 };
2547
2548 static struct alc_codec_rename_table rename_tbl[] = {
2549         { 0x10ec0269, 0xfff0, 0x3010, "ALC277" },
2550         { 0x10ec0269, 0xf0f0, 0x2010, "ALC259" },
2551         { 0x10ec0269, 0xf0f0, 0x3010, "ALC258" },
2552         { 0x10ec0269, 0x00f0, 0x0010, "ALC269VB" },
2553         { 0x10ec0269, 0xffff, 0xa023, "ALC259" },
2554         { 0x10ec0269, 0xffff, 0x6023, "ALC281X" },
2555         { 0x10ec0269, 0x00f0, 0x0020, "ALC269VC" },
2556         { 0x10ec0887, 0x00f0, 0x0030, "ALC887-VD" },
2557         { 0x10ec0888, 0x00f0, 0x0030, "ALC888-VD" },
2558         { 0x10ec0888, 0xf0f0, 0x3020, "ALC886" },
2559         { 0x10ec0899, 0x2000, 0x2000, "ALC899" },
2560         { 0x10ec0892, 0xffff, 0x8020, "ALC661" },
2561         { 0x10ec0892, 0xffff, 0x8011, "ALC661" },
2562         { 0x10ec0892, 0xffff, 0x4011, "ALC656" },
2563         { } /* terminator */
2564 };
2565
2566 static int alc_codec_rename_from_preset(struct hda_codec *codec)
2567 {
2568         const struct alc_codec_rename_table *p;
2569
2570         for (p = rename_tbl; p->vendor_id; p++) {
2571                 if (p->vendor_id != codec->vendor_id)
2572                         continue;
2573                 if ((alc_get_coef0(codec) & p->coef_mask) == p->coef_bits)
2574                         return alc_codec_rename(codec, p->name);
2575         }
2576         return 0;
2577 }
2578
2579 /*
2580  * Automatic parse of I/O pins from the BIOS configuration
2581  */
2582
2583 enum {
2584         ALC_CTL_WIDGET_VOL,
2585         ALC_CTL_WIDGET_MUTE,
2586         ALC_CTL_BIND_MUTE,
2587         ALC_CTL_BIND_VOL,
2588         ALC_CTL_BIND_SW,
2589 };
2590 static const struct snd_kcontrol_new alc_control_templates[] = {
2591         HDA_CODEC_VOLUME(NULL, 0, 0, 0),
2592         HDA_CODEC_MUTE(NULL, 0, 0, 0),
2593         HDA_BIND_MUTE(NULL, 0, 0, 0),
2594         HDA_BIND_VOL(NULL, 0),
2595         HDA_BIND_SW(NULL, 0),
2596 };
2597
2598 /* add dynamic controls */
2599 static int add_control(struct alc_spec *spec, int type, const char *name,
2600                        int cidx, unsigned long val)
2601 {
2602         struct snd_kcontrol_new *knew;
2603
2604         knew = alc_kcontrol_new(spec);
2605         if (!knew)
2606                 return -ENOMEM;
2607         *knew = alc_control_templates[type];
2608         knew->name = kstrdup(name, GFP_KERNEL);
2609         if (!knew->name)
2610                 return -ENOMEM;
2611         knew->index = cidx;
2612         if (get_amp_nid_(val))
2613                 knew->subdevice = HDA_SUBDEV_AMP_FLAG;
2614         knew->private_value = val;
2615         return 0;
2616 }
2617
2618 static int add_control_with_pfx(struct alc_spec *spec, int type,
2619                                 const char *pfx, const char *dir,
2620                                 const char *sfx, int cidx, unsigned long val)
2621 {
2622         char name[32];
2623         snprintf(name, sizeof(name), "%s %s %s", pfx, dir, sfx);
2624         return add_control(spec, type, name, cidx, val);
2625 }
2626
2627 #define add_pb_vol_ctrl(spec, type, pfx, val)                   \
2628         add_control_with_pfx(spec, type, pfx, "Playback", "Volume", 0, val)
2629 #define add_pb_sw_ctrl(spec, type, pfx, val)                    \
2630         add_control_with_pfx(spec, type, pfx, "Playback", "Switch", 0, val)
2631 #define __add_pb_vol_ctrl(spec, type, pfx, cidx, val)                   \
2632         add_control_with_pfx(spec, type, pfx, "Playback", "Volume", cidx, val)
2633 #define __add_pb_sw_ctrl(spec, type, pfx, cidx, val)                    \
2634         add_control_with_pfx(spec, type, pfx, "Playback", "Switch", cidx, val)
2635
2636 static const char * const channel_name[4] = {
2637         "Front", "Surround", "CLFE", "Side"
2638 };
2639
2640 static const char *alc_get_line_out_pfx(struct alc_spec *spec, int ch,
2641                                         bool can_be_master, int *index)
2642 {
2643         struct auto_pin_cfg *cfg = &spec->autocfg;
2644
2645         *index = 0;
2646         if (cfg->line_outs == 1 && !spec->multi_ios &&
2647             !cfg->hp_outs && !cfg->speaker_outs && can_be_master)
2648                 return "Master";
2649
2650         switch (cfg->line_out_type) {
2651         case AUTO_PIN_SPEAKER_OUT:
2652                 if (cfg->line_outs == 1)
2653                         return "Speaker";
2654                 if (cfg->line_outs == 2)
2655                         return ch ? "Bass Speaker" : "Speaker";
2656                 break;
2657         case AUTO_PIN_HP_OUT:
2658                 /* for multi-io case, only the primary out */
2659                 if (ch && spec->multi_ios)
2660                         break;
2661                 *index = ch;
2662                 return "Headphone";
2663         default:
2664                 if (cfg->line_outs == 1 && !spec->multi_ios)
2665                         return "PCM";
2666                 break;
2667         }
2668         if (ch >= ARRAY_SIZE(channel_name)) {
2669                 snd_BUG();
2670                 return "PCM";
2671         }
2672
2673         return channel_name[ch];
2674 }
2675
2676 /* create input playback/capture controls for the given pin */
2677 static int new_analog_input(struct alc_spec *spec, hda_nid_t pin,
2678                             const char *ctlname, int ctlidx,
2679                             int idx, hda_nid_t mix_nid)
2680 {
2681         int err;
2682
2683         err = __add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, ctlname, ctlidx,
2684                           HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT));
2685         if (err < 0)
2686                 return err;
2687         err = __add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, ctlname, ctlidx,
2688                           HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT));
2689         if (err < 0)
2690                 return err;
2691         return 0;
2692 }
2693
2694 static int alc_is_input_pin(struct hda_codec *codec, hda_nid_t nid)
2695 {
2696         unsigned int pincap = snd_hda_query_pin_caps(codec, nid);
2697         return (pincap & AC_PINCAP_IN) != 0;
2698 }
2699
2700 /* Parse the codec tree and retrieve ADCs and corresponding capsrc MUXs */
2701 static int alc_auto_fill_adc_caps(struct hda_codec *codec)
2702 {
2703         struct alc_spec *spec = codec->spec;
2704         hda_nid_t nid;
2705         hda_nid_t *adc_nids = spec->private_adc_nids;
2706         hda_nid_t *cap_nids = spec->private_capsrc_nids;
2707         int max_nums = ARRAY_SIZE(spec->private_adc_nids);
2708         int i, nums = 0;
2709
2710         nid = codec->start_nid;
2711         for (i = 0; i < codec->num_nodes; i++, nid++) {
2712                 hda_nid_t src;
2713                 const hda_nid_t *list;
2714                 unsigned int caps = get_wcaps(codec, nid);
2715                 int type = get_wcaps_type(caps);
2716
2717                 if (type != AC_WID_AUD_IN || (caps & AC_WCAP_DIGITAL))
2718                         continue;
2719                 adc_nids[nums] = nid;
2720                 cap_nids[nums] = nid;
2721                 src = nid;
2722                 for (;;) {
2723                         int n;
2724                         type = get_wcaps_type(get_wcaps(codec, src));
2725                         if (type == AC_WID_PIN)
2726                                 break;
2727                         if (type == AC_WID_AUD_SEL) {
2728                                 cap_nids[nums] = src;
2729                                 break;
2730                         }
2731                         n = snd_hda_get_conn_list(codec, src, &list);
2732                         if (n > 1) {
2733                                 cap_nids[nums] = src;
2734                                 break;
2735                         } else if (n != 1)
2736                                 break;
2737                         src = *list;
2738                 }
2739                 if (++nums >= max_nums)
2740                         break;
2741         }
2742         spec->adc_nids = spec->private_adc_nids;
2743         spec->capsrc_nids = spec->private_capsrc_nids;
2744         spec->num_adc_nids = nums;
2745         return nums;
2746 }
2747
2748 /* create playback/capture controls for input pins */
2749 static int alc_auto_create_input_ctls(struct hda_codec *codec)
2750 {
2751         struct alc_spec *spec = codec->spec;
2752         const struct auto_pin_cfg *cfg = &spec->autocfg;
2753         hda_nid_t mixer = spec->mixer_nid;
2754         struct hda_input_mux *imux = &spec->private_imux[0];
2755         int num_adcs;
2756         int i, c, err, idx, type_idx = 0;
2757         const char *prev_label = NULL;
2758
2759         num_adcs = alc_auto_fill_adc_caps(codec);
2760         if (num_adcs < 0)
2761                 return 0;
2762
2763         for (i = 0; i < cfg->num_inputs; i++) {
2764                 hda_nid_t pin;
2765                 const char *label;
2766
2767                 pin = cfg->inputs[i].pin;
2768                 if (!alc_is_input_pin(codec, pin))
2769                         continue;
2770
2771                 label = hda_get_autocfg_input_label(codec, cfg, i);
2772                 if (prev_label && !strcmp(label, prev_label))
2773                         type_idx++;
2774                 else
2775                         type_idx = 0;
2776                 prev_label = label;
2777
2778                 if (mixer) {
2779                         idx = get_connection_index(codec, mixer, pin);
2780                         if (idx >= 0) {
2781                                 err = new_analog_input(spec, pin,
2782                                                        label, type_idx,
2783                                                        idx, mixer);
2784                                 if (err < 0)
2785                                         return err;
2786                         }
2787                 }
2788
2789                 for (c = 0; c < num_adcs; c++) {
2790                         hda_nid_t cap = get_capsrc(spec, c);
2791                         idx = get_connection_index(codec, cap, pin);
2792                         if (idx >= 0) {
2793                                 spec->imux_pins[imux->num_items] = pin;
2794                                 snd_hda_add_imux_item(imux, label, idx, NULL);
2795                                 break;
2796                         }
2797                 }
2798         }
2799
2800         spec->num_mux_defs = 1;
2801         spec->input_mux = imux;
2802
2803         return 0;
2804 }
2805
2806 static void alc_set_pin_output(struct hda_codec *codec, hda_nid_t nid,
2807                                unsigned int pin_type)
2808 {
2809         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
2810                             pin_type);
2811         /* unmute pin */
2812         if (nid_has_mute(codec, nid, HDA_OUTPUT))
2813                 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE,
2814                             AMP_OUT_UNMUTE);
2815 }
2816
2817 static int get_pin_type(int line_out_type)
2818 {
2819         if (line_out_type == AUTO_PIN_HP_OUT)
2820                 return PIN_HP;
2821         else
2822                 return PIN_OUT;
2823 }
2824
2825 static void alc_auto_init_analog_input(struct hda_codec *codec)
2826 {
2827         struct alc_spec *spec = codec->spec;
2828         struct auto_pin_cfg *cfg = &spec->autocfg;
2829         int i;
2830
2831         for (i = 0; i < cfg->num_inputs; i++) {
2832                 hda_nid_t nid = cfg->inputs[i].pin;
2833                 if (alc_is_input_pin(codec, nid)) {
2834                         alc_set_input_pin(codec, nid, cfg->inputs[i].type);
2835                         if (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP)
2836                                 snd_hda_codec_write(codec, nid, 0,
2837                                                     AC_VERB_SET_AMP_GAIN_MUTE,
2838                                                     AMP_OUT_MUTE);
2839                 }
2840         }
2841
2842         /* mute all loopback inputs */
2843         if (spec->mixer_nid) {
2844                 int nums = snd_hda_get_conn_list(codec, spec->mixer_nid, NULL);
2845                 for (i = 0; i < nums; i++)
2846                         snd_hda_codec_write(codec, spec->mixer_nid, 0,
2847                                             AC_VERB_SET_AMP_GAIN_MUTE,
2848                                             AMP_IN_MUTE(i));
2849         }
2850 }
2851
2852 /* convert from MIX nid to DAC */
2853 static hda_nid_t alc_auto_mix_to_dac(struct hda_codec *codec, hda_nid_t nid)
2854 {
2855         hda_nid_t list[5];
2856         int i, num;
2857
2858         if (get_wcaps_type(get_wcaps(codec, nid)) == AC_WID_AUD_OUT)
2859                 return nid;
2860         num = snd_hda_get_connections(codec, nid, list, ARRAY_SIZE(list));
2861         for (i = 0; i < num; i++) {
2862                 if (get_wcaps_type(get_wcaps(codec, list[i])) == AC_WID_AUD_OUT)
2863                         return list[i];
2864         }
2865         return 0;
2866 }
2867
2868 /* go down to the selector widget before the mixer */
2869 static hda_nid_t alc_go_down_to_selector(struct hda_codec *codec, hda_nid_t pin)
2870 {
2871         hda_nid_t srcs[5];
2872         int num = snd_hda_get_connections(codec, pin, srcs,
2873                                           ARRAY_SIZE(srcs));
2874         if (num != 1 ||
2875             get_wcaps_type(get_wcaps(codec, srcs[0])) != AC_WID_AUD_SEL)
2876                 return pin;
2877         return srcs[0];
2878 }
2879
2880 /* get MIX nid connected to the given pin targeted to DAC */
2881 static hda_nid_t alc_auto_dac_to_mix(struct hda_codec *codec, hda_nid_t pin,
2882                                    hda_nid_t dac)
2883 {
2884         hda_nid_t mix[5];
2885         int i, num;
2886
2887         pin = alc_go_down_to_selector(codec, pin);
2888         num = snd_hda_get_connections(codec, pin, mix, ARRAY_SIZE(mix));
2889         for (i = 0; i < num; i++) {
2890                 if (alc_auto_mix_to_dac(codec, mix[i]) == dac)
2891                         return mix[i];
2892         }
2893         return 0;
2894 }
2895
2896 /* select the connection from pin to DAC if needed */
2897 static int alc_auto_select_dac(struct hda_codec *codec, hda_nid_t pin,
2898                                hda_nid_t dac)
2899 {
2900         hda_nid_t mix[5];
2901         int i, num;
2902
2903         pin = alc_go_down_to_selector(codec, pin);
2904         num = snd_hda_get_connections(codec, pin, mix, ARRAY_SIZE(mix));
2905         if (num < 2)
2906                 return 0;
2907         for (i = 0; i < num; i++) {
2908                 if (alc_auto_mix_to_dac(codec, mix[i]) == dac) {
2909                         snd_hda_codec_update_cache(codec, pin, 0,
2910                                                    AC_VERB_SET_CONNECT_SEL, i);
2911                         return 0;
2912                 }
2913         }
2914         return 0;
2915 }
2916
2917 /* look for an empty DAC slot */
2918 static hda_nid_t alc_auto_look_for_dac(struct hda_codec *codec, hda_nid_t pin)
2919 {
2920         struct alc_spec *spec = codec->spec;
2921         hda_nid_t srcs[5];
2922         int i, num;
2923
2924         pin = alc_go_down_to_selector(codec, pin);
2925         num = snd_hda_get_connections(codec, pin, srcs, ARRAY_SIZE(srcs));
2926         for (i = 0; i < num; i++) {
2927                 hda_nid_t nid = alc_auto_mix_to_dac(codec, srcs[i]);
2928                 if (!nid)
2929                         continue;
2930                 if (found_in_nid_list(nid, spec->multiout.dac_nids,
2931                                       ARRAY_SIZE(spec->private_dac_nids)))
2932                         continue;
2933                 if (found_in_nid_list(nid, spec->multiout.hp_out_nid,
2934                                       ARRAY_SIZE(spec->multiout.hp_out_nid)))
2935                     continue;
2936                 if (found_in_nid_list(nid, spec->multiout.extra_out_nid,
2937                                       ARRAY_SIZE(spec->multiout.extra_out_nid)))
2938                     continue;
2939                 return nid;
2940         }
2941         return 0;
2942 }
2943
2944 static hda_nid_t get_dac_if_single(struct hda_codec *codec, hda_nid_t pin)
2945 {
2946         hda_nid_t sel = alc_go_down_to_selector(codec, pin);
2947         if (snd_hda_get_conn_list(codec, sel, NULL) == 1)
2948                 return alc_auto_look_for_dac(codec, pin);
2949         return 0;
2950 }
2951
2952 /* return 0 if no possible DAC is found, 1 if one or more found */
2953 static int alc_auto_fill_extra_dacs(struct hda_codec *codec, int num_outs,
2954                                     const hda_nid_t *pins, hda_nid_t *dacs)
2955 {
2956         int i;
2957
2958         if (num_outs && !dacs[0]) {
2959                 dacs[0] = alc_auto_look_for_dac(codec, pins[0]);
2960                 if (!dacs[0])
2961                         return 0;
2962         }
2963
2964         for (i = 1; i < num_outs; i++)
2965                 dacs[i] = get_dac_if_single(codec, pins[i]);
2966         for (i = 1; i < num_outs; i++) {
2967                 if (!dacs[i])
2968                         dacs[i] = alc_auto_look_for_dac(codec, pins[i]);
2969         }
2970         return 1;
2971 }
2972
2973 static int alc_auto_fill_multi_ios(struct hda_codec *codec,
2974                                    unsigned int location);
2975
2976 /* fill in the dac_nids table from the parsed pin configuration */
2977 static int alc_auto_fill_dac_nids(struct hda_codec *codec)
2978 {
2979         struct alc_spec *spec = codec->spec;
2980         struct auto_pin_cfg *cfg = &spec->autocfg;
2981         bool redone = false;
2982         int i;
2983
2984  again:
2985         /* set num_dacs once to full for alc_auto_look_for_dac() */
2986         spec->multiout.num_dacs = cfg->line_outs;
2987         spec->multiout.hp_out_nid[0] = 0;
2988         spec->multiout.extra_out_nid[0] = 0;
2989         memset(spec->private_dac_nids, 0, sizeof(spec->private_dac_nids));
2990         spec->multiout.dac_nids = spec->private_dac_nids;
2991         spec->multi_ios = 0;
2992
2993         /* fill hard-wired DACs first */
2994         if (!redone) {
2995                 for (i = 0; i < cfg->line_outs; i++)
2996                         spec->private_dac_nids[i] =
2997                                 get_dac_if_single(codec, cfg->line_out_pins[i]);
2998                 if (cfg->hp_outs)
2999                         spec->multiout.hp_out_nid[0] =
3000                                 get_dac_if_single(codec, cfg->hp_pins[0]);
3001                 if (cfg->speaker_outs)
3002                         spec->multiout.extra_out_nid[0] =
3003                                 get_dac_if_single(codec, cfg->speaker_pins[0]);
3004         }
3005
3006         for (i = 0; i < cfg->line_outs; i++) {
3007                 hda_nid_t pin = cfg->line_out_pins[i];
3008                 if (spec->private_dac_nids[i])
3009                         continue;
3010                 spec->private_dac_nids[i] = alc_auto_look_for_dac(codec, pin);
3011                 if (!spec->private_dac_nids[i] && !redone) {
3012                         /* if we can't find primary DACs, re-probe without
3013                          * checking the hard-wired DACs
3014                          */
3015                         redone = true;
3016                         goto again;
3017                 }
3018         }
3019
3020         /* re-count num_dacs and squash invalid entries */
3021         spec->multiout.num_dacs = 0;
3022         for (i = 0; i < cfg->line_outs; i++) {
3023                 if (spec->private_dac_nids[i])
302