ALSA: hda - Add another jack-detection suppression for ASUS ALC892
[pandora-kernel.git] / sound / pci / hda / alc260_quirks.c
1 /*
2  * ALC260 quirk models
3  * included by patch_realtek.c
4  */
5
6 /* ALC260 models */
7 enum {
8         ALC260_AUTO,
9         ALC260_BASIC,
10         ALC260_FUJITSU_S702X,
11         ALC260_ACER,
12         ALC260_WILL,
13         ALC260_REPLACER_672V,
14         ALC260_FAVORIT100,
15 #ifdef CONFIG_SND_DEBUG
16         ALC260_TEST,
17 #endif
18         ALC260_MODEL_LAST /* last tag */
19 };
20
21 static const hda_nid_t alc260_dac_nids[1] = {
22         /* front */
23         0x02,
24 };
25
26 static const hda_nid_t alc260_adc_nids[1] = {
27         /* ADC0 */
28         0x04,
29 };
30
31 static const hda_nid_t alc260_adc_nids_alt[1] = {
32         /* ADC1 */
33         0x05,
34 };
35
36 /* NIDs used when simultaneous access to both ADCs makes sense.  Note that
37  * alc260_capture_mixer assumes ADC0 (nid 0x04) is the first ADC.
38  */
39 static const hda_nid_t alc260_dual_adc_nids[2] = {
40         /* ADC0, ADC1 */
41         0x04, 0x05
42 };
43
44 #define ALC260_DIGOUT_NID       0x03
45 #define ALC260_DIGIN_NID        0x06
46
47 static const struct hda_input_mux alc260_capture_source = {
48         .num_items = 4,
49         .items = {
50                 { "Mic", 0x0 },
51                 { "Front Mic", 0x1 },
52                 { "Line", 0x2 },
53                 { "CD", 0x4 },
54         },
55 };
56
57 /* On Fujitsu S702x laptops capture only makes sense from Mic/LineIn jack,
58  * headphone jack and the internal CD lines since these are the only pins at
59  * which audio can appear.  For flexibility, also allow the option of
60  * recording the mixer output on the second ADC (ADC0 doesn't have a
61  * connection to the mixer output).
62  */
63 static const struct hda_input_mux alc260_fujitsu_capture_sources[2] = {
64         {
65                 .num_items = 3,
66                 .items = {
67                         { "Mic/Line", 0x0 },
68                         { "CD", 0x4 },
69                         { "Headphone", 0x2 },
70                 },
71         },
72         {
73                 .num_items = 4,
74                 .items = {
75                         { "Mic/Line", 0x0 },
76                         { "CD", 0x4 },
77                         { "Headphone", 0x2 },
78                         { "Mixer", 0x5 },
79                 },
80         },
81
82 };
83
84 /* Acer TravelMate(/Extensa/Aspire) notebooks have similar configuration to
85  * the Fujitsu S702x, but jacks are marked differently.
86  */
87 static const struct hda_input_mux alc260_acer_capture_sources[2] = {
88         {
89                 .num_items = 4,
90                 .items = {
91                         { "Mic", 0x0 },
92                         { "Line", 0x2 },
93                         { "CD", 0x4 },
94                         { "Headphone", 0x5 },
95                 },
96         },
97         {
98                 .num_items = 5,
99                 .items = {
100                         { "Mic", 0x0 },
101                         { "Line", 0x2 },
102                         { "CD", 0x4 },
103                         { "Headphone", 0x6 },
104                         { "Mixer", 0x5 },
105                 },
106         },
107 };
108
109 /* Maxdata Favorit 100XS */
110 static const struct hda_input_mux alc260_favorit100_capture_sources[2] = {
111         {
112                 .num_items = 2,
113                 .items = {
114                         { "Line/Mic", 0x0 },
115                         { "CD", 0x4 },
116                 },
117         },
118         {
119                 .num_items = 3,
120                 .items = {
121                         { "Line/Mic", 0x0 },
122                         { "CD", 0x4 },
123                         { "Mixer", 0x5 },
124                 },
125         },
126 };
127
128 /*
129  * This is just place-holder, so there's something for alc_build_pcms to look
130  * at when it calculates the maximum number of channels. ALC260 has no mixer
131  * element which allows changing the channel mode, so the verb list is
132  * never used.
133  */
134 static const struct hda_channel_mode alc260_modes[1] = {
135         { 2, NULL },
136 };
137
138
139 /* Mixer combinations
140  *
141  * basic: base_output + input + pc_beep + capture
142  * fujitsu: fujitsu + capture
143  * acer: acer + capture
144  */
145
146 static const struct snd_kcontrol_new alc260_base_output_mixer[] = {
147         HDA_CODEC_VOLUME("Front Playback Volume", 0x08, 0x0, HDA_OUTPUT),
148         HDA_BIND_MUTE("Front Playback Switch", 0x08, 2, HDA_INPUT),
149         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x09, 0x0, HDA_OUTPUT),
150         HDA_BIND_MUTE("Headphone Playback Switch", 0x09, 2, HDA_INPUT),
151         HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT),
152         HDA_BIND_MUTE_MONO("Mono Playback Switch", 0x0a, 1, 2, HDA_INPUT),
153         { } /* end */
154 };
155
156 static const struct snd_kcontrol_new alc260_input_mixer[] = {
157         HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
158         HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
159         HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
160         HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
161         HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
162         HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
163         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x07, 0x01, HDA_INPUT),
164         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x07, 0x01, HDA_INPUT),
165         { } /* end */
166 };
167
168 /* Fujitsu S702x series laptops.  ALC260 pin usage: Mic/Line jack = 0x12,
169  * HP jack = 0x14, CD audio =  0x16, internal speaker = 0x10.
170  */
171 static const struct snd_kcontrol_new alc260_fujitsu_mixer[] = {
172         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x08, 0x0, HDA_OUTPUT),
173         HDA_BIND_MUTE("Headphone Playback Switch", 0x08, 2, HDA_INPUT),
174         ALC_PIN_MODE("Headphone Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
175         HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
176         HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
177         HDA_CODEC_VOLUME("Mic/Line Playback Volume", 0x07, 0x0, HDA_INPUT),
178         HDA_CODEC_MUTE("Mic/Line Playback Switch", 0x07, 0x0, HDA_INPUT),
179         ALC_PIN_MODE("Mic/Line Jack Mode", 0x12, ALC_PIN_DIR_IN),
180         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x09, 0x0, HDA_OUTPUT),
181         HDA_BIND_MUTE("Speaker Playback Switch", 0x09, 2, HDA_INPUT),
182         { } /* end */
183 };
184
185 /* Mixer for Acer TravelMate(/Extensa/Aspire) notebooks.  Note that current
186  * versions of the ALC260 don't act on requests to enable mic bias from NID
187  * 0x0f (used to drive the headphone jack in these laptops).  The ALC260
188  * datasheet doesn't mention this restriction.  At this stage it's not clear
189  * whether this behaviour is intentional or is a hardware bug in chip
190  * revisions available in early 2006.  Therefore for now allow the
191  * "Headphone Jack Mode" control to span all choices, but if it turns out
192  * that the lack of mic bias for this NID is intentional we could change the
193  * mode from ALC_PIN_DIR_INOUT to ALC_PIN_DIR_INOUT_NOMICBIAS.
194  *
195  * In addition, Acer TravelMate(/Extensa/Aspire) notebooks in early 2006
196  * don't appear to make the mic bias available from the "line" jack, even
197  * though the NID used for this jack (0x14) can supply it.  The theory is
198  * that perhaps Acer have included blocking capacitors between the ALC260
199  * and the output jack.  If this turns out to be the case for all such
200  * models the "Line Jack Mode" mode could be changed from ALC_PIN_DIR_INOUT
201  * to ALC_PIN_DIR_INOUT_NOMICBIAS.
202  *
203  * The C20x Tablet series have a mono internal speaker which is controlled
204  * via the chip's Mono sum widget and pin complex, so include the necessary
205  * controls for such models.  On models without a "mono speaker" the control
206  * won't do anything.
207  */
208 static const struct snd_kcontrol_new alc260_acer_mixer[] = {
209         HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT),
210         HDA_BIND_MUTE("Master Playback Switch", 0x08, 2, HDA_INPUT),
211         ALC_PIN_MODE("Headphone Jack Mode", 0x0f, ALC_PIN_DIR_INOUT),
212         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0a, 1, 0x0,
213                               HDA_OUTPUT),
214         HDA_BIND_MUTE_MONO("Speaker Playback Switch", 0x0a, 1, 2,
215                            HDA_INPUT),
216         HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
217         HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
218         HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
219         HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
220         ALC_PIN_MODE("Mic Jack Mode", 0x12, ALC_PIN_DIR_IN),
221         HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
222         HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
223         ALC_PIN_MODE("Line Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
224         { } /* end */
225 };
226
227 /* Maxdata Favorit 100XS: one output and one input (0x12) jack
228  */
229 static const struct snd_kcontrol_new alc260_favorit100_mixer[] = {
230         HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT),
231         HDA_BIND_MUTE("Master Playback Switch", 0x08, 2, HDA_INPUT),
232         ALC_PIN_MODE("Output Jack Mode", 0x0f, ALC_PIN_DIR_INOUT),
233         HDA_CODEC_VOLUME("Line/Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
234         HDA_CODEC_MUTE("Line/Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
235         ALC_PIN_MODE("Line/Mic Jack Mode", 0x12, ALC_PIN_DIR_IN),
236         { } /* end */
237 };
238
239 /* Packard bell V7900  ALC260 pin usage: HP = 0x0f, Mic jack = 0x12,
240  * Line In jack = 0x14, CD audio =  0x16, pc beep = 0x17.
241  */
242 static const struct snd_kcontrol_new alc260_will_mixer[] = {
243         HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT),
244         HDA_BIND_MUTE("Master Playback Switch", 0x08, 0x2, HDA_INPUT),
245         HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
246         HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
247         ALC_PIN_MODE("Mic Jack Mode", 0x12, ALC_PIN_DIR_IN),
248         HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
249         HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
250         ALC_PIN_MODE("Line Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
251         HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
252         HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
253         { } /* end */
254 };
255
256 /* Replacer 672V ALC260 pin usage: Mic jack = 0x12,
257  * Line In jack = 0x14, ATAPI Mic = 0x13, speaker = 0x0f.
258  */
259 static const struct snd_kcontrol_new alc260_replacer_672v_mixer[] = {
260         HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT),
261         HDA_BIND_MUTE("Master Playback Switch", 0x08, 0x2, HDA_INPUT),
262         HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
263         HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
264         ALC_PIN_MODE("Mic Jack Mode", 0x12, ALC_PIN_DIR_IN),
265         HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x07, 0x1, HDA_INPUT),
266         HDA_CODEC_MUTE("ATATI Mic Playback Switch", 0x07, 0x1, HDA_INPUT),
267         HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
268         HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
269         ALC_PIN_MODE("Line Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
270         { } /* end */
271 };
272
273 /*
274  * initialization verbs
275  */
276 static const struct hda_verb alc260_init_verbs[] = {
277         /* Line In pin widget for input */
278         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
279         /* CD pin widget for input */
280         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
281         /* Mic1 (rear panel) pin widget for input and vref at 80% */
282         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
283         /* Mic2 (front panel) pin widget for input and vref at 80% */
284         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
285         /* LINE-2 is used for line-out in rear */
286         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
287         /* select line-out */
288         {0x0e, AC_VERB_SET_CONNECT_SEL, 0x00},
289         /* LINE-OUT pin */
290         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
291         /* enable HP */
292         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
293         /* enable Mono */
294         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
295         /* mute capture amp left and right */
296         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
297         /* set connection select to line in (default select for this ADC) */
298         {0x04, AC_VERB_SET_CONNECT_SEL, 0x02},
299         /* mute capture amp left and right */
300         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
301         /* set connection select to line in (default select for this ADC) */
302         {0x05, AC_VERB_SET_CONNECT_SEL, 0x02},
303         /* set vol=0 Line-Out mixer amp left and right */
304         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
305         /* unmute pin widget amp left and right (no gain on this amp) */
306         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
307         /* set vol=0 HP mixer amp left and right */
308         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
309         /* unmute pin widget amp left and right (no gain on this amp) */
310         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
311         /* set vol=0 Mono mixer amp left and right */
312         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
313         /* unmute pin widget amp left and right (no gain on this amp) */
314         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
315         /* unmute LINE-2 out pin */
316         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
317         /* Amp Indexes: CD = 0x04, Line In 1 = 0x02, Mic 1 = 0x00 &
318          * Line In 2 = 0x03
319          */
320         /* mute analog inputs */
321         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
322         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
323         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
324         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
325         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
326         /* Amp Indexes: DAC = 0x01 & mixer = 0x00 */
327         /* mute Front out path */
328         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
329         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
330         /* mute Headphone out path */
331         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
332         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
333         /* mute Mono out path */
334         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
335         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
336         { }
337 };
338
339 /* Initialisation sequence for ALC260 as configured in Fujitsu S702x
340  * laptops.  ALC260 pin usage: Mic/Line jack = 0x12, HP jack = 0x14, CD
341  * audio = 0x16, internal speaker = 0x10.
342  */
343 static const struct hda_verb alc260_fujitsu_init_verbs[] = {
344         /* Disable all GPIOs */
345         {0x01, AC_VERB_SET_GPIO_MASK, 0},
346         /* Internal speaker is connected to headphone pin */
347         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
348         /* Headphone/Line-out jack connects to Line1 pin; make it an output */
349         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
350         /* Mic/Line-in jack is connected to mic1 pin, so make it an input */
351         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
352         /* Ensure all other unused pins are disabled and muted. */
353         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
354         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
355         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
356         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
357         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
358         {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
359         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
360         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
361
362         /* Disable digital (SPDIF) pins */
363         {0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
364         {0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
365
366         /* Ensure Line1 pin widget takes its input from the OUT1 sum bus
367          * when acting as an output.
368          */
369         {0x0d, AC_VERB_SET_CONNECT_SEL, 0},
370
371         /* Start with output sum widgets muted and their output gains at min */
372         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
373         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
374         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
375         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
376         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
377         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
378         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
379         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
380         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
381
382         /* Unmute HP pin widget amp left and right (no equiv mixer ctrl) */
383         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
384         /* Unmute Line1 pin widget output buffer since it starts as an output.
385          * If the pin mode is changed by the user the pin mode control will
386          * take care of enabling the pin's input/output buffers as needed.
387          * Therefore there's no need to enable the input buffer at this
388          * stage.
389          */
390         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
391         /* Unmute input buffer of pin widget used for Line-in (no equiv
392          * mixer ctrl)
393          */
394         {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
395
396         /* Mute capture amp left and right */
397         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
398         /* Set ADC connection select to match default mixer setting - line
399          * in (on mic1 pin)
400          */
401         {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
402
403         /* Do the same for the second ADC: mute capture input amp and
404          * set ADC connection to line in (on mic1 pin)
405          */
406         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
407         {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
408
409         /* Mute all inputs to mixer widget (even unconnected ones) */
410         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
411         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
412         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
413         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
414         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
415         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
416         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
417         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
418
419         { }
420 };
421
422 /* Initialisation sequence for ALC260 as configured in Acer TravelMate and
423  * similar laptops (adapted from Fujitsu init verbs).
424  */
425 static const struct hda_verb alc260_acer_init_verbs[] = {
426         /* On TravelMate laptops, GPIO 0 enables the internal speaker and
427          * the headphone jack.  Turn this on and rely on the standard mute
428          * methods whenever the user wants to turn these outputs off.
429          */
430         {0x01, AC_VERB_SET_GPIO_MASK, 0x01},
431         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
432         {0x01, AC_VERB_SET_GPIO_DATA, 0x01},
433         /* Internal speaker/Headphone jack is connected to Line-out pin */
434         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
435         /* Internal microphone/Mic jack is connected to Mic1 pin */
436         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
437         /* Line In jack is connected to Line1 pin */
438         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
439         /* Some Acers (eg: C20x Tablets) use Mono pin for internal speaker */
440         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
441         /* Ensure all other unused pins are disabled and muted. */
442         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
443         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
444         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
445         {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
446         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
447         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
448         /* Disable digital (SPDIF) pins */
449         {0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
450         {0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
451
452         /* Ensure Mic1 and Line1 pin widgets take input from the OUT1 sum
453          * bus when acting as outputs.
454          */
455         {0x0b, AC_VERB_SET_CONNECT_SEL, 0},
456         {0x0d, AC_VERB_SET_CONNECT_SEL, 0},
457
458         /* Start with output sum widgets muted and their output gains at min */
459         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
460         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
461         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
462         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
463         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
464         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
465         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
466         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
467         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
468
469         /* Unmute Line-out pin widget amp left and right
470          * (no equiv mixer ctrl)
471          */
472         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
473         /* Unmute mono pin widget amp output (no equiv mixer ctrl) */
474         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
475         /* Unmute Mic1 and Line1 pin widget input buffers since they start as
476          * inputs. If the pin mode is changed by the user the pin mode control
477          * will take care of enabling the pin's input/output buffers as needed.
478          * Therefore there's no need to enable the input buffer at this
479          * stage.
480          */
481         {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
482         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
483
484         /* Mute capture amp left and right */
485         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
486         /* Set ADC connection select to match default mixer setting - mic
487          * (on mic1 pin)
488          */
489         {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
490
491         /* Do similar with the second ADC: mute capture input amp and
492          * set ADC connection to mic to match ALSA's default state.
493          */
494         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
495         {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
496
497         /* Mute all inputs to mixer widget (even unconnected ones) */
498         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
499         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
500         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
501         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
502         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
503         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
504         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
505         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
506
507         { }
508 };
509
510 /* Initialisation sequence for Maxdata Favorit 100XS
511  * (adapted from Acer init verbs).
512  */
513 static const struct hda_verb alc260_favorit100_init_verbs[] = {
514         /* GPIO 0 enables the output jack.
515          * Turn this on and rely on the standard mute
516          * methods whenever the user wants to turn these outputs off.
517          */
518         {0x01, AC_VERB_SET_GPIO_MASK, 0x01},
519         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
520         {0x01, AC_VERB_SET_GPIO_DATA, 0x01},
521         /* Line/Mic input jack is connected to Mic1 pin */
522         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
523         /* Ensure all other unused pins are disabled and muted. */
524         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
525         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
526         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
527         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
528         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
529         {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
530         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
531         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
532         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
533         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
534         /* Disable digital (SPDIF) pins */
535         {0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
536         {0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
537
538         /* Ensure Mic1 and Line1 pin widgets take input from the OUT1 sum
539          * bus when acting as outputs.
540          */
541         {0x0b, AC_VERB_SET_CONNECT_SEL, 0},
542         {0x0d, AC_VERB_SET_CONNECT_SEL, 0},
543
544         /* Start with output sum widgets muted and their output gains at min */
545         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
546         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
547         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
548         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
549         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
550         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
551         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
552         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
553         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
554
555         /* Unmute Line-out pin widget amp left and right
556          * (no equiv mixer ctrl)
557          */
558         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
559         /* Unmute Mic1 and Line1 pin widget input buffers since they start as
560          * inputs. If the pin mode is changed by the user the pin mode control
561          * will take care of enabling the pin's input/output buffers as needed.
562          * Therefore there's no need to enable the input buffer at this
563          * stage.
564          */
565         {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
566
567         /* Mute capture amp left and right */
568         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
569         /* Set ADC connection select to match default mixer setting - mic
570          * (on mic1 pin)
571          */
572         {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
573
574         /* Do similar with the second ADC: mute capture input amp and
575          * set ADC connection to mic to match ALSA's default state.
576          */
577         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
578         {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
579
580         /* Mute all inputs to mixer widget (even unconnected ones) */
581         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
582         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
583         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
584         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
585         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
586         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
587         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
588         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
589
590         { }
591 };
592
593 static const struct hda_verb alc260_will_verbs[] = {
594         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
595         {0x0b, AC_VERB_SET_CONNECT_SEL, 0x00},
596         {0x0d, AC_VERB_SET_CONNECT_SEL, 0x00},
597         {0x0f, AC_VERB_SET_EAPD_BTLENABLE, 0x02},
598         {0x1a, AC_VERB_SET_COEF_INDEX, 0x07},
599         {0x1a, AC_VERB_SET_PROC_COEF, 0x3040},
600         {}
601 };
602
603 static const struct hda_verb alc260_replacer_672v_verbs[] = {
604         {0x0f, AC_VERB_SET_EAPD_BTLENABLE, 0x02},
605         {0x1a, AC_VERB_SET_COEF_INDEX, 0x07},
606         {0x1a, AC_VERB_SET_PROC_COEF, 0x3050},
607
608         {0x01, AC_VERB_SET_GPIO_MASK, 0x01},
609         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
610         {0x01, AC_VERB_SET_GPIO_DATA, 0x00},
611
612         {0x0f, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_HP_EVENT},
613         {}
614 };
615
616 /* toggle speaker-output according to the hp-jack state */
617 static void alc260_replacer_672v_automute(struct hda_codec *codec)
618 {
619         unsigned int present;
620
621         /* speaker --> GPIO Data 0, hp or spdif --> GPIO data 1 */
622         present = snd_hda_jack_detect(codec, 0x0f);
623         if (present) {
624                 snd_hda_codec_write_cache(codec, 0x01, 0,
625                                           AC_VERB_SET_GPIO_DATA, 1);
626                 snd_hda_codec_write_cache(codec, 0x0f, 0,
627                                           AC_VERB_SET_PIN_WIDGET_CONTROL,
628                                           PIN_HP);
629         } else {
630                 snd_hda_codec_write_cache(codec, 0x01, 0,
631                                           AC_VERB_SET_GPIO_DATA, 0);
632                 snd_hda_codec_write_cache(codec, 0x0f, 0,
633                                           AC_VERB_SET_PIN_WIDGET_CONTROL,
634                                           PIN_OUT);
635         }
636 }
637
638 static void alc260_replacer_672v_unsol_event(struct hda_codec *codec,
639                                        unsigned int res)
640 {
641         if ((res >> 26) == ALC_HP_EVENT)
642                 alc260_replacer_672v_automute(codec);
643 }
644
645 static const struct hda_verb alc260_hp_dc7600_verbs[] = {
646         {0x05, AC_VERB_SET_CONNECT_SEL, 0x01},
647         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
648         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
649         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
650         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
651         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
652         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
653         {0x10, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_HP_EVENT},
654         {0x11, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_HP_EVENT},
655         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_HP_EVENT},
656         {}
657 };
658
659 /* Test configuration for debugging, modelled after the ALC880 test
660  * configuration.
661  */
662 #ifdef CONFIG_SND_DEBUG
663 static const hda_nid_t alc260_test_dac_nids[1] = {
664         0x02,
665 };
666 static const hda_nid_t alc260_test_adc_nids[2] = {
667         0x04, 0x05,
668 };
669 /* For testing the ALC260, each input MUX needs its own definition since
670  * the signal assignments are different.  This assumes that the first ADC
671  * is NID 0x04.
672  */
673 static const struct hda_input_mux alc260_test_capture_sources[2] = {
674         {
675                 .num_items = 7,
676                 .items = {
677                         { "MIC1 pin", 0x0 },
678                         { "MIC2 pin", 0x1 },
679                         { "LINE1 pin", 0x2 },
680                         { "LINE2 pin", 0x3 },
681                         { "CD pin", 0x4 },
682                         { "LINE-OUT pin", 0x5 },
683                         { "HP-OUT pin", 0x6 },
684                 },
685         },
686         {
687                 .num_items = 8,
688                 .items = {
689                         { "MIC1 pin", 0x0 },
690                         { "MIC2 pin", 0x1 },
691                         { "LINE1 pin", 0x2 },
692                         { "LINE2 pin", 0x3 },
693                         { "CD pin", 0x4 },
694                         { "Mixer", 0x5 },
695                         { "LINE-OUT pin", 0x6 },
696                         { "HP-OUT pin", 0x7 },
697                 },
698         },
699 };
700 static const struct snd_kcontrol_new alc260_test_mixer[] = {
701         /* Output driver widgets */
702         HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT),
703         HDA_BIND_MUTE_MONO("Mono Playback Switch", 0x0a, 1, 2, HDA_INPUT),
704         HDA_CODEC_VOLUME("LOUT2 Playback Volume", 0x09, 0x0, HDA_OUTPUT),
705         HDA_BIND_MUTE("LOUT2 Playback Switch", 0x09, 2, HDA_INPUT),
706         HDA_CODEC_VOLUME("LOUT1 Playback Volume", 0x08, 0x0, HDA_OUTPUT),
707         HDA_BIND_MUTE("LOUT1 Playback Switch", 0x08, 2, HDA_INPUT),
708
709         /* Modes for retasking pin widgets
710          * Note: the ALC260 doesn't seem to act on requests to enable mic
711          * bias from NIDs 0x0f and 0x10.  The ALC260 datasheet doesn't
712          * mention this restriction.  At this stage it's not clear whether
713          * this behaviour is intentional or is a hardware bug in chip
714          * revisions available at least up until early 2006.  Therefore for
715          * now allow the "HP-OUT" and "LINE-OUT" Mode controls to span all
716          * choices, but if it turns out that the lack of mic bias for these
717          * NIDs is intentional we could change their modes from
718          * ALC_PIN_DIR_INOUT to ALC_PIN_DIR_INOUT_NOMICBIAS.
719          */
720         ALC_PIN_MODE("HP-OUT pin mode", 0x10, ALC_PIN_DIR_INOUT),
721         ALC_PIN_MODE("LINE-OUT pin mode", 0x0f, ALC_PIN_DIR_INOUT),
722         ALC_PIN_MODE("LINE2 pin mode", 0x15, ALC_PIN_DIR_INOUT),
723         ALC_PIN_MODE("LINE1 pin mode", 0x14, ALC_PIN_DIR_INOUT),
724         ALC_PIN_MODE("MIC2 pin mode", 0x13, ALC_PIN_DIR_INOUT),
725         ALC_PIN_MODE("MIC1 pin mode", 0x12, ALC_PIN_DIR_INOUT),
726
727         /* Loopback mixer controls */
728         HDA_CODEC_VOLUME("MIC1 Playback Volume", 0x07, 0x00, HDA_INPUT),
729         HDA_CODEC_MUTE("MIC1 Playback Switch", 0x07, 0x00, HDA_INPUT),
730         HDA_CODEC_VOLUME("MIC2 Playback Volume", 0x07, 0x01, HDA_INPUT),
731         HDA_CODEC_MUTE("MIC2 Playback Switch", 0x07, 0x01, HDA_INPUT),
732         HDA_CODEC_VOLUME("LINE1 Playback Volume", 0x07, 0x02, HDA_INPUT),
733         HDA_CODEC_MUTE("LINE1 Playback Switch", 0x07, 0x02, HDA_INPUT),
734         HDA_CODEC_VOLUME("LINE2 Playback Volume", 0x07, 0x03, HDA_INPUT),
735         HDA_CODEC_MUTE("LINE2 Playback Switch", 0x07, 0x03, HDA_INPUT),
736         HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
737         HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
738         HDA_CODEC_VOLUME("LINE-OUT loopback Playback Volume", 0x07, 0x06, HDA_INPUT),
739         HDA_CODEC_MUTE("LINE-OUT loopback Playback Switch", 0x07, 0x06, HDA_INPUT),
740         HDA_CODEC_VOLUME("HP-OUT loopback Playback Volume", 0x07, 0x7, HDA_INPUT),
741         HDA_CODEC_MUTE("HP-OUT loopback Playback Switch", 0x07, 0x7, HDA_INPUT),
742
743         /* Controls for GPIO pins, assuming they are configured as outputs */
744         ALC_GPIO_DATA_SWITCH("GPIO pin 0", 0x01, 0x01),
745         ALC_GPIO_DATA_SWITCH("GPIO pin 1", 0x01, 0x02),
746         ALC_GPIO_DATA_SWITCH("GPIO pin 2", 0x01, 0x04),
747         ALC_GPIO_DATA_SWITCH("GPIO pin 3", 0x01, 0x08),
748
749         /* Switches to allow the digital IO pins to be enabled.  The datasheet
750          * is ambigious as to which NID is which; testing on laptops which
751          * make this output available should provide clarification.
752          */
753         ALC_SPDIF_CTRL_SWITCH("SPDIF Playback Switch", 0x03, 0x01),
754         ALC_SPDIF_CTRL_SWITCH("SPDIF Capture Switch", 0x06, 0x01),
755
756         /* A switch allowing EAPD to be enabled.  Some laptops seem to use
757          * this output to turn on an external amplifier.
758          */
759         ALC_EAPD_CTRL_SWITCH("LINE-OUT EAPD Enable Switch", 0x0f, 0x02),
760         ALC_EAPD_CTRL_SWITCH("HP-OUT EAPD Enable Switch", 0x10, 0x02),
761
762         { } /* end */
763 };
764 static const struct hda_verb alc260_test_init_verbs[] = {
765         /* Enable all GPIOs as outputs with an initial value of 0 */
766         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x0f},
767         {0x01, AC_VERB_SET_GPIO_DATA, 0x00},
768         {0x01, AC_VERB_SET_GPIO_MASK, 0x0f},
769
770         /* Enable retasking pins as output, initially without power amp */
771         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
772         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
773         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
774         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
775         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
776         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
777
778         /* Disable digital (SPDIF) pins initially, but users can enable
779          * them via a mixer switch.  In the case of SPDIF-out, this initverb
780          * payload also sets the generation to 0, output to be in "consumer"
781          * PCM format, copyright asserted, no pre-emphasis and no validity
782          * control.
783          */
784         {0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
785         {0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
786
787         /* Ensure mic1, mic2, line1 and line2 pin widgets take input from the
788          * OUT1 sum bus when acting as an output.
789          */
790         {0x0b, AC_VERB_SET_CONNECT_SEL, 0},
791         {0x0c, AC_VERB_SET_CONNECT_SEL, 0},
792         {0x0d, AC_VERB_SET_CONNECT_SEL, 0},
793         {0x0e, AC_VERB_SET_CONNECT_SEL, 0},
794
795         /* Start with output sum widgets muted and their output gains at min */
796         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
797         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
798         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
799         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
800         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
801         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
802         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
803         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
804         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
805
806         /* Unmute retasking pin widget output buffers since the default
807          * state appears to be output.  As the pin mode is changed by the
808          * user the pin mode control will take care of enabling the pin's
809          * input/output buffers as needed.
810          */
811         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
812         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
813         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
814         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
815         {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
816         {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
817         /* Also unmute the mono-out pin widget */
818         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
819
820         /* Mute capture amp left and right */
821         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
822         /* Set ADC connection select to match default mixer setting (mic1
823          * pin)
824          */
825         {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
826
827         /* Do the same for the second ADC: mute capture input amp and
828          * set ADC connection to mic1 pin
829          */
830         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
831         {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
832
833         /* Mute all inputs to mixer widget (even unconnected ones) */
834         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
835         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
836         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
837         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
838         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
839         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
840         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
841         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
842
843         { }
844 };
845 #endif
846
847 /*
848  * ALC260 configurations
849  */
850 static const char * const alc260_models[ALC260_MODEL_LAST] = {
851         [ALC260_BASIC]          = "basic",
852         [ALC260_FUJITSU_S702X]  = "fujitsu",
853         [ALC260_ACER]           = "acer",
854         [ALC260_WILL]           = "will",
855         [ALC260_REPLACER_672V]  = "replacer",
856         [ALC260_FAVORIT100]     = "favorit100",
857 #ifdef CONFIG_SND_DEBUG
858         [ALC260_TEST]           = "test",
859 #endif
860         [ALC260_AUTO]           = "auto",
861 };
862
863 static const struct snd_pci_quirk alc260_cfg_tbl[] = {
864         SND_PCI_QUIRK(0x1025, 0x007b, "Acer C20x", ALC260_ACER),
865         SND_PCI_QUIRK(0x1025, 0x007f, "Acer", ALC260_WILL),
866         SND_PCI_QUIRK(0x1025, 0x008f, "Acer", ALC260_ACER),
867         SND_PCI_QUIRK(0x1509, 0x4540, "Favorit 100XS", ALC260_FAVORIT100),
868         SND_PCI_QUIRK(0x104d, 0x81bb, "Sony VAIO", ALC260_BASIC),
869         SND_PCI_QUIRK(0x104d, 0x81cc, "Sony VAIO", ALC260_BASIC),
870         SND_PCI_QUIRK(0x104d, 0x81cd, "Sony VAIO", ALC260_BASIC),
871         SND_PCI_QUIRK(0x10cf, 0x1326, "Fujitsu S702X", ALC260_FUJITSU_S702X),
872         SND_PCI_QUIRK(0x152d, 0x0729, "CTL U553W", ALC260_BASIC),
873         SND_PCI_QUIRK(0x161f, 0x2057, "Replacer 672V", ALC260_REPLACER_672V),
874         SND_PCI_QUIRK(0x1631, 0xc017, "PB V7900", ALC260_WILL),
875         {}
876 };
877
878 static const struct alc_config_preset alc260_presets[] = {
879         [ALC260_BASIC] = {
880                 .mixers = { alc260_base_output_mixer,
881                             alc260_input_mixer },
882                 .init_verbs = { alc260_init_verbs },
883                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
884                 .dac_nids = alc260_dac_nids,
885                 .num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids),
886                 .adc_nids = alc260_dual_adc_nids,
887                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
888                 .channel_mode = alc260_modes,
889                 .input_mux = &alc260_capture_source,
890         },
891         [ALC260_FUJITSU_S702X] = {
892                 .mixers = { alc260_fujitsu_mixer },
893                 .init_verbs = { alc260_fujitsu_init_verbs },
894                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
895                 .dac_nids = alc260_dac_nids,
896                 .num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids),
897                 .adc_nids = alc260_dual_adc_nids,
898                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
899                 .channel_mode = alc260_modes,
900                 .num_mux_defs = ARRAY_SIZE(alc260_fujitsu_capture_sources),
901                 .input_mux = alc260_fujitsu_capture_sources,
902         },
903         [ALC260_ACER] = {
904                 .mixers = { alc260_acer_mixer },
905                 .init_verbs = { alc260_acer_init_verbs },
906                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
907                 .dac_nids = alc260_dac_nids,
908                 .num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids),
909                 .adc_nids = alc260_dual_adc_nids,
910                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
911                 .channel_mode = alc260_modes,
912                 .num_mux_defs = ARRAY_SIZE(alc260_acer_capture_sources),
913                 .input_mux = alc260_acer_capture_sources,
914         },
915         [ALC260_FAVORIT100] = {
916                 .mixers = { alc260_favorit100_mixer },
917                 .init_verbs = { alc260_favorit100_init_verbs },
918                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
919                 .dac_nids = alc260_dac_nids,
920                 .num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids),
921                 .adc_nids = alc260_dual_adc_nids,
922                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
923                 .channel_mode = alc260_modes,
924                 .num_mux_defs = ARRAY_SIZE(alc260_favorit100_capture_sources),
925                 .input_mux = alc260_favorit100_capture_sources,
926         },
927         [ALC260_WILL] = {
928                 .mixers = { alc260_will_mixer },
929                 .init_verbs = { alc260_init_verbs, alc260_will_verbs },
930                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
931                 .dac_nids = alc260_dac_nids,
932                 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids),
933                 .adc_nids = alc260_adc_nids,
934                 .dig_out_nid = ALC260_DIGOUT_NID,
935                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
936                 .channel_mode = alc260_modes,
937                 .input_mux = &alc260_capture_source,
938         },
939         [ALC260_REPLACER_672V] = {
940                 .mixers = { alc260_replacer_672v_mixer },
941                 .init_verbs = { alc260_init_verbs, alc260_replacer_672v_verbs },
942                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
943                 .dac_nids = alc260_dac_nids,
944                 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids),
945                 .adc_nids = alc260_adc_nids,
946                 .dig_out_nid = ALC260_DIGOUT_NID,
947                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
948                 .channel_mode = alc260_modes,
949                 .input_mux = &alc260_capture_source,
950                 .unsol_event = alc260_replacer_672v_unsol_event,
951                 .init_hook = alc260_replacer_672v_automute,
952         },
953 #ifdef CONFIG_SND_DEBUG
954         [ALC260_TEST] = {
955                 .mixers = { alc260_test_mixer },
956                 .init_verbs = { alc260_test_init_verbs },
957                 .num_dacs = ARRAY_SIZE(alc260_test_dac_nids),
958                 .dac_nids = alc260_test_dac_nids,
959                 .num_adc_nids = ARRAY_SIZE(alc260_test_adc_nids),
960                 .adc_nids = alc260_test_adc_nids,
961                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
962                 .channel_mode = alc260_modes,
963                 .num_mux_defs = ARRAY_SIZE(alc260_test_capture_sources),
964                 .input_mux = alc260_test_capture_sources,
965         },
966 #endif
967 };
968