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