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