projects / deliverable / linux.git / blob
? search:


5d7f6198200157bba1964d6dbf252c5badeb496e
[deliverable/linux.git] / sound / pci / hda / patch_realtek.c
1 /*
2 * Universal Interface for Intel High Definition Audio Codec
3 *
4 * HD audio interface patch for ALC 260/880/882 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 <sound/driver.h>
27 #include <linux/init.h>
28 #include <linux/delay.h>
29 #include <linux/slab.h>
30 #include <linux/pci.h>
31 #include <sound/core.h>
32 #include "hda_codec.h"
33 #include "hda_local.h"
34
35 #define ALC880_FRONT_EVENT 0x01
36 #define ALC880_DCVOL_EVENT 0x02
37 #define ALC880_HP_EVENT 0x04
38 #define ALC880_MIC_EVENT 0x08
39
40 /* ALC880 board config type */
41 enum {
42 ALC880_3ST,
43 ALC880_3ST_DIG,
44 ALC880_5ST,
45 ALC880_5ST_DIG,
46 ALC880_W810,
47 ALC880_Z71V,
48 ALC880_6ST,
49 ALC880_6ST_DIG,
50 ALC880_F1734,
51 ALC880_ASUS,
52 ALC880_ASUS_DIG,
53 ALC880_ASUS_W1V,
54 ALC880_ASUS_DIG2,
55 ALC880_FUJITSU,
56 ALC880_UNIWILL_DIG,
57 ALC880_UNIWILL,
58 ALC880_UNIWILL_P53,
59 ALC880_CLEVO,
60 ALC880_TCL_S700,
61 ALC880_LG,
62 ALC880_LG_LW,
63 #ifdef CONFIG_SND_DEBUG
64 ALC880_TEST,
65 #endif
66 ALC880_AUTO,
67 ALC880_MODEL_LAST /* last tag */
68 };
69
70 /* ALC260 models */
71 enum {
72 ALC260_BASIC,
73 ALC260_HP,
74 ALC260_HP_3013,
75 ALC260_FUJITSU_S702X,
76 ALC260_ACER,
77 ALC260_WILL,
78 ALC260_REPLACER_672V,
79 #ifdef CONFIG_SND_DEBUG
80 ALC260_TEST,
81 #endif
82 ALC260_AUTO,
83 ALC260_MODEL_LAST /* last tag */
84 };
85
86 /* ALC262 models */
87 enum {
88 ALC262_BASIC,
89 ALC262_HIPPO,
90 ALC262_HIPPO_1,
91 ALC262_FUJITSU,
92 ALC262_HP_BPC,
93 ALC262_HP_BPC_D7000_WL,
94 ALC262_HP_BPC_D7000_WF,
95 ALC262_BENQ_ED8,
96 ALC262_AUTO,
97 ALC262_MODEL_LAST /* last tag */
98 };
99
100 /* ALC861 models */
101 enum {
102 ALC861_3ST,
103 ALC660_3ST,
104 ALC861_3ST_DIG,
105 ALC861_6ST_DIG,
106 ALC861_UNIWILL_M31,
107 ALC861_TOSHIBA,
108 ALC861_ASUS,
109 ALC861_ASUS_LAPTOP,
110 ALC861_AUTO,
111 ALC861_MODEL_LAST,
112 };
113
114 /* ALC861-VD models */
115 enum {
116 ALC660VD_3ST,
117 ALC861VD_3ST,
118 ALC861VD_3ST_DIG,
119 ALC861VD_6ST_DIG,
120 ALC861VD_AUTO,
121 ALC861VD_MODEL_LAST,
122 };
123
124 /* ALC662 models */
125 enum {
126 ALC662_3ST_2ch_DIG,
127 ALC662_3ST_6ch_DIG,
128 ALC662_3ST_6ch,
129 ALC662_5ST_DIG,
130 ALC662_LENOVO_101E,
131 ALC662_AUTO,
132 ALC662_MODEL_LAST,
133 };
134
135 /* ALC882 models */
136 enum {
137 ALC882_3ST_DIG,
138 ALC882_6ST_DIG,
139 ALC882_ARIMA,
140 ALC882_AUTO,
141 ALC885_MACPRO,
142 ALC882_MODEL_LAST,
143 };
144
145 /* ALC883 models */
146 enum {
147 ALC883_3ST_2ch_DIG,
148 ALC883_3ST_6ch_DIG,
149 ALC883_3ST_6ch,
150 ALC883_6ST_DIG,
151 ALC883_TARGA_DIG,
152 ALC883_TARGA_2ch_DIG,
153 ALC888_DEMO_BOARD,
154 ALC883_ACER,
155 ALC883_MEDION,
156 ALC883_LAPTOP_EAPD,
157 ALC883_LENOVO_101E_2ch,
158 ALC883_AUTO,
159 ALC883_MODEL_LAST,
160 };
161
162 /* for GPIO Poll */
163 #define GPIO_MASK 0x03
164
165 struct alc_spec {
166 /* codec parameterization */
167 struct snd_kcontrol_new *mixers[5]; /* mixer arrays */
168 unsigned int num_mixers;
169
170 const struct hda_verb *init_verbs[5]; /* initialization verbs
171 * don't forget NULL
172 * termination!
173 */
174 unsigned int num_init_verbs;
175
176 char *stream_name_analog; /* analog PCM stream */
177 struct hda_pcm_stream *stream_analog_playback;
178 struct hda_pcm_stream *stream_analog_capture;
179
180 char *stream_name_digital; /* digital PCM stream */
181 struct hda_pcm_stream *stream_digital_playback;
182 struct hda_pcm_stream *stream_digital_capture;
183
184 /* playback */
185 struct hda_multi_out multiout; /* playback set-up
186 * max_channels, dacs must be set
187 * dig_out_nid and hp_nid are optional
188 */
189
190 /* capture */
191 unsigned int num_adc_nids;
192 hda_nid_t *adc_nids;
193 hda_nid_t dig_in_nid; /* digital-in NID; optional */
194
195 /* capture source */
196 unsigned int num_mux_defs;
197 const struct hda_input_mux *input_mux;
198 unsigned int cur_mux[3];
199
200 /* channel model */
201 const struct hda_channel_mode *channel_mode;
202 int num_channel_mode;
203 int need_dac_fix;
204
205 /* PCM information */
206 struct hda_pcm pcm_rec[3]; /* used in alc_build_pcms() */
207
208 /* dynamic controls, init_verbs and input_mux */
209 struct auto_pin_cfg autocfg;
210 unsigned int num_kctl_alloc, num_kctl_used;
211 struct snd_kcontrol_new *kctl_alloc;
212 struct hda_input_mux private_imux;
213 hda_nid_t private_dac_nids[5];
214
215 /* hooks */
216 void (*init_hook)(struct hda_codec *codec);
217 void (*unsol_event)(struct hda_codec *codec, unsigned int res);
218
219 /* for pin sensing */
220 unsigned int sense_updated: 1;
221 unsigned int jack_present: 1;
222 };
223
224 /*
225 * configuration template - to be copied to the spec instance
226 */
227 struct alc_config_preset {
228 struct snd_kcontrol_new *mixers[5]; /* should be identical size
229 * with spec
230 */
231 const struct hda_verb *init_verbs[5];
232 unsigned int num_dacs;
233 hda_nid_t *dac_nids;
234 hda_nid_t dig_out_nid; /* optional */
235 hda_nid_t hp_nid; /* optional */
236 unsigned int num_adc_nids;
237 hda_nid_t *adc_nids;
238 hda_nid_t dig_in_nid;
239 unsigned int num_channel_mode;
240 const struct hda_channel_mode *channel_mode;
241 int need_dac_fix;
242 unsigned int num_mux_defs;
243 const struct hda_input_mux *input_mux;
244 void (*unsol_event)(struct hda_codec *, unsigned int);
245 void (*init_hook)(struct hda_codec *);
246 };
247
248
249 /*
250 * input MUX handling
251 */
252 static int alc_mux_enum_info(struct snd_kcontrol *kcontrol,
253 struct snd_ctl_elem_info *uinfo)
254 {
255 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
256 struct alc_spec *spec = codec->spec;
257 unsigned int mux_idx = snd_ctl_get_ioffidx(kcontrol, &uinfo->id);
258 if (mux_idx >= spec->num_mux_defs)
259 mux_idx = 0;
260 return snd_hda_input_mux_info(&spec->input_mux[mux_idx], uinfo);
261 }
262
263 static int alc_mux_enum_get(struct snd_kcontrol *kcontrol,
264 struct snd_ctl_elem_value *ucontrol)
265 {
266 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
267 struct alc_spec *spec = codec->spec;
268 unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
269
270 ucontrol->value.enumerated.item[0] = spec->cur_mux[adc_idx];
271 return 0;
272 }
273
274 static int alc_mux_enum_put(struct snd_kcontrol *kcontrol,
275 struct snd_ctl_elem_value *ucontrol)
276 {
277 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
278 struct alc_spec *spec = codec->spec;
279 unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
280 unsigned int mux_idx = adc_idx >= spec->num_mux_defs ? 0 : adc_idx;
281 return snd_hda_input_mux_put(codec, &spec->input_mux[mux_idx], ucontrol,
282 spec->adc_nids[adc_idx],
283 &spec->cur_mux[adc_idx]);
284 }
285
286
287 /*
288 * channel mode setting
289 */
290 static int alc_ch_mode_info(struct snd_kcontrol *kcontrol,
291 struct snd_ctl_elem_info *uinfo)
292 {
293 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
294 struct alc_spec *spec = codec->spec;
295 return snd_hda_ch_mode_info(codec, uinfo, spec->channel_mode,
296 spec->num_channel_mode);
297 }
298
299 static int alc_ch_mode_get(struct snd_kcontrol *kcontrol,
300 struct snd_ctl_elem_value *ucontrol)
301 {
302 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
303 struct alc_spec *spec = codec->spec;
304 return snd_hda_ch_mode_get(codec, ucontrol, spec->channel_mode,
305 spec->num_channel_mode,
306 spec->multiout.max_channels);
307 }
308
309 static int alc_ch_mode_put(struct snd_kcontrol *kcontrol,
310 struct snd_ctl_elem_value *ucontrol)
311 {
312 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
313 struct alc_spec *spec = codec->spec;
314 int err = snd_hda_ch_mode_put(codec, ucontrol, spec->channel_mode,
315 spec->num_channel_mode,
316 &spec->multiout.max_channels);
317 if (err >= 0 && spec->need_dac_fix)
318 spec->multiout.num_dacs = spec->multiout.max_channels / 2;
319 return err;
320 }
321
322 /*
323 * Control the mode of pin widget settings via the mixer. "pc" is used
324 * instead of "%" to avoid consequences of accidently treating the % as
325 * being part of a format specifier. Maximum allowed length of a value is
326 * 63 characters plus NULL terminator.
327 *
328 * Note: some retasking pin complexes seem to ignore requests for input
329 * states other than HiZ (eg: PIN_VREFxx) and revert to HiZ if any of these
330 * are requested. Therefore order this list so that this behaviour will not
331 * cause problems when mixer clients move through the enum sequentially.
332 * NIDs 0x0f and 0x10 have been observed to have this behaviour as of
333 * March 2006.
334 */
335 static char *alc_pin_mode_names[] = {
336 "Mic 50pc bias", "Mic 80pc bias",
337 "Line in", "Line out", "Headphone out",
338 };
339 static unsigned char alc_pin_mode_values[] = {
340 PIN_VREF50, PIN_VREF80, PIN_IN, PIN_OUT, PIN_HP,
341 };
342 /* The control can present all 5 options, or it can limit the options based
343 * in the pin being assumed to be exclusively an input or an output pin. In
344 * addition, "input" pins may or may not process the mic bias option
345 * depending on actual widget capability (NIDs 0x0f and 0x10 don't seem to
346 * accept requests for bias as of chip versions up to March 2006) and/or
347 * wiring in the computer.
348 */
349 #define ALC_PIN_DIR_IN 0x00
350 #define ALC_PIN_DIR_OUT 0x01
351 #define ALC_PIN_DIR_INOUT 0x02
352 #define ALC_PIN_DIR_IN_NOMICBIAS 0x03
353 #define ALC_PIN_DIR_INOUT_NOMICBIAS 0x04
354
355 /* Info about the pin modes supported by the different pin direction modes.
356 * For each direction the minimum and maximum values are given.
357 */
358 static signed char alc_pin_mode_dir_info[5][2] = {
359 { 0, 2 }, /* ALC_PIN_DIR_IN */
360 { 3, 4 }, /* ALC_PIN_DIR_OUT */
361 { 0, 4 }, /* ALC_PIN_DIR_INOUT */
362 { 2, 2 }, /* ALC_PIN_DIR_IN_NOMICBIAS */
363 { 2, 4 }, /* ALC_PIN_DIR_INOUT_NOMICBIAS */
364 };
365 #define alc_pin_mode_min(_dir) (alc_pin_mode_dir_info[_dir][0])
366 #define alc_pin_mode_max(_dir) (alc_pin_mode_dir_info[_dir][1])
367 #define alc_pin_mode_n_items(_dir) \
368 (alc_pin_mode_max(_dir)-alc_pin_mode_min(_dir)+1)
369
370 static int alc_pin_mode_info(struct snd_kcontrol *kcontrol,
371 struct snd_ctl_elem_info *uinfo)
372 {
373 unsigned int item_num = uinfo->value.enumerated.item;
374 unsigned char dir = (kcontrol->private_value >> 16) & 0xff;
375
376 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
377 uinfo->count = 1;
378 uinfo->value.enumerated.items = alc_pin_mode_n_items(dir);
379
380 if (item_num<alc_pin_mode_min(dir) || item_num>alc_pin_mode_max(dir))
381 item_num = alc_pin_mode_min(dir);
382 strcpy(uinfo->value.enumerated.name, alc_pin_mode_names[item_num]);
383 return 0;
384 }
385
386 static int alc_pin_mode_get(struct snd_kcontrol *kcontrol,
387 struct snd_ctl_elem_value *ucontrol)
388 {
389 unsigned int i;
390 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
391 hda_nid_t nid = kcontrol->private_value & 0xffff;
392 unsigned char dir = (kcontrol->private_value >> 16) & 0xff;
393 long *valp = ucontrol->value.integer.value;
394 unsigned int pinctl = snd_hda_codec_read(codec, nid, 0,
395 AC_VERB_GET_PIN_WIDGET_CONTROL,
396 0x00);
397
398 /* Find enumerated value for current pinctl setting */
399 i = alc_pin_mode_min(dir);
400 while (alc_pin_mode_values[i] != pinctl && i <= alc_pin_mode_max(dir))
401 i++;
402 *valp = i <= alc_pin_mode_max(dir) ? i: alc_pin_mode_min(dir);
403 return 0;
404 }
405
406 static int alc_pin_mode_put(struct snd_kcontrol *kcontrol,
407 struct snd_ctl_elem_value *ucontrol)
408 {
409 signed int change;
410 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
411 hda_nid_t nid = kcontrol->private_value & 0xffff;
412 unsigned char dir = (kcontrol->private_value >> 16) & 0xff;
413 long val = *ucontrol->value.integer.value;
414 unsigned int pinctl = snd_hda_codec_read(codec, nid, 0,
415 AC_VERB_GET_PIN_WIDGET_CONTROL,
416 0x00);
417
418 if (val < alc_pin_mode_min(dir) || val > alc_pin_mode_max(dir))
419 val = alc_pin_mode_min(dir);
420
421 change = pinctl != alc_pin_mode_values[val];
422 if (change) {
423 /* Set pin mode to that requested */
424 snd_hda_codec_write(codec,nid,0,AC_VERB_SET_PIN_WIDGET_CONTROL,
425 alc_pin_mode_values[val]);
426
427 /* Also enable the retasking pin's input/output as required
428 * for the requested pin mode. Enum values of 2 or less are
429 * input modes.
430 *
431 * Dynamically switching the input/output buffers probably
432 * reduces noise slightly (particularly on input) so we'll
433 * do it. However, having both input and output buffers
434 * enabled simultaneously doesn't seem to be problematic if
435 * this turns out to be necessary in the future.
436 */
437 if (val <= 2) {
438 snd_hda_codec_write(codec, nid, 0,
439 AC_VERB_SET_AMP_GAIN_MUTE,
440 AMP_OUT_MUTE);
441 snd_hda_codec_write(codec, nid, 0,
442 AC_VERB_SET_AMP_GAIN_MUTE,
443 AMP_IN_UNMUTE(0));
444 } else {
445 snd_hda_codec_write(codec, nid, 0,
446 AC_VERB_SET_AMP_GAIN_MUTE,
447 AMP_IN_MUTE(0));
448 snd_hda_codec_write(codec, nid, 0,
449 AC_VERB_SET_AMP_GAIN_MUTE,
450 AMP_OUT_UNMUTE);
451 }
452 }
453 return change;
454 }
455
456 #define ALC_PIN_MODE(xname, nid, dir) \
457 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0, \
458 .info = alc_pin_mode_info, \
459 .get = alc_pin_mode_get, \
460 .put = alc_pin_mode_put, \
461 .private_value = nid | (dir<<16) }
462
463 /* A switch control for ALC260 GPIO pins. Multiple GPIOs can be ganged
464 * together using a mask with more than one bit set. This control is
465 * currently used only by the ALC260 test model. At this stage they are not
466 * needed for any "production" models.
467 */
468 #ifdef CONFIG_SND_DEBUG
469 static int alc_gpio_data_info(struct snd_kcontrol *kcontrol,
470 struct snd_ctl_elem_info *uinfo)
471 {
472 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
473 uinfo->count = 1;
474 uinfo->value.integer.min = 0;
475 uinfo->value.integer.max = 1;
476 return 0;
477 }
478 static int alc_gpio_data_get(struct snd_kcontrol *kcontrol,
479 struct snd_ctl_elem_value *ucontrol)
480 {
481 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
482 hda_nid_t nid = kcontrol->private_value & 0xffff;
483 unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
484 long *valp = ucontrol->value.integer.value;
485 unsigned int val = snd_hda_codec_read(codec, nid, 0,
486 AC_VERB_GET_GPIO_DATA, 0x00);
487
488 *valp = (val & mask) != 0;
489 return 0;
490 }
491 static int alc_gpio_data_put(struct snd_kcontrol *kcontrol,
492 struct snd_ctl_elem_value *ucontrol)
493 {
494 signed int change;
495 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
496 hda_nid_t nid = kcontrol->private_value & 0xffff;
497 unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
498 long val = *ucontrol->value.integer.value;
499 unsigned int gpio_data = snd_hda_codec_read(codec, nid, 0,
500 AC_VERB_GET_GPIO_DATA,
501 0x00);
502
503 /* Set/unset the masked GPIO bit(s) as needed */
504 change = (val == 0 ? 0 : mask) != (gpio_data & mask);
505 if (val == 0)
506 gpio_data &= ~mask;
507 else
508 gpio_data |= mask;
509 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_GPIO_DATA, gpio_data);
510
511 return change;
512 }
513 #define ALC_GPIO_DATA_SWITCH(xname, nid, mask) \
514 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0, \
515 .info = alc_gpio_data_info, \
516 .get = alc_gpio_data_get, \
517 .put = alc_gpio_data_put, \
518 .private_value = nid | (mask<<16) }
519 #endif /* CONFIG_SND_DEBUG */
520
521 /* A switch control to allow the enabling of the digital IO pins on the
522 * ALC260. This is incredibly simplistic; the intention of this control is
523 * to provide something in the test model allowing digital outputs to be
524 * identified if present. If models are found which can utilise these
525 * outputs a more complete mixer control can be devised for those models if
526 * necessary.
527 */
528 #ifdef CONFIG_SND_DEBUG
529 static int alc_spdif_ctrl_info(struct snd_kcontrol *kcontrol,
530 struct snd_ctl_elem_info *uinfo)
531 {
532 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
533 uinfo->count = 1;
534 uinfo->value.integer.min = 0;
535 uinfo->value.integer.max = 1;
536 return 0;
537 }
538 static int alc_spdif_ctrl_get(struct snd_kcontrol *kcontrol,
539 struct snd_ctl_elem_value *ucontrol)
540 {
541 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
542 hda_nid_t nid = kcontrol->private_value & 0xffff;
543 unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
544 long *valp = ucontrol->value.integer.value;
545 unsigned int val = snd_hda_codec_read(codec, nid, 0,
546 AC_VERB_GET_DIGI_CONVERT, 0x00);
547
548 *valp = (val & mask) != 0;
549 return 0;
550 }
551 static int alc_spdif_ctrl_put(struct snd_kcontrol *kcontrol,
552 struct snd_ctl_elem_value *ucontrol)
553 {
554 signed int change;
555 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
556 hda_nid_t nid = kcontrol->private_value & 0xffff;
557 unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
558 long val = *ucontrol->value.integer.value;
559 unsigned int ctrl_data = snd_hda_codec_read(codec, nid, 0,
560 AC_VERB_GET_DIGI_CONVERT,
561 0x00);
562
563 /* Set/unset the masked control bit(s) as needed */
564 change = (val == 0 ? 0 : mask) != (ctrl_data & mask);
565 if (val==0)
566 ctrl_data &= ~mask;
567 else
568 ctrl_data |= mask;
569 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_DIGI_CONVERT_1,
570 ctrl_data);
571
572 return change;
573 }
574 #define ALC_SPDIF_CTRL_SWITCH(xname, nid, mask) \
575 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0, \
576 .info = alc_spdif_ctrl_info, \
577 .get = alc_spdif_ctrl_get, \
578 .put = alc_spdif_ctrl_put, \
579 .private_value = nid | (mask<<16) }
580 #endif /* CONFIG_SND_DEBUG */
581
582 /*
583 * set up from the preset table
584 */
585 static void setup_preset(struct alc_spec *spec,
586 const struct alc_config_preset *preset)
587 {
588 int i;
589
590 for (i = 0; i < ARRAY_SIZE(preset->mixers) && preset->mixers[i]; i++)
591 spec->mixers[spec->num_mixers++] = preset->mixers[i];
592 for (i = 0; i < ARRAY_SIZE(preset->init_verbs) && preset->init_verbs[i];
593 i++)
594 spec->init_verbs[spec->num_init_verbs++] =
595 preset->init_verbs[i];
596
597 spec->channel_mode = preset->channel_mode;
598 spec->num_channel_mode = preset->num_channel_mode;
599 spec->need_dac_fix = preset->need_dac_fix;
600
601 spec->multiout.max_channels = spec->channel_mode[0].channels;
602
603 spec->multiout.num_dacs = preset->num_dacs;
604 spec->multiout.dac_nids = preset->dac_nids;
605 spec->multiout.dig_out_nid = preset->dig_out_nid;
606 spec->multiout.hp_nid = preset->hp_nid;
607
608 spec->num_mux_defs = preset->num_mux_defs;
609 if (! spec->num_mux_defs)
610 spec->num_mux_defs = 1;
611 spec->input_mux = preset->input_mux;
612
613 spec->num_adc_nids = preset->num_adc_nids;
614 spec->adc_nids = preset->adc_nids;
615 spec->dig_in_nid = preset->dig_in_nid;
616
617 spec->unsol_event = preset->unsol_event;
618 spec->init_hook = preset->init_hook;
619 }
620
621 /* Enable GPIO mask and set output */
622 static struct hda_verb alc_gpio1_init_verbs[] = {
623 {0x01, AC_VERB_SET_GPIO_MASK, 0x01},
624 {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
625 {0x01, AC_VERB_SET_GPIO_DATA, 0x01},
626 { }
627 };
628
629 static struct hda_verb alc_gpio2_init_verbs[] = {
630 {0x01, AC_VERB_SET_GPIO_MASK, 0x02},
631 {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x02},
632 {0x01, AC_VERB_SET_GPIO_DATA, 0x02},
633 { }
634 };
635
636 /* 32-bit subsystem ID for BIOS loading in HD Audio codec.
637 * 31 ~ 16 : Manufacture ID
638 * 15 ~ 8 : SKU ID
639 * 7 ~ 0 : Assembly ID
640 * port-A --> pin 39/41, port-E --> pin 14/15, port-D --> pin 35/36
641 */
642 static void alc_subsystem_id(struct hda_codec *codec,
643 unsigned int porta, unsigned int porte,
644 unsigned int portd)
645 {
646 unsigned int ass, tmp;
647
648 ass = codec->subsystem_id;
649 if (!(ass & 1))
650 return;
651
652 /* Override */
653 tmp = (ass & 0x38) >> 3; /* external Amp control */
654 switch (tmp) {
655 case 1:
656 snd_hda_sequence_write(codec, alc_gpio1_init_verbs);
657 break;
658 case 3:
659 snd_hda_sequence_write(codec, alc_gpio2_init_verbs);
660 break;
661 case 5:
662 case 6:
663 if (ass & 4) { /* bit 2 : 0 = Desktop, 1 = Laptop */
664 hda_nid_t port = 0;
665 tmp = (ass & 0x1800) >> 11;
666 switch (tmp) {
667 case 0: port = porta; break;
668 case 1: port = porte; break;
669 case 2: port = portd; break;
670 }
671 if (port)
672 snd_hda_codec_write(codec, port, 0,
673 AC_VERB_SET_EAPD_BTLENABLE,
674 2);
675 }
676 snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_COEF_INDEX, 7);
677 snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_PROC_COEF,
678 (tmp == 5 ? 0x3040 : 0x3050));
679 break;
680 }
681 }
682
683 /*
684 * ALC880 3-stack model
685 *
686 * DAC: Front = 0x02 (0x0c), Surr = 0x05 (0x0f), CLFE = 0x04 (0x0e)
687 * Pin assignment: Front = 0x14, Line-In/Surr = 0x1a, Mic/CLFE = 0x18,
688 * F-Mic = 0x1b, HP = 0x19
689 */
690
691 static hda_nid_t alc880_dac_nids[4] = {
692 /* front, rear, clfe, rear_surr */
693 0x02, 0x05, 0x04, 0x03
694 };
695
696 static hda_nid_t alc880_adc_nids[3] = {
697 /* ADC0-2 */
698 0x07, 0x08, 0x09,
699 };
700
701 /* The datasheet says the node 0x07 is connected from inputs,
702 * but it shows zero connection in the real implementation on some devices.
703 * Note: this is a 915GAV bug, fixed on 915GLV
704 */
705 static hda_nid_t alc880_adc_nids_alt[2] = {
706 /* ADC1-2 */
707 0x08, 0x09,
708 };
709
710 #define ALC880_DIGOUT_NID 0x06
711 #define ALC880_DIGIN_NID 0x0a
712
713 static struct hda_input_mux alc880_capture_source = {
714 .num_items = 4,
715 .items = {
716 { "Mic", 0x0 },
717 { "Front Mic", 0x3 },
718 { "Line", 0x2 },
719 { "CD", 0x4 },
720 },
721 };
722
723 /* channel source setting (2/6 channel selection for 3-stack) */
724 /* 2ch mode */
725 static struct hda_verb alc880_threestack_ch2_init[] = {
726 /* set line-in to input, mute it */
727 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
728 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
729 /* set mic-in to input vref 80%, mute it */
730 { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
731 { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
732 { } /* end */
733 };
734
735 /* 6ch mode */
736 static struct hda_verb alc880_threestack_ch6_init[] = {
737 /* set line-in to output, unmute it */
738 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
739 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
740 /* set mic-in to output, unmute it */
741 { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
742 { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
743 { } /* end */
744 };
745
746 static struct hda_channel_mode alc880_threestack_modes[2] = {
747 { 2, alc880_threestack_ch2_init },
748 { 6, alc880_threestack_ch6_init },
749 };
750
751 static struct snd_kcontrol_new alc880_three_stack_mixer[] = {
752 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
753 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
754 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
755 HDA_BIND_MUTE("Surround Playback Switch", 0x0f, 2, HDA_INPUT),
756 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
757 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
758 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
759 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
760 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
761 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
762 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
763 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
764 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
765 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
766 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x3, HDA_INPUT),
767 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x3, HDA_INPUT),
768 HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
769 HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
770 HDA_CODEC_MUTE("Headphone Playback Switch", 0x19, 0x0, HDA_OUTPUT),
771 {
772 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
773 .name = "Channel Mode",
774 .info = alc_ch_mode_info,
775 .get = alc_ch_mode_get,
776 .put = alc_ch_mode_put,
777 },
778 { } /* end */
779 };
780
781 /* capture mixer elements */
782 static struct snd_kcontrol_new alc880_capture_mixer[] = {
783 HDA_CODEC_VOLUME("Capture Volume", 0x07, 0x0, HDA_INPUT),
784 HDA_CODEC_MUTE("Capture Switch", 0x07, 0x0, HDA_INPUT),
785 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x08, 0x0, HDA_INPUT),
786 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x08, 0x0, HDA_INPUT),
787 HDA_CODEC_VOLUME_IDX("Capture Volume", 2, 0x09, 0x0, HDA_INPUT),
788 HDA_CODEC_MUTE_IDX("Capture Switch", 2, 0x09, 0x0, HDA_INPUT),
789 {
790 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
791 /* The multiple "Capture Source" controls confuse alsamixer
792 * So call somewhat different..
793 * FIXME: the controls appear in the "playback" view!
794 */
795 /* .name = "Capture Source", */
796 .name = "Input Source",
797 .count = 3,
798 .info = alc_mux_enum_info,
799 .get = alc_mux_enum_get,
800 .put = alc_mux_enum_put,
801 },
802 { } /* end */
803 };
804
805 /* capture mixer elements (in case NID 0x07 not available) */
806 static struct snd_kcontrol_new alc880_capture_alt_mixer[] = {
807 HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
808 HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
809 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT),
810 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT),
811 {
812 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
813 /* The multiple "Capture Source" controls confuse alsamixer
814 * So call somewhat different..
815 * FIXME: the controls appear in the "playback" view!
816 */
817 /* .name = "Capture Source", */
818 .name = "Input Source",
819 .count = 2,
820 .info = alc_mux_enum_info,
821 .get = alc_mux_enum_get,
822 .put = alc_mux_enum_put,
823 },
824 { } /* end */
825 };
826
827
828
829 /*
830 * ALC880 5-stack model
831 *
832 * DAC: Front = 0x02 (0x0c), Surr = 0x05 (0x0f), CLFE = 0x04 (0x0d),
833 * Side = 0x02 (0xd)
834 * Pin assignment: Front = 0x14, Surr = 0x17, CLFE = 0x16
835 * Line-In/Side = 0x1a, Mic = 0x18, F-Mic = 0x1b, HP = 0x19
836 */
837
838 /* additional mixers to alc880_three_stack_mixer */
839 static struct snd_kcontrol_new alc880_five_stack_mixer[] = {
840 HDA_CODEC_VOLUME("Side Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
841 HDA_BIND_MUTE("Side Playback Switch", 0x0d, 2, HDA_INPUT),
842 { } /* end */
843 };
844
845 /* channel source setting (6/8 channel selection for 5-stack) */
846 /* 6ch mode */
847 static struct hda_verb alc880_fivestack_ch6_init[] = {
848 /* set line-in to input, mute it */
849 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
850 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
851 { } /* end */
852 };
853
854 /* 8ch mode */
855 static struct hda_verb alc880_fivestack_ch8_init[] = {
856 /* set line-in to output, unmute it */
857 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
858 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
859 { } /* end */
860 };
861
862 static struct hda_channel_mode alc880_fivestack_modes[2] = {
863 { 6, alc880_fivestack_ch6_init },
864 { 8, alc880_fivestack_ch8_init },
865 };
866
867
868 /*
869 * ALC880 6-stack model
870 *
871 * DAC: Front = 0x02 (0x0c), Surr = 0x03 (0x0d), CLFE = 0x04 (0x0e),
872 * Side = 0x05 (0x0f)
873 * Pin assignment: Front = 0x14, Surr = 0x15, CLFE = 0x16, Side = 0x17,
874 * Mic = 0x18, F-Mic = 0x19, Line = 0x1a, HP = 0x1b
875 */
876
877 static hda_nid_t alc880_6st_dac_nids[4] = {
878 /* front, rear, clfe, rear_surr */
879 0x02, 0x03, 0x04, 0x05
880 };
881
882 static struct hda_input_mux alc880_6stack_capture_source = {
883 .num_items = 4,
884 .items = {
885 { "Mic", 0x0 },
886 { "Front Mic", 0x1 },
887 { "Line", 0x2 },
888 { "CD", 0x4 },
889 },
890 };
891
892 /* fixed 8-channels */
893 static struct hda_channel_mode alc880_sixstack_modes[1] = {
894 { 8, NULL },
895 };
896
897 static struct snd_kcontrol_new alc880_six_stack_mixer[] = {
898 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
899 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
900 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
901 HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
902 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
903 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
904 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
905 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
906 HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
907 HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
908 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
909 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
910 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
911 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
912 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
913 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
914 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
915 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
916 HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
917 HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
918 {
919 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
920 .name = "Channel Mode",
921 .info = alc_ch_mode_info,
922 .get = alc_ch_mode_get,
923 .put = alc_ch_mode_put,
924 },
925 { } /* end */
926 };
927
928
929 /*
930 * ALC880 W810 model
931 *
932 * W810 has rear IO for:
933 * Front (DAC 02)
934 * Surround (DAC 03)
935 * Center/LFE (DAC 04)
936 * Digital out (06)
937 *
938 * The system also has a pair of internal speakers, and a headphone jack.
939 * These are both connected to Line2 on the codec, hence to DAC 02.
940 *
941 * There is a variable resistor to control the speaker or headphone
942 * volume. This is a hardware-only device without a software API.
943 *
944 * Plugging headphones in will disable the internal speakers. This is
945 * implemented in hardware, not via the driver using jack sense. In
946 * a similar fashion, plugging into the rear socket marked "front" will
947 * disable both the speakers and headphones.
948 *
949 * For input, there's a microphone jack, and an "audio in" jack.
950 * These may not do anything useful with this driver yet, because I
951 * haven't setup any initialization verbs for these yet...
952 */
953
954 static hda_nid_t alc880_w810_dac_nids[3] = {
955 /* front, rear/surround, clfe */
956 0x02, 0x03, 0x04
957 };
958
959 /* fixed 6 channels */
960 static struct hda_channel_mode alc880_w810_modes[1] = {
961 { 6, NULL }
962 };
963
964 /* Pin assignment: Front = 0x14, Surr = 0x15, CLFE = 0x16, HP = 0x1b */
965 static struct snd_kcontrol_new alc880_w810_base_mixer[] = {
966 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
967 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
968 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
969 HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
970 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
971 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
972 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
973 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
974 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
975 { } /* end */
976 };
977
978
979 /*
980 * Z710V model
981 *
982 * DAC: Front = 0x02 (0x0c), HP = 0x03 (0x0d)
983 * Pin assignment: Front = 0x14, HP = 0x15, Mic = 0x18, Mic2 = 0x19(?),
984 * Line = 0x1a
985 */
986
987 static hda_nid_t alc880_z71v_dac_nids[1] = {
988 0x02
989 };
990 #define ALC880_Z71V_HP_DAC 0x03
991
992 /* fixed 2 channels */
993 static struct hda_channel_mode alc880_2_jack_modes[1] = {
994 { 2, NULL }
995 };
996
997 static struct snd_kcontrol_new alc880_z71v_mixer[] = {
998 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
999 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
1000 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1001 HDA_BIND_MUTE("Headphone Playback Switch", 0x0d, 2, HDA_INPUT),
1002 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
1003 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
1004 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
1005 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
1006 { } /* end */
1007 };
1008
1009
1010 /* FIXME! */
1011 /*
1012 * ALC880 F1734 model
1013 *
1014 * DAC: HP = 0x02 (0x0c), Front = 0x03 (0x0d)
1015 * Pin assignment: HP = 0x14, Front = 0x15, Mic = 0x18
1016 */
1017
1018 static hda_nid_t alc880_f1734_dac_nids[1] = {
1019 0x03
1020 };
1021 #define ALC880_F1734_HP_DAC 0x02
1022
1023 static struct snd_kcontrol_new alc880_f1734_mixer[] = {
1024 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1025 HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
1026 HDA_CODEC_VOLUME("Internal Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1027 HDA_BIND_MUTE("Internal Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
1028 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
1029 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
1030 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
1031 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
1032 { } /* end */
1033 };
1034
1035
1036 /* FIXME! */
1037 /*
1038 * ALC880 ASUS model
1039 *
1040 * DAC: HP/Front = 0x02 (0x0c), Surr = 0x03 (0x0d), CLFE = 0x04 (0x0e)
1041 * Pin assignment: HP/Front = 0x14, Surr = 0x15, CLFE = 0x16,
1042 * Mic = 0x18, Line = 0x1a
1043 */
1044
1045 #define alc880_asus_dac_nids alc880_w810_dac_nids /* identical with w810 */
1046 #define alc880_asus_modes alc880_threestack_modes /* 2/6 channel mode */
1047
1048 static struct snd_kcontrol_new alc880_asus_mixer[] = {
1049 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1050 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
1051 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1052 HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
1053 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
1054 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
1055 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
1056 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
1057 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
1058 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
1059 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
1060 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
1061 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
1062 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
1063 {
1064 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1065 .name = "Channel Mode",
1066 .info = alc_ch_mode_info,
1067 .get = alc_ch_mode_get,
1068 .put = alc_ch_mode_put,
1069 },
1070 { } /* end */
1071 };
1072
1073 /* FIXME! */
1074 /*
1075 * ALC880 ASUS W1V model
1076 *
1077 * DAC: HP/Front = 0x02 (0x0c), Surr = 0x03 (0x0d), CLFE = 0x04 (0x0e)
1078 * Pin assignment: HP/Front = 0x14, Surr = 0x15, CLFE = 0x16,
1079 * Mic = 0x18, Line = 0x1a, Line2 = 0x1b
1080 */
1081
1082 /* additional mixers to alc880_asus_mixer */
1083 static struct snd_kcontrol_new alc880_asus_w1v_mixer[] = {
1084 HDA_CODEC_VOLUME("Line2 Playback Volume", 0x0b, 0x03, HDA_INPUT),
1085 HDA_CODEC_MUTE("Line2 Playback Switch", 0x0b, 0x03, HDA_INPUT),
1086 { } /* end */
1087 };
1088
1089 /* additional mixers to alc880_asus_mixer */
1090 static struct snd_kcontrol_new alc880_pcbeep_mixer[] = {
1091 HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
1092 HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
1093 { } /* end */
1094 };
1095
1096 /* TCL S700 */
1097 static struct snd_kcontrol_new alc880_tcl_s700_mixer[] = {
1098 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1099 HDA_CODEC_MUTE("Front Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
1100 HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
1101 HDA_CODEC_VOLUME("CD Playback Volume", 0x0B, 0x04, HDA_INPUT),
1102 HDA_CODEC_MUTE("CD Playback Switch", 0x0B, 0x04, HDA_INPUT),
1103 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0B, 0x0, HDA_INPUT),
1104 HDA_CODEC_MUTE("Mic Playback Switch", 0x0B, 0x0, HDA_INPUT),
1105 HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
1106 HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
1107 {
1108 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1109 /* The multiple "Capture Source" controls confuse alsamixer
1110 * So call somewhat different..
1111 * FIXME: the controls appear in the "playback" view!
1112 */
1113 /* .name = "Capture Source", */
1114 .name = "Input Source",
1115 .count = 1,
1116 .info = alc_mux_enum_info,
1117 .get = alc_mux_enum_get,
1118 .put = alc_mux_enum_put,
1119 },
1120 { } /* end */
1121 };
1122
1123 /* Uniwill */
1124 static struct snd_kcontrol_new alc880_uniwill_mixer[] = {
1125 HDA_CODEC_VOLUME("HPhone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1126 HDA_BIND_MUTE("HPhone Playback Switch", 0x0c, 2, HDA_INPUT),
1127 HDA_CODEC_VOLUME("iSpeaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1128 HDA_BIND_MUTE("iSpeaker Playback Switch", 0x0d, 2, HDA_INPUT),
1129 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
1130 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
1131 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
1132 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
1133 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
1134 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
1135 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
1136 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
1137 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
1138 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
1139 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
1140 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
1141 HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
1142 HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
1143 {
1144 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1145 .name = "Channel Mode",
1146 .info = alc_ch_mode_info,
1147 .get = alc_ch_mode_get,
1148 .put = alc_ch_mode_put,
1149 },
1150 { } /* end */
1151 };
1152
1153 static struct snd_kcontrol_new alc880_fujitsu_mixer[] = {
1154 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1155 HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
1156 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1157 HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
1158 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
1159 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
1160 HDA_CODEC_VOLUME("Ext Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
1161 HDA_CODEC_MUTE("Ext Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
1162 HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
1163 HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
1164 { } /* end */
1165 };
1166
1167 static struct snd_kcontrol_new alc880_uniwill_p53_mixer[] = {
1168 HDA_CODEC_VOLUME("HPhone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1169 HDA_BIND_MUTE("HPhone Playback Switch", 0x0c, 2, HDA_INPUT),
1170 HDA_CODEC_VOLUME("iSpeaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1171 HDA_BIND_MUTE("iSpeaker Playback Switch", 0x0d, 2, HDA_INPUT),
1172 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
1173 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
1174 { } /* end */
1175 };
1176
1177 /*
1178 * build control elements
1179 */
1180 static int alc_build_controls(struct hda_codec *codec)
1181 {
1182 struct alc_spec *spec = codec->spec;
1183 int err;
1184 int i;
1185
1186 for (i = 0; i < spec->num_mixers; i++) {
1187 err = snd_hda_add_new_ctls(codec, spec->mixers[i]);
1188 if (err < 0)
1189 return err;
1190 }
1191
1192 if (spec->multiout.dig_out_nid) {
1193 err = snd_hda_create_spdif_out_ctls(codec,
1194 spec->multiout.dig_out_nid);
1195 if (err < 0)
1196 return err;
1197 }
1198 if (spec->dig_in_nid) {
1199 err = snd_hda_create_spdif_in_ctls(codec, spec->dig_in_nid);
1200 if (err < 0)
1201 return err;
1202 }
1203 return 0;
1204 }
1205
1206
1207 /*
1208 * initialize the codec volumes, etc
1209 */
1210
1211 /*
1212 * generic initialization of ADC, input mixers and output mixers
1213 */
1214 static struct hda_verb alc880_volume_init_verbs[] = {
1215 /*
1216 * Unmute ADC0-2 and set the default input to mic-in
1217 */
1218 {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
1219 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
1220 {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
1221 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
1222 {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
1223 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
1224
1225 /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
1226 * mixer widget
1227 * Note: PASD motherboards uses the Line In 2 as the input for front
1228 * panel mic (mic 2)
1229 */
1230 /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
1231 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
1232 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
1233 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
1234 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
1235 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
1236
1237 /*
1238 * Set up output mixers (0x0c - 0x0f)
1239 */
1240 /* set vol=0 to output mixers */
1241 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
1242 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
1243 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
1244 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
1245 /* set up input amps for analog loopback */
1246 /* Amp Indices: DAC = 0, mixer = 1 */
1247 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
1248 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
1249 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
1250 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
1251 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
1252 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
1253 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
1254 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
1255
1256 { }
1257 };
1258
1259 /*
1260 * 3-stack pin configuration:
1261 * front = 0x14, mic/clfe = 0x18, HP = 0x19, line/surr = 0x1a, f-mic = 0x1b
1262 */
1263 static struct hda_verb alc880_pin_3stack_init_verbs[] = {
1264 /*
1265 * preset connection lists of input pins
1266 * 0 = front, 1 = rear_surr, 2 = CLFE, 3 = surround
1267 */
1268 {0x10, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
1269 {0x11, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
1270 {0x12, AC_VERB_SET_CONNECT_SEL, 0x03}, /* line/surround */
1271
1272 /*
1273 * Set pin mode and muting
1274 */
1275 /* set front pin widgets 0x14 for output */
1276 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1277 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1278 /* Mic1 (rear panel) pin widget for input and vref at 80% */
1279 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
1280 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
1281 /* Mic2 (as headphone out) for HP output */
1282 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
1283 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1284 /* Line In pin widget for input */
1285 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1286 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
1287 /* Line2 (as front mic) pin widget for input and vref at 80% */
1288 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
1289 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
1290 /* CD pin widget for input */
1291 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1292
1293 { }
1294 };
1295
1296 /*
1297 * 5-stack pin configuration:
1298 * front = 0x14, surround = 0x17, clfe = 0x16, mic = 0x18, HP = 0x19,
1299 * line-in/side = 0x1a, f-mic = 0x1b
1300 */
1301 static struct hda_verb alc880_pin_5stack_init_verbs[] = {
1302 /*
1303 * preset connection lists of input pins
1304 * 0 = front, 1 = rear_surr, 2 = CLFE, 3 = surround
1305 */
1306 {0x11, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
1307 {0x12, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/side */
1308
1309 /*
1310 * Set pin mode and muting
1311 */
1312 /* set pin widgets 0x14-0x17 for output */
1313 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1314 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1315 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1316 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1317 /* unmute pins for output (no gain on this amp) */
1318 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1319 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1320 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1321 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1322
1323 /* Mic1 (rear panel) pin widget for input and vref at 80% */
1324 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
1325 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
1326 /* Mic2 (as headphone out) for HP output */
1327 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
1328 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1329 /* Line In pin widget for input */
1330 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1331 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
1332 /* Line2 (as front mic) pin widget for input and vref at 80% */
1333 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
1334 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
1335 /* CD pin widget for input */
1336 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1337
1338 { }
1339 };
1340
1341 /*
1342 * W810 pin configuration:
1343 * front = 0x14, surround = 0x15, clfe = 0x16, HP = 0x1b
1344 */
1345 static struct hda_verb alc880_pin_w810_init_verbs[] = {
1346 /* hphone/speaker input selector: front DAC */
1347 {0x13, AC_VERB_SET_CONNECT_SEL, 0x0},
1348
1349 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1350 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1351 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1352 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1353 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1354 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1355
1356 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
1357 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
1358
1359 { }
1360 };
1361
1362 /*
1363 * Z71V pin configuration:
1364 * Speaker-out = 0x14, HP = 0x15, Mic = 0x18, Line-in = 0x1a, Mic2 = 0x1b (?)
1365 */
1366 static struct hda_verb alc880_pin_z71v_init_verbs[] = {
1367 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1368 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1369 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
1370 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1371
1372 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
1373 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1374 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
1375 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1376
1377 { }
1378 };
1379
1380 /*
1381 * 6-stack pin configuration:
1382 * front = 0x14, surr = 0x15, clfe = 0x16, side = 0x17, mic = 0x18,
1383 * f-mic = 0x19, line = 0x1a, HP = 0x1b
1384 */
1385 static struct hda_verb alc880_pin_6stack_init_verbs[] = {
1386 {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
1387
1388 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1389 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1390 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1391 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1392 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1393 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1394 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1395 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1396
1397 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
1398 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
1399 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
1400 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
1401 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1402 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
1403 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
1404 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1405 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1406
1407 { }
1408 };
1409
1410 /*
1411 * Uniwill pin configuration:
1412 * HP = 0x14, InternalSpeaker = 0x15, mic = 0x18, internal mic = 0x19,
1413 * line = 0x1a
1414 */
1415 static struct hda_verb alc880_uniwill_init_verbs[] = {
1416 {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
1417
1418 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
1419 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1420 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
1421 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1422 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
1423 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1424 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1425 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1426 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
1427 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
1428 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
1429 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
1430 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
1431 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
1432
1433 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
1434 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
1435 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
1436 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
1437 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1438 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
1439 /* {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, */
1440 /* {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, */
1441 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1442
1443 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
1444 {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
1445
1446 { }
1447 };
1448
1449 /*
1450 * Uniwill P53
1451 * HP = 0x14, InternalSpeaker = 0x15, mic = 0x19,
1452 */
1453 static struct hda_verb alc880_uniwill_p53_init_verbs[] = {
1454 {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
1455
1456 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
1457 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1458 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
1459 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1460 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
1461 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1462 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
1463 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
1464 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
1465 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
1466 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
1467 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
1468
1469 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
1470 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
1471 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
1472 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
1473 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1474 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
1475
1476 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
1477 {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_DCVOL_EVENT},
1478
1479 { }
1480 };
1481
1482 static struct hda_verb alc880_beep_init_verbs[] = {
1483 { 0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(5) },
1484 { }
1485 };
1486
1487 /* toggle speaker-output according to the hp-jack state */
1488 static void alc880_uniwill_automute(struct hda_codec *codec)
1489 {
1490 unsigned int present;
1491
1492 present = snd_hda_codec_read(codec, 0x14, 0,
1493 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
1494 snd_hda_codec_amp_update(codec, 0x15, 0, HDA_OUTPUT, 0,
1495 0x80, present ? 0x80 : 0);
1496 snd_hda_codec_amp_update(codec, 0x15, 1, HDA_OUTPUT, 0,
1497 0x80, present ? 0x80 : 0);
1498 snd_hda_codec_amp_update(codec, 0x16, 0, HDA_OUTPUT, 0,
1499 0x80, present ? 0x80 : 0);
1500 snd_hda_codec_amp_update(codec, 0x16, 1, HDA_OUTPUT, 0,
1501 0x80, present ? 0x80 : 0);
1502
1503 present = snd_hda_codec_read(codec, 0x18, 0,
1504 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
1505 snd_hda_codec_write(codec, 0x0b, 0, AC_VERB_SET_AMP_GAIN_MUTE,
1506 0x7000 | (0x01 << 8) | (present ? 0x80 : 0));
1507 }
1508
1509 static void alc880_uniwill_unsol_event(struct hda_codec *codec,
1510 unsigned int res)
1511 {
1512 /* Looks like the unsol event is incompatible with the standard
1513 * definition. 4bit tag is placed at 28 bit!
1514 */
1515 if ((res >> 28) == ALC880_HP_EVENT ||
1516 (res >> 28) == ALC880_MIC_EVENT)
1517 alc880_uniwill_automute(codec);
1518 }
1519
1520 static void alc880_uniwill_p53_hp_automute(struct hda_codec *codec)
1521 {
1522 unsigned int present;
1523
1524 present = snd_hda_codec_read(codec, 0x14, 0,
1525 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
1526
1527 snd_hda_codec_amp_update(codec, 0x15, 0, HDA_INPUT, 0,
1528 0x80, present ? 0x80 : 0);
1529 snd_hda_codec_amp_update(codec, 0x15, 1, HDA_INPUT, 0,
1530 0x80, present ? 0x80 : 0);
1531 }
1532
1533 static void alc880_uniwill_p53_dcvol_automute(struct hda_codec *codec)
1534 {
1535 unsigned int present;
1536
1537 present = snd_hda_codec_read(codec, 0x21, 0,
1538 AC_VERB_GET_VOLUME_KNOB_CONTROL, 0) & 0x7f;
1539
1540 snd_hda_codec_amp_update(codec, 0x0c, 0, HDA_OUTPUT, 0,
1541 0x7f, present);
1542 snd_hda_codec_amp_update(codec, 0x0c, 1, HDA_OUTPUT, 0,
1543 0x7f, present);
1544
1545 snd_hda_codec_amp_update(codec, 0x0d, 0, HDA_OUTPUT, 0,
1546 0x7f, present);
1547 snd_hda_codec_amp_update(codec, 0x0d, 1, HDA_OUTPUT, 0,
1548 0x7f, present);
1549
1550 }
1551 static void alc880_uniwill_p53_unsol_event(struct hda_codec *codec,
1552 unsigned int res)
1553 {
1554 /* Looks like the unsol event is incompatible with the standard
1555 * definition. 4bit tag is placed at 28 bit!
1556 */
1557 if ((res >> 28) == ALC880_HP_EVENT)
1558 alc880_uniwill_p53_hp_automute(codec);
1559 if ((res >> 28) == ALC880_DCVOL_EVENT)
1560 alc880_uniwill_p53_dcvol_automute(codec);
1561 }
1562
1563 /* FIXME! */
1564 /*
1565 * F1734 pin configuration:
1566 * HP = 0x14, speaker-out = 0x15, mic = 0x18
1567 */
1568 static struct hda_verb alc880_pin_f1734_init_verbs[] = {
1569 {0x10, AC_VERB_SET_CONNECT_SEL, 0x02},
1570 {0x11, AC_VERB_SET_CONNECT_SEL, 0x00},
1571 {0x12, AC_VERB_SET_CONNECT_SEL, 0x01},
1572 {0x13, AC_VERB_SET_CONNECT_SEL, 0x00},
1573
1574 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
1575 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1576 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1577 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1578
1579 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
1580 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
1581 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
1582 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
1583 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1584 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1585 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1586 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1587 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1588
1589 { }
1590 };
1591
1592 /* FIXME! */
1593 /*
1594 * ASUS pin configuration:
1595 * HP/front = 0x14, surr = 0x15, clfe = 0x16, mic = 0x18, line = 0x1a
1596 */
1597 static struct hda_verb alc880_pin_asus_init_verbs[] = {
1598 {0x10, AC_VERB_SET_CONNECT_SEL, 0x02},
1599 {0x11, AC_VERB_SET_CONNECT_SEL, 0x00},
1600 {0x12, AC_VERB_SET_CONNECT_SEL, 0x01},
1601 {0x13, AC_VERB_SET_CONNECT_SEL, 0x00},
1602
1603 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
1604 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1605 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1606 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1607 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1608 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1609 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1610 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1611
1612 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
1613 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
1614 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
1615 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
1616 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1617 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
1618 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1619 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1620 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1621
1622 { }
1623 };
1624
1625 /* Enable GPIO mask and set output */
1626 #define alc880_gpio1_init_verbs alc_gpio1_init_verbs
1627 #define alc880_gpio2_init_verbs alc_gpio2_init_verbs
1628
1629 /* Clevo m520g init */
1630 static struct hda_verb alc880_pin_clevo_init_verbs[] = {
1631 /* headphone output */
1632 {0x11, AC_VERB_SET_CONNECT_SEL, 0x01},
1633 /* line-out */
1634 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1635 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1636 /* Line-in */
1637 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1638 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1639 /* CD */
1640 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1641 {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1642 /* Mic1 (rear panel) */
1643 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
1644 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1645 /* Mic2 (front panel) */
1646 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
1647 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1648 /* headphone */
1649 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
1650 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1651 /* change to EAPD mode */
1652 {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
1653 {0x20, AC_VERB_SET_PROC_COEF, 0x3060},
1654
1655 { }
1656 };
1657
1658 static struct hda_verb alc880_pin_tcl_S700_init_verbs[] = {
1659 /* change to EAPD mode */
1660 {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
1661 {0x20, AC_VERB_SET_PROC_COEF, 0x3060},
1662
1663 /* Headphone output */
1664 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
1665 /* Front output*/
1666 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1667 {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
1668
1669 /* Line In pin widget for input */
1670 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1671 /* CD pin widget for input */
1672 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1673 /* Mic1 (rear panel) pin widget for input and vref at 80% */
1674 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
1675
1676 /* change to EAPD mode */
1677 {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
1678 {0x20, AC_VERB_SET_PROC_COEF, 0x3070},
1679
1680 { }
1681 };
1682
1683 /*
1684 * LG m1 express dual
1685 *
1686 * Pin assignment:
1687 * Rear Line-In/Out (blue): 0x14
1688 * Build-in Mic-In: 0x15
1689 * Speaker-out: 0x17
1690 * HP-Out (green): 0x1b
1691 * Mic-In/Out (red): 0x19
1692 * SPDIF-Out: 0x1e
1693 */
1694
1695 /* To make 5.1 output working (green=Front, blue=Surr, red=CLFE) */
1696 static hda_nid_t alc880_lg_dac_nids[3] = {
1697 0x05, 0x02, 0x03
1698 };
1699
1700 /* seems analog CD is not working */
1701 static struct hda_input_mux alc880_lg_capture_source = {
1702 .num_items = 3,
1703 .items = {
1704 { "Mic", 0x1 },
1705 { "Line", 0x5 },
1706 { "Internal Mic", 0x6 },
1707 },
1708 };
1709
1710 /* 2,4,6 channel modes */
1711 static struct hda_verb alc880_lg_ch2_init[] = {
1712 /* set line-in and mic-in to input */
1713 { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
1714 { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
1715 { }
1716 };
1717
1718 static struct hda_verb alc880_lg_ch4_init[] = {
1719 /* set line-in to out and mic-in to input */
1720 { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },
1721 { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
1722 { }
1723 };
1724
1725 static struct hda_verb alc880_lg_ch6_init[] = {
1726 /* set line-in and mic-in to output */
1727 { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },
1728 { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },
1729 { }
1730 };
1731
1732 static struct hda_channel_mode alc880_lg_ch_modes[3] = {
1733 { 2, alc880_lg_ch2_init },
1734 { 4, alc880_lg_ch4_init },
1735 { 6, alc880_lg_ch6_init },
1736 };
1737
1738 static struct snd_kcontrol_new alc880_lg_mixer[] = {
1739 /* FIXME: it's not really "master" but front channels */
1740 HDA_CODEC_VOLUME("Master Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
1741 HDA_BIND_MUTE("Master Playback Switch", 0x0f, 2, HDA_INPUT),
1742 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1743 HDA_BIND_MUTE("Surround Playback Switch", 0x0c, 2, HDA_INPUT),
1744 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0d, 1, 0x0, HDA_OUTPUT),
1745 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0d, 2, 0x0, HDA_OUTPUT),
1746 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0d, 1, 2, HDA_INPUT),
1747 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0d, 2, 2, HDA_INPUT),
1748 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
1749 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
1750 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x06, HDA_INPUT),
1751 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x06, HDA_INPUT),
1752 HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x07, HDA_INPUT),
1753 HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x07, HDA_INPUT),
1754 {
1755 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1756 .name = "Channel Mode",
1757 .info = alc_ch_mode_info,
1758 .get = alc_ch_mode_get,
1759 .put = alc_ch_mode_put,
1760 },
1761 { } /* end */
1762 };
1763
1764 static struct hda_verb alc880_lg_init_verbs[] = {
1765 /* set capture source to mic-in */
1766 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
1767 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
1768 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
1769 /* mute all amp mixer inputs */
1770 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(5)},
1771 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(6)},
1772 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(7)},
1773 /* line-in to input */
1774 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1775 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1776 /* built-in mic */
1777 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
1778 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1779 /* speaker-out */
1780 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
1781 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1782 /* mic-in to input */
1783 {0x11, AC_VERB_SET_CONNECT_SEL, 0x01},
1784 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
1785 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1786 /* HP-out */
1787 {0x13, AC_VERB_SET_CONNECT_SEL, 0x03},
1788 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
1789 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1790 /* jack sense */
1791 {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | 0x1},
1792 { }
1793 };
1794
1795 /* toggle speaker-output according to the hp-jack state */
1796 static void alc880_lg_automute(struct hda_codec *codec)
1797 {
1798 unsigned int present;
1799
1800 present = snd_hda_codec_read(codec, 0x1b, 0,
1801 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
1802 snd_hda_codec_amp_update(codec, 0x17, 0, HDA_OUTPUT, 0,
1803 0x80, present ? 0x80 : 0);
1804 snd_hda_codec_amp_update(codec, 0x17, 1, HDA_OUTPUT, 0,
1805 0x80, present ? 0x80 : 0);
1806 }
1807
1808 static void alc880_lg_unsol_event(struct hda_codec *codec, unsigned int res)
1809 {
1810 /* Looks like the unsol event is incompatible with the standard
1811 * definition. 4bit tag is placed at 28 bit!
1812 */
1813 if ((res >> 28) == 0x01)
1814 alc880_lg_automute(codec);
1815 }
1816
1817 /*
1818 * LG LW20
1819 *
1820 * Pin assignment:
1821 * Speaker-out: 0x14
1822 * Mic-In: 0x18
1823 * Built-in Mic-In: 0x19 (?)
1824 * HP-Out: 0x1b
1825 * SPDIF-Out: 0x1e
1826 */
1827
1828 /* seems analog CD is not working */
1829 static struct hda_input_mux alc880_lg_lw_capture_source = {
1830 .num_items = 2,
1831 .items = {
1832 { "Mic", 0x0 },
1833 { "Internal Mic", 0x1 },
1834 },
1835 };
1836
1837 static struct snd_kcontrol_new alc880_lg_lw_mixer[] = {
1838 HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1839 HDA_BIND_MUTE("Master Playback Switch", 0x0c, 2, HDA_INPUT),
1840 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
1841 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
1842 HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
1843 HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
1844 { } /* end */
1845 };
1846
1847 static struct hda_verb alc880_lg_lw_init_verbs[] = {
1848 /* set capture source to mic-in */
1849 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
1850 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
1851 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
1852 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(7)},
1853 /* speaker-out */
1854 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
1855 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1856 /* HP-out */
1857 {0x13, AC_VERB_SET_CONNECT_SEL, 0x00},
1858 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
1859 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1860 /* mic-in to input */
1861 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
1862 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1863 /* built-in mic */
1864 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
1865 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1866 /* jack sense */
1867 {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | 0x1},
1868 { }
1869 };
1870
1871 /* toggle speaker-output according to the hp-jack state */
1872 static void alc880_lg_lw_automute(struct hda_codec *codec)
1873 {
1874 unsigned int present;
1875
1876 present = snd_hda_codec_read(codec, 0x1b, 0,
1877 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
1878 snd_hda_codec_amp_update(codec, 0x14, 0, HDA_OUTPUT, 0,
1879 0x80, present ? 0x80 : 0);
1880 snd_hda_codec_amp_update(codec, 0x14, 1, HDA_OUTPUT, 0,
1881 0x80, present ? 0x80 : 0);
1882 }
1883
1884 static void alc880_lg_lw_unsol_event(struct hda_codec *codec, unsigned int res)
1885 {
1886 /* Looks like the unsol event is incompatible with the standard
1887 * definition. 4bit tag is placed at 28 bit!
1888 */
1889 if ((res >> 28) == 0x01)
1890 alc880_lg_lw_automute(codec);
1891 }
1892
1893 /*
1894 * Common callbacks
1895 */
1896
1897 static int alc_init(struct hda_codec *codec)
1898 {
1899 struct alc_spec *spec = codec->spec;
1900 unsigned int i;
1901
1902 for (i = 0; i < spec->num_init_verbs; i++)
1903 snd_hda_sequence_write(codec, spec->init_verbs[i]);
1904
1905 if (spec->init_hook)
1906 spec->init_hook(codec);
1907
1908 return 0;
1909 }
1910
1911 static void alc_unsol_event(struct hda_codec *codec, unsigned int res)
1912 {
1913 struct alc_spec *spec = codec->spec;
1914
1915 if (spec->unsol_event)
1916 spec->unsol_event(codec, res);
1917 }
1918
1919 #ifdef CONFIG_PM
1920 /*
1921 * resume
1922 */
1923 static int alc_resume(struct hda_codec *codec)
1924 {
1925 struct alc_spec *spec = codec->spec;
1926 int i;
1927
1928 alc_init(codec);
1929 for (i = 0; i < spec->num_mixers; i++)
1930 snd_hda_resume_ctls(codec, spec->mixers[i]);
1931 if (spec->multiout.dig_out_nid)
1932 snd_hda_resume_spdif_out(codec);
1933 if (spec->dig_in_nid)
1934 snd_hda_resume_spdif_in(codec);
1935
1936 return 0;
1937 }
1938 #endif
1939
1940 /*
1941 * Analog playback callbacks
1942 */
1943 static int alc880_playback_pcm_open(struct hda_pcm_stream *hinfo,
1944 struct hda_codec *codec,
1945 struct snd_pcm_substream *substream)
1946 {
1947 struct alc_spec *spec = codec->spec;
1948 return snd_hda_multi_out_analog_open(codec, &spec->multiout, substream);
1949 }
1950
1951 static int alc880_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
1952 struct hda_codec *codec,
1953 unsigned int stream_tag,
1954 unsigned int format,
1955 struct snd_pcm_substream *substream)
1956 {
1957 struct alc_spec *spec = codec->spec;
1958 return snd_hda_multi_out_analog_prepare(codec, &spec->multiout,
1959 stream_tag, format, substream);
1960 }
1961
1962 static int alc880_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
1963 struct hda_codec *codec,
1964 struct snd_pcm_substream *substream)
1965 {
1966 struct alc_spec *spec = codec->spec;
1967 return snd_hda_multi_out_analog_cleanup(codec, &spec->multiout);
1968 }
1969
1970 /*
1971 * Digital out
1972 */
1973 static int alc880_dig_playback_pcm_open(struct hda_pcm_stream *hinfo,
1974 struct hda_codec *codec,
1975 struct snd_pcm_substream *substream)
1976 {
1977 struct alc_spec *spec = codec->spec;
1978 return snd_hda_multi_out_dig_open(codec, &spec->multiout);
1979 }
1980
1981 static int alc880_dig_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
1982 struct hda_codec *codec,
1983 unsigned int stream_tag,
1984 unsigned int format,
1985 struct snd_pcm_substream *substream)
1986 {
1987 struct alc_spec *spec = codec->spec;
1988 return snd_hda_multi_out_dig_prepare(codec, &spec->multiout,
1989 stream_tag, format, substream);
1990 }
1991
1992 static int alc880_dig_playback_pcm_close(struct hda_pcm_stream *hinfo,
1993 struct hda_codec *codec,
1994 struct snd_pcm_substream *substream)
1995 {
1996 struct alc_spec *spec = codec->spec;
1997 return snd_hda_multi_out_dig_close(codec, &spec->multiout);
1998 }
1999
2000 /*
2001 * Analog capture
2002 */
2003 static int alc880_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
2004 struct hda_codec *codec,
2005 unsigned int stream_tag,
2006 unsigned int format,
2007 struct snd_pcm_substream *substream)
2008 {
2009 struct alc_spec *spec = codec->spec;
2010
2011 snd_hda_codec_setup_stream(codec, spec->adc_nids[substream->number],
2012 stream_tag, 0, format);
2013 return 0;
2014 }
2015
2016 static int alc880_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
2017 struct hda_codec *codec,
2018 struct snd_pcm_substream *substream)
2019 {
2020 struct alc_spec *spec = codec->spec;
2021
2022 snd_hda_codec_setup_stream(codec, spec->adc_nids[substream->number],
2023 0, 0, 0);
2024 return 0;
2025 }
2026
2027
2028 /*
2029 */
2030 static struct hda_pcm_stream alc880_pcm_analog_playback = {
2031 .substreams = 1,
2032 .channels_min = 2,
2033 .channels_max = 8,
2034 /* NID is set in alc_build_pcms */
2035 .ops = {
2036 .open = alc880_playback_pcm_open,
2037 .prepare = alc880_playback_pcm_prepare,
2038 .cleanup = alc880_playback_pcm_cleanup
2039 },
2040 };
2041
2042 static struct hda_pcm_stream alc880_pcm_analog_capture = {
2043 .substreams = 2,
2044 .channels_min = 2,
2045 .channels_max = 2,
2046 /* NID is set in alc_build_pcms */
2047 .ops = {
2048 .prepare = alc880_capture_pcm_prepare,
2049 .cleanup = alc880_capture_pcm_cleanup
2050 },
2051 };
2052
2053 static struct hda_pcm_stream alc880_pcm_digital_playback = {
2054 .substreams = 1,
2055 .channels_min = 2,
2056 .channels_max = 2,
2057 /* NID is set in alc_build_pcms */
2058 .ops = {
2059 .open = alc880_dig_playback_pcm_open,
2060 .close = alc880_dig_playback_pcm_close,
2061 .prepare = alc880_dig_playback_pcm_prepare
2062 },
2063 };
2064
2065 static struct hda_pcm_stream alc880_pcm_digital_capture = {
2066 .substreams = 1,
2067 .channels_min = 2,
2068 .channels_max = 2,
2069 /* NID is set in alc_build_pcms */
2070 };
2071
2072 /* Used by alc_build_pcms to flag that a PCM has no playback stream */
2073 static struct hda_pcm_stream alc_pcm_null_playback = {
2074 .substreams = 0,
2075 .channels_min = 0,
2076 .channels_max = 0,
2077 };
2078
2079 static int alc_build_pcms(struct hda_codec *codec)
2080 {
2081 struct alc_spec *spec = codec->spec;
2082 struct hda_pcm *info = spec->pcm_rec;
2083 int i;
2084
2085 codec->num_pcms = 1;
2086 codec->pcm_info = info;
2087
2088 info->name = spec->stream_name_analog;
2089 if (spec->stream_analog_playback) {
2090 snd_assert(spec->multiout.dac_nids, return -EINVAL);
2091 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *(spec->stream_analog_playback);
2092 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dac_nids[0];
2093 }
2094 if (spec->stream_analog_capture) {
2095 snd_assert(spec->adc_nids, return -EINVAL);
2096 info->stream[SNDRV_PCM_STREAM_CAPTURE] = *(spec->stream_analog_capture);
2097 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adc_nids[0];
2098 }
2099
2100 if (spec->channel_mode) {
2101 info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max = 0;
2102 for (i = 0; i < spec->num_channel_mode; i++) {
2103 if (spec->channel_mode[i].channels > info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max) {
2104 info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max = spec->channel_mode[i].channels;
2105 }
2106 }
2107 }
2108
2109 /* SPDIF for stream index #1 */
2110 if (spec->multiout.dig_out_nid || spec->dig_in_nid) {
2111 codec->num_pcms = 2;
2112 info = spec->pcm_rec + 1;
2113 info->name = spec->stream_name_digital;
2114 if (spec->multiout.dig_out_nid &&
2115 spec->stream_digital_playback) {
2116 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *(spec->stream_digital_playback);
2117 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dig_out_nid;
2118 }
2119 if (spec->dig_in_nid &&
2120 spec->stream_digital_capture) {
2121 info->stream[SNDRV_PCM_STREAM_CAPTURE] = *(spec->stream_digital_capture);
2122 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->dig_in_nid;
2123 }
2124 }
2125
2126 /* If the use of more than one ADC is requested for the current
2127 * model, configure a second analog capture-only PCM.
2128 */
2129 /* Additional Analaog capture for index #2 */
2130 if (spec->num_adc_nids > 1 && spec->stream_analog_capture &&
2131 spec->adc_nids) {
2132 codec->num_pcms = 3;
2133 info = spec->pcm_rec + 2;
2134 info->name = spec->stream_name_analog;
2135 /* No playback stream for second PCM */
2136 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = alc_pcm_null_playback;
2137 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = 0;
2138 if (spec->stream_analog_capture) {
2139 info->stream[SNDRV_PCM_STREAM_CAPTURE] = *(spec->stream_analog_capture);
2140 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adc_nids[1];
2141 }
2142 }
2143
2144 return 0;
2145 }
2146
2147 static void alc_free(struct hda_codec *codec)
2148 {
2149 struct alc_spec *spec = codec->spec;
2150 unsigned int i;
2151
2152 if (! spec)
2153 return;
2154
2155 if (spec->kctl_alloc) {
2156 for (i = 0; i < spec->num_kctl_used; i++)
2157 kfree(spec->kctl_alloc[i].name);
2158 kfree(spec->kctl_alloc);
2159 }
2160 kfree(spec);
2161 }
2162
2163 /*
2164 */
2165 static struct hda_codec_ops alc_patch_ops = {
2166 .build_controls = alc_build_controls,
2167 .build_pcms = alc_build_pcms,
2168 .init = alc_init,
2169 .free = alc_free,
2170 .unsol_event = alc_unsol_event,
2171 #ifdef CONFIG_PM
2172 .resume = alc_resume,
2173 #endif
2174 };
2175
2176
2177 /*
2178 * Test configuration for debugging
2179 *
2180 * Almost all inputs/outputs are enabled. I/O pins can be configured via
2181 * enum controls.
2182 */
2183 #ifdef CONFIG_SND_DEBUG
2184 static hda_nid_t alc880_test_dac_nids[4] = {
2185 0x02, 0x03, 0x04, 0x05
2186 };
2187
2188 static struct hda_input_mux alc880_test_capture_source = {
2189 .num_items = 7,
2190 .items = {
2191 { "In-1", 0x0 },
2192 { "In-2", 0x1 },
2193 { "In-3", 0x2 },
2194 { "In-4", 0x3 },
2195 { "CD", 0x4 },
2196 { "Front", 0x5 },
2197 { "Surround", 0x6 },
2198 },
2199 };
2200
2201 static struct hda_channel_mode alc880_test_modes[4] = {
2202 { 2, NULL },
2203 { 4, NULL },
2204 { 6, NULL },
2205 { 8, NULL },
2206 };
2207
2208 static int alc_test_pin_ctl_info(struct snd_kcontrol *kcontrol,
2209 struct snd_ctl_elem_info *uinfo)
2210 {
2211 static char *texts[] = {
2212 "N/A", "Line Out", "HP Out",
2213 "In Hi-Z", "In 50%", "In Grd", "In 80%", "In 100%"
2214 };
2215 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
2216 uinfo->count = 1;
2217 uinfo->value.enumerated.items = 8;
2218 if (uinfo->value.enumerated.item >= 8)
2219 uinfo->value.enumerated.item = 7;
2220 strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
2221 return 0;
2222 }
2223
2224 static int alc_test_pin_ctl_get(struct snd_kcontrol *kcontrol,
2225 struct snd_ctl_elem_value *ucontrol)
2226 {
2227 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2228 hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
2229 unsigned int pin_ctl, item = 0;
2230
2231 pin_ctl = snd_hda_codec_read(codec, nid, 0,
2232 AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
2233 if (pin_ctl & AC_PINCTL_OUT_EN) {
2234 if (pin_ctl & AC_PINCTL_HP_EN)
2235 item = 2;
2236 else
2237 item = 1;
2238 } else if (pin_ctl & AC_PINCTL_IN_EN) {
2239 switch (pin_ctl & AC_PINCTL_VREFEN) {
2240 case AC_PINCTL_VREF_HIZ: item = 3; break;
2241 case AC_PINCTL_VREF_50: item = 4; break;
2242 case AC_PINCTL_VREF_GRD: item = 5; break;
2243 case AC_PINCTL_VREF_80: item = 6; break;
2244 case AC_PINCTL_VREF_100: item = 7; break;
2245 }
2246 }
2247 ucontrol->value.enumerated.item[0] = item;
2248 return 0;
2249 }
2250
2251 static int alc_test_pin_ctl_put(struct snd_kcontrol *kcontrol,
2252 struct snd_ctl_elem_value *ucontrol)
2253 {
2254 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2255 hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
2256 static unsigned int ctls[] = {
2257 0, AC_PINCTL_OUT_EN, AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN,
2258 AC_PINCTL_IN_EN | AC_PINCTL_VREF_HIZ,
2259 AC_PINCTL_IN_EN | AC_PINCTL_VREF_50,
2260 AC_PINCTL_IN_EN | AC_PINCTL_VREF_GRD,
2261 AC_PINCTL_IN_EN | AC_PINCTL_VREF_80,
2262 AC_PINCTL_IN_EN | AC_PINCTL_VREF_100,
2263 };
2264 unsigned int old_ctl, new_ctl;
2265
2266 old_ctl = snd_hda_codec_read(codec, nid, 0,
2267 AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
2268 new_ctl = ctls[ucontrol->value.enumerated.item[0]];
2269 if (old_ctl != new_ctl) {
2270 snd_hda_codec_write(codec, nid, 0,
2271 AC_VERB_SET_PIN_WIDGET_CONTROL, new_ctl);
2272 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE,
2273 (ucontrol->value.enumerated.item[0] >= 3 ?
2274 0xb080 : 0xb000));
2275 return 1;
2276 }
2277 return 0;
2278 }
2279
2280 static int alc_test_pin_src_info(struct snd_kcontrol *kcontrol,
2281 struct snd_ctl_elem_info *uinfo)
2282 {
2283 static char *texts[] = {
2284 "Front", "Surround", "CLFE", "Side"
2285 };
2286 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
2287 uinfo->count = 1;
2288 uinfo->value.enumerated.items = 4;
2289 if (uinfo->value.enumerated.item >= 4)
2290 uinfo->value.enumerated.item = 3;
2291 strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
2292 return 0;
2293 }
2294
2295 static int alc_test_pin_src_get(struct snd_kcontrol *kcontrol,
2296 struct snd_ctl_elem_value *ucontrol)
2297 {
2298 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2299 hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
2300 unsigned int sel;
2301
2302 sel = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_CONNECT_SEL, 0);
2303 ucontrol->value.enumerated.item[0] = sel & 3;
2304 return 0;
2305 }
2306
2307 static int alc_test_pin_src_put(struct snd_kcontrol *kcontrol,
2308 struct snd_ctl_elem_value *ucontrol)
2309 {
2310 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2311 hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
2312 unsigned int sel;
2313
2314 sel = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_CONNECT_SEL, 0) & 3;
2315 if (ucontrol->value.enumerated.item[0] != sel) {
2316 sel = ucontrol->value.enumerated.item[0] & 3;
2317 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CONNECT_SEL, sel);
2318 return 1;
2319 }
2320 return 0;
2321 }
2322
2323 #define PIN_CTL_TEST(xname,nid) { \
2324 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
2325 .name = xname, \
2326 .info = alc_test_pin_ctl_info, \
2327 .get = alc_test_pin_ctl_get, \
2328 .put = alc_test_pin_ctl_put, \
2329 .private_value = nid \
2330 }
2331
2332 #define PIN_SRC_TEST(xname,nid) { \
2333 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
2334 .name = xname, \
2335 .info = alc_test_pin_src_info, \
2336 .get = alc_test_pin_src_get, \
2337 .put = alc_test_pin_src_put, \
2338 .private_value = nid \
2339 }
2340
2341 static struct snd_kcontrol_new alc880_test_mixer[] = {
2342 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2343 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2344 HDA_CODEC_VOLUME("CLFE Playback Volume", 0x0e, 0x0, HDA_OUTPUT),
2345 HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
2346 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
2347 HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
2348 HDA_BIND_MUTE("CLFE Playback Switch", 0x0e, 2, HDA_INPUT),
2349 HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
2350 PIN_CTL_TEST("Front Pin Mode", 0x14),
2351 PIN_CTL_TEST("Surround Pin Mode", 0x15),
2352 PIN_CTL_TEST("CLFE Pin Mode", 0x16),
2353 PIN_CTL_TEST("Side Pin Mode", 0x17),
2354 PIN_CTL_TEST("In-1 Pin Mode", 0x18),
2355 PIN_CTL_TEST("In-2 Pin Mode", 0x19),
2356 PIN_CTL_TEST("In-3 Pin Mode", 0x1a),
2357 PIN_CTL_TEST("In-4 Pin Mode", 0x1b),
2358 PIN_SRC_TEST("In-1 Pin Source", 0x18),
2359 PIN_SRC_TEST("In-2 Pin Source", 0x19),
2360 PIN_SRC_TEST("In-3 Pin Source", 0x1a),
2361 PIN_SRC_TEST("In-4 Pin Source", 0x1b),
2362 HDA_CODEC_VOLUME("In-1 Playback Volume", 0x0b, 0x0, HDA_INPUT),
2363 HDA_CODEC_MUTE("In-1 Playback Switch", 0x0b, 0x0, HDA_INPUT),
2364 HDA_CODEC_VOLUME("In-2 Playback Volume", 0x0b, 0x1, HDA_INPUT),
2365 HDA_CODEC_MUTE("In-2 Playback Switch", 0x0b, 0x1, HDA_INPUT),
2366 HDA_CODEC_VOLUME("In-3 Playback Volume", 0x0b, 0x2, HDA_INPUT),
2367 HDA_CODEC_MUTE("In-3 Playback Switch", 0x0b, 0x2, HDA_INPUT),
2368 HDA_CODEC_VOLUME("In-4 Playback Volume", 0x0b, 0x3, HDA_INPUT),
2369 HDA_CODEC_MUTE("In-4 Playback Switch", 0x0b, 0x3, HDA_INPUT),
2370 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x4, HDA_INPUT),
2371 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x4, HDA_INPUT),
2372 {
2373 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2374 .name = "Channel Mode",
2375 .info = alc_ch_mode_info,
2376 .get = alc_ch_mode_get,
2377 .put = alc_ch_mode_put,
2378 },
2379 { } /* end */
2380 };
2381
2382 static struct hda_verb alc880_test_init_verbs[] = {
2383 /* Unmute inputs of 0x0c - 0x0f */
2384 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2385 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
2386 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2387 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
2388 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2389 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
2390 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2391 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
2392 /* Vol output for 0x0c-0x0f */
2393 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2394 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2395 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2396 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2397 /* Set output pins 0x14-0x17 */
2398 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2399 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2400 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2401 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2402 /* Unmute output pins 0x14-0x17 */
2403 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2404 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2405 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2406 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2407 /* Set input pins 0x18-0x1c */
2408 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2409 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2410 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2411 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2412 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2413 /* Mute input pins 0x18-0x1b */
2414 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2415 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2416 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2417 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2418 /* ADC set up */
2419 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2420 {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
2421 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2422 {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
2423 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2424 {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
2425 /* Analog input/passthru */
2426 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2427 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2428 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
2429 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
2430 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
2431 { }
2432 };
2433 #endif
2434
2435 /*
2436 */
2437
2438 static const char *alc880_models[ALC880_MODEL_LAST] = {
2439 [ALC880_3ST] = "3stack",
2440 [ALC880_TCL_S700] = "tcl",
2441 [ALC880_3ST_DIG] = "3stack-digout",
2442 [ALC880_CLEVO] = "clevo",
2443 [ALC880_5ST] = "5stack",
2444 [ALC880_5ST_DIG] = "5stack-digout",
2445 [ALC880_W810] = "w810",
2446 [ALC880_Z71V] = "z71v",
2447 [ALC880_6ST] = "6stack",
2448 [ALC880_6ST_DIG] = "6stack-digout",
2449 [ALC880_ASUS] = "asus",
2450 [ALC880_ASUS_W1V] = "asus-w1v",
2451 [ALC880_ASUS_DIG] = "asus-dig",
2452 [ALC880_ASUS_DIG2] = "asus-dig2",
2453 [ALC880_UNIWILL_DIG] = "uniwill",
2454 [ALC880_UNIWILL_P53] = "uniwill-p53",
2455 [ALC880_FUJITSU] = "fujitsu",
2456 [ALC880_F1734] = "F1734",
2457 [ALC880_LG] = "lg",
2458 [ALC880_LG_LW] = "lg-lw",
2459 #ifdef CONFIG_SND_DEBUG
2460 [ALC880_TEST] = "test",
2461 #endif
2462 [ALC880_AUTO] = "auto",
2463 };
2464
2465 static struct snd_pci_quirk alc880_cfg_tbl[] = {
2466 /* Broken BIOS configuration */
2467 SND_PCI_QUIRK(0x2668, 0x8086, NULL, ALC880_6ST_DIG),
2468 SND_PCI_QUIRK(0x8086, 0x2668, NULL, ALC880_6ST_DIG),
2469
2470 SND_PCI_QUIRK(0x1019, 0xa880, "ECS", ALC880_5ST_DIG),
2471 SND_PCI_QUIRK(0x1019, 0xa884, "Acer APFV", ALC880_6ST),
2472 SND_PCI_QUIRK(0x1019, 0x0f69, "Coeus G610P", ALC880_W810),
2473 SND_PCI_QUIRK(0x1025, 0x0070, "ULI", ALC880_3ST_DIG),
2474 SND_PCI_QUIRK(0x1025, 0x0077, "ULI", ALC880_6ST_DIG),
2475 SND_PCI_QUIRK(0x1025, 0x0078, "ULI", ALC880_6ST_DIG),
2476 SND_PCI_QUIRK(0x1025, 0x0087, "ULI", ALC880_6ST_DIG),
2477 SND_PCI_QUIRK(0x1025, 0xe309, "ULI", ALC880_3ST_DIG),
2478 SND_PCI_QUIRK(0x1025, 0xe310, "ULI", ALC880_3ST),
2479
2480 SND_PCI_QUIRK(0x1039, 0x1234, NULL, ALC880_6ST_DIG),
2481 SND_PCI_QUIRK(0x103c, 0x2a09, "HP", ALC880_5ST),
2482
2483 SND_PCI_QUIRK(0x1043, 0x10b3, "ASUS W1V", ALC880_ASUS_W1V),
2484 SND_PCI_QUIRK(0x1043, 0x10c2, "ASUS W6A", ALC880_ASUS_DIG),
2485 SND_PCI_QUIRK(0x1043, 0x10c3, "ASUS Wxx", ALC880_ASUS_DIG),
2486 SND_PCI_QUIRK(0x1043, 0x1113, "ASUS", ALC880_ASUS_DIG),
2487 SND_PCI_QUIRK(0x1043, 0x1123, "ASUS", ALC880_ASUS_DIG),
2488 SND_PCI_QUIRK(0x1043, 0x1173, "ASUS", ALC880_ASUS_DIG),
2489 SND_PCI_QUIRK(0x1043, 0x1964, "ASUS Z71V", ALC880_Z71V),
2490 /* SND_PCI_QUIRK(0x1043, 0x1964, "ASUS", ALC880_ASUS_DIG), */
2491 SND_PCI_QUIRK(0x1043, 0x1973, "ASUS", ALC880_ASUS_DIG),
2492 SND_PCI_QUIRK(0x1043, 0x19b3, "ASUS", ALC880_ASUS_DIG),
2493 SND_PCI_QUIRK(0x1043, 0x814e, "ASUS", ALC880_ASUS),
2494 SND_PCI_QUIRK(0x1043, 0x8181, "ASUS P4GPL", ALC880_ASUS_DIG),
2495 SND_PCI_QUIRK(0x1043, 0x8196, "ASUS P5GD1", ALC880_6ST),
2496 SND_PCI_QUIRK(0x1043, 0x81b4, "ASUS", ALC880_6ST),
2497 SND_PCI_QUIRK(0x1043, 0, "ASUS", ALC880_ASUS),
2498
2499 SND_PCI_QUIRK(0x104d, 0x81d6, "Sony", ALC880_3ST),
2500 SND_PCI_QUIRK(0x104d, 0x81a0, "Sony", ALC880_3ST),
2501 SND_PCI_QUIRK(0x107b, 0x3033, "Gateway", ALC880_5ST),
2502 SND_PCI_QUIRK(0x107b, 0x4039, "Gateway", ALC880_5ST),
2503 SND_PCI_QUIRK(0x107b, 0x3032, "Gateway", ALC880_5ST),
2504 SND_PCI_QUIRK(0x1558, 0x0520, "Clevo m520G", ALC880_CLEVO),
2505 SND_PCI_QUIRK(0x1558, 0x0660, "Clevo m655n", ALC880_CLEVO),
2506 SND_PCI_QUIRK(0x1565, 0x8202, "Biostar", ALC880_5ST_DIG),
2507 SND_PCI_QUIRK(0x161f, 0x203d, "W810", ALC880_W810),
2508 SND_PCI_QUIRK(0x1695, 0x400d, "EPoX", ALC880_5ST_DIG),
2509 SND_PCI_QUIRK(0x19db, 0x4188, "TCL S700", ALC880_TCL_S700),
2510 SND_PCI_QUIRK(0xa0a0, 0x0560, "AOpen i915GMm-HFS", ALC880_5ST_DIG),
2511 SND_PCI_QUIRK(0xe803, 0x1019, NULL, ALC880_6ST_DIG),
2512 SND_PCI_QUIRK(0x1297, 0xc790, "Shuttle ST20G5", ALC880_6ST_DIG),
2513 SND_PCI_QUIRK(0x1458, 0xa102, "Gigabyte K8", ALC880_6ST_DIG),
2514 SND_PCI_QUIRK(0x1462, 0x1150, "MSI", ALC880_6ST_DIG),
2515 SND_PCI_QUIRK(0x1509, 0x925d, "FIC P4M", ALC880_6ST_DIG),
2516 SND_PCI_QUIRK(0x1558, 0x5401, "ASUS", ALC880_ASUS_DIG2),
2517
2518 SND_PCI_QUIRK(0x1584, 0x9050, "Uniwill", ALC880_UNIWILL_DIG),
2519 SND_PCI_QUIRK(0x1584, 0x9070, "Uniwill", ALC880_UNIWILL),
2520 SND_PCI_QUIRK(0x1584, 0x9077, "Uniwill P53", ALC880_UNIWILL_P53),
2521 SND_PCI_QUIRK(0x1584, 0x9054, "Uniwlll", ALC880_F1734),
2522
2523 SND_PCI_QUIRK(0x1695, 0x4012, "EPox EP-5LDA", ALC880_5ST_DIG),
2524 SND_PCI_QUIRK(0x1734, 0x10ac, "FSC", ALC880_UNIWILL),
2525 SND_PCI_QUIRK(0x1734, 0x107c, "FSC F1734", ALC880_F1734),
2526 SND_PCI_QUIRK(0x1734, 0x10b0, "Fujitsu", ALC880_FUJITSU),
2527
2528 SND_PCI_QUIRK(0x1854, 0x003b, "LG", ALC880_LG),
2529 SND_PCI_QUIRK(0x1854, 0x0068, "LG w1", ALC880_LG),
2530 SND_PCI_QUIRK(0x1854, 0x0018, "LG LW20", ALC880_LG_LW),
2531 SND_PCI_QUIRK(0x1854, 0x0077, "LG LW25", ALC880_LG_LW),
2532
2533 SND_PCI_QUIRK(0x8086, 0xe308, "Intel mobo", ALC880_3ST_DIG),
2534 SND_PCI_QUIRK(0x8086, 0xe305, "Intel mobo", ALC880_3ST_DIG),
2535 SND_PCI_QUIRK(0x8086, 0xd402, "Intel mobo", ALC880_3ST_DIG),
2536 SND_PCI_QUIRK(0x8086, 0xd400, "Intel mobo", ALC880_5ST_DIG),
2537 SND_PCI_QUIRK(0x8086, 0xd401, "Intel mobo", ALC880_5ST_DIG),
2538 SND_PCI_QUIRK(0x8086, 0xe224, "Intel mobo", ALC880_5ST_DIG),
2539 SND_PCI_QUIRK(0x8086, 0xe400, "Intel mobo", ALC880_5ST_DIG),
2540 SND_PCI_QUIRK(0x8086, 0xe401, "Intel mobo", ALC880_5ST_DIG),
2541 SND_PCI_QUIRK(0x8086, 0xe402, "Intel mobo", ALC880_5ST_DIG),
2542 SND_PCI_QUIRK(0x8086, 0xa100, "Intel mobo", ALC880_5ST_DIG),
2543 SND_PCI_QUIRK(0x8086, 0, "Intel mobo", ALC880_3ST),
2544
2545 {}
2546 };
2547
2548 /*
2549 * ALC880 codec presets
2550 */
2551 static struct alc_config_preset alc880_presets[] = {
2552 [ALC880_3ST] = {
2553 .mixers = { alc880_three_stack_mixer },
2554 .init_verbs = { alc880_volume_init_verbs, alc880_pin_3stack_init_verbs },
2555 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
2556 .dac_nids = alc880_dac_nids,
2557 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
2558 .channel_mode = alc880_threestack_modes,
2559 .need_dac_fix = 1,
2560 .input_mux = &alc880_capture_source,
2561 },
2562 [ALC880_3ST_DIG] = {
2563 .mixers = { alc880_three_stack_mixer },
2564 .init_verbs = { alc880_volume_init_verbs, alc880_pin_3stack_init_verbs },
2565 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
2566 .dac_nids = alc880_dac_nids,
2567 .dig_out_nid = ALC880_DIGOUT_NID,
2568 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
2569 .channel_mode = alc880_threestack_modes,
2570 .need_dac_fix = 1,
2571 .input_mux = &alc880_capture_source,
2572 },
2573 [ALC880_TCL_S700] = {
2574 .mixers = { alc880_tcl_s700_mixer },
2575 .init_verbs = { alc880_volume_init_verbs,
2576 alc880_pin_tcl_S700_init_verbs,
2577 alc880_gpio2_init_verbs },
2578 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
2579 .dac_nids = alc880_dac_nids,
2580 .hp_nid = 0x03,
2581 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
2582 .channel_mode = alc880_2_jack_modes,
2583 .input_mux = &alc880_capture_source,
2584 },
2585 [ALC880_5ST] = {
2586 .mixers = { alc880_three_stack_mixer, alc880_five_stack_mixer},
2587 .init_verbs = { alc880_volume_init_verbs, alc880_pin_5stack_init_verbs },
2588 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
2589 .dac_nids = alc880_dac_nids,
2590 .num_channel_mode = ARRAY_SIZE(alc880_fivestack_modes),
2591 .channel_mode = alc880_fivestack_modes,
2592 .input_mux = &alc880_capture_source,
2593 },
2594 [ALC880_5ST_DIG] = {
2595 .mixers = { alc880_three_stack_mixer, alc880_five_stack_mixer },
2596 .init_verbs = { alc880_volume_init_verbs, alc880_pin_5stack_init_verbs },
2597 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
2598 .dac_nids = alc880_dac_nids,
2599 .dig_out_nid = ALC880_DIGOUT_NID,
2600 .num_channel_mode = ARRAY_SIZE(alc880_fivestack_modes),
2601 .channel_mode = alc880_fivestack_modes,
2602 .input_mux = &alc880_capture_source,
2603 },
2604 [ALC880_6ST] = {
2605 .mixers = { alc880_six_stack_mixer },
2606 .init_verbs = { alc880_volume_init_verbs, alc880_pin_6stack_init_verbs },
2607 .num_dacs = ARRAY_SIZE(alc880_6st_dac_nids),
2608 .dac_nids = alc880_6st_dac_nids,
2609 .num_channel_mode = ARRAY_SIZE(alc880_sixstack_modes),
2610 .channel_mode = alc880_sixstack_modes,
2611 .input_mux = &alc880_6stack_capture_source,
2612 },
2613 [ALC880_6ST_DIG] = {
2614 .mixers = { alc880_six_stack_mixer },
2615 .init_verbs = { alc880_volume_init_verbs, alc880_pin_6stack_init_verbs },
2616 .num_dacs = ARRAY_SIZE(alc880_6st_dac_nids),
2617 .dac_nids = alc880_6st_dac_nids,
2618 .dig_out_nid = ALC880_DIGOUT_NID,
2619 .num_channel_mode = ARRAY_SIZE(alc880_sixstack_modes),
2620 .channel_mode = alc880_sixstack_modes,
2621 .input_mux = &alc880_6stack_capture_source,
2622 },
2623 [ALC880_W810] = {
2624 .mixers = { alc880_w810_base_mixer },
2625 .init_verbs = { alc880_volume_init_verbs, alc880_pin_w810_init_verbs,
2626 alc880_gpio2_init_verbs },
2627 .num_dacs = ARRAY_SIZE(alc880_w810_dac_nids),
2628 .dac_nids = alc880_w810_dac_nids,
2629 .dig_out_nid = ALC880_DIGOUT_NID,
2630 .num_channel_mode = ARRAY_SIZE(alc880_w810_modes),
2631 .channel_mode = alc880_w810_modes,
2632 .input_mux = &alc880_capture_source,
2633 },
2634 [ALC880_Z71V] = {
2635 .mixers = { alc880_z71v_mixer },
2636 .init_verbs = { alc880_volume_init_verbs, alc880_pin_z71v_init_verbs },
2637 .num_dacs = ARRAY_SIZE(alc880_z71v_dac_nids),
2638 .dac_nids = alc880_z71v_dac_nids,
2639 .dig_out_nid = ALC880_DIGOUT_NID,
2640 .hp_nid = 0x03,
2641 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
2642 .channel_mode = alc880_2_jack_modes,
2643 .input_mux = &alc880_capture_source,
2644 },
2645 [ALC880_F1734] = {
2646 .mixers = { alc880_f1734_mixer },
2647 .init_verbs = { alc880_volume_init_verbs, alc880_pin_f1734_init_verbs },
2648 .num_dacs = ARRAY_SIZE(alc880_f1734_dac_nids),
2649 .dac_nids = alc880_f1734_dac_nids,
2650 .hp_nid = 0x02,
2651 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
2652 .channel_mode = alc880_2_jack_modes,
2653 .input_mux = &alc880_capture_source,
2654 },
2655 [ALC880_ASUS] = {
2656 .mixers = { alc880_asus_mixer },
2657 .init_verbs = { alc880_volume_init_verbs, alc880_pin_asus_init_verbs,
2658 alc880_gpio1_init_verbs },
2659 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
2660 .dac_nids = alc880_asus_dac_nids,
2661 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
2662 .channel_mode = alc880_asus_modes,
2663 .need_dac_fix = 1,
2664 .input_mux = &alc880_capture_source,
2665 },
2666 [ALC880_ASUS_DIG] = {
2667 .mixers = { alc880_asus_mixer },
2668 .init_verbs = { alc880_volume_init_verbs, alc880_pin_asus_init_verbs,
2669 alc880_gpio1_init_verbs },
2670 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
2671 .dac_nids = alc880_asus_dac_nids,
2672 .dig_out_nid = ALC880_DIGOUT_NID,
2673 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
2674 .channel_mode = alc880_asus_modes,
2675 .need_dac_fix = 1,
2676 .input_mux = &alc880_capture_source,
2677 },
2678 [ALC880_ASUS_DIG2] = {
2679 .mixers = { alc880_asus_mixer },
2680 .init_verbs = { alc880_volume_init_verbs, alc880_pin_asus_init_verbs,
2681 alc880_gpio2_init_verbs }, /* use GPIO2 */
2682 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
2683 .dac_nids = alc880_asus_dac_nids,
2684 .dig_out_nid = ALC880_DIGOUT_NID,
2685 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
2686 .channel_mode = alc880_asus_modes,
2687 .need_dac_fix = 1,
2688 .input_mux = &alc880_capture_source,
2689 },
2690 [ALC880_ASUS_W1V] = {
2691 .mixers = { alc880_asus_mixer, alc880_asus_w1v_mixer },
2692 .init_verbs = { alc880_volume_init_verbs, alc880_pin_asus_init_verbs,
2693 alc880_gpio1_init_verbs },
2694 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
2695 .dac_nids = alc880_asus_dac_nids,
2696 .dig_out_nid = ALC880_DIGOUT_NID,
2697 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
2698 .channel_mode = alc880_asus_modes,
2699 .need_dac_fix = 1,
2700 .input_mux = &alc880_capture_source,
2701 },
2702 [ALC880_UNIWILL_DIG] = {
2703 .mixers = { alc880_asus_mixer, alc880_pcbeep_mixer },
2704 .init_verbs = { alc880_volume_init_verbs,
2705 alc880_pin_asus_init_verbs },
2706 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
2707 .dac_nids = alc880_asus_dac_nids,
2708 .dig_out_nid = ALC880_DIGOUT_NID,
2709 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
2710 .channel_mode = alc880_asus_modes,
2711 .need_dac_fix = 1,
2712 .input_mux = &alc880_capture_source,
2713 },
2714 [ALC880_UNIWILL] = {
2715 .mixers = { alc880_uniwill_mixer },
2716 .init_verbs = { alc880_volume_init_verbs,
2717 alc880_uniwill_init_verbs },
2718 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
2719 .dac_nids = alc880_asus_dac_nids,
2720 .dig_out_nid = ALC880_DIGOUT_NID,
2721 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
2722 .channel_mode = alc880_threestack_modes,
2723 .need_dac_fix = 1,
2724 .input_mux = &alc880_capture_source,
2725 .unsol_event = alc880_uniwill_unsol_event,
2726 .init_hook = alc880_uniwill_automute,
2727 },
2728 [ALC880_UNIWILL_P53] = {
2729 .mixers = { alc880_uniwill_p53_mixer },
2730 .init_verbs = { alc880_volume_init_verbs,
2731 alc880_uniwill_p53_init_verbs },
2732 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
2733 .dac_nids = alc880_asus_dac_nids,
2734 .num_channel_mode = ARRAY_SIZE(alc880_w810_modes),
2735 .channel_mode = alc880_threestack_modes,
2736 .input_mux = &alc880_capture_source,
2737 .unsol_event = alc880_uniwill_p53_unsol_event,
2738 .init_hook = alc880_uniwill_p53_hp_automute,
2739 },
2740 [ALC880_FUJITSU] = {
2741 .mixers = { alc880_fujitsu_mixer,
2742 alc880_pcbeep_mixer, },
2743 .init_verbs = { alc880_volume_init_verbs,
2744 alc880_uniwill_p53_init_verbs,
2745 alc880_beep_init_verbs },
2746 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
2747 .dac_nids = alc880_dac_nids,
2748 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
2749 .channel_mode = alc880_2_jack_modes,
2750 .input_mux = &alc880_capture_source,
2751 .unsol_event = alc880_uniwill_p53_unsol_event,
2752 .init_hook = alc880_uniwill_p53_hp_automute,
2753 },
2754 [ALC880_CLEVO] = {
2755 .mixers = { alc880_three_stack_mixer },
2756 .init_verbs = { alc880_volume_init_verbs,
2757 alc880_pin_clevo_init_verbs },
2758 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
2759 .dac_nids = alc880_dac_nids,
2760 .hp_nid = 0x03,
2761 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
2762 .channel_mode = alc880_threestack_modes,
2763 .need_dac_fix = 1,
2764 .input_mux = &alc880_capture_source,
2765 },
2766 [ALC880_LG] = {
2767 .mixers = { alc880_lg_mixer },
2768 .init_verbs = { alc880_volume_init_verbs,
2769 alc880_lg_init_verbs },
2770 .num_dacs = ARRAY_SIZE(alc880_lg_dac_nids),
2771 .dac_nids = alc880_lg_dac_nids,
2772 .dig_out_nid = ALC880_DIGOUT_NID,
2773 .num_channel_mode = ARRAY_SIZE(alc880_lg_ch_modes),
2774 .channel_mode = alc880_lg_ch_modes,
2775 .need_dac_fix = 1,
2776 .input_mux = &alc880_lg_capture_source,
2777 .unsol_event = alc880_lg_unsol_event,
2778 .init_hook = alc880_lg_automute,
2779 },
2780 [ALC880_LG_LW] = {
2781 .mixers = { alc880_lg_lw_mixer },
2782 .init_verbs = { alc880_volume_init_verbs,
2783 alc880_lg_lw_init_verbs },
2784 .num_dacs = 1,
2785 .dac_nids = alc880_dac_nids,
2786 .dig_out_nid = ALC880_DIGOUT_NID,
2787 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
2788 .channel_mode = alc880_2_jack_modes,
2789 .input_mux = &alc880_lg_lw_capture_source,
2790 .unsol_event = alc880_lg_lw_unsol_event,
2791 .init_hook = alc880_lg_lw_automute,
2792 },
2793 #ifdef CONFIG_SND_DEBUG
2794 [ALC880_TEST] = {
2795 .mixers = { alc880_test_mixer },
2796 .init_verbs = { alc880_test_init_verbs },
2797 .num_dacs = ARRAY_SIZE(alc880_test_dac_nids),
2798 .dac_nids = alc880_test_dac_nids,
2799 .dig_out_nid = ALC880_DIGOUT_NID,
2800 .num_channel_mode = ARRAY_SIZE(alc880_test_modes),
2801 .channel_mode = alc880_test_modes,
2802 .input_mux = &alc880_test_capture_source,
2803 },
2804 #endif
2805 };
2806
2807 /*
2808 * Automatic parse of I/O pins from the BIOS configuration
2809 */
2810
2811 #define NUM_CONTROL_ALLOC 32
2812 #define NUM_VERB_ALLOC 32
2813
2814 enum {
2815 ALC_CTL_WIDGET_VOL,
2816 ALC_CTL_WIDGET_MUTE,
2817 ALC_CTL_BIND_MUTE,
2818 };
2819 static struct snd_kcontrol_new alc880_control_templates[] = {
2820 HDA_CODEC_VOLUME(NULL, 0, 0, 0),
2821 HDA_CODEC_MUTE(NULL, 0, 0, 0),
2822 HDA_BIND_MUTE(NULL, 0, 0, 0),
2823 };
2824
2825 /* add dynamic controls */
2826 static int add_control(struct alc_spec *spec, int type, const char *name, unsigned long val)
2827 {
2828 struct snd_kcontrol_new *knew;
2829
2830 if (spec->num_kctl_used >= spec->num_kctl_alloc) {
2831 int num = spec->num_kctl_alloc + NUM_CONTROL_ALLOC;
2832
2833 knew = kcalloc(num + 1, sizeof(*knew), GFP_KERNEL); /* array + terminator */
2834 if (! knew)
2835 return -ENOMEM;
2836 if (spec->kctl_alloc) {
2837 memcpy(knew, spec->kctl_alloc, sizeof(*knew) * spec->num_kctl_alloc);
2838 kfree(spec->kctl_alloc);
2839 }
2840 spec->kctl_alloc = knew;
2841 spec->num_kctl_alloc = num;
2842 }
2843
2844 knew = &spec->kctl_alloc[spec->num_kctl_used];
2845 *knew = alc880_control_templates[type];
2846 knew->name = kstrdup(name, GFP_KERNEL);
2847 if (! knew->name)
2848 return -ENOMEM;
2849 knew->private_value = val;
2850 spec->num_kctl_used++;
2851 return 0;
2852 }
2853
2854 #define alc880_is_fixed_pin(nid) ((nid) >= 0x14 && (nid) <= 0x17)
2855 #define alc880_fixed_pin_idx(nid) ((nid) - 0x14)
2856 #define alc880_is_multi_pin(nid) ((nid) >= 0x18)
2857 #define alc880_multi_pin_idx(nid) ((nid) - 0x18)
2858 #define alc880_is_input_pin(nid) ((nid) >= 0x18)
2859 #define alc880_input_pin_idx(nid) ((nid) - 0x18)
2860 #define alc880_idx_to_dac(nid) ((nid) + 0x02)
2861 #define alc880_dac_to_idx(nid) ((nid) - 0x02)
2862 #define alc880_idx_to_mixer(nid) ((nid) + 0x0c)
2863 #define alc880_idx_to_selector(nid) ((nid) + 0x10)
2864 #define ALC880_PIN_CD_NID 0x1c
2865
2866 /* fill in the dac_nids table from the parsed pin configuration */
2867 static int alc880_auto_fill_dac_nids(struct alc_spec *spec, const struct auto_pin_cfg *cfg)
2868 {
2869 hda_nid_t nid;
2870 int assigned[4];
2871 int i, j;
2872
2873 memset(assigned, 0, sizeof(assigned));
2874 spec->multiout.dac_nids = spec->private_dac_nids;
2875
2876 /* check the pins hardwired to audio widget */
2877 for (i = 0; i < cfg->line_outs; i++) {
2878 nid = cfg->line_out_pins[i];
2879 if (alc880_is_fixed_pin(nid)) {
2880 int idx = alc880_fixed_pin_idx(nid);
2881 spec->multiout.dac_nids[i] = alc880_idx_to_dac(idx);
2882 assigned[idx] = 1;
2883 }
2884 }
2885 /* left pins can be connect to any audio widget */
2886 for (i = 0; i < cfg->line_outs; i++) {
2887 nid = cfg->line_out_pins[i];
2888 if (alc880_is_fixed_pin(nid))
2889 continue;
2890 /* search for an empty channel */
2891 for (j = 0; j < cfg->line_outs; j++) {
2892 if (! assigned[j]) {
2893 spec->multiout.dac_nids[i] = alc880_idx_to_dac(j);
2894 assigned[j] = 1;
2895 break;
2896 }
2897 }
2898 }
2899 spec->multiout.num_dacs = cfg->line_outs;
2900 return 0;
2901 }
2902
2903 /* add playback controls from the parsed DAC table */
2904 static int alc880_auto_create_multi_out_ctls(struct alc_spec *spec,
2905 const struct auto_pin_cfg *cfg)
2906 {
2907 char name[32];
2908 static const char *chname[4] = { "Front", "Surround", NULL /*CLFE*/, "Side" };
2909 hda_nid_t nid;
2910 int i, err;
2911
2912 for (i = 0; i < cfg->line_outs; i++) {
2913 if (! spec->multiout.dac_nids[i])
2914 continue;
2915 nid = alc880_idx_to_mixer(alc880_dac_to_idx(spec->multiout.dac_nids[i]));
2916 if (i == 2) {
2917 /* Center/LFE */
2918 if ((err = add_control(spec, ALC_CTL_WIDGET_VOL, "Center Playback Volume",
2919 HDA_COMPOSE_AMP_VAL(nid, 1, 0, HDA_OUTPUT))) < 0)
2920 return err;
2921 if ((err = add_control(spec, ALC_CTL_WIDGET_VOL, "LFE Playback Volume",
2922 HDA_COMPOSE_AMP_VAL(nid, 2, 0, HDA_OUTPUT))) < 0)
2923 return err;
2924 if ((err = add_control(spec, ALC_CTL_BIND_MUTE, "Center Playback Switch",
2925 HDA_COMPOSE_AMP_VAL(nid, 1, 2, HDA_INPUT))) < 0)
2926 return err;
2927 if ((err = add_control(spec, ALC_CTL_BIND_MUTE, "LFE Playback Switch",
2928 HDA_COMPOSE_AMP_VAL(nid, 2, 2, HDA_INPUT))) < 0)
2929 return err;
2930 } else {
2931 sprintf(name, "%s Playback Volume", chname[i]);
2932 if ((err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
2933 HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT))) < 0)
2934 return err;
2935 sprintf(name, "%s Playback Switch", chname[i]);
2936 if ((err = add_control(spec, ALC_CTL_BIND_MUTE, name,
2937 HDA_COMPOSE_AMP_VAL(nid, 3, 2, HDA_INPUT))) < 0)
2938 return err;
2939 }
2940 }
2941 return 0;
2942 }
2943
2944 /* add playback controls for speaker and HP outputs */
2945 static int alc880_auto_create_extra_out(struct alc_spec *spec, hda_nid_t pin,
2946 const char *pfx)
2947 {
2948 hda_nid_t nid;
2949 int err;
2950 char name[32];
2951
2952 if (! pin)
2953 return 0;
2954
2955 if (alc880_is_fixed_pin(pin)) {
2956 nid = alc880_idx_to_dac(alc880_fixed_pin_idx(pin));
2957 /* specify the DAC as the extra output */
2958 if (! spec->multiout.hp_nid)
2959 spec->multiout.hp_nid = nid;
2960 else
2961 spec->multiout.extra_out_nid[0] = nid;
2962 /* control HP volume/switch on the output mixer amp */
2963 nid = alc880_idx_to_mixer(alc880_fixed_pin_idx(pin));
2964 sprintf(name, "%s Playback Volume", pfx);
2965 if ((err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
2966 HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT))) < 0)
2967 return err;
2968 sprintf(name, "%s Playback Switch", pfx);
2969 if ((err = add_control(spec, ALC_CTL_BIND_MUTE, name,
2970 HDA_COMPOSE_AMP_VAL(nid, 3, 2, HDA_INPUT))) < 0)
2971 return err;
2972 } else if (alc880_is_multi_pin(pin)) {
2973 /* set manual connection */
2974 /* we have only a switch on HP-out PIN */
2975 sprintf(name, "%s Playback Switch", pfx);
2976 if ((err = add_control(spec, ALC_CTL_WIDGET_MUTE, name,
2977 HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT))) < 0)
2978 return err;
2979 }
2980 return 0;
2981 }
2982
2983 /* create input playback/capture controls for the given pin */
2984 static int new_analog_input(struct alc_spec *spec, hda_nid_t pin, const char *ctlname,
2985 int idx, hda_nid_t mix_nid)
2986 {
2987 char name[32];
2988 int err;
2989
2990 sprintf(name, "%s Playback Volume", ctlname);
2991 if ((err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
2992 HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT))) < 0)
2993 return err;
2994 sprintf(name, "%s Playback Switch", ctlname);
2995 if ((err = add_control(spec, ALC_CTL_WIDGET_MUTE, name,
2996 HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT))) < 0)
2997 return err;
2998 return 0;
2999 }
3000
3001 /* create playback/capture controls for input pins */
3002 static int alc880_auto_create_analog_input_ctls(struct alc_spec *spec,
3003 const struct auto_pin_cfg *cfg)
3004 {
3005 struct hda_input_mux *imux = &spec->private_imux;
3006 int i, err, idx;
3007
3008 for (i = 0; i < AUTO_PIN_LAST; i++) {
3009 if (alc880_is_input_pin(cfg->input_pins[i])) {
3010 idx = alc880_input_pin_idx(cfg->input_pins[i]);
3011 err = new_analog_input(spec, cfg->input_pins[i],
3012 auto_pin_cfg_labels[i],
3013 idx, 0x0b);
3014 if (err < 0)
3015 return err;
3016 imux->items[imux->num_items].label = auto_pin_cfg_labels[i];
3017 imux->items[imux->num_items].index = alc880_input_pin_idx(cfg->input_pins[i]);
3018 imux->num_items++;
3019 }
3020 }
3021 return 0;
3022 }
3023
3024 static void alc880_auto_set_output_and_unmute(struct hda_codec *codec,
3025 hda_nid_t nid, int pin_type,
3026 int dac_idx)
3027 {
3028 /* set as output */
3029 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, pin_type);
3030 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE);
3031 /* need the manual connection? */
3032 if (alc880_is_multi_pin(nid)) {
3033 struct alc_spec *spec = codec->spec;
3034 int idx = alc880_multi_pin_idx(nid);
3035 snd_hda_codec_write(codec, alc880_idx_to_selector(idx), 0,
3036 AC_VERB_SET_CONNECT_SEL,
3037 alc880_dac_to_idx(spec->multiout.dac_nids[dac_idx]));
3038 }
3039 }
3040
3041 static void alc880_auto_init_multi_out(struct hda_codec *codec)
3042 {
3043 struct alc_spec *spec = codec->spec;
3044 int i;
3045
3046 alc_subsystem_id(codec, 0x15, 0x1b, 0x14);
3047 for (i = 0; i < spec->autocfg.line_outs; i++) {
3048 hda_nid_t nid = spec->autocfg.line_out_pins[i];
3049 alc880_auto_set_output_and_unmute(codec, nid, PIN_OUT, i);
3050 }
3051 }
3052
3053 static void alc880_auto_init_extra_out(struct hda_codec *codec)
3054 {
3055 struct alc_spec *spec = codec->spec;
3056 hda_nid_t pin;
3057
3058 pin = spec->autocfg.speaker_pins[0];
3059 if (pin) /* connect to front */
3060 alc880_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
3061 pin = spec->autocfg.hp_pins[0];
3062 if (pin) /* connect to front */
3063 alc880_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
3064 }
3065
3066 static void alc880_auto_init_analog_input(struct hda_codec *codec)
3067 {
3068 struct alc_spec *spec = codec->spec;
3069 int i;
3070
3071 for (i = 0; i < AUTO_PIN_LAST; i++) {
3072 hda_nid_t nid = spec->autocfg.input_pins[i];
3073 if (alc880_is_input_pin(nid)) {
3074 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
3075 i <= AUTO_PIN_FRONT_MIC ? PIN_VREF80 : PIN_IN);
3076 if (nid != ALC880_PIN_CD_NID)
3077 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE,
3078 AMP_OUT_MUTE);
3079 }
3080 }
3081 }
3082
3083 /* parse the BIOS configuration and set up the alc_spec */
3084 /* return 1 if successful, 0 if the proper config is not found, or a negative error code */
3085 static int alc880_parse_auto_config(struct hda_codec *codec)
3086 {
3087 struct alc_spec *spec = codec->spec;
3088 int err;
3089 static hda_nid_t alc880_ignore[] = { 0x1d, 0 };
3090
3091 if ((err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
3092 alc880_ignore)) < 0)
3093 return err;
3094 if (! spec->autocfg.line_outs)
3095 return 0; /* can't find valid BIOS pin config */
3096
3097 if ((err = alc880_auto_fill_dac_nids(spec, &spec->autocfg)) < 0 ||
3098 (err = alc880_auto_create_multi_out_ctls(spec, &spec->autocfg)) < 0 ||
3099 (err = alc880_auto_create_extra_out(spec,
3100 spec->autocfg.speaker_pins[0],
3101 "Speaker")) < 0 ||
3102 (err = alc880_auto_create_extra_out(spec, spec->autocfg.hp_pins[0],
3103 "Headphone")) < 0 ||
3104 (err = alc880_auto_create_analog_input_ctls(spec, &spec->autocfg)) < 0)
3105 return err;
3106
3107 spec->multiout.max_channels = spec->multiout.num_dacs * 2;
3108
3109 if (spec->autocfg.dig_out_pin)
3110 spec->multiout.dig_out_nid = ALC880_DIGOUT_NID;
3111 if (spec->autocfg.dig_in_pin)
3112 spec->dig_in_nid = ALC880_DIGIN_NID;
3113
3114 if (spec->kctl_alloc)
3115 spec->mixers[spec->num_mixers++] = spec->kctl_alloc;
3116
3117 spec->init_verbs[spec->num_init_verbs++] = alc880_volume_init_verbs;
3118
3119 spec->num_mux_defs = 1;
3120 spec->input_mux = &spec->private_imux;
3121
3122 return 1;
3123 }
3124
3125 /* additional initialization for auto-configuration model */
3126 static void alc880_auto_init(struct hda_codec *codec)
3127 {
3128 alc880_auto_init_multi_out(codec);
3129 alc880_auto_init_extra_out(codec);
3130 alc880_auto_init_analog_input(codec);
3131 }
3132
3133 /*
3134 * OK, here we have finally the patch for ALC880
3135 */
3136
3137 static int patch_alc880(struct hda_codec *codec)
3138 {
3139 struct alc_spec *spec;
3140 int board_config;
3141 int err;
3142
3143 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
3144 if (spec == NULL)
3145 return -ENOMEM;
3146
3147 codec->spec = spec;
3148
3149 board_config = snd_hda_check_board_config(codec, ALC880_MODEL_LAST,
3150 alc880_models,
3151 alc880_cfg_tbl);
3152 if (board_config < 0) {
3153 printk(KERN_INFO "hda_codec: Unknown model for ALC880, "
3154 "trying auto-probe from BIOS...\n");
3155 board_config = ALC880_AUTO;
3156 }
3157
3158 if (board_config == ALC880_AUTO) {
3159 /* automatic parse from the BIOS config */
3160 err = alc880_parse_auto_config(codec);
3161 if (err < 0) {
3162 alc_free(codec);
3163 return err;
3164 } else if (! err) {
3165 printk(KERN_INFO
3166 "hda_codec: Cannot set up configuration "
3167 "from BIOS. Using 3-stack mode...\n");
3168 board_config = ALC880_3ST;
3169 }
3170 }
3171
3172 if (board_config != ALC880_AUTO)
3173 setup_preset(spec, &alc880_presets[board_config]);
3174
3175 spec->stream_name_analog = "ALC880 Analog";
3176 spec->stream_analog_playback = &alc880_pcm_analog_playback;
3177 spec->stream_analog_capture = &alc880_pcm_analog_capture;
3178
3179 spec->stream_name_digital = "ALC880 Digital";
3180 spec->stream_digital_playback = &alc880_pcm_digital_playback;
3181 spec->stream_digital_capture = &alc880_pcm_digital_capture;
3182
3183 if (! spec->adc_nids && spec->input_mux) {
3184 /* check whether NID 0x07 is valid */
3185 unsigned int wcap = get_wcaps(codec, alc880_adc_nids[0]);
3186 wcap = (wcap & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT; /* get type */
3187 if (wcap != AC_WID_AUD_IN) {
3188 spec->adc_nids = alc880_adc_nids_alt;
3189 spec->num_adc_nids = ARRAY_SIZE(alc880_adc_nids_alt);
3190 spec->mixers[spec->num_mixers] = alc880_capture_alt_mixer;
3191 spec->num_mixers++;
3192 } else {
3193 spec->adc_nids = alc880_adc_nids;
3194 spec->num_adc_nids = ARRAY_SIZE(alc880_adc_nids);
3195 spec->mixers[spec->num_mixers] = alc880_capture_mixer;
3196 spec->num_mixers++;
3197 }
3198 }
3199
3200 codec->patch_ops = alc_patch_ops;
3201 if (board_config == ALC880_AUTO)
3202 spec->init_hook = alc880_auto_init;
3203
3204 return 0;
3205 }
3206
3207
3208 /*
3209 * ALC260 support
3210 */
3211
3212 static hda_nid_t alc260_dac_nids[1] = {
3213 /* front */
3214 0x02,
3215 };
3216
3217 static hda_nid_t alc260_adc_nids[1] = {
3218 /* ADC0 */
3219 0x04,
3220 };
3221
3222 static hda_nid_t alc260_adc_nids_alt[1] = {
3223 /* ADC1 */
3224 0x05,
3225 };
3226
3227 static hda_nid_t alc260_hp_adc_nids[2] = {
3228 /* ADC1, 0 */
3229 0x05, 0x04
3230 };
3231
3232 /* NIDs used when simultaneous access to both ADCs makes sense. Note that
3233 * alc260_capture_mixer assumes ADC0 (nid 0x04) is the first ADC.
3234 */
3235 static hda_nid_t alc260_dual_adc_nids[2] = {
3236 /* ADC0, ADC1 */
3237 0x04, 0x05
3238 };
3239
3240 #define ALC260_DIGOUT_NID 0x03
3241 #define ALC260_DIGIN_NID 0x06
3242
3243 static struct hda_input_mux alc260_capture_source = {
3244 .num_items = 4,
3245 .items = {
3246 { "Mic", 0x0 },
3247 { "Front Mic", 0x1 },
3248 { "Line", 0x2 },
3249 { "CD", 0x4 },
3250 },
3251 };
3252
3253 /* On Fujitsu S702x laptops capture only makes sense from Mic/LineIn jack,
3254 * headphone jack and the internal CD lines since these are the only pins at
3255 * which audio can appear. For flexibility, also allow the option of
3256 * recording the mixer output on the second ADC (ADC0 doesn't have a
3257 * connection to the mixer output).
3258 */
3259 static struct hda_input_mux alc260_fujitsu_capture_sources[2] = {
3260 {
3261 .num_items = 3,
3262 .items = {
3263 { "Mic/Line", 0x0 },
3264 { "CD", 0x4 },
3265 { "Headphone", 0x2 },
3266 },
3267 },
3268 {
3269 .num_items = 4,
3270 .items = {
3271 { "Mic/Line", 0x0 },
3272 { "CD", 0x4 },
3273 { "Headphone", 0x2 },
3274 { "Mixer", 0x5 },
3275 },
3276 },
3277
3278 };
3279
3280 /* Acer TravelMate(/Extensa/Aspire) notebooks have similar configuration to
3281 * the Fujitsu S702x, but jacks are marked differently.
3282 */
3283 static struct hda_input_mux alc260_acer_capture_sources[2] = {
3284 {
3285 .num_items = 4,
3286 .items = {
3287 { "Mic", 0x0 },
3288 { "Line", 0x2 },
3289 { "CD", 0x4 },
3290 { "Headphone", 0x5 },
3291 },
3292 },
3293 {
3294 .num_items = 5,
3295 .items = {
3296 { "Mic", 0x0 },
3297 { "Line", 0x2 },
3298 { "CD", 0x4 },
3299 { "Headphone", 0x6 },
3300 { "Mixer", 0x5 },
3301 },
3302 },
3303 };
3304 /*
3305 * This is just place-holder, so there's something for alc_build_pcms to look
3306 * at when it calculates the maximum number of channels. ALC260 has no mixer
3307 * element which allows changing the channel mode, so the verb list is
3308 * never used.
3309 */
3310 static struct hda_channel_mode alc260_modes[1] = {
3311 { 2, NULL },
3312 };
3313
3314
3315 /* Mixer combinations
3316 *
3317 * basic: base_output + input + pc_beep + capture
3318 * HP: base_output + input + capture_alt
3319 * HP_3013: hp_3013 + input + capture
3320 * fujitsu: fujitsu + capture
3321 * acer: acer + capture
3322 */
3323
3324 static struct snd_kcontrol_new alc260_base_output_mixer[] = {
3325 HDA_CODEC_VOLUME("Front Playback Volume", 0x08, 0x0, HDA_OUTPUT),
3326 HDA_BIND_MUTE("Front Playback Switch", 0x08, 2, HDA_INPUT),
3327 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x09, 0x0, HDA_OUTPUT),
3328 HDA_BIND_MUTE("Headphone Playback Switch", 0x09, 2, HDA_INPUT),
3329 HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT),
3330 HDA_BIND_MUTE_MONO("Mono Playback Switch", 0x0a, 1, 2, HDA_INPUT),
3331 { } /* end */
3332 };
3333
3334 static struct snd_kcontrol_new alc260_input_mixer[] = {
3335 HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
3336 HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
3337 HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
3338 HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
3339 HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
3340 HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
3341 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x07, 0x01, HDA_INPUT),
3342 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x07, 0x01, HDA_INPUT),
3343 { } /* end */
3344 };
3345
3346 static struct snd_kcontrol_new alc260_pc_beep_mixer[] = {
3347 HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x07, 0x05, HDA_INPUT),
3348 HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x07, 0x05, HDA_INPUT),
3349 { } /* end */
3350 };
3351
3352 static struct snd_kcontrol_new alc260_hp_3013_mixer[] = {
3353 HDA_CODEC_VOLUME("Front Playback Volume", 0x09, 0x0, HDA_OUTPUT),
3354 HDA_CODEC_MUTE("Front Playback Switch", 0x10, 0x0, HDA_OUTPUT),
3355 HDA_CODEC_VOLUME("Aux-In Playback Volume", 0x07, 0x06, HDA_INPUT),
3356 HDA_CODEC_MUTE("Aux-In Playback Switch", 0x07, 0x06, HDA_INPUT),
3357 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x08, 0x0, HDA_OUTPUT),
3358 HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
3359 HDA_CODEC_VOLUME_MONO("iSpeaker Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT),
3360 HDA_CODEC_MUTE_MONO("iSpeaker Playback Switch", 0x11, 1, 0x0, HDA_OUTPUT),
3361 { } /* end */
3362 };
3363
3364 /* Fujitsu S702x series laptops. ALC260 pin usage: Mic/Line jack = 0x12,
3365 * HP jack = 0x14, CD audio = 0x16, internal speaker = 0x10.
3366 */
3367 static struct snd_kcontrol_new alc260_fujitsu_mixer[] = {
3368 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x08, 0x0, HDA_OUTPUT),
3369 HDA_BIND_MUTE("Headphone Playback Switch", 0x08, 2, HDA_INPUT),
3370 ALC_PIN_MODE("Headphone Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
3371 HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
3372 HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
3373 HDA_CODEC_VOLUME("Mic/Line Playback Volume", 0x07, 0x0, HDA_INPUT),
3374 HDA_CODEC_MUTE("Mic/Line Playback Switch", 0x07, 0x0, HDA_INPUT),
3375 ALC_PIN_MODE("Mic/Line Jack Mode", 0x12, ALC_PIN_DIR_IN),
3376 HDA_CODEC_VOLUME("Beep Playback Volume", 0x07, 0x05, HDA_INPUT),
3377 HDA_CODEC_MUTE("Beep Playback Switch", 0x07, 0x05, HDA_INPUT),
3378 HDA_CODEC_VOLUME("Internal Speaker Playback Volume", 0x09, 0x0, HDA_OUTPUT),
3379 HDA_BIND_MUTE("Internal Speaker Playback Switch", 0x09, 2, HDA_INPUT),
3380 { } /* end */
3381 };
3382
3383 /* Mixer for Acer TravelMate(/Extensa/Aspire) notebooks. Note that current
3384 * versions of the ALC260 don't act on requests to enable mic bias from NID
3385 * 0x0f (used to drive the headphone jack in these laptops). The ALC260
3386 * datasheet doesn't mention this restriction. At this stage it's not clear
3387 * whether this behaviour is intentional or is a hardware bug in chip
3388 * revisions available in early 2006. Therefore for now allow the
3389 * "Headphone Jack Mode" control to span all choices, but if it turns out
3390 * that the lack of mic bias for this NID is intentional we could change the
3391 * mode from ALC_PIN_DIR_INOUT to ALC_PIN_DIR_INOUT_NOMICBIAS.
3392 *
3393 * In addition, Acer TravelMate(/Extensa/Aspire) notebooks in early 2006
3394 * don't appear to make the mic bias available from the "line" jack, even
3395 * though the NID used for this jack (0x14) can supply it. The theory is
3396 * that perhaps Acer have included blocking capacitors between the ALC260
3397 * and the output jack. If this turns out to be the case for all such
3398 * models the "Line Jack Mode" mode could be changed from ALC_PIN_DIR_INOUT
3399 * to ALC_PIN_DIR_INOUT_NOMICBIAS.
3400 *
3401 * The C20x Tablet series have a mono internal speaker which is controlled
3402 * via the chip's Mono sum widget and pin complex, so include the necessary
3403 * controls for such models. On models without a "mono speaker" the control
3404 * won't do anything.
3405 */
3406 static struct snd_kcontrol_new alc260_acer_mixer[] = {
3407 HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT),
3408 HDA_BIND_MUTE("Master Playback Switch", 0x08, 2, HDA_INPUT),
3409 ALC_PIN_MODE("Headphone Jack Mode", 0x0f, ALC_PIN_DIR_INOUT),
3410 HDA_CODEC_VOLUME_MONO("Mono Speaker Playback Volume", 0x0a, 1, 0x0,
3411 HDA_OUTPUT),
3412 HDA_BIND_MUTE_MONO("Mono Speaker Playback Switch", 0x0a, 1, 2,
3413 HDA_INPUT),
3414 HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
3415 HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
3416 HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
3417 HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
3418 ALC_PIN_MODE("Mic Jack Mode", 0x12, ALC_PIN_DIR_IN),
3419 HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
3420 HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
3421 ALC_PIN_MODE("Line Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
3422 HDA_CODEC_VOLUME("Beep Playback Volume", 0x07, 0x05, HDA_INPUT),
3423 HDA_CODEC_MUTE("Beep Playback Switch", 0x07, 0x05, HDA_INPUT),
3424 { } /* end */
3425 };
3426
3427 /* Packard bell V7900 ALC260 pin usage: HP = 0x0f, Mic jack = 0x12,
3428 * Line In jack = 0x14, CD audio = 0x16, pc beep = 0x17.
3429 */
3430 static struct snd_kcontrol_new alc260_will_mixer[] = {
3431 HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT),
3432 HDA_BIND_MUTE("Master Playback Switch", 0x08, 0x2, HDA_INPUT),
3433 HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
3434 HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
3435 ALC_PIN_MODE("Mic Jack Mode", 0x12, ALC_PIN_DIR_IN),
3436 HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
3437 HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
3438 ALC_PIN_MODE("Line Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
3439 HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
3440 HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
3441 HDA_CODEC_VOLUME("Beep Playback Volume", 0x07, 0x05, HDA_INPUT),
3442 HDA_CODEC_MUTE("Beep Playback Switch", 0x07, 0x05, HDA_INPUT),
3443 { } /* end */
3444 };
3445
3446 /* Replacer 672V ALC260 pin usage: Mic jack = 0x12,
3447 * Line In jack = 0x14, ATAPI Mic = 0x13, speaker = 0x0f.
3448 */
3449 static struct snd_kcontrol_new alc260_replacer_672v_mixer[] = {
3450 HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT),
3451 HDA_BIND_MUTE("Master Playback Switch", 0x08, 0x2, HDA_INPUT),
3452 HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
3453 HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
3454 ALC_PIN_MODE("Mic Jack Mode", 0x12, ALC_PIN_DIR_IN),
3455 HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x07, 0x1, HDA_INPUT),
3456 HDA_CODEC_MUTE("ATATI Mic Playback Switch", 0x07, 0x1, HDA_INPUT),
3457 HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
3458 HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
3459 ALC_PIN_MODE("Line Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
3460 { } /* end */
3461 };
3462
3463 /* capture mixer elements */
3464 static struct snd_kcontrol_new alc260_capture_mixer[] = {
3465 HDA_CODEC_VOLUME("Capture Volume", 0x04, 0x0, HDA_INPUT),
3466 HDA_CODEC_MUTE("Capture Switch", 0x04, 0x0, HDA_INPUT),
3467 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x05, 0x0, HDA_INPUT),
3468 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x05, 0x0, HDA_INPUT),
3469 {
3470 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3471 /* The multiple "Capture Source" controls confuse alsamixer
3472 * So call somewhat different..
3473 * FIXME: the controls appear in the "playback" view!
3474 */
3475 /* .name = "Capture Source", */
3476 .name = "Input Source",
3477 .count = 2,
3478 .info = alc_mux_enum_info,
3479 .get = alc_mux_enum_get,
3480 .put = alc_mux_enum_put,
3481 },
3482 { } /* end */
3483 };
3484
3485 static struct snd_kcontrol_new alc260_capture_alt_mixer[] = {
3486 HDA_CODEC_VOLUME("Capture Volume", 0x05, 0x0, HDA_INPUT),
3487 HDA_CODEC_MUTE("Capture Switch", 0x05, 0x0, HDA_INPUT),
3488 {
3489 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3490 /* The multiple "Capture Source" controls confuse alsamixer
3491 * So call somewhat different..
3492 * FIXME: the controls appear in the "playback" view!
3493 */
3494 /* .name = "Capture Source", */
3495 .name = "Input Source",
3496 .count = 1,
3497 .info = alc_mux_enum_info,
3498 .get = alc_mux_enum_get,
3499 .put = alc_mux_enum_put,
3500 },
3501 { } /* end */
3502 };
3503
3504 /*
3505 * initialization verbs
3506 */
3507 static struct hda_verb alc260_init_verbs[] = {
3508 /* Line In pin widget for input */
3509 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3510 /* CD pin widget for input */
3511 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3512 /* Mic1 (rear panel) pin widget for input and vref at 80% */
3513 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3514 /* Mic2 (front panel) pin widget for input and vref at 80% */
3515 {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3516 /* LINE-2 is used for line-out in rear */
3517 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3518 /* select line-out */
3519 {0x0e, AC_VERB_SET_CONNECT_SEL, 0x00},
3520 /* LINE-OUT pin */
3521 {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3522 /* enable HP */
3523 {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3524 /* enable Mono */
3525 {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3526 /* mute capture amp left and right */
3527 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3528 /* set connection select to line in (default select for this ADC) */
3529 {0x04, AC_VERB_SET_CONNECT_SEL, 0x02},
3530 /* mute capture amp left and right */
3531 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3532 /* set connection select to line in (default select for this ADC) */
3533 {0x05, AC_VERB_SET_CONNECT_SEL, 0x02},
3534 /* set vol=0 Line-Out mixer amp left and right */
3535 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3536 /* unmute pin widget amp left and right (no gain on this amp) */
3537 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3538 /* set vol=0 HP mixer amp left and right */
3539 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3540 /* unmute pin widget amp left and right (no gain on this amp) */
3541 {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3542 /* set vol=0 Mono mixer amp left and right */
3543 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3544 /* unmute pin widget amp left and right (no gain on this amp) */
3545 {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3546 /* unmute LINE-2 out pin */
3547 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3548 /* Amp Indexes: CD = 0x04, Line In 1 = 0x02, Mic 1 = 0x00 & Line In 2 = 0x03 */
3549 /* mute CD */
3550 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
3551 /* mute Line In */
3552 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
3553 /* mute Mic */
3554 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3555 /* Amp Indexes: DAC = 0x01 & mixer = 0x00 */
3556 /* mute Front out path */
3557 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3558 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
3559 /* mute Headphone out path */
3560 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3561 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
3562 /* mute Mono out path */
3563 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3564 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
3565 { }
3566 };
3567
3568 #if 0 /* should be identical with alc260_init_verbs? */
3569 static struct hda_verb alc260_hp_init_verbs[] = {
3570 /* Headphone and output */
3571 {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
3572 /* mono output */
3573 {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
3574 /* Mic1 (rear panel) pin widget for input and vref at 80% */
3575 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
3576 /* Mic2 (front panel) pin widget for input and vref at 80% */
3577 {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
3578 /* Line In pin widget for input */
3579 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
3580 /* Line-2 pin widget for output */
3581 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
3582 /* CD pin widget for input */
3583 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
3584 /* unmute amp left and right */
3585 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000},
3586 /* set connection select to line in (default select for this ADC) */
3587 {0x04, AC_VERB_SET_CONNECT_SEL, 0x02},
3588 /* unmute Line-Out mixer amp left and right (volume = 0) */
3589 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
3590 /* mute pin widget amp left and right (no gain on this amp) */
3591 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
3592 /* unmute HP mixer amp left and right (volume = 0) */
3593 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
3594 /* mute pin widget amp left and right (no gain on this amp) */
3595 {0x10, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
3596 /* Amp Indexes: CD = 0x04, Line In 1 = 0x02, Mic 1 = 0x00 & Line In 2 = 0x03 */
3597 /* unmute CD */
3598 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))},
3599 /* unmute Line In */
3600 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))},
3601 /* unmute Mic */
3602 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
3603 /* Amp Indexes: DAC = 0x01 & mixer = 0x00 */
3604 /* Unmute Front out path */
3605 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
3606 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
3607 /* Unmute Headphone out path */
3608 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
3609 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
3610 /* Unmute Mono out path */
3611 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
3612 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
3613 { }
3614 };
3615 #endif
3616
3617 static struct hda_verb alc260_hp_3013_init_verbs[] = {
3618 /* Line out and output */
3619 {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
3620 /* mono output */
3621 {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
3622 /* Mic1 (rear panel) pin widget for input and vref at 80% */
3623 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
3624 /* Mic2 (front panel) pin widget for input and vref at 80% */
3625 {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
3626 /* Line In pin widget for input */
3627 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
3628 /* Headphone pin widget for output */
3629 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
3630 /* CD pin widget for input */
3631 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
3632 /* unmute amp left and right */
3633 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000},
3634 /* set connection select to line in (default select for this ADC) */
3635 {0x04, AC_VERB_SET_CONNECT_SEL, 0x02},
3636 /* unmute Line-Out mixer amp left and right (volume = 0) */
3637 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
3638 /* mute pin widget amp left and right (no gain on this amp) */
3639 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
3640 /* unmute HP mixer amp left and right (volume = 0) */
3641 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
3642 /* mute pin widget amp left and right (no gain on this amp) */
3643 {0x10, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
3644 /* Amp Indexes: CD = 0x04, Line In 1 = 0x02, Mic 1 = 0x00 & Line In 2 = 0x03 */
3645 /* unmute CD */
3646 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))},
3647 /* unmute Line In */
3648 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))},
3649 /* unmute Mic */
3650 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
3651 /* Amp Indexes: DAC = 0x01 & mixer = 0x00 */
3652 /* Unmute Front out path */
3653 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
3654 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
3655 /* Unmute Headphone out path */
3656 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
3657 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
3658 /* Unmute Mono out path */
3659 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
3660 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
3661 { }
3662 };
3663
3664 /* Initialisation sequence for ALC260 as configured in Fujitsu S702x
3665 * laptops. ALC260 pin usage: Mic/Line jack = 0x12, HP jack = 0x14, CD
3666 * audio = 0x16, internal speaker = 0x10.
3667 */
3668 static struct hda_verb alc260_fujitsu_init_verbs[] = {
3669 /* Disable all GPIOs */
3670 {0x01, AC_VERB_SET_GPIO_MASK, 0},
3671 /* Internal speaker is connected to headphone pin */
3672 {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3673 /* Headphone/Line-out jack connects to Line1 pin; make it an output */
3674 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3675 /* Mic/Line-in jack is connected to mic1 pin, so make it an input */
3676 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3677 /* Ensure all other unused pins are disabled and muted. */
3678 {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
3679 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3680 {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
3681 {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3682 {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
3683 {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3684 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
3685 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3686
3687 /* Disable digital (SPDIF) pins */
3688 {0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
3689 {0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
3690
3691 /* Ensure Line1 pin widget takes its input from the OUT1 sum bus
3692 * when acting as an output.
3693 */
3694 {0x0d, AC_VERB_SET_CONNECT_SEL, 0},
3695
3696 /* Start with output sum widgets muted and their output gains at min */
3697 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3698 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
3699 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3700 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3701 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
3702 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3703 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3704 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
3705 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3706
3707 /* Unmute HP pin widget amp left and right (no equiv mixer ctrl) */
3708 {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3709 /* Unmute Line1 pin widget output buffer since it starts as an output.
3710 * If the pin mode is changed by the user the pin mode control will
3711 * take care of enabling the pin's input/output buffers as needed.
3712 * Therefore there's no need to enable the input buffer at this
3713 * stage.
3714 */
3715 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3716 /* Unmute input buffer of pin widget used for Line-in (no equiv
3717 * mixer ctrl)
3718 */
3719 {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3720
3721 /* Mute capture amp left and right */
3722 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3723 /* Set ADC connection select to match default mixer setting - line
3724 * in (on mic1 pin)
3725 */
3726 {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
3727
3728 /* Do the same for the second ADC: mute capture input amp and
3729 * set ADC connection to line in (on mic1 pin)
3730 */
3731 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3732 {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
3733
3734 /* Mute all inputs to mixer widget (even unconnected ones) */
3735 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
3736 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
3737 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
3738 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
3739 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
3740 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
3741 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
3742 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
3743
3744 { }
3745 };
3746
3747 /* Initialisation sequence for ALC260 as configured in Acer TravelMate and
3748 * similar laptops (adapted from Fujitsu init verbs).
3749 */
3750 static struct hda_verb alc260_acer_init_verbs[] = {
3751 /* On TravelMate laptops, GPIO 0 enables the internal speaker and
3752 * the headphone jack. Turn this on and rely on the standard mute
3753 * methods whenever the user wants to turn these outputs off.
3754 */
3755 {0x01, AC_VERB_SET_GPIO_MASK, 0x01},
3756 {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
3757 {0x01, AC_VERB_SET_GPIO_DATA, 0x01},
3758 /* Internal speaker/Headphone jack is connected to Line-out pin */
3759 {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3760 /* Internal microphone/Mic jack is connected to Mic1 pin */
3761 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
3762 /* Line In jack is connected to Line1 pin */
3763 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3764 /* Some Acers (eg: C20x Tablets) use Mono pin for internal speaker */
3765 {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3766 /* Ensure all other unused pins are disabled and muted. */
3767 {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
3768 {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3769 {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
3770 {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3771 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
3772 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3773 /* Disable digital (SPDIF) pins */
3774 {0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
3775 {0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
3776
3777 /* Ensure Mic1 and Line1 pin widgets take input from the OUT1 sum
3778 * bus when acting as outputs.
3779 */
3780 {0x0b, AC_VERB_SET_CONNECT_SEL, 0},
3781 {0x0d, AC_VERB_SET_CONNECT_SEL, 0},
3782
3783 /* Start with output sum widgets muted and their output gains at min */
3784 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3785 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
3786 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3787 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3788 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
3789 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3790 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3791 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
3792 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3793
3794 /* Unmute Line-out pin widget amp left and right (no equiv mixer ctrl) */
3795 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3796 /* Unmute mono pin widget amp output (no equiv mixer ctrl) */
3797 {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3798 /* Unmute Mic1 and Line1 pin widget input buffers since they start as
3799 * inputs. If the pin mode is changed by the user the pin mode control
3800 * will take care of enabling the pin's input/output buffers as needed.
3801 * Therefore there's no need to enable the input buffer at this
3802 * stage.
3803 */
3804 {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3805 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3806
3807 /* Mute capture amp left and right */
3808 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3809 /* Set ADC connection select to match default mixer setting - mic
3810 * (on mic1 pin)
3811 */
3812 {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
3813
3814 /* Do similar with the second ADC: mute capture input amp and
3815 * set ADC connection to mic to match ALSA's default state.
3816 */
3817 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3818 {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
3819
3820 /* Mute all inputs to mixer widget (even unconnected ones) */
3821 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
3822 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
3823 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
3824 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
3825 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
3826 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
3827 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
3828 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
3829
3830 { }
3831 };
3832
3833 static struct hda_verb alc260_will_verbs[] = {
3834 {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3835 {0x0b, AC_VERB_SET_CONNECT_SEL, 0x00},
3836 {0x0d, AC_VERB_SET_CONNECT_SEL, 0x00},
3837 {0x0f, AC_VERB_SET_EAPD_BTLENABLE, 0x02},
3838 {0x1a, AC_VERB_SET_COEF_INDEX, 0x07},
3839 {0x1a, AC_VERB_SET_PROC_COEF, 0x3040},
3840 {}
3841 };
3842
3843 static struct hda_verb alc260_replacer_672v_verbs[] = {
3844 {0x0f, AC_VERB_SET_EAPD_BTLENABLE, 0x02},
3845 {0x1a, AC_VERB_SET_COEF_INDEX, 0x07},
3846 {0x1a, AC_VERB_SET_PROC_COEF, 0x3050},
3847
3848 {0x01, AC_VERB_SET_GPIO_MASK, 0x01},
3849 {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
3850 {0x01, AC_VERB_SET_GPIO_DATA, 0x00},
3851
3852 {0x0f, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
3853 {}
3854 };
3855
3856 /* toggle speaker-output according to the hp-jack state */
3857 static void alc260_replacer_672v_automute(struct hda_codec *codec)
3858 {
3859 unsigned int present;
3860
3861 /* speaker --> GPIO Data 0, hp or spdif --> GPIO data 1 */
3862 present = snd_hda_codec_read(codec, 0x0f, 0,
3863 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
3864 if (present) {
3865 snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA, 1);
3866 snd_hda_codec_write(codec, 0x0f, 0,
3867 AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP);
3868 } else {
3869 snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA, 0);
3870 snd_hda_codec_write(codec, 0x0f, 0,
3871 AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
3872 }
3873 }
3874
3875 static void alc260_replacer_672v_unsol_event(struct hda_codec *codec,
3876 unsigned int res)
3877 {
3878 if ((res >> 26) == ALC880_HP_EVENT)
3879 alc260_replacer_672v_automute(codec);
3880 }
3881
3882 /* Test configuration for debugging, modelled after the ALC880 test
3883 * configuration.
3884 */
3885 #ifdef CONFIG_SND_DEBUG
3886 static hda_nid_t alc260_test_dac_nids[1] = {
3887 0x02,
3888 };
3889 static hda_nid_t alc260_test_adc_nids[2] = {
3890 0x04, 0x05,
3891 };
3892 /* For testing the ALC260, each input MUX needs its own definition since
3893 * the signal assignments are different. This assumes that the first ADC
3894 * is NID 0x04.
3895 */
3896 static struct hda_input_mux alc260_test_capture_sources[2] = {
3897 {
3898 .num_items = 7,
3899 .items = {
3900 { "MIC1 pin", 0x0 },
3901 { "MIC2 pin", 0x1 },
3902 { "LINE1 pin", 0x2 },
3903 { "LINE2 pin", 0x3 },
3904 { "CD pin", 0x4 },
3905 { "LINE-OUT pin", 0x5 },
3906 { "HP-OUT pin", 0x6 },
3907 },
3908 },
3909 {
3910 .num_items = 8,
3911 .items = {
3912 { "MIC1 pin", 0x0 },
3913 { "MIC2 pin", 0x1 },
3914 { "LINE1 pin", 0x2 },
3915 { "LINE2 pin", 0x3 },
3916 { "CD pin", 0x4 },
3917 { "Mixer", 0x5 },
3918 { "LINE-OUT pin", 0x6 },
3919 { "HP-OUT pin", 0x7 },
3920 },
3921 },
3922 };
3923 static struct snd_kcontrol_new alc260_test_mixer[] = {
3924 /* Output driver widgets */
3925 HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT),
3926 HDA_BIND_MUTE_MONO("Mono Playback Switch", 0x0a, 1, 2, HDA_INPUT),
3927 HDA_CODEC_VOLUME("LOUT2 Playback Volume", 0x09, 0x0, HDA_OUTPUT),
3928 HDA_BIND_MUTE("LOUT2 Playback Switch", 0x09, 2, HDA_INPUT),
3929 HDA_CODEC_VOLUME("LOUT1 Playback Volume", 0x08, 0x0, HDA_OUTPUT),
3930 HDA_BIND_MUTE("LOUT1 Playback Switch", 0x08, 2, HDA_INPUT),
3931
3932 /* Modes for retasking pin widgets
3933 * Note: the ALC260 doesn't seem to act on requests to enable mic
3934 * bias from NIDs 0x0f and 0x10. The ALC260 datasheet doesn't
3935 * mention this restriction. At this stage it's not clear whether
3936 * this behaviour is intentional or is a hardware bug in chip
3937 * revisions available at least up until early 2006. Therefore for
3938 * now allow the "HP-OUT" and "LINE-OUT" Mode controls to span all
3939 * choices, but if it turns out that the lack of mic bias for these
3940 * NIDs is intentional we could change their modes from
3941 * ALC_PIN_DIR_INOUT to ALC_PIN_DIR_INOUT_NOMICBIAS.
3942 */
3943 ALC_PIN_MODE("HP-OUT pin mode", 0x10, ALC_PIN_DIR_INOUT),
3944 ALC_PIN_MODE("LINE-OUT pin mode", 0x0f, ALC_PIN_DIR_INOUT),
3945 ALC_PIN_MODE("LINE2 pin mode", 0x15, ALC_PIN_DIR_INOUT),
3946 ALC_PIN_MODE("LINE1 pin mode", 0x14, ALC_PIN_DIR_INOUT),
3947 ALC_PIN_MODE("MIC2 pin mode", 0x13, ALC_PIN_DIR_INOUT),
3948 ALC_PIN_MODE("MIC1 pin mode", 0x12, ALC_PIN_DIR_INOUT),
3949
3950 /* Loopback mixer controls */
3951 HDA_CODEC_VOLUME("MIC1 Playback Volume", 0x07, 0x00, HDA_INPUT),
3952 HDA_CODEC_MUTE("MIC1 Playback Switch", 0x07, 0x00, HDA_INPUT),
3953 HDA_CODEC_VOLUME("MIC2 Playback Volume", 0x07, 0x01, HDA_INPUT),
3954 HDA_CODEC_MUTE("MIC2 Playback Switch", 0x07, 0x01, HDA_INPUT),
3955 HDA_CODEC_VOLUME("LINE1 Playback Volume", 0x07, 0x02, HDA_INPUT),
3956 HDA_CODEC_MUTE("LINE1 Playback Switch", 0x07, 0x02, HDA_INPUT),
3957 HDA_CODEC_VOLUME("LINE2 Playback Volume", 0x07, 0x03, HDA_INPUT),
3958 HDA_CODEC_MUTE("LINE2 Playback Switch", 0x07, 0x03, HDA_INPUT),
3959 HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
3960 HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
3961 HDA_CODEC_VOLUME("Beep Playback Volume", 0x07, 0x05, HDA_INPUT),
3962 HDA_CODEC_MUTE("Beep Playback Switch", 0x07, 0x05, HDA_INPUT),
3963 HDA_CODEC_VOLUME("LINE-OUT loopback Playback Volume", 0x07, 0x06, HDA_INPUT),
3964 HDA_CODEC_MUTE("LINE-OUT loopback Playback Switch", 0x07, 0x06, HDA_INPUT),
3965 HDA_CODEC_VOLUME("HP-OUT loopback Playback Volume", 0x07, 0x7, HDA_INPUT),
3966 HDA_CODEC_MUTE("HP-OUT loopback Playback Switch", 0x07, 0x7, HDA_INPUT),
3967
3968 /* Controls for GPIO pins, assuming they are configured as outputs */
3969 ALC_GPIO_DATA_SWITCH("GPIO pin 0", 0x01, 0x01),
3970 ALC_GPIO_DATA_SWITCH("GPIO pin 1", 0x01, 0x02),
3971 ALC_GPIO_DATA_SWITCH("GPIO pin 2", 0x01, 0x04),
3972 ALC_GPIO_DATA_SWITCH("GPIO pin 3", 0x01, 0x08),
3973
3974 /* Switches to allow the digital IO pins to be enabled. The datasheet
3975 * is ambigious as to which NID is which; testing on laptops which
3976 * make this output available should provide clarification.
3977 */
3978 ALC_SPDIF_CTRL_SWITCH("SPDIF Playback Switch", 0x03, 0x01),
3979 ALC_SPDIF_CTRL_SWITCH("SPDIF Capture Switch", 0x06, 0x01),
3980
3981 { } /* end */
3982 };
3983 static struct hda_verb alc260_test_init_verbs[] = {
3984 /* Enable all GPIOs as outputs with an initial value of 0 */
3985 {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x0f},
3986 {0x01, AC_VERB_SET_GPIO_DATA, 0x00},
3987 {0x01, AC_VERB_SET_GPIO_MASK, 0x0f},
3988
3989 /* Enable retasking pins as output, initially without power amp */
3990 {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3991 {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3992 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3993 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3994 {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3995 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3996
3997 /* Disable digital (SPDIF) pins initially, but users can enable
3998 * them via a mixer switch. In the case of SPDIF-out, this initverb
3999 * payload also sets the generation to 0, output to be in "consumer"
4000 * PCM format, copyright asserted, no pre-emphasis and no validity
4001 * control.
4002 */
4003 {0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
4004 {0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
4005
4006 /* Ensure mic1, mic2, line1 and line2 pin widgets take input from the
4007 * OUT1 sum bus when acting as an output.
4008 */
4009 {0x0b, AC_VERB_SET_CONNECT_SEL, 0},
4010 {0x0c, AC_VERB_SET_CONNECT_SEL, 0},
4011 {0x0d, AC_VERB_SET_CONNECT_SEL, 0},
4012 {0x0e, AC_VERB_SET_CONNECT_SEL, 0},
4013
4014 /* Start with output sum widgets muted and their output gains at min */
4015 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4016 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4017 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4018 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4019 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4020 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4021 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4022 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4023 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4024
4025 /* Unmute retasking pin widget output buffers since the default
4026 * state appears to be output. As the pin mode is changed by the
4027 * user the pin mode control will take care of enabling the pin's
4028 * input/output buffers as needed.
4029 */
4030 {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4031 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4032 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4033 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4034 {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4035 {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4036 /* Also unmute the mono-out pin widget */
4037 {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4038
4039 /* Mute capture amp left and right */
4040 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4041 /* Set ADC connection select to match default mixer setting (mic1
4042 * pin)
4043 */
4044 {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
4045
4046 /* Do the same for the second ADC: mute capture input amp and
4047 * set ADC connection to mic1 pin
4048 */
4049 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4050 {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
4051
4052 /* Mute all inputs to mixer widget (even unconnected ones) */
4053 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
4054 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
4055 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
4056 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
4057 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
4058 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
4059 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
4060 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
4061
4062 { }
4063 };
4064 #endif
4065
4066 static struct hda_pcm_stream alc260_pcm_analog_playback = {
4067 .substreams = 1,
4068 .channels_min = 2,
4069 .channels_max = 2,
4070 };
4071
4072 static struct hda_pcm_stream alc260_pcm_analog_capture = {
4073 .substreams = 1,
4074 .channels_min = 2,
4075 .channels_max = 2,
4076 };
4077
4078 #define alc260_pcm_digital_playback alc880_pcm_digital_playback
4079 #define alc260_pcm_digital_capture alc880_pcm_digital_capture
4080
4081 /*
4082 * for BIOS auto-configuration
4083 */
4084
4085 static int alc260_add_playback_controls(struct alc_spec *spec, hda_nid_t nid,
4086 const char *pfx)
4087 {
4088 hda_nid_t nid_vol;
4089 unsigned long vol_val, sw_val;
4090 char name[32];
4091 int err;
4092
4093 if (nid >= 0x0f && nid < 0x11) {
4094 nid_vol = nid - 0x7;
4095 vol_val = HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, HDA_OUTPUT);
4096 sw_val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
4097 } else if (nid == 0x11) {
4098 nid_vol = nid - 0x7;
4099 vol_val = HDA_COMPOSE_AMP_VAL(nid_vol, 2, 0, HDA_OUTPUT);
4100 sw_val = HDA_COMPOSE_AMP_VAL(nid, 2, 0, HDA_OUTPUT);
4101 } else if (nid >= 0x12 && nid <= 0x15) {
4102 nid_vol = 0x08;
4103 vol_val = HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, HDA_OUTPUT);
4104 sw_val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
4105 } else
4106 return 0; /* N/A */
4107
4108 snprintf(name, sizeof(name), "%s Playback Volume", pfx);
4109 if ((err = add_control(spec, ALC_CTL_WIDGET_VOL, name, vol_val)) < 0)
4110 return err;
4111 snprintf(name, sizeof(name), "%s Playback Switch", pfx);
4112 if ((err = add_control(spec, ALC_CTL_WIDGET_MUTE, name, sw_val)) < 0)
4113 return err;
4114 return 1;
4115 }
4116
4117 /* add playback controls from the parsed DAC table */
4118 static int alc260_auto_create_multi_out_ctls(struct alc_spec *spec,
4119 const struct auto_pin_cfg *cfg)
4120 {
4121 hda_nid_t nid;
4122 int err;
4123
4124 spec->multiout.num_dacs = 1;
4125 spec->multiout.dac_nids = spec->private_dac_nids;
4126 spec->multiout.dac_nids[0] = 0x02;
4127
4128 nid = cfg->line_out_pins[0];
4129 if (nid) {
4130 err = alc260_add_playback_controls(spec, nid, "Front");
4131 if (err < 0)
4132 return err;
4133 }
4134
4135 nid = cfg->speaker_pins[0];
4136 if (nid) {
4137 err = alc260_add_playback_controls(spec, nid, "Speaker");
4138 if (err < 0)
4139 return err;
4140 }
4141
4142 nid = cfg->hp_pins[0];
4143 if (nid) {
4144 err = alc260_add_playback_controls(spec, nid, "Headphone");
4145 if (err < 0)
4146 return err;
4147 }
4148 return 0;
4149 }
4150
4151 /* create playback/capture controls for input pins */
4152 static int alc260_auto_create_analog_input_ctls(struct alc_spec *spec,
4153 const struct auto_pin_cfg *cfg)
4154 {
4155 struct hda_input_mux *imux = &spec->private_imux;
4156 int i, err, idx;
4157
4158 for (i = 0; i < AUTO_PIN_LAST; i++) {
4159 if (cfg->input_pins[i] >= 0x12) {
4160 idx = cfg->input_pins[i] - 0x12;
4161 err = new_analog_input(spec, cfg->input_pins[i],
4162 auto_pin_cfg_labels[i], idx, 0x07);
4163 if (err < 0)
4164 return err;
4165 imux->items[imux->num_items].label = auto_pin_cfg_labels[i];
4166 imux->items[imux->num_items].index = idx;
4167 imux->num_items++;
4168 }
4169 if ((cfg->input_pins[i] >= 0x0f) && (cfg->input_pins[i] <= 0x10)){
4170 idx = cfg->input_pins[i] - 0x09;
4171 err = new_analog_input(spec, cfg->input_pins[i],
4172 auto_pin_cfg_labels[i], idx, 0x07);
4173 if (err < 0)
4174 return err;
4175 imux->items[imux->num_items].label = auto_pin_cfg_labels[i];
4176 imux->items[imux->num_items].index = idx;
4177 imux->num_items++;
4178 }
4179 }
4180 return 0;
4181 }
4182
4183 static void alc260_auto_set_output_and_unmute(struct hda_codec *codec,
4184 hda_nid_t nid, int pin_type,
4185 int sel_idx)
4186 {
4187 /* set as output */
4188 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, pin_type);
4189 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE);
4190 /* need the manual connection? */
4191 if (nid >= 0x12) {
4192 int idx = nid - 0x12;
4193 snd_hda_codec_write(codec, idx + 0x0b, 0,
4194 AC_VERB_SET_CONNECT_SEL, sel_idx);
4195
4196 }
4197 }
4198
4199 static void alc260_auto_init_multi_out(struct hda_codec *codec)
4200 {
4201 struct alc_spec *spec = codec->spec;
4202 hda_nid_t nid;
4203
4204 alc_subsystem_id(codec, 0x10, 0x15, 0x0f);
4205 nid = spec->autocfg.line_out_pins[0];
4206 if (nid)
4207 alc260_auto_set_output_and_unmute(codec, nid, PIN_OUT, 0);
4208
4209 nid = spec->autocfg.speaker_pins[0];
4210 if (nid)
4211 alc260_auto_set_output_and_unmute(codec, nid, PIN_OUT, 0);
4212
4213 nid = spec->autocfg.hp_pins[0];
4214 if (nid)
4215 alc260_auto_set_output_and_unmute(codec, nid, PIN_OUT, 0);
4216 }
4217
4218 #define ALC260_PIN_CD_NID 0x16
4219 static void alc260_auto_init_analog_input(struct hda_codec *codec)
4220 {
4221 struct alc_spec *spec = codec->spec;
4222 int i;
4223
4224 for (i = 0; i < AUTO_PIN_LAST; i++) {
4225 hda_nid_t nid = spec->autocfg.input_pins[i];
4226 if (nid >= 0x12) {
4227 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
4228 i <= AUTO_PIN_FRONT_MIC ? PIN_VREF80 : PIN_IN);
4229 if (nid != ALC260_PIN_CD_NID)
4230 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE,
4231 AMP_OUT_MUTE);
4232 }
4233 }
4234 }
4235
4236 /*
4237 * generic initialization of ADC, input mixers and output mixers
4238 */
4239 static struct hda_verb alc260_volume_init_verbs[] = {
4240 /*
4241 * Unmute ADC0-1 and set the default input to mic-in
4242 */
4243 {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
4244 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4245 {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
4246 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4247
4248 /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
4249 * mixer widget
4250 * Note: PASD motherboards uses the Line In 2 as the input for front panel
4251 * mic (mic 2)
4252 */
4253 /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
4254 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4255 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
4256 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
4257 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
4258 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
4259
4260 /*
4261 * Set up output mixers (0x08 - 0x0a)
4262 */
4263 /* set vol=0 to output mixers */
4264 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4265 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4266 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4267 /* set up input amps for analog loopback */
4268 /* Amp Indices: DAC = 0, mixer = 1 */
4269 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4270 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
4271 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4272 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
4273 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4274 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
4275
4276 { }
4277 };
4278
4279 static int alc260_parse_auto_config(struct hda_codec *codec)
4280 {
4281 struct alc_spec *spec = codec->spec;
4282 unsigned int wcap;
4283 int err;
4284 static hda_nid_t alc260_ignore[] = { 0x17, 0 };
4285
4286 if ((err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
4287 alc260_ignore)) < 0)
4288 return err;
4289 if ((err = alc260_auto_create_multi_out_ctls(spec, &spec->autocfg)) < 0)
4290 return err;
4291 if (! spec->kctl_alloc)
4292 return 0; /* can't find valid BIOS pin config */
4293 if ((err = alc260_auto_create_analog_input_ctls(spec, &spec->autocfg)) < 0)
4294 return err;
4295
4296 spec->multiout.max_channels = 2;
4297
4298 if (spec->autocfg.dig_out_pin)
4299 spec->multiout.dig_out_nid = ALC260_DIGOUT_NID;
4300 if (spec->kctl_alloc)
4301 spec->mixers[spec->num_mixers++] = spec->kctl_alloc;
4302
4303 spec->init_verbs[spec->num_init_verbs++] = alc260_volume_init_verbs;
4304
4305 spec->num_mux_defs = 1;
4306 spec->input_mux = &spec->private_imux;
4307
4308 /* check whether NID 0x04 is valid */
4309 wcap = get_wcaps(codec, 0x04);
4310 wcap = (wcap & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT; /* get type */
4311 if (wcap != AC_WID_AUD_IN) {
4312 spec->adc_nids = alc260_adc_nids_alt;
4313 spec->num_adc_nids = ARRAY_SIZE(alc260_adc_nids_alt);
4314 spec->mixers[spec->num_mixers] = alc260_capture_alt_mixer;
4315 } else {
4316 spec->adc_nids = alc260_adc_nids;
4317 spec->num_adc_nids = ARRAY_SIZE(alc260_adc_nids);
4318 spec->mixers[spec->num_mixers] = alc260_capture_mixer;
4319 }
4320 spec->num_mixers++;
4321
4322 return 1;
4323 }
4324
4325 /* additional initialization for auto-configuration model */
4326 static void alc260_auto_init(struct hda_codec *codec)
4327 {
4328 alc260_auto_init_multi_out(codec);
4329 alc260_auto_init_analog_input(codec);
4330 }
4331
4332 /*
4333 * ALC260 configurations
4334 */
4335 static const char *alc260_models[ALC260_MODEL_LAST] = {
4336 [ALC260_BASIC] = "basic",
4337 [ALC260_HP] = "hp",
4338 [ALC260_HP_3013] = "hp-3013",
4339 [ALC260_FUJITSU_S702X] = "fujitsu",
4340 [ALC260_ACER] = "acer",
4341 [ALC260_WILL] = "will",
4342 [ALC260_REPLACER_672V] = "replacer",
4343 #ifdef CONFIG_SND_DEBUG
4344 [ALC260_TEST] = "test",
4345 #endif
4346 [ALC260_AUTO] = "auto",
4347 };
4348
4349 static struct snd_pci_quirk alc260_cfg_tbl[] = {
4350 SND_PCI_QUIRK(0x1025, 0x007b, "Acer C20x", ALC260_ACER),
4351 SND_PCI_QUIRK(0x1025, 0x008f, "Acer", ALC260_ACER),
4352 SND_PCI_QUIRK(0x103c, 0x2808, "HP d5700", ALC260_HP_3013),
4353 SND_PCI_QUIRK(0x103c, 0x280a, "HP d5750", ALC260_HP_3013),
4354 SND_PCI_QUIRK(0x103c, 0x3010, "HP", ALC260_HP_3013),
4355 SND_PCI_QUIRK(0x103c, 0x3011, "HP", ALC260_HP),
4356 SND_PCI_QUIRK(0x103c, 0x3012, "HP", ALC260_HP_3013),
4357 SND_PCI_QUIRK(0x103c, 0x3013, "HP", ALC260_HP_3013),
4358 SND_PCI_QUIRK(0x103c, 0x3014, "HP", ALC260_HP),
4359 SND_PCI_QUIRK(0x103c, 0x3015, "HP", ALC260_HP),
4360 SND_PCI_QUIRK(0x103c, 0x3016, "HP", ALC260_HP),
4361 SND_PCI_QUIRK(0x104d, 0x81bb, "Sony VAIO", ALC260_BASIC),
4362 SND_PCI_QUIRK(0x104d, 0x81cc, "Sony VAIO", ALC260_BASIC),
4363 SND_PCI_QUIRK(0x104d, 0x81cd, "Sony VAIO", ALC260_BASIC),
4364 SND_PCI_QUIRK(0x10cf, 0x1326, "Fujitsu S702X", ALC260_FUJITSU_S702X),
4365 SND_PCI_QUIRK(0x152d, 0x0729, "CTL U553W", ALC260_BASIC),
4366 SND_PCI_QUIRK(0x1631, 0xc017, "PB V7900", ALC260_WILL),
4367 SND_PCI_QUIRK(0x161f, 0x2057, "Replacer 672V", ALC260_REPLACER_672V),
4368 {}
4369 };
4370
4371 static struct alc_config_preset alc260_presets[] = {
4372 [ALC260_BASIC] = {
4373 .mixers = { alc260_base_output_mixer,
4374 alc260_input_mixer,
4375 alc260_pc_beep_mixer,
4376 alc260_capture_mixer },
4377 .init_verbs = { alc260_init_verbs },
4378 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
4379 .dac_nids = alc260_dac_nids,
4380 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids),
4381 .adc_nids = alc260_adc_nids,
4382 .num_channel_mode = ARRAY_SIZE(alc260_modes),
4383 .channel_mode = alc260_modes,
4384 .input_mux = &alc260_capture_source,
4385 },
4386 [ALC260_HP] = {
4387 .mixers = { alc260_base_output_mixer,
4388 alc260_input_mixer,
4389 alc260_capture_alt_mixer },
4390 .init_verbs = { alc260_init_verbs },
4391 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
4392 .dac_nids = alc260_dac_nids,
4393 .num_adc_nids = ARRAY_SIZE(alc260_hp_adc_nids),
4394 .adc_nids = alc260_hp_adc_nids,
4395 .num_channel_mode = ARRAY_SIZE(alc260_modes),
4396 .channel_mode = alc260_modes,
4397 .input_mux = &alc260_capture_source,
4398 },
4399 [ALC260_HP_3013] = {
4400 .mixers = { alc260_hp_3013_mixer,
4401 alc260_input_mixer,
4402 alc260_capture_alt_mixer },
4403 .init_verbs = { alc260_hp_3013_init_verbs },
4404 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
4405 .dac_nids = alc260_dac_nids,
4406 .num_adc_nids = ARRAY_SIZE(alc260_hp_adc_nids),
4407 .adc_nids = alc260_hp_adc_nids,
4408 .num_channel_mode = ARRAY_SIZE(alc260_modes),
4409 .channel_mode = alc260_modes,
4410 .input_mux = &alc260_capture_source,
4411 },
4412 [ALC260_FUJITSU_S702X] = {
4413 .mixers = { alc260_fujitsu_mixer,
4414 alc260_capture_mixer },
4415 .init_verbs = { alc260_fujitsu_init_verbs },
4416 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
4417 .dac_nids = alc260_dac_nids,
4418 .num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids),
4419 .adc_nids = alc260_dual_adc_nids,
4420 .num_channel_mode = ARRAY_SIZE(alc260_modes),
4421 .channel_mode = alc260_modes,
4422 .num_mux_defs = ARRAY_SIZE(alc260_fujitsu_capture_sources),
4423 .input_mux = alc260_fujitsu_capture_sources,
4424 },
4425 [ALC260_ACER] = {
4426 .mixers = { alc260_acer_mixer,
4427 alc260_capture_mixer },
4428 .init_verbs = { alc260_acer_init_verbs },
4429 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
4430 .dac_nids = alc260_dac_nids,
4431 .num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids),
4432 .adc_nids = alc260_dual_adc_nids,
4433 .num_channel_mode = ARRAY_SIZE(alc260_modes),
4434 .channel_mode = alc260_modes,
4435 .num_mux_defs = ARRAY_SIZE(alc260_acer_capture_sources),
4436 .input_mux = alc260_acer_capture_sources,
4437 },
4438 [ALC260_WILL] = {
4439 .mixers = { alc260_will_mixer,
4440 alc260_capture_mixer },
4441 .init_verbs = { alc260_init_verbs, alc260_will_verbs },
4442 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
4443 .dac_nids = alc260_dac_nids,
4444 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids),
4445 .adc_nids = alc260_adc_nids,
4446 .dig_out_nid = ALC260_DIGOUT_NID,
4447 .num_channel_mode = ARRAY_SIZE(alc260_modes),
4448 .channel_mode = alc260_modes,
4449 .input_mux = &alc260_capture_source,
4450 },
4451 [ALC260_REPLACER_672V] = {
4452 .mixers = { alc260_replacer_672v_mixer,
4453 alc260_capture_mixer },
4454 .init_verbs = { alc260_init_verbs, alc260_replacer_672v_verbs },
4455 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
4456 .dac_nids = alc260_dac_nids,
4457 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids),
4458 .adc_nids = alc260_adc_nids,
4459 .dig_out_nid = ALC260_DIGOUT_NID,
4460 .num_channel_mode = ARRAY_SIZE(alc260_modes),
4461 .channel_mode = alc260_modes,
4462 .input_mux = &alc260_capture_source,
4463 .unsol_event = alc260_replacer_672v_unsol_event,
4464 .init_hook = alc260_replacer_672v_automute,
4465 },
4466 #ifdef CONFIG_SND_DEBUG
4467 [ALC260_TEST] = {
4468 .mixers = { alc260_test_mixer,
4469 alc260_capture_mixer },
4470 .init_verbs = { alc260_test_init_verbs },
4471 .num_dacs = ARRAY_SIZE(alc260_test_dac_nids),
4472 .dac_nids = alc260_test_dac_nids,
4473 .num_adc_nids = ARRAY_SIZE(alc260_test_adc_nids),
4474 .adc_nids = alc260_test_adc_nids,
4475 .num_channel_mode = ARRAY_SIZE(alc260_modes),
4476 .channel_mode = alc260_modes,
4477 .num_mux_defs = ARRAY_SIZE(alc260_test_capture_sources),
4478 .input_mux = alc260_test_capture_sources,
4479 },
4480 #endif
4481 };
4482
4483 static int patch_alc260(struct hda_codec *codec)
4484 {
4485 struct alc_spec *spec;
4486 int err, board_config;
4487
4488 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
4489 if (spec == NULL)
4490 return -ENOMEM;
4491
4492 codec->spec = spec;
4493
4494 board_config = snd_hda_check_board_config(codec, ALC260_MODEL_LAST,
4495 alc260_models,
4496 alc260_cfg_tbl);
4497 if (board_config < 0) {
4498 snd_printd(KERN_INFO "hda_codec: Unknown model for ALC260, "
4499 "trying auto-probe from BIOS...\n");
4500 board_config = ALC260_AUTO;
4501 }
4502
4503 if (board_config == ALC260_AUTO) {
4504 /* automatic parse from the BIOS config */
4505 err = alc260_parse_auto_config(codec);
4506 if (err < 0) {
4507 alc_free(codec);
4508 return err;
4509 } else if (! err) {
4510 printk(KERN_INFO
4511 "hda_codec: Cannot set up configuration "
4512 "from BIOS. Using base mode...\n");
4513 board_config = ALC260_BASIC;
4514 }
4515 }
4516
4517 if (board_config != ALC260_AUTO)
4518 setup_preset(spec, &alc260_presets[board_config]);
4519
4520 spec->stream_name_analog = "ALC260 Analog";
4521 spec->stream_analog_playback = &alc260_pcm_analog_playback;
4522 spec->stream_analog_capture = &alc260_pcm_analog_capture;
4523
4524 spec->stream_name_digital = "ALC260 Digital";
4525 spec->stream_digital_playback = &alc260_pcm_digital_playback;
4526 spec->stream_digital_capture = &alc260_pcm_digital_capture;
4527
4528 codec->patch_ops = alc_patch_ops;
4529 if (board_config == ALC260_AUTO)
4530 spec->init_hook = alc260_auto_init;
4531
4532 return 0;
4533 }
4534
4535
4536 /*
4537 * ALC882 support
4538 *
4539 * ALC882 is almost identical with ALC880 but has cleaner and more flexible
4540 * configuration. Each pin widget can choose any input DACs and a mixer.
4541 * Each ADC is connected from a mixer of all inputs. This makes possible
4542 * 6-channel independent captures.
4543 *
4544 * In addition, an independent DAC for the multi-playback (not used in this
4545 * driver yet).
4546 */
4547 #define ALC882_DIGOUT_NID 0x06
4548 #define ALC882_DIGIN_NID 0x0a
4549
4550 static struct hda_channel_mode alc882_ch_modes[1] = {
4551 { 8, NULL }
4552 };
4553
4554 static hda_nid_t alc882_dac_nids[4] = {
4555 /* front, rear, clfe, rear_surr */
4556 0x02, 0x03, 0x04, 0x05
4557 };
4558
4559 /* identical with ALC880 */
4560 #define alc882_adc_nids alc880_adc_nids
4561 #define alc882_adc_nids_alt alc880_adc_nids_alt
4562
4563 /* input MUX */
4564 /* FIXME: should be a matrix-type input source selection */
4565
4566 static struct hda_input_mux alc882_capture_source = {
4567 .num_items = 4,
4568 .items = {
4569 { "Mic", 0x0 },
4570 { "Front Mic", 0x1 },
4571 { "Line", 0x2 },
4572 { "CD", 0x4 },
4573 },
4574 };
4575 #define alc882_mux_enum_info alc_mux_enum_info
4576 #define alc882_mux_enum_get alc_mux_enum_get
4577
4578 static int alc882_mux_enum_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
4579 {
4580 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
4581 struct alc_spec *spec = codec->spec;
4582 const struct hda_input_mux *imux = spec->input_mux;
4583 unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
4584 static hda_nid_t capture_mixers[3] = { 0x24, 0x23, 0x22 };
4585 hda_nid_t nid = capture_mixers[adc_idx];
4586 unsigned int *cur_val = &spec->cur_mux[adc_idx];
4587 unsigned int i, idx;
4588
4589 idx = ucontrol->value.enumerated.item[0];
4590 if (idx >= imux->num_items)
4591 idx = imux->num_items - 1;
4592 if (*cur_val == idx && ! codec->in_resume)
4593 return 0;
4594 for (i = 0; i < imux->num_items; i++) {
4595 unsigned int v = (i == idx) ? 0x7000 : 0x7080;
4596 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE,
4597 v | (imux->items[i].index << 8));
4598 }
4599 *cur_val = idx;
4600 return 1;
4601 }
4602
4603 /*
4604 * 6ch mode
4605 */
4606 static struct hda_verb alc882_sixstack_ch6_init[] = {
4607 { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
4608 { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
4609 { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
4610 { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
4611 { } /* end */
4612 };
4613
4614 /*
4615 * 8ch mode
4616 */
4617 static struct hda_verb alc882_sixstack_ch8_init[] = {
4618 { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
4619 { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
4620 { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
4621 { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
4622 { } /* end */
4623 };
4624
4625 static struct hda_channel_mode alc882_sixstack_modes[2] = {
4626 { 6, alc882_sixstack_ch6_init },
4627 { 8, alc882_sixstack_ch8_init },
4628 };
4629
4630 /* Pin assignment: Front=0x14, Rear=0x15, CLFE=0x16, Side=0x17
4631 * Mic=0x18, Front Mic=0x19, Line-In=0x1a, HP=0x1b
4632 */
4633 static struct snd_kcontrol_new alc882_base_mixer[] = {
4634 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
4635 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
4636 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
4637 HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
4638 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
4639 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
4640 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
4641 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
4642 HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
4643 HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
4644 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
4645 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
4646 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
4647 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
4648 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
4649 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
4650 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
4651 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
4652 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
4653 HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
4654 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
4655 HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
4656 HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
4657 { } /* end */
4658 };
4659
4660 static struct snd_kcontrol_new alc882_chmode_mixer[] = {
4661 {
4662 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
4663 .name = "Channel Mode",
4664 .info = alc_ch_mode_info,
4665 .get = alc_ch_mode_get,
4666 .put = alc_ch_mode_put,
4667 },
4668 { } /* end */
4669 };
4670
4671 static struct hda_verb alc882_init_verbs[] = {
4672 /* Front mixer: unmute input/output amp left and right (volume = 0) */
4673 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4674 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4675 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4676 /* Rear mixer */
4677 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4678 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4679 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4680 /* CLFE mixer */
4681 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4682 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4683 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4684 /* Side mixer */
4685 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4686 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4687 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4688
4689 /* Front Pin: output 0 (0x0c) */
4690 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4691 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4692 {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
4693 /* Rear Pin: output 1 (0x0d) */
4694 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4695 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4696 {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
4697 /* CLFE Pin: output 2 (0x0e) */
4698 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4699 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4700 {0x16, AC_VERB_SET_CONNECT_SEL, 0x02},
4701 /* Side Pin: output 3 (0x0f) */
4702 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4703 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4704 {0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
4705 /* Mic (rear) pin: input vref at 80% */
4706 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
4707 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
4708 /* Front Mic pin: input vref at 80% */
4709 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
4710 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
4711 /* Line In pin: input */
4712 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
4713 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
4714 /* Line-2 In: Headphone output (output 0 - 0x0c) */
4715 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
4716 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4717 {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
4718 /* CD pin widget for input */
4719 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
4720
4721 /* FIXME: use matrix-type input source selection */
4722 /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
4723 /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
4724 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4725 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
4726 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
4727 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
4728 /* Input mixer2 */
4729 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4730 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
4731 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
4732 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
4733 /* Input mixer3 */
4734 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4735 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
4736 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
4737 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
4738 /* ADC1: mute amp left and right */
4739 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4740 {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
4741 /* ADC2: mute amp left and right */
4742 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4743 {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
4744 /* ADC3: mute amp left and right */
4745 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4746 {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
4747
4748 { }
4749 };
4750
4751 static struct hda_verb alc882_eapd_verbs[] = {
4752 /* change to EAPD mode */
4753 {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
4754 {0x20, AC_VERB_SET_PROC_COEF, 0x3060},
4755 { }
4756 };
4757
4758 /* Mac Pro test */
4759 static struct snd_kcontrol_new alc882_macpro_mixer[] = {
4760 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
4761 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
4762 HDA_CODEC_MUTE("Headphone Playback Switch", 0x18, 0x0, HDA_OUTPUT),
4763 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x01, HDA_INPUT),
4764 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x01, HDA_INPUT),
4765 HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x02, HDA_INPUT),
4766 HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x02, HDA_INPUT),
4767 { } /* end */
4768 };
4769
4770 static struct hda_verb alc882_macpro_init_verbs[] = {
4771 /* Front mixer: unmute input/output amp left and right (volume = 0) */
4772 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4773 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4774 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4775 /* Front Pin: output 0 (0x0c) */
4776 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4777 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4778 {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
4779 /* Front Mic pin: input vref at 80% */
4780 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
4781 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
4782 /* Speaker: output */
4783 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4784 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4785 {0x1a, AC_VERB_SET_CONNECT_SEL, 0x04},
4786 /* Headphone output (output 0 - 0x0c) */
4787 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
4788 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4789 {0x18, AC_VERB_SET_CONNECT_SEL, 0x00},
4790
4791 /* FIXME: use matrix-type input source selection */
4792 /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
4793 /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
4794 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4795 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
4796 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
4797 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
4798 /* Input mixer2 */
4799 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4800 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
4801 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
4802 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
4803 /* Input mixer3 */
4804 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4805 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
4806 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
4807 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
4808 /* ADC1: mute amp left and right */
4809 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4810 {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
4811 /* ADC2: mute amp left and right */
4812 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4813 {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
4814 /* ADC3: mute amp left and right */
4815 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4816 {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
4817
4818 { }
4819 };
4820 static void alc882_gpio_mute(struct hda_codec *codec, int pin, int muted)
4821 {
4822 unsigned int gpiostate, gpiomask, gpiodir;
4823
4824 gpiostate = snd_hda_codec_read(codec, codec->afg, 0,
4825 AC_VERB_GET_GPIO_DATA, 0);
4826
4827 if (!muted)
4828 gpiostate |= (1 << pin);
4829 else
4830 gpiostate &= ~(1 << pin);
4831
4832 gpiomask = snd_hda_codec_read(codec, codec->afg, 0,
4833 AC_VERB_GET_GPIO_MASK, 0);
4834 gpiomask |= (1 << pin);
4835
4836 gpiodir = snd_hda_codec_read(codec, codec->afg, 0,
4837 AC_VERB_GET_GPIO_DIRECTION, 0);
4838 gpiodir |= (1 << pin);
4839
4840
4841 snd_hda_codec_write(codec, codec->afg, 0,
4842 AC_VERB_SET_GPIO_MASK, gpiomask);
4843 snd_hda_codec_write(codec, codec->afg, 0,
4844 AC_VERB_SET_GPIO_DIRECTION, gpiodir);
4845
4846 msleep(1);
4847
4848 snd_hda_codec_write(codec, codec->afg, 0,
4849 AC_VERB_SET_GPIO_DATA, gpiostate);
4850 }
4851
4852 /*
4853 * generic initialization of ADC, input mixers and output mixers
4854 */
4855 static struct hda_verb alc882_auto_init_verbs[] = {
4856 /*
4857 * Unmute ADC0-2 and set the default input to mic-in
4858 */
4859 {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
4860 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4861 {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
4862 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4863 {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
4864 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4865
4866 /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
4867 * mixer widget
4868 * Note: PASD motherboards uses the Line In 2 as the input for front panel
4869 * mic (mic 2)
4870 */
4871 /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
4872 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4873 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
4874 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
4875 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
4876 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
4877
4878 /*
4879 * Set up output mixers (0x0c - 0x0f)
4880 */
4881 /* set vol=0 to output mixers */
4882 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4883 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4884 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4885 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4886 /* set up input amps for analog loopback */
4887 /* Amp Indices: DAC = 0, mixer = 1 */
4888 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4889 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
4890 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4891 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
4892 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4893 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
4894 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4895 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
4896 {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4897 {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
4898
4899 /* FIXME: use matrix-type input source selection */
4900 /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
4901 /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
4902 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
4903 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
4904 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
4905 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
4906 /* Input mixer2 */
4907 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
4908 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
4909 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
4910 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
4911 /* Input mixer3 */
4912 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
4913 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
4914 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
4915 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
4916
4917 { }
4918 };
4919
4920 /* capture mixer elements */
4921 static struct snd_kcontrol_new alc882_capture_alt_mixer[] = {
4922 HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
4923 HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
4924 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT),
4925 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT),
4926 {
4927 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
4928 /* The multiple "Capture Source" controls confuse alsamixer
4929 * So call somewhat different..
4930 * FIXME: the controls appear in the "playback" view!
4931 */
4932 /* .name = "Capture Source", */
4933 .name = "Input Source",
4934 .count = 2,
4935 .info = alc882_mux_enum_info,
4936 .get = alc882_mux_enum_get,
4937 .put = alc882_mux_enum_put,
4938 },
4939 { } /* end */
4940 };
4941
4942 static struct snd_kcontrol_new alc882_capture_mixer[] = {
4943 HDA_CODEC_VOLUME("Capture Volume", 0x07, 0x0, HDA_INPUT),
4944 HDA_CODEC_MUTE("Capture Switch", 0x07, 0x0, HDA_INPUT),
4945 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x08, 0x0, HDA_INPUT),
4946 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x08, 0x0, HDA_INPUT),
4947 HDA_CODEC_VOLUME_IDX("Capture Volume", 2, 0x09, 0x0, HDA_INPUT),
4948 HDA_CODEC_MUTE_IDX("Capture Switch", 2, 0x09, 0x0, HDA_INPUT),
4949 {
4950 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
4951 /* The multiple "Capture Source" controls confuse alsamixer
4952 * So call somewhat different..
4953 * FIXME: the controls appear in the "playback" view!
4954 */
4955 /* .name = "Capture Source", */
4956 .name = "Input Source",
4957 .count = 3,
4958 .info = alc882_mux_enum_info,
4959 .get = alc882_mux_enum_get,
4960 .put = alc882_mux_enum_put,
4961 },
4962 { } /* end */
4963 };
4964
4965 /* pcm configuration: identiacal with ALC880 */
4966 #define alc882_pcm_analog_playback alc880_pcm_analog_playback
4967 #define alc882_pcm_analog_capture alc880_pcm_analog_capture
4968 #define alc882_pcm_digital_playback alc880_pcm_digital_playback
4969 #define alc882_pcm_digital_capture alc880_pcm_digital_capture
4970
4971 /*
4972 * configuration and preset
4973 */
4974 static const char *alc882_models[ALC882_MODEL_LAST] = {
4975 [ALC882_3ST_DIG] = "3stack-dig",
4976 [ALC882_6ST_DIG] = "6stack-dig",
4977 [ALC882_ARIMA] = "arima",
4978 [ALC885_MACPRO] = "macpro",
4979 [ALC882_AUTO] = "auto",
4980 };
4981
4982 static struct snd_pci_quirk alc882_cfg_tbl[] = {
4983 SND_PCI_QUIRK(0x1019, 0x6668, "ECS", ALC882_6ST_DIG),
4984 SND_PCI_QUIRK(0x105b, 0x6668, "Foxconn", ALC882_6ST_DIG),
4985 SND_PCI_QUIRK(0x1462, 0x6668, "MSI", ALC882_6ST_DIG),
4986 SND_PCI_QUIRK(0x161f, 0x2054, "Arima W820", ALC882_ARIMA),
4987 SND_PCI_QUIRK(0x1043, 0x81d8, "Asus P5WD", ALC882_6ST_DIG),
4988 {}
4989 };
4990
4991 static struct alc_config_preset alc882_presets[] = {
4992 [ALC882_3ST_DIG] = {
4993 .mixers = { alc882_base_mixer },
4994 .init_verbs = { alc882_init_verbs },
4995 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
4996 .dac_nids = alc882_dac_nids,
4997 .dig_out_nid = ALC882_DIGOUT_NID,
4998 .dig_in_nid = ALC882_DIGIN_NID,
4999 .num_channel_mode = ARRAY_SIZE(alc882_ch_modes),
5000 .channel_mode = alc882_ch_modes,
5001 .need_dac_fix = 1,
5002 .input_mux = &alc882_capture_source,
5003 },
5004 [ALC882_6ST_DIG] = {
5005 .mixers = { alc882_base_mixer, alc882_chmode_mixer },
5006 .init_verbs = { alc882_init_verbs },
5007 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
5008 .dac_nids = alc882_dac_nids,
5009 .dig_out_nid = ALC882_DIGOUT_NID,
5010 .dig_in_nid = ALC882_DIGIN_NID,
5011 .num_channel_mode = ARRAY_SIZE(alc882_sixstack_modes),
5012 .channel_mode = alc882_sixstack_modes,
5013 .input_mux = &alc882_capture_source,
5014 },
5015 [ALC882_ARIMA] = {
5016 .mixers = { alc882_base_mixer, alc882_chmode_mixer },
5017 .init_verbs = { alc882_init_verbs, alc882_eapd_verbs },
5018 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
5019 .dac_nids = alc882_dac_nids,
5020 .num_channel_mode = ARRAY_SIZE(alc882_sixstack_modes),
5021 .channel_mode = alc882_sixstack_modes,
5022 .input_mux = &alc882_capture_source,
5023 },
5024 [ALC885_MACPRO] = {
5025 .mixers = { alc882_macpro_mixer },
5026 .init_verbs = { alc882_macpro_init_verbs },
5027 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
5028 .dac_nids = alc882_dac_nids,
5029 .dig_out_nid = ALC882_DIGOUT_NID,
5030 .dig_in_nid = ALC882_DIGIN_NID,
5031 .num_channel_mode = ARRAY_SIZE(alc882_ch_modes),
5032 .channel_mode = alc882_ch_modes,
5033 .input_mux = &alc882_capture_source,
5034 },
5035 };
5036
5037
5038 /*
5039 * BIOS auto configuration
5040 */
5041 static void alc882_auto_set_output_and_unmute(struct hda_codec *codec,
5042 hda_nid_t nid, int pin_type,
5043 int dac_idx)
5044 {
5045 /* set as output */
5046 struct alc_spec *spec = codec->spec;
5047 int idx;
5048
5049 if (spec->multiout.dac_nids[dac_idx] == 0x25)
5050 idx = 4;
5051 else
5052 idx = spec->multiout.dac_nids[dac_idx] - 2;
5053
5054 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, pin_type);
5055 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE);
5056 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CONNECT_SEL, idx);
5057
5058 }
5059
5060 static void alc882_auto_init_multi_out(struct hda_codec *codec)
5061 {
5062 struct alc_spec *spec = codec->spec;
5063 int i;
5064
5065 alc_subsystem_id(codec, 0x15, 0x1b, 0x14);
5066 for (i = 0; i <= HDA_SIDE; i++) {
5067 hda_nid_t nid = spec->autocfg.line_out_pins[i];
5068 if (nid)
5069 alc882_auto_set_output_and_unmute(codec, nid, PIN_OUT, i);
5070 }
5071 }
5072
5073 static void alc882_auto_init_hp_out(struct hda_codec *codec)
5074 {
5075 struct alc_spec *spec = codec->spec;
5076 hda_nid_t pin;
5077
5078 pin = spec->autocfg.hp_pins[0];
5079 if (pin) /* connect to front */
5080 alc882_auto_set_output_and_unmute(codec, pin, PIN_HP, 0); /* use dac 0 */
5081 }
5082
5083 #define alc882_is_input_pin(nid) alc880_is_input_pin(nid)
5084 #define ALC882_PIN_CD_NID ALC880_PIN_CD_NID
5085
5086 static void alc882_auto_init_analog_input(struct hda_codec *codec)
5087 {
5088 struct alc_spec *spec = codec->spec;
5089 int i;
5090
5091 for (i = 0; i < AUTO_PIN_LAST; i++) {
5092 hda_nid_t nid = spec->autocfg.input_pins[i];
5093 if (alc882_is_input_pin(nid)) {
5094 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
5095 i <= AUTO_PIN_FRONT_MIC ? PIN_VREF80 : PIN_IN);
5096 if (nid != ALC882_PIN_CD_NID)
5097 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE,
5098 AMP_OUT_MUTE);
5099 }
5100 }
5101 }
5102
5103 /* almost identical with ALC880 parser... */
5104 static int alc882_parse_auto_config(struct hda_codec *codec)
5105 {
5106 struct alc_spec *spec = codec->spec;
5107 int err = alc880_parse_auto_config(codec);
5108
5109 if (err < 0)
5110 return err;
5111 else if (err > 0)
5112 /* hack - override the init verbs */
5113 spec->init_verbs[0] = alc882_auto_init_verbs;
5114 return err;
5115 }
5116
5117 /* additional initialization for auto-configuration model */
5118 static void alc882_auto_init(struct hda_codec *codec)
5119 {
5120 alc882_auto_init_multi_out(codec);
5121 alc882_auto_init_hp_out(codec);
5122 alc882_auto_init_analog_input(codec);
5123 }
5124
5125 static int patch_alc882(struct hda_codec *codec)
5126 {
5127 struct alc_spec *spec;
5128 int err, board_config;
5129
5130 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
5131 if (spec == NULL)
5132 return -ENOMEM;
5133
5134 codec->spec = spec;
5135
5136 board_config = snd_hda_check_board_config(codec, ALC882_MODEL_LAST,
5137 alc882_models,
5138 alc882_cfg_tbl);
5139
5140 if (board_config < 0 || board_config >= ALC882_MODEL_LAST) {
5141 /* Pick up systems that don't supply PCI SSID */
5142 switch (codec->subsystem_id) {
5143 case 0x106b0c00: /* Mac Pro */
5144 board_config = ALC885_MACPRO;
5145 break;
5146 default:
5147 printk(KERN_INFO "hda_codec: Unknown model for ALC882, "
5148 "trying auto-probe from BIOS...\n");
5149 board_config = ALC882_AUTO;
5150 }
5151 }
5152
5153 if (board_config == ALC882_AUTO) {
5154 /* automatic parse from the BIOS config */
5155 err = alc882_parse_auto_config(codec);
5156 if (err < 0) {
5157 alc_free(codec);
5158 return err;
5159 } else if (! err) {
5160 printk(KERN_INFO
5161 "hda_codec: Cannot set up configuration "
5162 "from BIOS. Using base mode...\n");
5163 board_config = ALC882_3ST_DIG;
5164 }
5165 }
5166
5167 if (board_config != ALC882_AUTO)
5168 setup_preset(spec, &alc882_presets[board_config]);
5169
5170 if (board_config == ALC885_MACPRO) {
5171 alc882_gpio_mute(codec, 0, 0);
5172 alc882_gpio_mute(codec, 1, 0);
5173 }
5174
5175 spec->stream_name_analog = "ALC882 Analog";
5176 spec->stream_analog_playback = &alc882_pcm_analog_playback;
5177 spec->stream_analog_capture = &alc882_pcm_analog_capture;
5178
5179 spec->stream_name_digital = "ALC882 Digital";
5180 spec->stream_digital_playback = &alc882_pcm_digital_playback;
5181 spec->stream_digital_capture = &alc882_pcm_digital_capture;
5182
5183 if (! spec->adc_nids && spec->input_mux) {
5184 /* check whether NID 0x07 is valid */
5185 unsigned int wcap = get_wcaps(codec, 0x07);
5186 wcap = (wcap & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT; /* get type */
5187 if (wcap != AC_WID_AUD_IN) {
5188 spec->adc_nids = alc882_adc_nids_alt;
5189 spec->num_adc_nids = ARRAY_SIZE(alc882_adc_nids_alt);
5190 spec->mixers[spec->num_mixers] = alc882_capture_alt_mixer;
5191 spec->num_mixers++;
5192 } else {
5193 spec->adc_nids = alc882_adc_nids;
5194 spec->num_adc_nids = ARRAY_SIZE(alc882_adc_nids);
5195 spec->mixers[spec->num_mixers] = alc882_capture_mixer;
5196 spec->num_mixers++;
5197 }
5198 }
5199
5200 codec->patch_ops = alc_patch_ops;
5201 if (board_config == ALC882_AUTO)
5202 spec->init_hook = alc882_auto_init;
5203
5204 return 0;
5205 }
5206
5207 /*
5208 * ALC883 support
5209 *
5210 * ALC883 is almost identical with ALC880 but has cleaner and more flexible
5211 * configuration. Each pin widget can choose any input DACs and a mixer.
5212 * Each ADC is connected from a mixer of all inputs. This makes possible
5213 * 6-channel independent captures.
5214 *
5215 * In addition, an independent DAC for the multi-playback (not used in this
5216 * driver yet).
5217 */
5218 #define ALC883_DIGOUT_NID 0x06
5219 #define ALC883_DIGIN_NID 0x0a
5220
5221 static hda_nid_t alc883_dac_nids[4] = {
5222 /* front, rear, clfe, rear_surr */
5223 0x02, 0x04, 0x03, 0x05
5224 };
5225
5226 static hda_nid_t alc883_adc_nids[2] = {
5227 /* ADC1-2 */
5228 0x08, 0x09,
5229 };
5230 /* input MUX */
5231 /* FIXME: should be a matrix-type input source selection */
5232
5233 static struct hda_input_mux alc883_capture_source = {
5234 .num_items = 4,
5235 .items = {
5236 { "Mic", 0x0 },
5237 { "Front Mic", 0x1 },
5238 { "Line", 0x2 },
5239 { "CD", 0x4 },
5240 },
5241 };
5242
5243 static struct hda_input_mux alc883_lenovo_101e_capture_source = {
5244 .num_items = 2,
5245 .items = {
5246 { "Mic", 0x1 },
5247 { "Line", 0x2 },
5248 },
5249 };
5250
5251 #define alc883_mux_enum_info alc_mux_enum_info
5252 #define alc883_mux_enum_get alc_mux_enum_get
5253
5254 static int alc883_mux_enum_put(struct snd_kcontrol *kcontrol,
5255 struct snd_ctl_elem_value *ucontrol)
5256 {
5257 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
5258 struct alc_spec *spec = codec->spec;
5259 const struct hda_input_mux *imux = spec->input_mux;
5260 unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
5261 static hda_nid_t capture_mixers[3] = { 0x24, 0x23, 0x22 };
5262 hda_nid_t nid = capture_mixers[adc_idx];
5263 unsigned int *cur_val = &spec->cur_mux[adc_idx];
5264 unsigned int i, idx;
5265
5266 idx = ucontrol->value.enumerated.item[0];
5267 if (idx >= imux->num_items)
5268 idx = imux->num_items - 1;
5269 if (*cur_val == idx && ! codec->in_resume)
5270 return 0;
5271 for (i = 0; i < imux->num_items; i++) {
5272 unsigned int v = (i == idx) ? 0x7000 : 0x7080;
5273 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE,
5274 v | (imux->items[i].index << 8));
5275 }
5276 *cur_val = idx;
5277 return 1;
5278 }
5279 /*
5280 * 2ch mode
5281 */
5282 static struct hda_channel_mode alc883_3ST_2ch_modes[1] = {
5283 { 2, NULL }
5284 };
5285
5286 /*
5287 * 2ch mode
5288 */
5289 static struct hda_verb alc883_3ST_ch2_init[] = {
5290 { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
5291 { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
5292 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
5293 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
5294 { } /* end */
5295 };
5296
5297 /*
5298 * 6ch mode
5299 */
5300 static struct hda_verb alc883_3ST_ch6_init[] = {
5301 { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
5302 { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
5303 { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
5304 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
5305 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
5306 { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
5307 { } /* end */
5308 };
5309
5310 static struct hda_channel_mode alc883_3ST_6ch_modes[2] = {
5311 { 2, alc883_3ST_ch2_init },
5312 { 6, alc883_3ST_ch6_init },
5313 };
5314
5315 /*
5316 * 6ch mode
5317 */
5318 static struct hda_verb alc883_sixstack_ch6_init[] = {
5319 { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
5320 { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
5321 { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
5322 { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
5323 { } /* end */
5324 };
5325
5326 /*
5327 * 8ch mode
5328 */
5329 static struct hda_verb alc883_sixstack_ch8_init[] = {
5330 { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
5331 { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
5332 { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
5333 { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
5334 { } /* end */
5335 };
5336
5337 static struct hda_channel_mode alc883_sixstack_modes[2] = {
5338 { 6, alc883_sixstack_ch6_init },
5339 { 8, alc883_sixstack_ch8_init },
5340 };
5341
5342 static struct hda_verb alc883_medion_eapd_verbs[] = {
5343 /* eanable EAPD on medion laptop */
5344 {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
5345 {0x20, AC_VERB_SET_PROC_COEF, 0x3070},
5346 { }
5347 };
5348
5349 /* Pin assignment: Front=0x14, Rear=0x15, CLFE=0x16, Side=0x17
5350 * Mic=0x18, Front Mic=0x19, Line-In=0x1a, HP=0x1b
5351 */
5352
5353 static struct snd_kcontrol_new alc883_base_mixer[] = {
5354 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
5355 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
5356 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
5357 HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
5358 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
5359 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
5360 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
5361 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
5362 HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
5363 HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
5364 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
5365 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
5366 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
5367 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
5368 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
5369 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
5370 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
5371 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
5372 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
5373 HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
5374 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
5375 HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
5376 HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
5377 HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
5378 HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
5379 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT),
5380 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT),
5381 {
5382 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
5383 /* .name = "Capture Source", */
5384 .name = "Input Source",
5385 .count = 2,
5386 .info = alc883_mux_enum_info,
5387 .get = alc883_mux_enum_get,
5388 .put = alc883_mux_enum_put,
5389 },
5390 { } /* end */
5391 };
5392
5393 static struct snd_kcontrol_new alc883_3ST_2ch_mixer[] = {
5394 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
5395 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
5396 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
5397 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
5398 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
5399 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
5400 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
5401 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
5402 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
5403 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
5404 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
5405 HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
5406 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
5407 HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
5408 HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
5409 HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
5410 HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
5411 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT),
5412 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT),
5413 {
5414 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
5415 /* .name = "Capture Source", */
5416 .name = "Input Source",
5417 .count = 2,
5418 .info = alc883_mux_enum_info,
5419 .get = alc883_mux_enum_get,
5420 .put = alc883_mux_enum_put,
5421 },
5422 { } /* end */
5423 };
5424
5425 static struct snd_kcontrol_new alc883_3ST_6ch_mixer[] = {
5426 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
5427 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
5428 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
5429 HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
5430 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
5431 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
5432 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
5433 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
5434 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
5435 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
5436 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
5437 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
5438 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
5439 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
5440 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
5441 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
5442 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
5443 HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
5444 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
5445 HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
5446 HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
5447 HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
5448 HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
5449 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT),
5450 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT),
5451 {
5452 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
5453 /* .name = "Capture Source", */
5454 .name = "Input Source",
5455 .count = 2,
5456 .info = alc883_mux_enum_info,
5457 .get = alc883_mux_enum_get,
5458 .put = alc883_mux_enum_put,
5459 },
5460 { } /* end */
5461 };
5462
5463 static struct snd_kcontrol_new alc883_fivestack_mixer[] = {
5464 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
5465 HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
5466 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
5467 HDA_CODEC_MUTE("Surround Playback Switch", 0x15, 0x0, HDA_OUTPUT),
5468 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
5469 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
5470 HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x16, 1, 0x0, HDA_OUTPUT),
5471 HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x16, 2, 0x0, HDA_OUTPUT),
5472 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
5473 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
5474 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
5475 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
5476 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
5477 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
5478 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
5479 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
5480 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
5481 HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
5482 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
5483 HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
5484 HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
5485 HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
5486 HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
5487
5488 {
5489 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
5490 /* .name = "Capture Source", */
5491 .name = "Input Source",
5492 .count = 1,
5493 .info = alc883_mux_enum_info,
5494 .get = alc883_mux_enum_get,
5495 .put = alc883_mux_enum_put,
5496 },
5497 { } /* end */
5498 };
5499
5500 static struct snd_kcontrol_new alc883_tagra_mixer[] = {
5501 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
5502 HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
5503 HDA_CODEC_MUTE("Front Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
5504 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
5505 HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
5506 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
5507 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
5508 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
5509 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
5510 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
5511 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
5512 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
5513 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
5514 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
5515 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
5516 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
5517 HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
5518 HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
5519 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT),
5520 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT),
5521 {
5522 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
5523 /* .name = "Capture Source", */
5524 .name = "Input Source",
5525 .count = 2,
5526 .info = alc883_mux_enum_info,
5527 .get = alc883_mux_enum_get,
5528 .put = alc883_mux_enum_put,
5529 },
5530 { } /* end */
5531 };
5532
5533 static struct snd_kcontrol_new alc883_tagra_2ch_mixer[] = {
5534 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
5535 HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
5536 HDA_CODEC_MUTE("Front Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
5537 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
5538 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
5539 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
5540 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
5541 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
5542 HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
5543 HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
5544 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT),
5545 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT),
5546 {
5547 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
5548 /* .name = "Capture Source", */
5549 .name = "Input Source",
5550 .count = 2,
5551 .info = alc883_mux_enum_info,
5552 .get = alc883_mux_enum_get,
5553 .put = alc883_mux_enum_put,
5554 },
5555 { } /* end */
5556 };
5557
5558 static struct snd_kcontrol_new alc883_lenovo_101e_2ch_mixer[] = {
5559 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
5560 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
5561 HDA_CODEC_VOLUME("iSpeaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
5562 HDA_BIND_MUTE("iSpeaker Playback Switch", 0x0d, 2, HDA_INPUT),
5563 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
5564 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
5565 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
5566 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
5567 HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
5568 HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
5569 {
5570 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
5571 /* .name = "Capture Source", */
5572 .name = "Input Source",
5573 .count = 1,
5574 .info = alc883_mux_enum_info,
5575 .get = alc883_mux_enum_get,
5576 .put = alc883_mux_enum_put,
5577 },
5578 { } /* end */
5579 };
5580
5581 static struct snd_kcontrol_new alc883_chmode_mixer[] = {
5582 {
5583 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
5584 .name = "Channel Mode",
5585 .info = alc_ch_mode_info,
5586 .get = alc_ch_mode_get,
5587 .put = alc_ch_mode_put,
5588 },
5589 { } /* end */
5590 };
5591
5592 static struct hda_verb alc883_init_verbs[] = {
5593 /* ADC1: mute amp left and right */
5594 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5595 {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
5596 /* ADC2: mute amp left and right */
5597 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5598 {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
5599 /* Front mixer: unmute input/output amp left and right (volume = 0) */
5600 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5601 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5602 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5603 /* Rear mixer */
5604 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5605 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5606 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5607 /* CLFE mixer */
5608 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5609 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5610 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5611 /* Side mixer */
5612 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5613 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5614 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5615
5616 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5617 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
5618 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
5619 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
5620 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
5621
5622 /* Front Pin: output 0 (0x0c) */
5623 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5624 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5625 {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
5626 /* Rear Pin: output 1 (0x0d) */
5627 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5628 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5629 {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
5630 /* CLFE Pin: output 2 (0x0e) */
5631 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5632 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5633 {0x16, AC_VERB_SET_CONNECT_SEL, 0x02},
5634 /* Side Pin: output 3 (0x0f) */
5635 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5636 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5637 {0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
5638 /* Mic (rear) pin: input vref at 80% */
5639 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
5640 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
5641 /* Front Mic pin: input vref at 80% */
5642 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
5643 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
5644 /* Line In pin: input */
5645 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
5646 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
5647 /* Line-2 In: Headphone output (output 0 - 0x0c) */
5648 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
5649 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5650 {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
5651 /* CD pin widget for input */
5652 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
5653
5654 /* FIXME: use matrix-type input source selection */
5655 /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
5656 /* Input mixer2 */
5657 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5658 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
5659 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
5660 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
5661 /* Input mixer3 */
5662 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5663 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
5664 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
5665 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
5666 { }
5667 };
5668
5669 static struct hda_verb alc883_tagra_verbs[] = {
5670 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5671 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
5672
5673 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
5674 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5675
5676 {0x18, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
5677 {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/surround */
5678 {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
5679
5680 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
5681 {0x01, AC_VERB_SET_GPIO_MASK, 0x03},
5682 {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x03},
5683 {0x01, AC_VERB_SET_GPIO_DATA, 0x03},
5684
5685 { } /* end */
5686 };
5687
5688 static struct hda_verb alc883_lenovo_101e_verbs[] = {
5689 {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
5690 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_FRONT_EVENT|AC_USRSP_EN},
5691 {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT|AC_USRSP_EN},
5692 { } /* end */
5693 };
5694
5695 /* toggle speaker-output according to the hp-jack state */
5696 static void alc883_tagra_automute(struct hda_codec *codec)
5697 {
5698 unsigned int present;
5699
5700 present = snd_hda_codec_read(codec, 0x14, 0,
5701 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
5702 snd_hda_codec_amp_update(codec, 0x1b, 0, HDA_OUTPUT, 0,
5703 0x80, present ? 0x80 : 0);
5704 snd_hda_codec_amp_update(codec, 0x1b, 1, HDA_OUTPUT, 0,
5705 0x80, present ? 0x80 : 0);
5706 snd_hda_codec_write(codec, 1, 0, AC_VERB_SET_GPIO_DATA, present ? 1 : 3);
5707 }
5708
5709 static void alc883_tagra_unsol_event(struct hda_codec *codec, unsigned int res)
5710 {
5711 if ((res >> 26) == ALC880_HP_EVENT)
5712 alc883_tagra_automute(codec);
5713 }
5714
5715 static void alc883_lenovo_101e_ispeaker_automute(struct hda_codec *codec)
5716 {
5717 unsigned int present;
5718
5719 present = snd_hda_codec_read(codec, 0x14, 0,
5720 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
5721
5722 snd_hda_codec_amp_update(codec, 0x15, 0, HDA_OUTPUT, 0,
5723 0x80, present ? 0x80 : 0);
5724 snd_hda_codec_amp_update(codec, 0x15, 1, HDA_OUTPUT, 0,
5725 0x80, present ? 0x80 : 0);
5726 }
5727
5728 static void alc883_lenovo_101e_all_automute(struct hda_codec *codec)
5729 {
5730 unsigned int present;
5731
5732 present = snd_hda_codec_read(codec, 0x1b, 0,
5733 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
5734
5735 snd_hda_codec_amp_update(codec, 0x15, 0, HDA_OUTPUT, 0,
5736 0x80, present ? 0x80 : 0);
5737 snd_hda_codec_amp_update(codec, 0x15, 1, HDA_OUTPUT, 0,
5738 0x80, present ? 0x80 : 0);
5739 snd_hda_codec_amp_update(codec, 0x14, 0, HDA_OUTPUT, 0,
5740 0x80, present ? 0x80 : 0);
5741 snd_hda_codec_amp_update(codec, 0x14, 1, HDA_OUTPUT, 0,
5742 0x80, present ? 0x80 : 0);
5743 }
5744
5745 static void alc883_lenovo_101e_unsol_event(struct hda_codec *codec,
5746 unsigned int res)
5747 {
5748 if ((res >> 26) == ALC880_HP_EVENT)
5749 alc883_lenovo_101e_all_automute(codec);
5750 if ((res >> 26) == ALC880_FRONT_EVENT)
5751 alc883_lenovo_101e_ispeaker_automute(codec);
5752 }
5753
5754 /*
5755 * generic initialization of ADC, input mixers and output mixers
5756 */
5757 static struct hda_verb alc883_auto_init_verbs[] = {
5758 /*
5759 * Unmute ADC0-2 and set the default input to mic-in
5760 */
5761 {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
5762 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5763 {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
5764 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5765
5766 /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
5767 * mixer widget
5768 * Note: PASD motherboards uses the Line In 2 as the input for front panel
5769 * mic (mic 2)
5770 */
5771 /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
5772 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5773 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
5774 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
5775 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
5776 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
5777
5778 /*
5779 * Set up output mixers (0x0c - 0x0f)
5780 */
5781 /* set vol=0 to output mixers */
5782 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5783 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5784 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5785 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5786 /* set up input amps for analog loopback */
5787 /* Amp Indices: DAC = 0, mixer = 1 */
5788 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5789 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
5790 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5791 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
5792 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5793 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
5794 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5795 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
5796 {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5797 {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
5798
5799 /* FIXME: use matrix-type input source selection */
5800 /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
5801 /* Input mixer1 */
5802 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5803 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
5804 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
5805 //{0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
5806 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
5807 /* Input mixer2 */
5808 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5809 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
5810 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
5811 //{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
5812 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
5813
5814 { }
5815 };
5816
5817 /* capture mixer elements */
5818 static struct snd_kcontrol_new alc883_capture_mixer[] = {
5819 HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
5820 HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
5821 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT),
5822 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT),
5823 {
5824 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
5825 /* The multiple "Capture Source" controls confuse alsamixer
5826 * So call somewhat different..
5827 * FIXME: the controls appear in the "playback" view!
5828 */
5829 /* .name = "Capture Source", */
5830 .name = "Input Source",
5831 .count = 2,
5832 .info = alc882_mux_enum_info,
5833 .get = alc882_mux_enum_get,
5834 .put = alc882_mux_enum_put,
5835 },
5836 { } /* end */
5837 };
5838
5839 /* pcm configuration: identiacal with ALC880 */
5840 #define alc883_pcm_analog_playback alc880_pcm_analog_playback
5841 #define alc883_pcm_analog_capture alc880_pcm_analog_capture
5842 #define alc883_pcm_digital_playback alc880_pcm_digital_playback
5843 #define alc883_pcm_digital_capture alc880_pcm_digital_capture
5844
5845 /*
5846 * configuration and preset
5847 */
5848 static const char *alc883_models[ALC883_MODEL_LAST] = {
5849 [ALC883_3ST_2ch_DIG] = "3stack-dig",
5850 [ALC883_3ST_6ch_DIG] = "3stack-6ch-dig",
5851 [ALC883_3ST_6ch] = "3stack-6ch",
5852 [ALC883_6ST_DIG] = "6stack-dig",
5853 [ALC883_TARGA_DIG] = "targa-dig",
5854 [ALC883_TARGA_2ch_DIG] = "targa-2ch-dig",
5855 [ALC888_DEMO_BOARD] = "6stack-dig-demo",
5856 [ALC883_ACER] = "acer",
5857 [ALC883_MEDION] = "medion",
5858 [ALC883_LAPTOP_EAPD] = "laptop-eapd",
5859 [ALC883_LENOVO_101E_2ch] = "lenovo-101e",
5860 [ALC883_AUTO] = "auto",
5861 };
5862
5863 static struct snd_pci_quirk alc883_cfg_tbl[] = {
5864 SND_PCI_QUIRK(0x1019, 0x6668, "ECS", ALC883_3ST_6ch_DIG),
5865 SND_PCI_QUIRK(0x108e, 0x534d, NULL, ALC883_3ST_6ch),
5866 SND_PCI_QUIRK(0x1558, 0, "Clevo laptop", ALC883_LAPTOP_EAPD),
5867 SND_PCI_QUIRK(0x105b, 0x6668, "Foxconn", ALC883_6ST_DIG),
5868 SND_PCI_QUIRK(0x1462, 0x6668, "MSI", ALC883_6ST_DIG),
5869 SND_PCI_QUIRK(0x1462, 0x7187, "MSI", ALC883_6ST_DIG),
5870 SND_PCI_QUIRK(0x1462, 0x7280, "MSI", ALC883_6ST_DIG),
5871 SND_PCI_QUIRK(0x1462, 0x0579, "MSI", ALC883_TARGA_2ch_DIG),
5872 SND_PCI_QUIRK(0x1462, 0x3ef9, "MSI", ALC883_TARGA_DIG),
5873 SND_PCI_QUIRK(0x1462, 0x3b7f, "MSI", ALC883_TARGA_2ch_DIG),
5874 SND_PCI_QUIRK(0x1462, 0x3fcc, "MSI", ALC883_TARGA_DIG),
5875 SND_PCI_QUIRK(0x1462, 0x3fc1, "MSI", ALC883_TARGA_DIG),
5876 SND_PCI_QUIRK(0x1462, 0x3fc3, "MSI", ALC883_TARGA_DIG),
5877 SND_PCI_QUIRK(0x1462, 0x4314, "MSI", ALC883_TARGA_DIG),
5878 SND_PCI_QUIRK(0x1462, 0x4319, "MSI", ALC883_TARGA_DIG),
5879 SND_PCI_QUIRK(0x1462, 0x4324, "MSI", ALC883_TARGA_DIG),
5880 SND_PCI_QUIRK(0x1462, 0xa422, "MSI", ALC883_TARGA_2ch_DIG),
5881 SND_PCI_QUIRK(0x1025, 0, "Acer laptop", ALC883_ACER),
5882 SND_PCI_QUIRK(0x161f, 0x2054, "Medion laptop", ALC883_MEDION),
5883 SND_PCI_QUIRK(0x1071, 0x8258, "Evesham Voyaeger", ALC883_LAPTOP_EAPD),
5884 SND_PCI_QUIRK(0x8086, 0xd601, "D102GGC", ALC883_3ST_6ch),
5885 SND_PCI_QUIRK(0x17aa, 0x101e, "lenovo 101e", ALC883_LENOVO_101E_2ch),
5886 {}
5887 };
5888
5889 static struct alc_config_preset alc883_presets[] = {
5890 [ALC883_3ST_2ch_DIG] = {
5891 .mixers = { alc883_3ST_2ch_mixer },
5892 .init_verbs = { alc883_init_verbs },
5893 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
5894 .dac_nids = alc883_dac_nids,
5895 .dig_out_nid = ALC883_DIGOUT_NID,
5896 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids),
5897 .adc_nids = alc883_adc_nids,
5898 .dig_in_nid = ALC883_DIGIN_NID,
5899 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
5900 .channel_mode = alc883_3ST_2ch_modes,
5901 .input_mux = &alc883_capture_source,
5902 },
5903 [ALC883_3ST_6ch_DIG] = {
5904 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
5905 .init_verbs = { alc883_init_verbs },
5906 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
5907 .dac_nids = alc883_dac_nids,
5908 .dig_out_nid = ALC883_DIGOUT_NID,
5909 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids),
5910 .adc_nids = alc883_adc_nids,
5911 .dig_in_nid = ALC883_DIGIN_NID,
5912 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
5913 .channel_mode = alc883_3ST_6ch_modes,
5914 .need_dac_fix = 1,
5915 .input_mux = &alc883_capture_source,
5916 },
5917 [ALC883_3ST_6ch] = {
5918 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
5919 .init_verbs = { alc883_init_verbs },
5920 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
5921 .dac_nids = alc883_dac_nids,
5922 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids),
5923 .adc_nids = alc883_adc_nids,
5924 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
5925 .channel_mode = alc883_3ST_6ch_modes,
5926 .need_dac_fix = 1,
5927 .input_mux = &alc883_capture_source,
5928 },
5929 [ALC883_6ST_DIG] = {
5930 .mixers = { alc883_base_mixer, alc883_chmode_mixer },
5931 .init_verbs = { alc883_init_verbs },
5932 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
5933 .dac_nids = alc883_dac_nids,
5934 .dig_out_nid = ALC883_DIGOUT_NID,
5935 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids),
5936 .adc_nids = alc883_adc_nids,
5937 .dig_in_nid = ALC883_DIGIN_NID,
5938 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
5939 .channel_mode = alc883_sixstack_modes,
5940 .input_mux = &alc883_capture_source,
5941 },
5942 [ALC883_TARGA_DIG] = {
5943 .mixers = { alc883_tagra_mixer, alc883_chmode_mixer },
5944 .init_verbs = { alc883_init_verbs, alc883_tagra_verbs},
5945 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
5946 .dac_nids = alc883_dac_nids,
5947 .dig_out_nid = ALC883_DIGOUT_NID,
5948 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids),
5949 .adc_nids = alc883_adc_nids,
5950 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
5951 .channel_mode = alc883_3ST_6ch_modes,
5952 .need_dac_fix = 1,
5953 .input_mux = &alc883_capture_source,
5954 .unsol_event = alc883_tagra_unsol_event,
5955 .init_hook = alc883_tagra_automute,
5956 },
5957 [ALC883_TARGA_2ch_DIG] = {
5958 .mixers = { alc883_tagra_2ch_mixer},
5959 .init_verbs = { alc883_init_verbs, alc883_tagra_verbs},
5960 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
5961 .dac_nids = alc883_dac_nids,
5962 .dig_out_nid = ALC883_DIGOUT_NID,
5963 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids),
5964 .adc_nids = alc883_adc_nids,
5965 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
5966 .channel_mode = alc883_3ST_2ch_modes,
5967 .input_mux = &alc883_capture_source,
5968 .unsol_event = alc883_tagra_unsol_event,
5969 .init_hook = alc883_tagra_automute,
5970 },
5971 [ALC888_DEMO_BOARD] = {
5972 .mixers = { alc883_base_mixer, alc883_chmode_mixer },
5973 .init_verbs = { alc883_init_verbs },
5974 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
5975 .dac_nids = alc883_dac_nids,
5976 .dig_out_nid = ALC883_DIGOUT_NID,
5977 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids),
5978 .adc_nids = alc883_adc_nids,
5979 .dig_in_nid = ALC883_DIGIN_NID,
5980 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
5981 .channel_mode = alc883_sixstack_modes,
5982 .input_mux = &alc883_capture_source,
5983 },
5984 [ALC883_ACER] = {
5985 .mixers = { alc883_base_mixer,
5986 alc883_chmode_mixer },
5987 /* On TravelMate laptops, GPIO 0 enables the internal speaker
5988 * and the headphone jack. Turn this on and rely on the
5989 * standard mute methods whenever the user wants to turn
5990 * these outputs off.
5991 */
5992 .init_verbs = { alc883_init_verbs, alc880_gpio1_init_verbs },
5993 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
5994 .dac_nids = alc883_dac_nids,
5995 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids),
5996 .adc_nids = alc883_adc_nids,
5997 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
5998 .channel_mode = alc883_3ST_2ch_modes,
5999 .input_mux = &alc883_capture_source,
6000 },
6001 [ALC883_MEDION] = {
6002 .mixers = { alc883_fivestack_mixer,
6003 alc883_chmode_mixer },
6004 .init_verbs = { alc883_init_verbs,
6005 alc883_medion_eapd_verbs },
6006 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
6007 .dac_nids = alc883_dac_nids,
6008 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids),
6009 .adc_nids = alc883_adc_nids,
6010 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
6011 .channel_mode = alc883_sixstack_modes,
6012 .input_mux = &alc883_capture_source,
6013 },
6014 [ALC883_LAPTOP_EAPD] = {
6015 .mixers = { alc883_base_mixer,
6016 alc883_chmode_mixer },
6017 .init_verbs = { alc883_init_verbs, alc882_eapd_verbs },
6018 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
6019 .dac_nids = alc883_dac_nids,
6020 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids),
6021 .adc_nids = alc883_adc_nids,
6022 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
6023 .channel_mode = alc883_3ST_2ch_modes,
6024 .input_mux = &alc883_capture_source,
6025 },
6026 [ALC883_LENOVO_101E_2ch] = {
6027 .mixers = { alc883_lenovo_101e_2ch_mixer},
6028 .init_verbs = { alc883_init_verbs, alc883_lenovo_101e_verbs},
6029 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
6030 .dac_nids = alc883_dac_nids,
6031 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids),
6032 .adc_nids = alc883_adc_nids,
6033 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
6034 .channel_mode = alc883_3ST_2ch_modes,
6035 .input_mux = &alc883_lenovo_101e_capture_source,
6036 .unsol_event = alc883_lenovo_101e_unsol_event,
6037 .init_hook = alc883_lenovo_101e_all_automute,
6038 },
6039 };
6040
6041
6042 /*
6043 * BIOS auto configuration
6044 */
6045 static void alc883_auto_set_output_and_unmute(struct hda_codec *codec,
6046 hda_nid_t nid, int pin_type,
6047 int dac_idx)
6048 {
6049 /* set as output */
6050 struct alc_spec *spec = codec->spec;
6051 int idx;
6052
6053 if (spec->multiout.dac_nids[dac_idx] == 0x25)
6054 idx = 4;
6055 else
6056 idx = spec->multiout.dac_nids[dac_idx] - 2;
6057
6058 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
6059 pin_type);
6060 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE,
6061 AMP_OUT_UNMUTE);
6062 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CONNECT_SEL, idx);
6063
6064 }
6065
6066 static void alc883_auto_init_multi_out(struct hda_codec *codec)
6067 {
6068 struct alc_spec *spec = codec->spec;
6069 int i;
6070
6071 alc_subsystem_id(codec, 0x15, 0x1b, 0x14);
6072 for (i = 0; i <= HDA_SIDE; i++) {
6073 hda_nid_t nid = spec->autocfg.line_out_pins[i];
6074 if (nid)
6075 alc883_auto_set_output_and_unmute(codec, nid, PIN_OUT, i);
6076 }
6077 }
6078
6079 static void alc883_auto_init_hp_out(struct hda_codec *codec)
6080 {
6081 struct alc_spec *spec = codec->spec;
6082 hda_nid_t pin;
6083
6084 pin = spec->autocfg.hp_pins[0];
6085 if (pin) /* connect to front */
6086 /* use dac 0 */
6087 alc883_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
6088 }
6089
6090 #define alc883_is_input_pin(nid) alc880_is_input_pin(nid)
6091 #define ALC883_PIN_CD_NID ALC880_PIN_CD_NID
6092
6093 static void alc883_auto_init_analog_input(struct hda_codec *codec)
6094 {
6095 struct alc_spec *spec = codec->spec;
6096 int i;
6097
6098 for (i = 0; i < AUTO_PIN_LAST; i++) {
6099 hda_nid_t nid = spec->autocfg.input_pins[i];
6100 if (alc883_is_input_pin(nid)) {
6101 snd_hda_codec_write(codec, nid, 0,
6102 AC_VERB_SET_PIN_WIDGET_CONTROL,
6103 (i <= AUTO_PIN_FRONT_MIC ?
6104 PIN_VREF80 : PIN_IN));
6105 if (nid != ALC883_PIN_CD_NID)
6106 snd_hda_codec_write(codec, nid, 0,
6107 AC_VERB_SET_AMP_GAIN_MUTE,
6108 AMP_OUT_MUTE);
6109 }
6110 }
6111 }
6112
6113 /* almost identical with ALC880 parser... */
6114 static int alc883_parse_auto_config(struct hda_codec *codec)
6115 {
6116 struct alc_spec *spec = codec->spec;
6117 int err = alc880_parse_auto_config(codec);
6118
6119 if (err < 0)
6120 return err;
6121 else if (err > 0)
6122 /* hack - override the init verbs */
6123 spec->init_verbs[0] = alc883_auto_init_verbs;
6124 spec->mixers[spec->num_mixers] = alc883_capture_mixer;
6125 spec->num_mixers++;
6126 return err;
6127 }
6128
6129 /* additional initialization for auto-configuration model */
6130 static void alc883_auto_init(struct hda_codec *codec)
6131 {
6132 alc883_auto_init_multi_out(codec);
6133 alc883_auto_init_hp_out(codec);
6134 alc883_auto_init_analog_input(codec);
6135 }
6136
6137 static int patch_alc883(struct hda_codec *codec)
6138 {
6139 struct alc_spec *spec;
6140 int err, board_config;
6141
6142 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
6143 if (spec == NULL)
6144 return -ENOMEM;
6145
6146 codec->spec = spec;
6147
6148 board_config = snd_hda_check_board_config(codec, ALC883_MODEL_LAST,
6149 alc883_models,
6150 alc883_cfg_tbl);
6151 if (board_config < 0) {
6152 printk(KERN_INFO "hda_codec: Unknown model for ALC883, "
6153 "trying auto-probe from BIOS...\n");
6154 board_config = ALC883_AUTO;
6155 }
6156
6157 if (board_config == ALC883_AUTO) {
6158 /* automatic parse from the BIOS config */
6159 err = alc883_parse_auto_config(codec);
6160 if (err < 0) {
6161 alc_free(codec);
6162 return err;
6163 } else if (! err) {
6164 printk(KERN_INFO
6165 "hda_codec: Cannot set up configuration "
6166 "from BIOS. Using base mode...\n");
6167 board_config = ALC883_3ST_2ch_DIG;
6168 }
6169 }
6170
6171 if (board_config != ALC883_AUTO)
6172 setup_preset(spec, &alc883_presets[board_config]);
6173
6174 spec->stream_name_analog = "ALC883 Analog";
6175 spec->stream_analog_playback = &alc883_pcm_analog_playback;
6176 spec->stream_analog_capture = &alc883_pcm_analog_capture;
6177
6178 spec->stream_name_digital = "ALC883 Digital";
6179 spec->stream_digital_playback = &alc883_pcm_digital_playback;
6180 spec->stream_digital_capture = &alc883_pcm_digital_capture;
6181
6182 if (! spec->adc_nids && spec->input_mux) {
6183 spec->adc_nids = alc883_adc_nids;
6184 spec->num_adc_nids = ARRAY_SIZE(alc883_adc_nids);
6185 }
6186
6187 codec->patch_ops = alc_patch_ops;
6188 if (board_config == ALC883_AUTO)
6189 spec->init_hook = alc883_auto_init;
6190
6191 return 0;
6192 }
6193
6194 /*
6195 * ALC262 support
6196 */
6197
6198 #define ALC262_DIGOUT_NID ALC880_DIGOUT_NID
6199 #define ALC262_DIGIN_NID ALC880_DIGIN_NID
6200
6201 #define alc262_dac_nids alc260_dac_nids
6202 #define alc262_adc_nids alc882_adc_nids
6203 #define alc262_adc_nids_alt alc882_adc_nids_alt
6204
6205 #define alc262_modes alc260_modes
6206 #define alc262_capture_source alc882_capture_source
6207
6208 static struct snd_kcontrol_new alc262_base_mixer[] = {
6209 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
6210 HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
6211 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
6212 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
6213 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
6214 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
6215 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
6216 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
6217 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
6218 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
6219 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
6220 HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
6221 /* HDA_CODEC_VOLUME("PC Beep Playback Volume", 0x0b, 0x05, HDA_INPUT),
6222 HDA_CODEC_MUTE("PC Beelp Playback Switch", 0x0b, 0x05, HDA_INPUT), */
6223 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0D, 0x0, HDA_OUTPUT),
6224 HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
6225 HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
6226 HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x16, 2, 0x0, HDA_OUTPUT),
6227 { } /* end */
6228 };
6229
6230 static struct snd_kcontrol_new alc262_hippo1_mixer[] = {
6231 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
6232 HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
6233 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
6234 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
6235 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
6236 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
6237 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
6238 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
6239 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
6240 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
6241 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
6242 HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
6243 /* HDA_CODEC_VOLUME("PC Beep Playback Volume", 0x0b, 0x05, HDA_INPUT),
6244 HDA_CODEC_MUTE("PC Beelp Playback Switch", 0x0b, 0x05, HDA_INPUT), */
6245 /*HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0D, 0x0, HDA_OUTPUT),*/
6246 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
6247 { } /* end */
6248 };
6249
6250 static struct snd_kcontrol_new alc262_HP_BPC_mixer[] = {
6251 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
6252 HDA_CODEC_MUTE("Front Playback Switch", 0x15, 0x0, HDA_OUTPUT),
6253 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
6254 HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
6255 HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x16, 2, 0x0, HDA_OUTPUT),
6256
6257 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
6258 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
6259 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
6260 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
6261 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
6262 HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
6263 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
6264 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
6265 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
6266 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
6267 HDA_CODEC_VOLUME("PC Beep Playback Volume", 0x0b, 0x05, HDA_INPUT),
6268 HDA_CODEC_MUTE("PC Beep Playback Switch", 0x0b, 0x05, HDA_INPUT),
6269 HDA_CODEC_VOLUME("AUX IN Playback Volume", 0x0b, 0x06, HDA_INPUT),
6270 HDA_CODEC_MUTE("AUX IN Playback Switch", 0x0b, 0x06, HDA_INPUT),
6271 { } /* end */
6272 };
6273
6274 static struct snd_kcontrol_new alc262_HP_BPC_WildWest_mixer[] = {
6275 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
6276 HDA_CODEC_MUTE("Front Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
6277 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
6278 HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
6279 HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
6280 HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x16, 2, 0x0, HDA_OUTPUT),
6281 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x02, HDA_INPUT),
6282 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x02, HDA_INPUT),
6283 HDA_CODEC_VOLUME("Front Mic Boost", 0x1a, 0, HDA_INPUT),
6284 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x01, HDA_INPUT),
6285 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x01, HDA_INPUT),
6286 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
6287 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
6288 HDA_CODEC_VOLUME("PC Beep Playback Volume", 0x0b, 0x05, HDA_INPUT),
6289 HDA_CODEC_MUTE("PC Beep Playback Switch", 0x0b, 0x05, HDA_INPUT),
6290 { } /* end */
6291 };
6292
6293 static struct snd_kcontrol_new alc262_HP_BPC_WildWest_option_mixer[] = {
6294 HDA_CODEC_VOLUME("Rear Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
6295 HDA_CODEC_MUTE("Rear Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
6296 HDA_CODEC_VOLUME("Rear Mic Boost", 0x18, 0, HDA_INPUT),
6297 { } /* end */
6298 };
6299
6300 #define alc262_capture_mixer alc882_capture_mixer
6301 #define alc262_capture_alt_mixer alc882_capture_alt_mixer
6302
6303 /*
6304 * generic initialization of ADC, input mixers and output mixers
6305 */
6306 static struct hda_verb alc262_init_verbs[] = {
6307 /*
6308 * Unmute ADC0-2 and set the default input to mic-in
6309 */
6310 {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
6311 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6312 {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
6313 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6314 {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
6315 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6316
6317 /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
6318 * mixer widget
6319 * Note: PASD motherboards uses the Line In 2 as the input for front panel
6320 * mic (mic 2)
6321 */
6322 /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
6323 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6324 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6325 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
6326 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
6327 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
6328
6329 /*
6330 * Set up output mixers (0x0c - 0x0e)
6331 */
6332 /* set vol=0 to output mixers */
6333 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6334 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6335 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6336 /* set up input amps for analog loopback */
6337 /* Amp Indices: DAC = 0, mixer = 1 */
6338 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6339 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6340 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6341 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6342 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6343 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6344
6345 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
6346 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
6347 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
6348 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
6349 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
6350 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
6351
6352 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
6353 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
6354 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
6355 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
6356 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
6357
6358 {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
6359 {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
6360
6361 /* FIXME: use matrix-type input source selection */
6362 /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
6363 /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
6364 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
6365 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
6366 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
6367 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
6368 /* Input mixer2 */
6369 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
6370 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
6371 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
6372 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
6373 /* Input mixer3 */
6374 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
6375 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
6376 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
6377 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
6378
6379 { }
6380 };
6381
6382 static struct hda_verb alc262_hippo_unsol_verbs[] = {
6383 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
6384 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
6385 {}
6386 };
6387
6388 static struct hda_verb alc262_hippo1_unsol_verbs[] = {
6389 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
6390 {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
6391 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
6392
6393 {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
6394 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
6395 {}
6396 };
6397
6398 /* mute/unmute internal speaker according to the hp jack and mute state */
6399 static void alc262_hippo_automute(struct hda_codec *codec, int force)
6400 {
6401 struct alc_spec *spec = codec->spec;
6402 unsigned int mute;
6403
6404 if (force || ! spec->sense_updated) {
6405 unsigned int present;
6406 /* need to execute and sync at first */
6407 snd_hda_codec_read(codec, 0x15, 0, AC_VERB_SET_PIN_SENSE, 0);
6408 present = snd_hda_codec_read(codec, 0x15, 0,
6409 AC_VERB_GET_PIN_SENSE, 0);
6410 spec->jack_present = (present & 0x80000000) != 0;
6411 spec->sense_updated = 1;
6412 }
6413 if (spec->jack_present) {
6414 /* mute internal speaker */
6415 snd_hda_codec_amp_update(codec, 0x14, 0, HDA_OUTPUT, 0,
6416 0x80, 0x80);
6417 snd_hda_codec_amp_update(codec, 0x14, 1, HDA_OUTPUT, 0,
6418 0x80, 0x80);
6419 } else {
6420 /* unmute internal speaker if necessary */
6421 mute = snd_hda_codec_amp_read(codec, 0x15, 0, HDA_OUTPUT, 0);
6422 snd_hda_codec_amp_update(codec, 0x14, 0, HDA_OUTPUT, 0,
6423 0x80, mute & 0x80);
6424 mute = snd_hda_codec_amp_read(codec, 0x15, 1, HDA_OUTPUT, 0);
6425 snd_hda_codec_amp_update(codec, 0x14, 1, HDA_OUTPUT, 0,
6426 0x80, mute & 0x80);
6427 }
6428 }
6429
6430 /* unsolicited event for HP jack sensing */
6431 static void alc262_hippo_unsol_event(struct hda_codec *codec,
6432 unsigned int res)
6433 {
6434 if ((res >> 26) != ALC880_HP_EVENT)
6435 return;
6436 alc262_hippo_automute(codec, 1);
6437 }
6438
6439 static void alc262_hippo1_automute(struct hda_codec *codec, int force)
6440 {
6441 struct alc_spec *spec = codec->spec;
6442 unsigned int mute;
6443
6444 if (force || ! spec->sense_updated) {
6445 unsigned int present;
6446 /* need to execute and sync at first */
6447 snd_hda_codec_read(codec, 0x1b, 0, AC_VERB_SET_PIN_SENSE, 0);
6448 present = snd_hda_codec_read(codec, 0x1b, 0,
6449 AC_VERB_GET_PIN_SENSE, 0);
6450 spec->jack_present = (present & 0x80000000) != 0;
6451 spec->sense_updated = 1;
6452 }
6453 if (spec->jack_present) {
6454 /* mute internal speaker */
6455 snd_hda_codec_amp_update(codec, 0x14, 0, HDA_OUTPUT, 0,
6456 0x80, 0x80);
6457 snd_hda_codec_amp_update(codec, 0x14, 1, HDA_OUTPUT, 0,
6458 0x80, 0x80);
6459 } else {
6460 /* unmute internal speaker if necessary */
6461 mute = snd_hda_codec_amp_read(codec, 0x1b, 0, HDA_OUTPUT, 0);
6462 snd_hda_codec_amp_update(codec, 0x14, 0, HDA_OUTPUT, 0,
6463 0x80, mute & 0x80);
6464 mute = snd_hda_codec_amp_read(codec, 0x1b, 1, HDA_OUTPUT, 0);
6465 snd_hda_codec_amp_update(codec, 0x14, 1, HDA_OUTPUT, 0,
6466 0x80, mute & 0x80);
6467 }
6468 }
6469
6470 /* unsolicited event for HP jack sensing */
6471 static void alc262_hippo1_unsol_event(struct hda_codec *codec,
6472 unsigned int res)
6473 {
6474 if ((res >> 26) != ALC880_HP_EVENT)
6475 return;
6476 alc262_hippo1_automute(codec, 1);
6477 }
6478
6479 /*
6480 * fujitsu model
6481 * 0x14 = headphone/spdif-out, 0x15 = internal speaker
6482 */
6483
6484 #define ALC_HP_EVENT 0x37
6485
6486 static struct hda_verb alc262_fujitsu_unsol_verbs[] = {
6487 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_HP_EVENT},
6488 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
6489 {}
6490 };
6491
6492 static struct hda_input_mux alc262_fujitsu_capture_source = {
6493 .num_items = 2,
6494 .items = {
6495 { "Mic", 0x0 },
6496 { "CD", 0x4 },
6497 },
6498 };
6499
6500 static struct hda_input_mux alc262_HP_capture_source = {
6501 .num_items = 5,
6502 .items = {
6503 { "Mic", 0x0 },
6504 { "Front Mic", 0x3 },
6505 { "Line", 0x2 },
6506 { "CD", 0x4 },
6507 { "AUX IN", 0x6 },
6508 },
6509 };
6510
6511 /* mute/unmute internal speaker according to the hp jack and mute state */
6512 static void alc262_fujitsu_automute(struct hda_codec *codec, int force)
6513 {
6514 struct alc_spec *spec = codec->spec;
6515 unsigned int mute;
6516
6517 if (force || ! spec->sense_updated) {
6518 unsigned int present;
6519 /* need to execute and sync at first */
6520 snd_hda_codec_read(codec, 0x14, 0, AC_VERB_SET_PIN_SENSE, 0);
6521 present = snd_hda_codec_read(codec, 0x14, 0,
6522 AC_VERB_GET_PIN_SENSE, 0);
6523 spec->jack_present = (present & 0x80000000) != 0;
6524 spec->sense_updated = 1;
6525 }
6526 if (spec->jack_present) {
6527 /* mute internal speaker */
6528 snd_hda_codec_amp_update(codec, 0x15, 0, HDA_OUTPUT, 0,
6529 0x80, 0x80);
6530 snd_hda_codec_amp_update(codec, 0x15, 1, HDA_OUTPUT, 0,
6531 0x80, 0x80);
6532 } else {
6533 /* unmute internal speaker if necessary */
6534 mute = snd_hda_codec_amp_read(codec, 0x14, 0, HDA_OUTPUT, 0);
6535 snd_hda_codec_amp_update(codec, 0x15, 0, HDA_OUTPUT, 0,
6536 0x80, mute & 0x80);
6537 mute = snd_hda_codec_amp_read(codec, 0x14, 1, HDA_OUTPUT, 0);
6538 snd_hda_codec_amp_update(codec, 0x15, 1, HDA_OUTPUT, 0,
6539 0x80, mute & 0x80);
6540 }
6541 }
6542
6543 /* unsolicited event for HP jack sensing */
6544 static void alc262_fujitsu_unsol_event(struct hda_codec *codec,
6545 unsigned int res)
6546 {
6547 if ((res >> 26) != ALC_HP_EVENT)
6548 return;
6549 alc262_fujitsu_automute(codec, 1);
6550 }
6551
6552 /* bind volumes of both NID 0x0c and 0x0d */
6553 static int alc262_fujitsu_master_vol_put(struct snd_kcontrol *kcontrol,
6554 struct snd_ctl_elem_value *ucontrol)
6555 {
6556 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
6557 long *valp = ucontrol->value.integer.value;
6558 int change;
6559
6560 change = snd_hda_codec_amp_update(codec, 0x0c, 0, HDA_OUTPUT, 0,
6561 0x7f, valp[0] & 0x7f);
6562 change |= snd_hda_codec_amp_update(codec, 0x0c, 1, HDA_OUTPUT, 0,
6563 0x7f, valp[1] & 0x7f);
6564 snd_hda_codec_amp_update(codec, 0x0d, 0, HDA_OUTPUT, 0,
6565 0x7f, valp[0] & 0x7f);
6566 snd_hda_codec_amp_update(codec, 0x0d, 1, HDA_OUTPUT, 0,
6567 0x7f, valp[1] & 0x7f);
6568 return change;
6569 }
6570
6571 /* bind hp and internal speaker mute (with plug check) */
6572 static int alc262_fujitsu_master_sw_put(struct snd_kcontrol *kcontrol,
6573 struct snd_ctl_elem_value *ucontrol)
6574 {
6575 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
6576 long *valp = ucontrol->value.integer.value;
6577 int change;
6578
6579 change = snd_hda_codec_amp_update(codec, 0x14, 0, HDA_OUTPUT, 0,
6580 0x80, valp[0] ? 0 : 0x80);
6581 change |= snd_hda_codec_amp_update(codec, 0x14, 1, HDA_OUTPUT, 0,
6582 0x80, valp[1] ? 0 : 0x80);
6583 if (change || codec->in_resume)
6584 alc262_fujitsu_automute(codec, codec->in_resume);
6585 return change;
6586 }
6587
6588 static struct snd_kcontrol_new alc262_fujitsu_mixer[] = {
6589 {
6590 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
6591 .name = "Master Playback Volume",
6592 .info = snd_hda_mixer_amp_volume_info,
6593 .get = snd_hda_mixer_amp_volume_get,
6594 .put = alc262_fujitsu_master_vol_put,
6595 .tlv = { .c = snd_hda_mixer_amp_tlv },
6596 .private_value = HDA_COMPOSE_AMP_VAL(0x0c, 3, 0, HDA_OUTPUT),
6597 },
6598 {
6599 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
6600 .name = "Master Playback Switch",
6601 .info = snd_hda_mixer_amp_switch_info,
6602 .get = snd_hda_mixer_amp_switch_get,
6603 .put = alc262_fujitsu_master_sw_put,
6604 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
6605 },
6606 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
6607 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
6608 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
6609 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
6610 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
6611 { } /* end */
6612 };
6613
6614 /* additional init verbs for Benq laptops */
6615 static struct hda_verb alc262_EAPD_verbs[] = {
6616 {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
6617 {0x20, AC_VERB_SET_PROC_COEF, 0x3070},
6618 {}
6619 };
6620
6621 /* add playback controls from the parsed DAC table */
6622 static int alc262_auto_create_multi_out_ctls(struct alc_spec *spec, const struct auto_pin_cfg *cfg)
6623 {
6624 hda_nid_t nid;
6625 int err;
6626
6627 spec->multiout.num_dacs = 1; /* only use one dac */
6628 spec->multiout.dac_nids = spec->private_dac_nids;
6629 spec->multiout.dac_nids[0] = 2;
6630
6631 nid = cfg->line_out_pins[0];
6632 if (nid) {
6633 if ((err = add_control(spec, ALC_CTL_WIDGET_VOL, "Front Playback Volume",
6634 HDA_COMPOSE_AMP_VAL(0x0c, 3, 0, HDA_OUTPUT))) < 0)
6635 return err;
6636 if ((err = add_control(spec, ALC_CTL_WIDGET_MUTE, "Front Playback Switch",
6637 HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT))) < 0)
6638 return err;
6639 }
6640
6641 nid = cfg->speaker_pins[0];
6642 if (nid) {
6643 if (nid == 0x16) {
6644 if ((err = add_control(spec, ALC_CTL_WIDGET_VOL, "Speaker Playback Volume",
6645 HDA_COMPOSE_AMP_VAL(0x0e, 2, 0, HDA_OUTPUT))) < 0)
6646 return err;
6647 if ((err = add_control(spec, ALC_CTL_WIDGET_MUTE, "Speaker Playback Switch",
6648 HDA_COMPOSE_AMP_VAL(nid, 2, 0, HDA_OUTPUT))) < 0)
6649 return err;
6650 } else {
6651 if ((err = add_control(spec, ALC_CTL_WIDGET_MUTE, "Speaker Playback Switch",
6652 HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT))) < 0)
6653 return err;
6654 }
6655 }
6656 nid = cfg->hp_pins[0];
6657 if (nid) {
6658 /* spec->multiout.hp_nid = 2; */
6659 if (nid == 0x16) {
6660 if ((err = add_control(spec, ALC_CTL_WIDGET_VOL, "Headphone Playback Volume",
6661 HDA_COMPOSE_AMP_VAL(0x0e, 2, 0, HDA_OUTPUT))) < 0)
6662 return err;
6663 if ((err = add_control(spec, ALC_CTL_WIDGET_MUTE, "Headphone Playback Switch",
6664 HDA_COMPOSE_AMP_VAL(nid, 2, 0, HDA_OUTPUT))) < 0)
6665 return err;
6666 } else {
6667 if ((err = add_control(spec, ALC_CTL_WIDGET_MUTE, "Headphone Playback Switch",
6668 HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT))) < 0)
6669 return err;
6670 }
6671 }
6672 return 0;
6673 }
6674
6675 /* identical with ALC880 */
6676 #define alc262_auto_create_analog_input_ctls alc880_auto_create_analog_input_ctls
6677
6678 /*
6679 * generic initialization of ADC, input mixers and output mixers
6680 */
6681 static struct hda_verb alc262_volume_init_verbs[] = {
6682 /*
6683 * Unmute ADC0-2 and set the default input to mic-in
6684 */
6685 {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
6686 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6687 {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
6688 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6689 {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
6690 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6691
6692 /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
6693 * mixer widget
6694 * Note: PASD motherboards uses the Line In 2 as the input for front panel
6695 * mic (mic 2)
6696 */
6697 /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
6698 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6699 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6700 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
6701 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
6702 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
6703
6704 /*
6705 * Set up output mixers (0x0c - 0x0f)
6706 */
6707 /* set vol=0 to output mixers */
6708 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6709 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6710 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6711
6712 /* set up input amps for analog loopback */
6713 /* Amp Indices: DAC = 0, mixer = 1 */
6714 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6715 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6716 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6717 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6718 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6719 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6720
6721 /* FIXME: use matrix-type input source selection */
6722 /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
6723 /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
6724 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
6725 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
6726 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
6727 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
6728 /* Input mixer2 */
6729 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
6730 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
6731 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
6732 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
6733 /* Input mixer3 */
6734 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
6735 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
6736 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
6737 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
6738
6739 { }
6740 };
6741
6742 static struct hda_verb alc262_HP_BPC_init_verbs[] = {
6743 /*
6744 * Unmute ADC0-2 and set the default input to mic-in
6745 */
6746 {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
6747 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6748 {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
6749 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6750 {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
6751 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6752
6753 /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
6754 * mixer widget
6755 * Note: PASD motherboards uses the Line In 2 as the input for front panel
6756 * mic (mic 2)
6757 */
6758 /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
6759 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6760 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6761 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
6762 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
6763 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
6764 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(5)},
6765 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(6)},
6766
6767 /*
6768 * Set up output mixers (0x0c - 0x0e)
6769 */
6770 /* set vol=0 to output mixers */
6771 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6772 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6773 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6774
6775 /* set up input amps for analog loopback */
6776 /* Amp Indices: DAC = 0, mixer = 1 */
6777 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6778 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6779 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6780 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6781 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6782 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6783
6784 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
6785 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6786 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6787
6788 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6789 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6790
6791 {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
6792 {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
6793
6794 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
6795 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
6796 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
6797 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
6798 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
6799
6800 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0x7023 },
6801 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
6802 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
6803 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0x7023 },
6804 {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
6805 {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
6806
6807
6808 /* FIXME: use matrix-type input source selection */
6809 /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
6810 /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
6811 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
6812 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))},
6813 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))},
6814 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))},
6815 /* Input mixer2 */
6816 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
6817 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))},
6818 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))},
6819 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))},
6820 /* Input mixer3 */
6821 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
6822 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))},
6823 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))},
6824 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))},
6825
6826 { }
6827 };
6828
6829 static struct hda_verb alc262_HP_BPC_WildWest_init_verbs[] = {
6830 /*
6831 * Unmute ADC0-2 and set the default input to mic-in
6832 */
6833 {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
6834 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6835 {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
6836 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6837 {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
6838 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6839
6840 /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
6841 * mixer widget
6842 * Note: PASD motherboards uses the Line In 2 as the input for front
6843 * panel mic (mic 2)
6844 */
6845 /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
6846 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6847 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6848 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
6849 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
6850 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
6851 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(5)},
6852 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(6)},
6853 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(7)},
6854 /*
6855 * Set up output mixers (0x0c - 0x0e)
6856 */
6857 /* set vol=0 to output mixers */
6858 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6859 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6860 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6861
6862 /* set up input amps for analog loopback */
6863 /* Amp Indices: DAC = 0, mixer = 1 */
6864 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6865 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6866 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6867 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6868 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6869 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6870
6871
6872 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP }, /* HP */
6873 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, /* Mono */
6874 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, /* rear MIC */
6875 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN }, /* Line in */
6876 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, /* Front MIC */
6877 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, /* Line out */
6878 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN }, /* CD in */
6879
6880 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6881 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6882
6883 {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
6884 {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
6885
6886 /* {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0x7023 }, */
6887 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
6888 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
6889 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0x7023 },
6890 {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
6891 {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
6892
6893 /* FIXME: use matrix-type input source selection */
6894 /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
6895 /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
6896 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, /*rear MIC*/
6897 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))}, /*Line in*/
6898 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))}, /*F MIC*/
6899 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))}, /*Front*/
6900 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))}, /*CD*/
6901 /* {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x06 << 8))}, */
6902 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x07 << 8))}, /*HP*/
6903 /* Input mixer2 */
6904 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
6905 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
6906 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))},
6907 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))},
6908 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))},
6909 /* {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x06 << 8))}, */
6910 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x07 << 8))},
6911 /* Input mixer3 */
6912 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
6913 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
6914 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))},
6915 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))},
6916 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))},
6917 /* {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x06 << 8))}, */
6918 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x07 << 8))},
6919
6920 { }
6921 };
6922
6923 /* pcm configuration: identiacal with ALC880 */
6924 #define alc262_pcm_analog_playback alc880_pcm_analog_playback
6925 #define alc262_pcm_analog_capture alc880_pcm_analog_capture
6926 #define alc262_pcm_digital_playback alc880_pcm_digital_playback
6927 #define alc262_pcm_digital_capture alc880_pcm_digital_capture
6928
6929 /*
6930 * BIOS auto configuration
6931 */
6932 static int alc262_parse_auto_config(struct hda_codec *codec)
6933 {
6934 struct alc_spec *spec = codec->spec;
6935 int err;
6936 static hda_nid_t alc262_ignore[] = { 0x1d, 0 };
6937
6938 if ((err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
6939 alc262_ignore)) < 0)
6940 return err;
6941 if (! spec->autocfg.line_outs)
6942 return 0; /* can't find valid BIOS pin config */
6943 if ((err = alc262_auto_create_multi_out_ctls(spec, &spec->autocfg)) < 0 ||
6944 (err = alc262_auto_create_analog_input_ctls(spec, &spec->autocfg)) < 0)
6945 return err;
6946
6947 spec->multiout.max_channels = spec->multiout.num_dacs * 2;
6948
6949 if (spec->autocfg.dig_out_pin)
6950 spec->multiout.dig_out_nid = ALC262_DIGOUT_NID;
6951 if (spec->autocfg.dig_in_pin)
6952 spec->dig_in_nid = ALC262_DIGIN_NID;
6953
6954 if (spec->kctl_alloc)
6955 spec->mixers[spec->num_mixers++] = spec->kctl_alloc;
6956
6957 spec->init_verbs[spec->num_init_verbs++] = alc262_volume_init_verbs;
6958 spec->num_mux_defs = 1;
6959 spec->input_mux = &spec->private_imux;
6960
6961 return 1;
6962 }
6963
6964 #define alc262_auto_init_multi_out alc882_auto_init_multi_out
6965 #define alc262_auto_init_hp_out alc882_auto_init_hp_out
6966 #define alc262_auto_init_analog_input alc882_auto_init_analog_input
6967
6968
6969 /* init callback for auto-configuration model -- overriding the default init */
6970 static void alc262_auto_init(struct hda_codec *codec)
6971 {
6972 alc262_auto_init_multi_out(codec);
6973 alc262_auto_init_hp_out(codec);
6974 alc262_auto_init_analog_input(codec);
6975 }
6976
6977 /*
6978 * configuration and preset
6979 */
6980 static const char *alc262_models[ALC262_MODEL_LAST] = {
6981 [ALC262_BASIC] = "basic",
6982 [ALC262_HIPPO] = "hippo",
6983 [ALC262_HIPPO_1] = "hippo_1",
6984 [ALC262_FUJITSU] = "fujitsu",
6985 [ALC262_HP_BPC] = "hp-bpc",
6986 [ALC262_HP_BPC_D7000_WL]= "hp-bpc-d7000",
6987 [ALC262_BENQ_ED8] = "benq",
6988 [ALC262_AUTO] = "auto",
6989 };
6990
6991 static struct snd_pci_quirk alc262_cfg_tbl[] = {
6992 SND_PCI_QUIRK(0x1002, 0x437b, "Hippo", ALC262_HIPPO),
6993 SND_PCI_QUIRK(0x103c, 0x12fe, "HP xw9400", ALC262_HP_BPC),
6994 SND_PCI_QUIRK(0x103c, 0x280c, "HP xw4400", ALC262_HP_BPC),
6995 SND_PCI_QUIRK(0x103c, 0x3014, "HP xw6400", ALC262_HP_BPC),
6996 SND_PCI_QUIRK(0x103c, 0x3015, "HP xw8400", ALC262_HP_BPC),
6997 SND_PCI_QUIRK(0x103c, 0x2800, "HP D7000", ALC262_HP_BPC_D7000_WL),
6998 SND_PCI_QUIRK(0x103c, 0x2802, "HP D7000", ALC262_HP_BPC_D7000_WL),
6999 SND_PCI_QUIRK(0x103c, 0x2804, "HP D7000", ALC262_HP_BPC_D7000_WL),
7000 SND_PCI_QUIRK(0x103c, 0x2806, "HP D7000", ALC262_HP_BPC_D7000_WL),
7001 SND_PCI_QUIRK(0x103c, 0x2801, "HP D7000", ALC262_HP_BPC_D7000_WF),
7002 SND_PCI_QUIRK(0x103c, 0x2803, "HP D7000", ALC262_HP_BPC_D7000_WF),
7003 SND_PCI_QUIRK(0x103c, 0x2805, "HP D7000", ALC262_HP_BPC_D7000_WF),
7004 SND_PCI_QUIRK(0x103c, 0x2807, "HP D7000", ALC262_HP_BPC_D7000_WF),
7005 SND_PCI_QUIRK(0x104d, 0x8203, "Sony UX-90", ALC262_HIPPO),
7006 SND_PCI_QUIRK(0x10cf, 0x1397, "Fujitsu", ALC262_FUJITSU),
7007 SND_PCI_QUIRK(0x17ff, 0x058f, "Benq Hippo", ALC262_HIPPO_1),
7008 SND_PCI_QUIRK(0x17ff, 0x0560, "Benq ED8", ALC262_BENQ_ED8),
7009 {}
7010 };
7011
7012 static struct alc_config_preset alc262_presets[] = {
7013 [ALC262_BASIC] = {
7014 .mixers = { alc262_base_mixer },
7015 .init_verbs = { alc262_init_verbs },
7016 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
7017 .dac_nids = alc262_dac_nids,
7018 .hp_nid = 0x03,
7019 .num_channel_mode = ARRAY_SIZE(alc262_modes),
7020 .channel_mode = alc262_modes,
7021 .input_mux = &alc262_capture_source,
7022 },
7023 [ALC262_HIPPO] = {
7024 .mixers = { alc262_base_mixer },
7025 .init_verbs = { alc262_init_verbs, alc262_hippo_unsol_verbs},
7026 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
7027 .dac_nids = alc262_dac_nids,
7028 .hp_nid = 0x03,
7029 .dig_out_nid = ALC262_DIGOUT_NID,
7030 .num_channel_mode = ARRAY_SIZE(alc262_modes),
7031 .channel_mode = alc262_modes,
7032 .input_mux = &alc262_capture_source,
7033 .unsol_event = alc262_hippo_unsol_event,
7034 },
7035 [ALC262_HIPPO_1] = {
7036 .mixers = { alc262_hippo1_mixer },
7037 .init_verbs = { alc262_init_verbs, alc262_hippo1_unsol_verbs},
7038 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
7039 .dac_nids = alc262_dac_nids,
7040 .hp_nid = 0x02,
7041 .dig_out_nid = ALC262_DIGOUT_NID,
7042 .num_channel_mode = ARRAY_SIZE(alc262_modes),
7043 .channel_mode = alc262_modes,
7044 .input_mux = &alc262_capture_source,
7045 .unsol_event = alc262_hippo1_unsol_event,
7046 },
7047 [ALC262_FUJITSU] = {
7048 .mixers = { alc262_fujitsu_mixer },
7049 .init_verbs = { alc262_init_verbs, alc262_fujitsu_unsol_verbs },
7050 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
7051 .dac_nids = alc262_dac_nids,
7052 .hp_nid = 0x03,
7053 .dig_out_nid = ALC262_DIGOUT_NID,
7054 .num_channel_mode = ARRAY_SIZE(alc262_modes),
7055 .channel_mode = alc262_modes,
7056 .input_mux = &alc262_fujitsu_capture_source,
7057 .unsol_event = alc262_fujitsu_unsol_event,
7058 },
7059 [ALC262_HP_BPC] = {
7060 .mixers = { alc262_HP_BPC_mixer },
7061 .init_verbs = { alc262_HP_BPC_init_verbs },
7062 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
7063 .dac_nids = alc262_dac_nids,
7064 .hp_nid = 0x03,
7065 .num_channel_mode = ARRAY_SIZE(alc262_modes),
7066 .channel_mode = alc262_modes,
7067 .input_mux = &alc262_HP_capture_source,
7068 },
7069 [ALC262_HP_BPC_D7000_WF] = {
7070 .mixers = { alc262_HP_BPC_WildWest_mixer },
7071 .init_verbs = { alc262_HP_BPC_WildWest_init_verbs },
7072 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
7073 .dac_nids = alc262_dac_nids,
7074 .hp_nid = 0x03,
7075 .num_channel_mode = ARRAY_SIZE(alc262_modes),
7076 .channel_mode = alc262_modes,
7077 .input_mux = &alc262_HP_capture_source,
7078 },
7079 [ALC262_HP_BPC_D7000_WL] = {
7080 .mixers = { alc262_HP_BPC_WildWest_mixer,
7081 alc262_HP_BPC_WildWest_option_mixer },
7082 .init_verbs = { alc262_HP_BPC_WildWest_init_verbs },
7083 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
7084 .dac_nids = alc262_dac_nids,
7085 .hp_nid = 0x03,
7086 .num_channel_mode = ARRAY_SIZE(alc262_modes),
7087 .channel_mode = alc262_modes,
7088 .input_mux = &alc262_HP_capture_source,
7089 },
7090 [ALC262_BENQ_ED8] = {
7091 .mixers = { alc262_base_mixer },
7092 .init_verbs = { alc262_init_verbs, alc262_EAPD_verbs },
7093 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
7094 .dac_nids = alc262_dac_nids,
7095 .hp_nid = 0x03,
7096 .num_channel_mode = ARRAY_SIZE(alc262_modes),
7097 .channel_mode = alc262_modes,
7098 .input_mux = &alc262_capture_source,
7099 },
7100 };
7101
7102 static int patch_alc262(struct hda_codec *codec)
7103 {
7104 struct alc_spec *spec;
7105 int board_config;
7106 int err;
7107
7108 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
7109 if (spec == NULL)
7110 return -ENOMEM;
7111
7112 codec->spec = spec;
7113 #if 0
7114 /* pshou 07/11/05 set a zero PCM sample to DAC when FIFO is under-run */
7115 {
7116 int tmp;
7117 snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_COEF_INDEX, 7);
7118 tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0);
7119 snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_COEF_INDEX, 7);
7120 snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_PROC_COEF, tmp | 0x80);
7121 }
7122 #endif
7123
7124 board_config = snd_hda_check_board_config(codec, ALC262_MODEL_LAST,
7125 alc262_models,
7126 alc262_cfg_tbl);
7127
7128 if (board_config < 0) {
7129 printk(KERN_INFO "hda_codec: Unknown model for ALC262, "
7130 "trying auto-probe from BIOS...\n");
7131 board_config = ALC262_AUTO;
7132 }
7133
7134 if (board_config == ALC262_AUTO) {
7135 /* automatic parse from the BIOS config */
7136 err = alc262_parse_auto_config(codec);
7137 if (err < 0) {
7138 alc_free(codec);
7139 return err;
7140 } else if (! err) {
7141 printk(KERN_INFO
7142 "hda_codec: Cannot set up configuration "
7143 "from BIOS. Using base mode...\n");
7144 board_config = ALC262_BASIC;
7145 }
7146 }
7147
7148 if (board_config != ALC262_AUTO)
7149 setup_preset(spec, &alc262_presets[board_config]);
7150
7151 spec->stream_name_analog = "ALC262 Analog";
7152 spec->stream_analog_playback = &alc262_pcm_analog_playback;
7153 spec->stream_analog_capture = &alc262_pcm_analog_capture;
7154
7155 spec->stream_name_digital = "ALC262 Digital";
7156 spec->stream_digital_playback = &alc262_pcm_digital_playback;
7157 spec->stream_digital_capture = &alc262_pcm_digital_capture;
7158
7159 if (! spec->adc_nids && spec->input_mux) {
7160 /* check whether NID 0x07 is valid */
7161 unsigned int wcap = get_wcaps(codec, 0x07);
7162
7163 wcap = (wcap & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT; /* get type */
7164 if (wcap != AC_WID_AUD_IN) {
7165 spec->adc_nids = alc262_adc_nids_alt;
7166 spec->num_adc_nids = ARRAY_SIZE(alc262_adc_nids_alt);
7167 spec->mixers[spec->num_mixers] = alc262_capture_alt_mixer;
7168 spec->num_mixers++;
7169 } else {
7170 spec->adc_nids = alc262_adc_nids;
7171 spec->num_adc_nids = ARRAY_SIZE(alc262_adc_nids);
7172 spec->mixers[spec->num_mixers] = alc262_capture_mixer;
7173 spec->num_mixers++;
7174 }
7175 }
7176
7177 codec->patch_ops = alc_patch_ops;
7178 if (board_config == ALC262_AUTO)
7179 spec->init_hook = alc262_auto_init;
7180
7181 return 0;
7182 }
7183
7184 /*
7185 * ALC861 channel source setting (2/6 channel selection for 3-stack)
7186 */
7187
7188 /*
7189 * set the path ways for 2 channel output
7190 * need to set the codec line out and mic 1 pin widgets to inputs
7191 */
7192 static struct hda_verb alc861_threestack_ch2_init[] = {
7193 /* set pin widget 1Ah (line in) for input */
7194 { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
7195 /* set pin widget 18h (mic1/2) for input, for mic also enable the vref */
7196 { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
7197
7198 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c },
7199 #if 0
7200 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8)) }, /*mic*/
7201 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8)) }, /*line-in*/
7202 #endif
7203 { } /* end */
7204 };
7205 /*
7206 * 6ch mode
7207 * need to set the codec line out and mic 1 pin widgets to outputs
7208 */
7209 static struct hda_verb alc861_threestack_ch6_init[] = {
7210 /* set pin widget 1Ah (line in) for output (Back Surround)*/
7211 { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
7212 /* set pin widget 18h (mic1) for output (CLFE)*/
7213 { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
7214
7215 { 0x0c, AC_VERB_SET_CONNECT_SEL, 0x00 },
7216 { 0x0d, AC_VERB_SET_CONNECT_SEL, 0x00 },
7217
7218 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080 },
7219 #if 0
7220 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8)) }, /*mic*/
7221 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8)) }, /*line in*/
7222 #endif
7223 { } /* end */
7224 };
7225
7226 static struct hda_channel_mode alc861_threestack_modes[2] = {
7227 { 2, alc861_threestack_ch2_init },
7228 { 6, alc861_threestack_ch6_init },
7229 };
7230 /* Set mic1 as input and unmute the mixer */
7231 static struct hda_verb alc861_uniwill_m31_ch2_init[] = {
7232 { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
7233 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8)) }, /*mic*/
7234 { } /* end */
7235 };
7236 /* Set mic1 as output and mute mixer */
7237 static struct hda_verb alc861_uniwill_m31_ch4_init[] = {
7238 { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
7239 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8)) }, /*mic*/
7240 { } /* end */
7241 };
7242
7243 static struct hda_channel_mode alc861_uniwill_m31_modes[2] = {
7244 { 2, alc861_uniwill_m31_ch2_init },
7245 { 4, alc861_uniwill_m31_ch4_init },
7246 };
7247
7248 /* Set mic1 and line-in as input and unmute the mixer */
7249 static struct hda_verb alc861_asus_ch2_init[] = {
7250 /* set pin widget 1Ah (line in) for input */
7251 { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
7252 /* set pin widget 18h (mic1/2) for input, for mic also enable the vref */
7253 { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
7254
7255 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c },
7256 #if 0
7257 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8)) }, /*mic*/
7258 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8)) }, /*line-in*/
7259 #endif
7260 { } /* end */
7261 };
7262 /* Set mic1 nad line-in as output and mute mixer */
7263 static struct hda_verb alc861_asus_ch6_init[] = {
7264 /* set pin widget 1Ah (line in) for output (Back Surround)*/
7265 { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
7266 /* { 0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, */
7267 /* set pin widget 18h (mic1) for output (CLFE)*/
7268 { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
7269 /* { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, */
7270 { 0x0c, AC_VERB_SET_CONNECT_SEL, 0x00 },
7271 { 0x0d, AC_VERB_SET_CONNECT_SEL, 0x00 },
7272
7273 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080 },
7274 #if 0
7275 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8)) }, /*mic*/
7276 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8)) }, /*line in*/
7277 #endif
7278 { } /* end */
7279 };
7280
7281 static struct hda_channel_mode alc861_asus_modes[2] = {
7282 { 2, alc861_asus_ch2_init },
7283 { 6, alc861_asus_ch6_init },
7284 };
7285
7286 /* patch-ALC861 */
7287
7288 static struct snd_kcontrol_new alc861_base_mixer[] = {
7289 /* output mixer control */
7290 HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
7291 HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
7292 HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
7293 HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
7294 HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT),
7295
7296 /*Input mixer control */
7297 /* HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
7298 HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT), */
7299 HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
7300 HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
7301 HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
7302 HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
7303 HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
7304 HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
7305 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
7306 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_INPUT),
7307
7308 /* Capture mixer control */
7309 HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
7310 HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
7311 {
7312 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
7313 .name = "Capture Source",
7314 .count = 1,
7315 .info = alc_mux_enum_info,
7316 .get = alc_mux_enum_get,
7317 .put = alc_mux_enum_put,
7318 },
7319 { } /* end */
7320 };
7321
7322 static struct snd_kcontrol_new alc861_3ST_mixer[] = {
7323 /* output mixer control */
7324 HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
7325 HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
7326 HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
7327 HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
7328 /*HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT), */
7329
7330 /* Input mixer control */
7331 /* HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
7332 HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT), */
7333 HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
7334 HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
7335 HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
7336 HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
7337 HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
7338 HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
7339 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
7340 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_INPUT),
7341
7342 /* Capture mixer control */
7343 HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
7344 HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
7345 {
7346 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
7347 .name = "Capture Source",
7348 .count = 1,
7349 .info = alc_mux_enum_info,
7350 .get = alc_mux_enum_get,
7351 .put = alc_mux_enum_put,
7352 },
7353 {
7354 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
7355 .name = "Channel Mode",
7356 .info = alc_ch_mode_info,
7357 .get = alc_ch_mode_get,
7358 .put = alc_ch_mode_put,
7359 .private_value = ARRAY_SIZE(alc861_threestack_modes),
7360 },
7361 { } /* end */
7362 };
7363
7364 static struct snd_kcontrol_new alc861_toshiba_mixer[] = {
7365 /* output mixer control */
7366 HDA_CODEC_MUTE("Master Playback Switch", 0x03, 0x0, HDA_OUTPUT),
7367 HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
7368 HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
7369
7370 /*Capture mixer control */
7371 HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
7372 HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
7373 {
7374 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
7375 .name = "Capture Source",
7376 .count = 1,
7377 .info = alc_mux_enum_info,
7378 .get = alc_mux_enum_get,
7379 .put = alc_mux_enum_put,
7380 },
7381
7382 { } /* end */
7383 };
7384
7385 static struct snd_kcontrol_new alc861_uniwill_m31_mixer[] = {
7386 /* output mixer control */
7387 HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
7388 HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
7389 HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
7390 HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
7391 /*HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT), */
7392
7393 /* Input mixer control */
7394 /* HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
7395 HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT), */
7396 HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
7397 HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
7398 HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
7399 HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
7400 HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
7401 HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
7402 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
7403 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_INPUT),
7404
7405 /* Capture mixer control */
7406 HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
7407 HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
7408 {
7409 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
7410 .name = "Capture Source",
7411 .count = 1,
7412 .info = alc_mux_enum_info,
7413 .get = alc_mux_enum_get,
7414 .put = alc_mux_enum_put,
7415 },
7416 {
7417 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
7418 .name = "Channel Mode",
7419 .info = alc_ch_mode_info,
7420 .get = alc_ch_mode_get,
7421 .put = alc_ch_mode_put,
7422 .private_value = ARRAY_SIZE(alc861_uniwill_m31_modes),
7423 },
7424 { } /* end */
7425 };
7426
7427 static struct snd_kcontrol_new alc861_asus_mixer[] = {
7428 /* output mixer control */
7429 HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
7430 HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
7431 HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
7432 HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
7433 HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT),
7434
7435 /* Input mixer control */
7436 HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
7437 HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT),
7438 HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
7439 HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
7440 HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
7441 HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
7442 HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
7443 HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
7444 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
7445 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_OUTPUT), /* was HDA_INPUT (why?) */
7446
7447 /* Capture mixer control */
7448 HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
7449 HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
7450 {
7451 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
7452 .name = "Capture Source",
7453 .count = 1,
7454 .info = alc_mux_enum_info,
7455 .get = alc_mux_enum_get,
7456 .put = alc_mux_enum_put,
7457 },
7458 {
7459 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
7460 .name = "Channel Mode",
7461 .info = alc_ch_mode_info,
7462 .get = alc_ch_mode_get,
7463 .put = alc_ch_mode_put,
7464 .private_value = ARRAY_SIZE(alc861_asus_modes),
7465 },
7466 { }
7467 };
7468
7469 /* additional mixer */
7470 static struct snd_kcontrol_new alc861_asus_laptop_mixer[] = {
7471 HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
7472 HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
7473 HDA_CODEC_VOLUME("PC Beep Playback Volume", 0x23, 0x0, HDA_OUTPUT),
7474 HDA_CODEC_MUTE("PC Beep Playback Switch", 0x23, 0x0, HDA_OUTPUT),
7475 { }
7476 };
7477
7478 /*
7479 * generic initialization of ADC, input mixers and output mixers
7480 */
7481 static struct hda_verb alc861_base_init_verbs[] = {
7482 /*
7483 * Unmute ADC0 and set the default input to mic-in
7484 */
7485 /* port-A for surround (rear panel) */
7486 { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
7487 { 0x0e, AC_VERB_SET_CONNECT_SEL, 0x00 },
7488 /* port-B for mic-in (rear panel) with vref */
7489 { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
7490 /* port-C for line-in (rear panel) */
7491 { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
7492 /* port-D for Front */
7493 { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
7494 { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
7495 /* port-E for HP out (front panel) */
7496 { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 },
7497 /* route front PCM to HP */
7498 { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
7499 /* port-F for mic-in (front panel) with vref */
7500 { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
7501 /* port-G for CLFE (rear panel) */
7502 { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
7503 { 0x1f, AC_VERB_SET_CONNECT_SEL, 0x00 },
7504 /* port-H for side (rear panel) */
7505 { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
7506 { 0x20, AC_VERB_SET_CONNECT_SEL, 0x00 },
7507 /* CD-in */
7508 { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
7509 /* route front mic to ADC1*/
7510 {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
7511 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7512
7513 /* Unmute DAC0~3 & spdif out*/
7514 {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7515 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7516 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7517 {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7518 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7519
7520 /* Unmute Mixer 14 (mic) 1c (Line in)*/
7521 {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7522 {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7523 {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7524 {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7525
7526 /* Unmute Stereo Mixer 15 */
7527 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7528 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7529 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
7530 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c }, //Output 0~12 step
7531
7532 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7533 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7534 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7535 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7536 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7537 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7538 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7539 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7540 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)}, // hp used DAC 3 (Front)
7541 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
7542
7543 { }
7544 };
7545
7546 static struct hda_verb alc861_threestack_init_verbs[] = {
7547 /*
7548 * Unmute ADC0 and set the default input to mic-in
7549 */
7550 /* port-A for surround (rear panel) */
7551 { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
7552 /* port-B for mic-in (rear panel) with vref */
7553 { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
7554 /* port-C for line-in (rear panel) */
7555 { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
7556 /* port-D for Front */
7557 { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
7558 { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
7559 /* port-E for HP out (front panel) */
7560 { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 },
7561 /* route front PCM to HP */
7562 { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
7563 /* port-F for mic-in (front panel) with vref */
7564 { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
7565 /* port-G for CLFE (rear panel) */
7566 { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
7567 /* port-H for side (rear panel) */
7568 { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
7569 /* CD-in */
7570 { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
7571 /* route front mic to ADC1*/
7572 {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
7573 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7574 /* Unmute DAC0~3 & spdif out*/
7575 {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7576 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7577 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7578 {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7579 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7580
7581 /* Unmute Mixer 14 (mic) 1c (Line in)*/
7582 {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7583 {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7584 {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7585 {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7586
7587 /* Unmute Stereo Mixer 15 */
7588 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7589 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7590 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
7591 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c }, //Output 0~12 step
7592
7593 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7594 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7595 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7596 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7597 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7598 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7599 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7600 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7601 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)}, // hp used DAC 3 (Front)
7602 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
7603 { }
7604 };
7605
7606 static struct hda_verb alc861_uniwill_m31_init_verbs[] = {
7607 /*
7608 * Unmute ADC0 and set the default input to mic-in
7609 */
7610 /* port-A for surround (rear panel) */
7611 { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
7612 /* port-B for mic-in (rear panel) with vref */
7613 { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
7614 /* port-C for line-in (rear panel) */
7615 { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
7616 /* port-D for Front */
7617 { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
7618 { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
7619 /* port-E for HP out (front panel) */
7620 { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 }, // this has to be set to VREF80
7621 /* route front PCM to HP */
7622 { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
7623 /* port-F for mic-in (front panel) with vref */
7624 { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
7625 /* port-G for CLFE (rear panel) */
7626 { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
7627 /* port-H for side (rear panel) */
7628 { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
7629 /* CD-in */
7630 { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
7631 /* route front mic to ADC1*/
7632 {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
7633 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7634 /* Unmute DAC0~3 & spdif out*/
7635 {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7636 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7637 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7638 {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7639 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7640
7641 /* Unmute Mixer 14 (mic) 1c (Line in)*/
7642 {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7643 {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7644 {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7645 {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7646
7647 /* Unmute Stereo Mixer 15 */
7648 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7649 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7650 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
7651 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c }, //Output 0~12 step
7652
7653 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7654 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7655 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7656 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7657 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7658 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7659 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7660 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7661 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)}, // hp used DAC 3 (Front)
7662 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
7663 { }
7664 };
7665
7666 static struct hda_verb alc861_asus_init_verbs[] = {
7667 /*
7668 * Unmute ADC0 and set the default input to mic-in
7669 */
7670 /* port-A for surround (rear panel) | according to codec#0 this is the HP jack*/
7671 { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 }, /* was 0x00 */
7672 /* route front PCM to HP */
7673 { 0x0e, AC_VERB_SET_CONNECT_SEL, 0x01 },
7674 /* port-B for mic-in (rear panel) with vref */
7675 { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
7676 /* port-C for line-in (rear panel) */
7677 { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
7678 /* port-D for Front */
7679 { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
7680 { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
7681 /* port-E for HP out (front panel) */
7682 { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 }, /* this has to be set to VREF80 */
7683 /* route front PCM to HP */
7684 { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
7685 /* port-F for mic-in (front panel) with vref */
7686 { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
7687 /* port-G for CLFE (rear panel) */
7688 { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
7689 /* port-H for side (rear panel) */
7690 { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
7691 /* CD-in */
7692 { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
7693 /* route front mic to ADC1*/
7694 {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
7695 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7696 /* Unmute DAC0~3 & spdif out*/
7697 {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7698 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7699 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7700 {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7701 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7702 /* Unmute Mixer 14 (mic) 1c (Line in)*/
7703 {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7704 {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7705 {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7706 {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7707
7708 /* Unmute Stereo Mixer 15 */
7709 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7710 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7711 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
7712 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c }, /* Output 0~12 step */
7713
7714 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7715 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7716 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7717 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7718 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7719 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7720 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7721 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7722 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)}, /* hp used DAC 3 (Front) */
7723 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
7724 { }
7725 };
7726
7727 /* additional init verbs for ASUS laptops */
7728 static struct hda_verb alc861_asus_laptop_init_verbs[] = {
7729 { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x45 }, /* HP-out */
7730 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2) }, /* mute line-in */
7731 { }
7732 };
7733
7734 /*
7735 * generic initialization of ADC, input mixers and output mixers
7736 */
7737 static struct hda_verb alc861_auto_init_verbs[] = {
7738 /*
7739 * Unmute ADC0 and set the default input to mic-in
7740 */
7741 // {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
7742 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7743
7744 /* Unmute DAC0~3 & spdif out*/
7745 {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7746 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7747 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7748 {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7749 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7750
7751 /* Unmute Mixer 14 (mic) 1c (Line in)*/
7752 {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7753 {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7754 {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7755 {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7756
7757 /* Unmute Stereo Mixer 15 */
7758 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7759 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7760 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
7761 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c},
7762
7763 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7764 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7765 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7766 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7767 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7768 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7769 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7770 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7771
7772 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7773 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7774 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
7775 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
7776 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7777 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7778 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
7779 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
7780
7781 {0x08, AC_VERB_SET_CONNECT_SEL, 0x00}, // set Mic 1
7782
7783 { }
7784 };
7785
7786 static struct hda_verb alc861_toshiba_init_verbs[] = {
7787 {0x0f, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
7788
7789 { }
7790 };
7791
7792 /* toggle speaker-output according to the hp-jack state */
7793 static void alc861_toshiba_automute(struct hda_codec *codec)
7794 {
7795 unsigned int present;
7796
7797 present = snd_hda_codec_read(codec, 0x0f, 0,
7798 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
7799 snd_hda_codec_amp_update(codec, 0x16, 0, HDA_INPUT, 0,
7800 0x80, present ? 0x80 : 0);
7801 snd_hda_codec_amp_update(codec, 0x16, 1, HDA_INPUT, 0,
7802 0x80, present ? 0x80 : 0);
7803 snd_hda_codec_amp_update(codec, 0x1a, 0, HDA_INPUT, 3,
7804 0x80, present ? 0 : 0x80);
7805 snd_hda_codec_amp_update(codec, 0x1a, 1, HDA_INPUT, 3,
7806 0x80, present ? 0 : 0x80);
7807 }
7808
7809 static void alc861_toshiba_unsol_event(struct hda_codec *codec,
7810 unsigned int res)
7811 {
7812 if ((res >> 26) == ALC880_HP_EVENT)
7813 alc861_toshiba_automute(codec);
7814 }
7815
7816 /* pcm configuration: identiacal with ALC880 */
7817 #define alc861_pcm_analog_playback alc880_pcm_analog_playback
7818 #define alc861_pcm_analog_capture alc880_pcm_analog_capture
7819 #define alc861_pcm_digital_playback alc880_pcm_digital_playback
7820 #define alc861_pcm_digital_capture alc880_pcm_digital_capture
7821
7822
7823 #define ALC861_DIGOUT_NID 0x07
7824
7825 static struct hda_channel_mode alc861_8ch_modes[1] = {
7826 { 8, NULL }
7827 };
7828
7829 static hda_nid_t alc861_dac_nids[4] = {
7830 /* front, surround, clfe, side */
7831 0x03, 0x06, 0x05, 0x04
7832 };
7833
7834 static hda_nid_t alc660_dac_nids[3] = {
7835 /* front, clfe, surround */
7836 0x03, 0x05, 0x06
7837 };
7838
7839 static hda_nid_t alc861_adc_nids[1] = {
7840 /* ADC0-2 */
7841 0x08,
7842 };
7843
7844 static struct hda_input_mux alc861_capture_source = {
7845 .num_items = 5,
7846 .items = {
7847 { "Mic", 0x0 },
7848 { "Front Mic", 0x3 },
7849 { "Line", 0x1 },
7850 { "CD", 0x4 },
7851 { "Mixer", 0x5 },
7852 },
7853 };
7854
7855 /* fill in the dac_nids table from the parsed pin configuration */
7856 static int alc861_auto_fill_dac_nids(struct alc_spec *spec, const struct auto_pin_cfg *cfg)
7857 {
7858 int i;
7859 hda_nid_t nid;
7860
7861 spec->multiout.dac_nids = spec->private_dac_nids;
7862 for (i = 0; i < cfg->line_outs; i++) {
7863 nid = cfg->line_out_pins[i];
7864 if (nid) {
7865 if (i >= ARRAY_SIZE(alc861_dac_nids))
7866 continue;
7867 spec->multiout.dac_nids[i] = alc861_dac_nids[i];
7868 }
7869 }
7870 spec->multiout.num_dacs = cfg->line_outs;
7871 return 0;
7872 }
7873
7874 /* add playback controls from the parsed DAC table */
7875 static int alc861_auto_create_multi_out_ctls(struct alc_spec *spec,
7876 const struct auto_pin_cfg *cfg)
7877 {
7878 char name[32];
7879 static const char *chname[4] = { "Front", "Surround", NULL /*CLFE*/, "Side" };
7880 hda_nid_t nid;
7881 int i, idx, err;
7882
7883 for (i = 0; i < cfg->line_outs; i++) {
7884 nid = spec->multiout.dac_nids[i];
7885 if (! nid)
7886 continue;
7887 if (nid == 0x05) {
7888 /* Center/LFE */
7889 if ((err = add_control(spec, ALC_CTL_BIND_MUTE, "Center Playback Switch",
7890 HDA_COMPOSE_AMP_VAL(nid, 1, 0, HDA_OUTPUT))) < 0)
7891 return err;
7892 if ((err = add_control(spec, ALC_CTL_BIND_MUTE, "LFE Playback Switch",
7893 HDA_COMPOSE_AMP_VAL(nid, 2, 0, HDA_OUTPUT))) < 0)
7894 return err;
7895 } else {
7896 for (idx = 0; idx < ARRAY_SIZE(alc861_dac_nids) - 1; idx++)
7897 if (nid == alc861_dac_nids[idx])
7898 break;
7899 sprintf(name, "%s Playback Switch", chname[idx]);
7900 if ((err = add_control(spec, ALC_CTL_BIND_MUTE, name,
7901 HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT))) < 0)
7902 return err;
7903 }
7904 }
7905 return 0;
7906 }
7907
7908 static int alc861_auto_create_hp_ctls(struct alc_spec *spec, hda_nid_t pin)
7909 {
7910 int err;
7911 hda_nid_t nid;
7912
7913 if (! pin)
7914 return 0;
7915
7916 if ((pin >= 0x0b && pin <= 0x10) || pin == 0x1f || pin == 0x20) {
7917 nid = 0x03;
7918 if ((err = add_control(spec, ALC_CTL_WIDGET_MUTE, "Headphone Playback Switch",
7919 HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT))) < 0)
7920 return err;
7921 spec->multiout.hp_nid = nid;
7922 }
7923 return 0;
7924 }
7925
7926 /* create playback/capture controls for input pins */
7927 static int alc861_auto_create_analog_input_ctls(struct alc_spec *spec, const struct auto_pin_cfg *cfg)
7928 {
7929 struct hda_input_mux *imux = &spec->private_imux;
7930 int i, err, idx, idx1;
7931
7932 for (i = 0; i < AUTO_PIN_LAST; i++) {
7933 switch(cfg->input_pins[i]) {
7934 case 0x0c:
7935 idx1 = 1;
7936 idx = 2; // Line In
7937 break;
7938 case 0x0f:
7939 idx1 = 2;
7940 idx = 2; // Line In
7941 break;
7942 case 0x0d:
7943 idx1 = 0;
7944 idx = 1; // Mic In
7945 break;
7946 case 0x10:
7947 idx1 = 3;
7948 idx = 1; // Mic In
7949 break;
7950 case 0x11:
7951 idx1 = 4;
7952 idx = 0; // CD
7953 break;
7954 default:
7955 continue;
7956 }
7957
7958 err = new_analog_input(spec, cfg->input_pins[i],
7959 auto_pin_cfg_labels[i], idx, 0x15);
7960 if (err < 0)
7961 return err;
7962
7963 imux->items[imux->num_items].label = auto_pin_cfg_labels[i];
7964 imux->items[imux->num_items].index = idx1;
7965 imux->num_items++;
7966 }
7967 return 0;
7968 }
7969
7970 static struct snd_kcontrol_new alc861_capture_mixer[] = {
7971 HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
7972 HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
7973
7974 {
7975 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
7976 /* The multiple "Capture Source" controls confuse alsamixer
7977 * So call somewhat different..
7978 *FIXME: the controls appear in the "playback" view!
7979 */
7980 /* .name = "Capture Source", */
7981 .name = "Input Source",
7982 .count = 1,
7983 .info = alc_mux_enum_info,
7984 .get = alc_mux_enum_get,
7985 .put = alc_mux_enum_put,
7986 },
7987 { } /* end */
7988 };
7989
7990 static void alc861_auto_set_output_and_unmute(struct hda_codec *codec, hda_nid_t nid,
7991 int pin_type, int dac_idx)
7992 {
7993 /* set as output */
7994
7995 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, pin_type);
7996 snd_hda_codec_write(codec, dac_idx, 0, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE);
7997
7998 }
7999
8000 static void alc861_auto_init_multi_out(struct hda_codec *codec)
8001 {
8002 struct alc_spec *spec = codec->spec;
8003 int i;
8004
8005 alc_subsystem_id(codec, 0x0e, 0x0f, 0x0b);
8006 for (i = 0; i < spec->autocfg.line_outs; i++) {
8007 hda_nid_t nid = spec->autocfg.line_out_pins[i];
8008 if (nid)
8009 alc861_auto_set_output_and_unmute(codec, nid, PIN_OUT, spec->multiout.dac_nids[i]);
8010 }
8011 }
8012
8013 static void alc861_auto_init_hp_out(struct hda_codec *codec)
8014 {
8015 struct alc_spec *spec = codec->spec;
8016 hda_nid_t pin;
8017
8018 pin = spec->autocfg.hp_pins[0];
8019 if (pin) /* connect to front */
8020 alc861_auto_set_output_and_unmute(codec, pin, PIN_HP, spec->multiout.dac_nids[0]);
8021 }
8022
8023 static void alc861_auto_init_analog_input(struct hda_codec *codec)
8024 {
8025 struct alc_spec *spec = codec->spec;
8026 int i;
8027
8028 for (i = 0; i < AUTO_PIN_LAST; i++) {
8029 hda_nid_t nid = spec->autocfg.input_pins[i];
8030 if ((nid>=0x0c) && (nid <=0x11)) {
8031 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
8032 i <= AUTO_PIN_FRONT_MIC ? PIN_VREF80 : PIN_IN);
8033 }
8034 }
8035 }
8036
8037 /* parse the BIOS configuration and set up the alc_spec */
8038 /* return 1 if successful, 0 if the proper config is not found, or a negative error code */
8039 static int alc861_parse_auto_config(struct hda_codec *codec)
8040 {
8041 struct alc_spec *spec = codec->spec;
8042 int err;
8043 static hda_nid_t alc861_ignore[] = { 0x1d, 0 };
8044
8045 if ((err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
8046 alc861_ignore)) < 0)
8047 return err;
8048 if (! spec->autocfg.line_outs)
8049 return 0; /* can't find valid BIOS pin config */
8050
8051 if ((err = alc861_auto_fill_dac_nids(spec, &spec->autocfg)) < 0 ||
8052 (err = alc861_auto_create_multi_out_ctls(spec, &spec->autocfg)) < 0 ||
8053 (err = alc861_auto_create_hp_ctls(spec, spec->autocfg.hp_pins[0])) < 0 ||
8054 (err = alc861_auto_create_analog_input_ctls(spec, &spec->autocfg)) < 0)
8055 return err;
8056
8057 spec->multiout.max_channels = spec->multiout.num_dacs * 2;
8058
8059 if (spec->autocfg.dig_out_pin)
8060 spec->multiout.dig_out_nid = ALC861_DIGOUT_NID;
8061
8062 if (spec->kctl_alloc)
8063 spec->mixers[spec->num_mixers++] = spec->kctl_alloc;
8064
8065 spec->init_verbs[spec->num_init_verbs++] = alc861_auto_init_verbs;
8066
8067 spec->num_mux_defs = 1;
8068 spec->input_mux = &spec->private_imux;
8069
8070 spec->adc_nids = alc861_adc_nids;
8071 spec->num_adc_nids = ARRAY_SIZE(alc861_adc_nids);
8072 spec->mixers[spec->num_mixers] = alc861_capture_mixer;
8073 spec->num_mixers++;
8074
8075 return 1;
8076 }
8077
8078 /* additional initialization for auto-configuration model */
8079 static void alc861_auto_init(struct hda_codec *codec)
8080 {
8081 alc861_auto_init_multi_out(codec);
8082 alc861_auto_init_hp_out(codec);
8083 alc861_auto_init_analog_input(codec);
8084 }
8085
8086
8087 /*
8088 * configuration and preset
8089 */
8090 static const char *alc861_models[ALC861_MODEL_LAST] = {
8091 [ALC861_3ST] = "3stack",
8092 [ALC660_3ST] = "3stack-660",
8093 [ALC861_3ST_DIG] = "3stack-dig",
8094 [ALC861_6ST_DIG] = "6stack-dig",
8095 [ALC861_UNIWILL_M31] = "uniwill-m31",
8096 [ALC861_TOSHIBA] = "toshiba",
8097 [ALC861_ASUS] = "asus",
8098 [ALC861_ASUS_LAPTOP] = "asus-laptop",
8099 [ALC861_AUTO] = "auto",
8100 };
8101
8102 static struct snd_pci_quirk alc861_cfg_tbl[] = {
8103 SND_PCI_QUIRK(0x1043, 0x1205, "ASUS W7J", ALC861_3ST),
8104 SND_PCI_QUIRK(0x1043, 0x1335, "ASUS F2/3", ALC861_ASUS_LAPTOP),
8105 SND_PCI_QUIRK(0x1043, 0x1338, "ASUS F2/3", ALC861_ASUS_LAPTOP),
8106 SND_PCI_QUIRK(0x1043, 0x1393, "ASUS", ALC861_ASUS),
8107 SND_PCI_QUIRK(0x1043, 0x81e7, "ASUS", ALC660_3ST),
8108 SND_PCI_QUIRK(0x1179, 0xff00, "Toshiba", ALC861_TOSHIBA),
8109 SND_PCI_QUIRK(0x1179, 0xff10, "Toshiba", ALC861_TOSHIBA),
8110 SND_PCI_QUIRK(0x1584, 0x9072, "Uniwill m31", ALC861_UNIWILL_M31),
8111 SND_PCI_QUIRK(0x1584, 0x2b01, "Uniwill X40AIx", ALC861_UNIWILL_M31),
8112 SND_PCI_QUIRK(0x1849, 0x0660, "Asrock 939SLI32", ALC660_3ST),
8113 SND_PCI_QUIRK(0x8086, 0xd600, "Intel", ALC861_3ST),
8114 {}
8115 };
8116
8117 static struct alc_config_preset alc861_presets[] = {
8118 [ALC861_3ST] = {
8119 .mixers = { alc861_3ST_mixer },
8120 .init_verbs = { alc861_threestack_init_verbs },
8121 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
8122 .dac_nids = alc861_dac_nids,
8123 .num_channel_mode = ARRAY_SIZE(alc861_threestack_modes),
8124 .channel_mode = alc861_threestack_modes,
8125 .need_dac_fix = 1,
8126 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
8127 .adc_nids = alc861_adc_nids,
8128 .input_mux = &alc861_capture_source,
8129 },
8130 [ALC861_3ST_DIG] = {
8131 .mixers = { alc861_base_mixer },
8132 .init_verbs = { alc861_threestack_init_verbs },
8133 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
8134 .dac_nids = alc861_dac_nids,
8135 .dig_out_nid = ALC861_DIGOUT_NID,
8136 .num_channel_mode = ARRAY_SIZE(alc861_threestack_modes),
8137 .channel_mode = alc861_threestack_modes,
8138 .need_dac_fix = 1,
8139 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
8140 .adc_nids = alc861_adc_nids,
8141 .input_mux = &alc861_capture_source,
8142 },
8143 [ALC861_6ST_DIG] = {
8144 .mixers = { alc861_base_mixer },
8145 .init_verbs = { alc861_base_init_verbs },
8146 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
8147 .dac_nids = alc861_dac_nids,
8148 .dig_out_nid = ALC861_DIGOUT_NID,
8149 .num_channel_mode = ARRAY_SIZE(alc861_8ch_modes),
8150 .channel_mode = alc861_8ch_modes,
8151 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
8152 .adc_nids = alc861_adc_nids,
8153 .input_mux = &alc861_capture_source,
8154 },
8155 [ALC660_3ST] = {
8156 .mixers = { alc861_3ST_mixer },
8157 .init_verbs = { alc861_threestack_init_verbs },
8158 .num_dacs = ARRAY_SIZE(alc660_dac_nids),
8159 .dac_nids = alc660_dac_nids,
8160 .num_channel_mode = ARRAY_SIZE(alc861_threestack_modes),
8161 .channel_mode = alc861_threestack_modes,
8162 .need_dac_fix = 1,
8163 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
8164 .adc_nids = alc861_adc_nids,
8165 .input_mux = &alc861_capture_source,
8166 },
8167 [ALC861_UNIWILL_M31] = {
8168 .mixers = { alc861_uniwill_m31_mixer },
8169 .init_verbs = { alc861_uniwill_m31_init_verbs },
8170 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
8171 .dac_nids = alc861_dac_nids,
8172 .dig_out_nid = ALC861_DIGOUT_NID,
8173 .num_channel_mode = ARRAY_SIZE(alc861_uniwill_m31_modes),
8174 .channel_mode = alc861_uniwill_m31_modes,
8175 .need_dac_fix = 1,
8176 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
8177 .adc_nids = alc861_adc_nids,
8178 .input_mux = &alc861_capture_source,
8179 },
8180 [ALC861_TOSHIBA] = {
8181 .mixers = { alc861_toshiba_mixer },
8182 .init_verbs = { alc861_base_init_verbs, alc861_toshiba_init_verbs },
8183 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
8184 .dac_nids = alc861_dac_nids,
8185 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8186 .channel_mode = alc883_3ST_2ch_modes,
8187 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
8188 .adc_nids = alc861_adc_nids,
8189 .input_mux = &alc861_capture_source,
8190 .unsol_event = alc861_toshiba_unsol_event,
8191 .init_hook = alc861_toshiba_automute,
8192 },
8193 [ALC861_ASUS] = {
8194 .mixers = { alc861_asus_mixer },
8195 .init_verbs = { alc861_asus_init_verbs },
8196 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
8197 .dac_nids = alc861_dac_nids,
8198 .dig_out_nid = ALC861_DIGOUT_NID,
8199 .num_channel_mode = ARRAY_SIZE(alc861_asus_modes),
8200 .channel_mode = alc861_asus_modes,
8201 .need_dac_fix = 1,
8202 .hp_nid = 0x06,
8203 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
8204 .adc_nids = alc861_adc_nids,
8205 .input_mux = &alc861_capture_source,
8206 },
8207 [ALC861_ASUS_LAPTOP] = {
8208 .mixers = { alc861_toshiba_mixer, alc861_asus_laptop_mixer },
8209 .init_verbs = { alc861_asus_init_verbs,
8210 alc861_asus_laptop_init_verbs },
8211 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
8212 .dac_nids = alc861_dac_nids,
8213 .dig_out_nid = ALC861_DIGOUT_NID,
8214 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8215 .channel_mode = alc883_3ST_2ch_modes,
8216 .need_dac_fix = 1,
8217 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
8218 .adc_nids = alc861_adc_nids,
8219 .input_mux = &alc861_capture_source,
8220 },
8221 };
8222
8223
8224 static int patch_alc861(struct hda_codec *codec)
8225 {
8226 struct alc_spec *spec;
8227 int board_config;
8228 int err;
8229
8230 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
8231 if (spec == NULL)
8232 return -ENOMEM;
8233
8234 codec->spec = spec;
8235
8236 board_config = snd_hda_check_board_config(codec, ALC861_MODEL_LAST,
8237 alc861_models,
8238 alc861_cfg_tbl);
8239
8240 if (board_config < 0) {
8241 printk(KERN_INFO "hda_codec: Unknown model for ALC861, "
8242 "trying auto-probe from BIOS...\n");
8243 board_config = ALC861_AUTO;
8244 }
8245
8246 if (board_config == ALC861_AUTO) {
8247 /* automatic parse from the BIOS config */
8248 err = alc861_parse_auto_config(codec);
8249 if (err < 0) {
8250 alc_free(codec);
8251 return err;
8252 } else if (! err) {
8253 printk(KERN_INFO
8254 "hda_codec: Cannot set up configuration "
8255 "from BIOS. Using base mode...\n");
8256 board_config = ALC861_3ST_DIG;
8257 }
8258 }
8259
8260 if (board_config != ALC861_AUTO)
8261 setup_preset(spec, &alc861_presets[board_config]);
8262
8263 spec->stream_name_analog = "ALC861 Analog";
8264 spec->stream_analog_playback = &alc861_pcm_analog_playback;
8265 spec->stream_analog_capture = &alc861_pcm_analog_capture;
8266
8267 spec->stream_name_digital = "ALC861 Digital";
8268 spec->stream_digital_playback = &alc861_pcm_digital_playback;
8269 spec->stream_digital_capture = &alc861_pcm_digital_capture;
8270
8271 codec->patch_ops = alc_patch_ops;
8272 if (board_config == ALC861_AUTO)
8273 spec->init_hook = alc861_auto_init;
8274
8275 return 0;
8276 }
8277
8278 /*
8279 * ALC861-VD support
8280 *
8281 * Based on ALC882
8282 *
8283 * In addition, an independent DAC
8284 */
8285 #define ALC861VD_DIGOUT_NID 0x06
8286
8287 static hda_nid_t alc861vd_dac_nids[4] = {
8288 /* front, surr, clfe, side surr */
8289 0x02, 0x03, 0x04, 0x05
8290 };
8291
8292 /* dac_nids for ALC660vd are in a different order - according to
8293 * Realtek's driver.
8294 * This should probably tesult in a different mixer for 6stack models
8295 * of ALC660vd codecs, but for now there is only 3stack mixer
8296 * - and it is the same as in 861vd.
8297 * adc_nids in ALC660vd are (is) the same as in 861vd
8298 */
8299 static hda_nid_t alc660vd_dac_nids[3] = {
8300 /* front, rear, clfe, rear_surr */
8301 0x02, 0x04, 0x03
8302 };
8303
8304 static hda_nid_t alc861vd_adc_nids[1] = {
8305 /* ADC0 */
8306 0x09,
8307 };
8308
8309 /* input MUX */
8310 /* FIXME: should be a matrix-type input source selection */
8311 static struct hda_input_mux alc861vd_capture_source = {
8312 .num_items = 4,
8313 .items = {
8314 { "Mic", 0x0 },
8315 { "Front Mic", 0x1 },
8316 { "Line", 0x2 },
8317 { "CD", 0x4 },
8318 },
8319 };
8320
8321 #define alc861vd_mux_enum_info alc_mux_enum_info
8322 #define alc861vd_mux_enum_get alc_mux_enum_get
8323
8324 static int alc861vd_mux_enum_put(struct snd_kcontrol *kcontrol,
8325 struct snd_ctl_elem_value *ucontrol)
8326 {
8327 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
8328 struct alc_spec *spec = codec->spec;
8329 const struct hda_input_mux *imux = spec->input_mux;
8330 unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
8331 static hda_nid_t capture_mixers[1] = { 0x22 };
8332 hda_nid_t nid = capture_mixers[adc_idx];
8333 unsigned int *cur_val = &spec->cur_mux[adc_idx];
8334 unsigned int i, idx;
8335
8336 idx = ucontrol->value.enumerated.item[0];
8337 if (idx >= imux->num_items)
8338 idx = imux->num_items - 1;
8339 if (*cur_val == idx && ! codec->in_resume)
8340 return 0;
8341 for (i = 0; i < imux->num_items; i++) {
8342 unsigned int v = (i == idx) ? 0x7000 : 0x7080;
8343 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE,
8344 v | (imux->items[i].index << 8));
8345 }
8346 *cur_val = idx;
8347 return 1;
8348 }
8349
8350 /*
8351 * 2ch mode
8352 */
8353 static struct hda_channel_mode alc861vd_3stack_2ch_modes[1] = {
8354 { 2, NULL }
8355 };
8356
8357 /*
8358 * 6ch mode
8359 */
8360 static struct hda_verb alc861vd_6stack_ch6_init[] = {
8361 { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
8362 { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
8363 { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
8364 { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
8365 { } /* end */
8366 };
8367
8368 /*
8369 * 8ch mode
8370 */
8371 static struct hda_verb alc861vd_6stack_ch8_init[] = {
8372 { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
8373 { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
8374 { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
8375 { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
8376 { } /* end */
8377 };
8378
8379 static struct hda_channel_mode alc861vd_6stack_modes[2] = {
8380 { 6, alc861vd_6stack_ch6_init },
8381 { 8, alc861vd_6stack_ch8_init },
8382 };
8383
8384 static struct snd_kcontrol_new alc861vd_chmode_mixer[] = {
8385 {
8386 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
8387 .name = "Channel Mode",
8388 .info = alc_ch_mode_info,
8389 .get = alc_ch_mode_get,
8390 .put = alc_ch_mode_put,
8391 },
8392 { } /* end */
8393 };
8394
8395 static struct snd_kcontrol_new alc861vd_capture_mixer[] = {
8396 HDA_CODEC_VOLUME("Capture Volume", 0x09, 0x0, HDA_INPUT),
8397 HDA_CODEC_MUTE("Capture Switch", 0x09, 0x0, HDA_INPUT),
8398
8399 {
8400 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
8401 /* The multiple "Capture Source" controls confuse alsamixer
8402 * So call somewhat different..
8403 *FIXME: the controls appear in the "playback" view!
8404 */
8405 /* .name = "Capture Source", */
8406 .name = "Input Source",
8407 .count = 1,
8408 .info = alc861vd_mux_enum_info,
8409 .get = alc861vd_mux_enum_get,
8410 .put = alc861vd_mux_enum_put,
8411 },
8412 { } /* end */
8413 };
8414
8415 /* Pin assignment: Front=0x14, Rear=0x15, CLFE=0x16, Side=0x17
8416 * Mic=0x18, Front Mic=0x19, Line-In=0x1a, HP=0x1b
8417 */
8418 static struct snd_kcontrol_new alc861vd_6st_mixer[] = {
8419 HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
8420 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8421
8422 HDA_CODEC_VOLUME("Surround Playback Volume", 0x03, 0x0, HDA_OUTPUT),
8423 HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
8424
8425 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0,
8426 HDA_OUTPUT),
8427 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0,
8428 HDA_OUTPUT),
8429 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
8430 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
8431
8432 HDA_CODEC_VOLUME("Side Playback Volume", 0x05, 0x0, HDA_OUTPUT),
8433 HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
8434
8435 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
8436
8437 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8438 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8439 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8440
8441 HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
8442 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8443 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8444
8445 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8446 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8447
8448 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8449 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8450
8451 HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
8452 HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
8453
8454 { } /* end */
8455 };
8456
8457 static struct snd_kcontrol_new alc861vd_3st_mixer[] = {
8458 HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
8459 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8460
8461 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
8462
8463 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8464 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8465 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8466
8467 HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
8468 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8469 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8470
8471 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8472 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8473
8474 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8475 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8476
8477 HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
8478 HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
8479
8480 { } /* end */
8481 };
8482
8483 /*
8484 * generic initialization of ADC, input mixers and output mixers
8485 */
8486 static struct hda_verb alc861vd_volume_init_verbs[] = {
8487 /*
8488 * Unmute ADC0 and set the default input to mic-in
8489 */
8490 {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
8491 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8492
8493 /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of
8494 * the analog-loopback mixer widget
8495 */
8496 /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
8497 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8498 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8499 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
8500 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
8501 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
8502
8503 /* Capture mixer: unmute Mic, F-Mic, Line, CD inputs */
8504 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
8505 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(5)},
8506 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(6)},
8507 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(8)},
8508
8509 /*
8510 * Set up output mixers (0x02 - 0x05)
8511 */
8512 /* set vol=0 to output mixers */
8513 {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8514 {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8515 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8516 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8517
8518 /* set up input amps for analog loopback */
8519 /* Amp Indices: DAC = 0, mixer = 1 */
8520 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8521 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8522 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8523 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8524 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8525 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8526 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8527 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8528
8529 { }
8530 };
8531
8532 /*
8533 * 3-stack pin configuration:
8534 * front = 0x14, mic/clfe = 0x18, HP = 0x19, line/surr = 0x1a, f-mic = 0x1b
8535 */
8536 static struct hda_verb alc861vd_3stack_init_verbs[] = {
8537 /*
8538 * Set pin mode and muting
8539 */
8540 /* set front pin widgets 0x14 for output */
8541 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8542 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8543 {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
8544
8545 /* Mic (rear) pin: input vref at 80% */
8546 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
8547 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8548 /* Front Mic pin: input vref at 80% */
8549 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
8550 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8551 /* Line In pin: input */
8552 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
8553 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8554 /* Line-2 In: Headphone output (output 0 - 0x0c) */
8555 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8556 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8557 {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
8558 /* CD pin widget for input */
8559 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
8560
8561 { }
8562 };
8563
8564 /*
8565 * 6-stack pin configuration:
8566 */
8567 static struct hda_verb alc861vd_6stack_init_verbs[] = {
8568 /*
8569 * Set pin mode and muting
8570 */
8571 /* set front pin widgets 0x14 for output */
8572 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8573 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8574 {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
8575
8576 /* Rear Pin: output 1 (0x0d) */
8577 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8578 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8579 {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
8580 /* CLFE Pin: output 2 (0x0e) */
8581 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8582 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8583 {0x16, AC_VERB_SET_CONNECT_SEL, 0x02},
8584 /* Side Pin: output 3 (0x0f) */
8585 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8586 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8587 {0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
8588
8589 /* Mic (rear) pin: input vref at 80% */
8590 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
8591 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8592 /* Front Mic pin: input vref at 80% */
8593 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
8594 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8595 /* Line In pin: input */
8596 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
8597 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8598 /* Line-2 In: Headphone output (output 0 - 0x0c) */
8599 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8600 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8601 {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
8602 /* CD pin widget for input */
8603 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
8604
8605 { }
8606 };
8607
8608 /* pcm configuration: identiacal with ALC880 */
8609 #define alc861vd_pcm_analog_playback alc880_pcm_analog_playback
8610 #define alc861vd_pcm_analog_capture alc880_pcm_analog_capture
8611 #define alc861vd_pcm_digital_playback alc880_pcm_digital_playback
8612 #define alc861vd_pcm_digital_capture alc880_pcm_digital_capture
8613
8614 /*
8615 * configuration and preset
8616 */
8617 static const char *alc861vd_models[ALC861VD_MODEL_LAST] = {
8618 [ALC660VD_3ST] = "3stack-660",
8619 [ALC861VD_3ST] = "3stack",
8620 [ALC861VD_3ST_DIG] = "3stack-digout",
8621 [ALC861VD_6ST_DIG] = "6stack-digout",
8622 [ALC861VD_AUTO] = "auto",
8623 };
8624
8625 static struct snd_pci_quirk alc861vd_cfg_tbl[] = {
8626 SND_PCI_QUIRK(0x1043, 0x12e2, "Asus z35m", ALC660VD_3ST),
8627 SND_PCI_QUIRK(0x1043, 0x1339, "Asus G1", ALC660VD_3ST),
8628 SND_PCI_QUIRK(0x10de, 0x03f0, "Realtek ALC660 demo", ALC660VD_3ST),
8629 SND_PCI_QUIRK(0x1019, 0xa88d, "Realtek ALC660 demo", ALC660VD_3ST),
8630
8631 SND_PCI_QUIRK(0x17aa, 0x3802, "Lenovo 3000 C200", ALC861VD_3ST),
8632 {}
8633 };
8634
8635 static struct alc_config_preset alc861vd_presets[] = {
8636 [ALC660VD_3ST] = {
8637 .mixers = { alc861vd_3st_mixer },
8638 .init_verbs = { alc861vd_volume_init_verbs,
8639 alc861vd_3stack_init_verbs },
8640 .num_dacs = ARRAY_SIZE(alc660vd_dac_nids),
8641 .dac_nids = alc660vd_dac_nids,
8642 .num_adc_nids = ARRAY_SIZE(alc861vd_adc_nids),
8643 .adc_nids = alc861vd_adc_nids,
8644 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
8645 .channel_mode = alc861vd_3stack_2ch_modes,
8646 .input_mux = &alc861vd_capture_source,
8647 },
8648 [ALC861VD_3ST] = {
8649 .mixers = { alc861vd_3st_mixer },
8650 .init_verbs = { alc861vd_volume_init_verbs,
8651 alc861vd_3stack_init_verbs },
8652 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
8653 .dac_nids = alc861vd_dac_nids,
8654 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
8655 .channel_mode = alc861vd_3stack_2ch_modes,
8656 .input_mux = &alc861vd_capture_source,
8657 },
8658 [ALC861VD_3ST_DIG] = {
8659 .mixers = { alc861vd_3st_mixer },
8660 .init_verbs = { alc861vd_volume_init_verbs,
8661 alc861vd_3stack_init_verbs },
8662 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
8663 .dac_nids = alc861vd_dac_nids,
8664 .dig_out_nid = ALC861VD_DIGOUT_NID,
8665 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
8666 .channel_mode = alc861vd_3stack_2ch_modes,
8667 .input_mux = &alc861vd_capture_source,
8668 },
8669 [ALC861VD_6ST_DIG] = {
8670 .mixers = { alc861vd_6st_mixer, alc861vd_chmode_mixer },
8671 .init_verbs = { alc861vd_volume_init_verbs,
8672 alc861vd_6stack_init_verbs },
8673 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
8674 .dac_nids = alc861vd_dac_nids,
8675 .dig_out_nid = ALC861VD_DIGOUT_NID,
8676 .num_channel_mode = ARRAY_SIZE(alc861vd_6stack_modes),
8677 .channel_mode = alc861vd_6stack_modes,
8678 .input_mux = &alc861vd_capture_source,
8679 },
8680 };
8681
8682 /*
8683 * BIOS auto configuration
8684 */
8685 static void alc861vd_auto_set_output_and_unmute(struct hda_codec *codec,
8686 hda_nid_t nid, int pin_type, int dac_idx)
8687 {
8688 /* set as output */
8689 snd_hda_codec_write(codec, nid, 0,
8690 AC_VERB_SET_PIN_WIDGET_CONTROL, pin_type);
8691 snd_hda_codec_write(codec, nid, 0,
8692 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE);
8693 }
8694
8695 static void alc861vd_auto_init_multi_out(struct hda_codec *codec)
8696 {
8697 struct alc_spec *spec = codec->spec;
8698 int i;
8699
8700 alc_subsystem_id(codec, 0x15, 0x1b, 0x14);
8701 for (i = 0; i <= HDA_SIDE; i++) {
8702 hda_nid_t nid = spec->autocfg.line_out_pins[i];
8703 if (nid)
8704 alc861vd_auto_set_output_and_unmute(codec, nid,
8705 PIN_OUT, i);
8706 }
8707 }
8708
8709
8710 static void alc861vd_auto_init_hp_out(struct hda_codec *codec)
8711 {
8712 struct alc_spec *spec = codec->spec;
8713 hda_nid_t pin;
8714
8715 pin = spec->autocfg.hp_pins[0];
8716 if (pin) /* connect to front and use dac 0 */
8717 alc861vd_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
8718 }
8719
8720 #define alc861vd_is_input_pin(nid) alc880_is_input_pin(nid)
8721 #define ALC861VD_PIN_CD_NID ALC880_PIN_CD_NID
8722
8723 static void alc861vd_auto_init_analog_input(struct hda_codec *codec)
8724 {
8725 struct alc_spec *spec = codec->spec;
8726 int i;
8727
8728 for (i = 0; i < AUTO_PIN_LAST; i++) {
8729 hda_nid_t nid = spec->autocfg.input_pins[i];
8730 if (alc861vd_is_input_pin(nid)) {
8731 snd_hda_codec_write(codec, nid, 0,
8732 AC_VERB_SET_PIN_WIDGET_CONTROL,
8733 i <= AUTO_PIN_FRONT_MIC ?
8734 PIN_VREF80 : PIN_IN);
8735 if (nid != ALC861VD_PIN_CD_NID)
8736 snd_hda_codec_write(codec, nid, 0,
8737 AC_VERB_SET_AMP_GAIN_MUTE,
8738 AMP_OUT_MUTE);
8739 }
8740 }
8741 }
8742
8743 #define alc861vd_idx_to_mixer_vol(nid) ((nid) + 0x02)
8744 #define alc861vd_idx_to_mixer_switch(nid) ((nid) + 0x0c)
8745
8746 /* add playback controls from the parsed DAC table */
8747 /* Based on ALC880 version. But ALC861VD has separate,
8748 * different NIDs for mute/unmute switch and volume control */
8749 static int alc861vd_auto_create_multi_out_ctls(struct alc_spec *spec,
8750 const struct auto_pin_cfg *cfg)
8751 {
8752 char name[32];
8753 static const char *chname[4] = {"Front", "Surround", "CLFE", "Side"};
8754 hda_nid_t nid_v, nid_s;
8755 int i, err;
8756
8757 for (i = 0; i < cfg->line_outs; i++) {
8758 if (! spec->multiout.dac_nids[i])
8759 continue;
8760 nid_v = alc861vd_idx_to_mixer_vol(
8761 alc880_dac_to_idx(
8762 spec->multiout.dac_nids[i]));
8763 nid_s = alc861vd_idx_to_mixer_switch(
8764 alc880_dac_to_idx(
8765 spec->multiout.dac_nids[i]));
8766
8767 if (i == 2) {
8768 /* Center/LFE */
8769 if ((err = add_control(spec, ALC_CTL_WIDGET_VOL,
8770 "Center Playback Volume",
8771 HDA_COMPOSE_AMP_VAL(nid_v, 1,
8772 0, HDA_OUTPUT))) < 0)
8773 return err;
8774 if ((err = add_control(spec, ALC_CTL_WIDGET_VOL,
8775 "LFE Playback Volume",
8776 HDA_COMPOSE_AMP_VAL(nid_v, 2,
8777 0, HDA_OUTPUT))) < 0)
8778 return err;
8779 if ((err = add_control(spec, ALC_CTL_BIND_MUTE,
8780 "Center Playback Switch",
8781 HDA_COMPOSE_AMP_VAL(nid_s, 1,
8782 2, HDA_INPUT))) < 0)
8783 return err;
8784 if ((err = add_control(spec, ALC_CTL_BIND_MUTE,
8785 "LFE Playback Switch",
8786 HDA_COMPOSE_AMP_VAL(nid_s, 2,
8787 2, HDA_INPUT))) < 0)
8788 return err;
8789 } else {
8790 sprintf(name, "%s Playback Volume", chname[i]);
8791 if ((err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
8792 HDA_COMPOSE_AMP_VAL(nid_v, 3,
8793 0, HDA_OUTPUT))) < 0)
8794 return err;
8795 sprintf(name, "%s Playback Switch", chname[i]);
8796 if ((err = add_control(spec, ALC_CTL_BIND_MUTE, name,
8797 HDA_COMPOSE_AMP_VAL(nid_v, 3,
8798 2, HDA_INPUT))) < 0)
8799 return err;
8800 }
8801 }
8802 return 0;
8803 }
8804
8805 /* add playback controls for speaker and HP outputs */
8806 /* Based on ALC880 version. But ALC861VD has separate,
8807 * different NIDs for mute/unmute switch and volume control */
8808 static int alc861vd_auto_create_extra_out(struct alc_spec *spec,
8809 hda_nid_t pin, const char *pfx)
8810 {
8811 hda_nid_t nid_v, nid_s;
8812 int err;
8813 char name[32];
8814
8815 if (! pin)
8816 return 0;
8817
8818 if (alc880_is_fixed_pin(pin)) {
8819 nid_v = alc880_idx_to_dac(alc880_fixed_pin_idx(pin));
8820 /* specify the DAC as the extra output */
8821 if (! spec->multiout.hp_nid)
8822 spec->multiout.hp_nid = nid_v;
8823 else
8824 spec->multiout.extra_out_nid[0] = nid_v;
8825 /* control HP volume/switch on the output mixer amp */
8826 nid_v = alc861vd_idx_to_mixer_vol(
8827 alc880_fixed_pin_idx(pin));
8828 nid_s = alc861vd_idx_to_mixer_switch(
8829 alc880_fixed_pin_idx(pin));
8830
8831 sprintf(name, "%s Playback Volume", pfx);
8832 if ((err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
8833 HDA_COMPOSE_AMP_VAL(nid_v, 3, 0,
8834 HDA_OUTPUT))) < 0)
8835 return err;
8836 sprintf(name, "%s Playback Switch", pfx);
8837 if ((err = add_control(spec, ALC_CTL_BIND_MUTE, name,
8838 HDA_COMPOSE_AMP_VAL(nid_s, 3, 2,
8839 HDA_INPUT))) < 0)
8840 return err;
8841 } else if (alc880_is_multi_pin(pin)) {
8842 /* set manual connection */
8843 /* we have only a switch on HP-out PIN */
8844 sprintf(name, "%s Playback Switch", pfx);
8845 if ((err = add_control(spec, ALC_CTL_WIDGET_MUTE, name,
8846 HDA_COMPOSE_AMP_VAL(pin, 3, 0,
8847 HDA_OUTPUT))) < 0)
8848 return err;
8849 }
8850 return 0;
8851 }
8852
8853 /* parse the BIOS configuration and set up the alc_spec
8854 * return 1 if successful, 0 if the proper config is not found,
8855 * or a negative error code
8856 * Based on ALC880 version - had to change it to override
8857 * alc880_auto_create_extra_out and alc880_auto_create_multi_out_ctls */
8858 static int alc861vd_parse_auto_config(struct hda_codec *codec)
8859 {
8860 struct alc_spec *spec = codec->spec;
8861 int err;
8862 static hda_nid_t alc861vd_ignore[] = { 0x1d, 0 };
8863
8864 if ((err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
8865 alc861vd_ignore)) < 0)
8866 return err;
8867 if (! spec->autocfg.line_outs)
8868 return 0; /* can't find valid BIOS pin config */
8869
8870 if ((err = alc880_auto_fill_dac_nids(spec, &spec->autocfg)) < 0 ||
8871 (err = alc861vd_auto_create_multi_out_ctls(spec,
8872 &spec->autocfg)) < 0 ||
8873 (err = alc861vd_auto_create_extra_out(spec,
8874 spec->autocfg.speaker_pins[0], "Speaker")) < 0 ||
8875 (err = alc861vd_auto_create_extra_out(spec,
8876 spec->autocfg.hp_pins[0], "Headphone")) < 0 ||
8877 (err = alc880_auto_create_analog_input_ctls(spec,
8878 &spec->autocfg)) < 0)
8879 return err;
8880
8881 spec->multiout.max_channels = spec->multiout.num_dacs * 2;
8882
8883 if (spec->autocfg.dig_out_pin)
8884 spec->multiout.dig_out_nid = ALC861VD_DIGOUT_NID;
8885
8886 if (spec->kctl_alloc)
8887 spec->mixers[spec->num_mixers++] = spec->kctl_alloc;
8888
8889 spec->init_verbs[spec->num_init_verbs++]
8890 = alc861vd_volume_init_verbs;
8891
8892 spec->num_mux_defs = 1;
8893 spec->input_mux = &spec->private_imux;
8894
8895 return 1;
8896 }
8897
8898 /* additional initialization for auto-configuration model */
8899 static void alc861vd_auto_init(struct hda_codec *codec)
8900 {
8901 alc861vd_auto_init_multi_out(codec);
8902 alc861vd_auto_init_hp_out(codec);
8903 alc861vd_auto_init_analog_input(codec);
8904 }
8905
8906 static int patch_alc861vd(struct hda_codec *codec)
8907 {
8908 struct alc_spec *spec;
8909 int err, board_config;
8910
8911 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
8912 if (spec == NULL)
8913 return -ENOMEM;
8914
8915 codec->spec = spec;
8916
8917 board_config = snd_hda_check_board_config(codec, ALC861VD_MODEL_LAST,
8918 alc861vd_models,
8919 alc861vd_cfg_tbl);
8920
8921 if (board_config < 0 || board_config >= ALC861VD_MODEL_LAST) {
8922 printk(KERN_INFO "hda_codec: Unknown model for ALC660VD/"
8923 "ALC861VD, trying auto-probe from BIOS...\n");
8924 board_config = ALC861VD_AUTO;
8925 }
8926
8927 if (board_config == ALC861VD_AUTO) {
8928 /* automatic parse from the BIOS config */
8929 err = alc861vd_parse_auto_config(codec);
8930 if (err < 0) {
8931 alc_free(codec);
8932 return err;
8933 } else if (! err) {
8934 printk(KERN_INFO
8935 "hda_codec: Cannot set up configuration "
8936 "from BIOS. Using base mode...\n");
8937 board_config = ALC861VD_3ST;
8938 }
8939 }
8940
8941 if (board_config != ALC861VD_AUTO)
8942 setup_preset(spec, &alc861vd_presets[board_config]);
8943
8944 spec->stream_name_analog = "ALC861VD Analog";
8945 spec->stream_analog_playback = &alc861vd_pcm_analog_playback;
8946 spec->stream_analog_capture = &alc861vd_pcm_analog_capture;
8947
8948 spec->stream_name_digital = "ALC861VD Digital";
8949 spec->stream_digital_playback = &alc861vd_pcm_digital_playback;
8950 spec->stream_digital_capture = &alc861vd_pcm_digital_capture;
8951
8952 spec->adc_nids = alc861vd_adc_nids;
8953 spec->num_adc_nids = ARRAY_SIZE(alc861vd_adc_nids);
8954
8955 spec->mixers[spec->num_mixers] = alc861vd_capture_mixer;
8956 spec->num_mixers++;
8957
8958 codec->patch_ops = alc_patch_ops;
8959
8960 if (board_config == ALC861VD_AUTO)
8961 spec->init_hook = alc861vd_auto_init;
8962
8963 return 0;
8964 }
8965
8966 /*
8967 * ALC662 support
8968 *
8969 * ALC662 is almost identical with ALC880 but has cleaner and more flexible
8970 * configuration. Each pin widget can choose any input DACs and a mixer.
8971 * Each ADC is connected from a mixer of all inputs. This makes possible
8972 * 6-channel independent captures.
8973 *
8974 * In addition, an independent DAC for the multi-playback (not used in this
8975 * driver yet).
8976 */
8977 #define ALC662_DIGOUT_NID 0x06
8978 #define ALC662_DIGIN_NID 0x0a
8979
8980 static hda_nid_t alc662_dac_nids[4] = {
8981 /* front, rear, clfe, rear_surr */
8982 0x02, 0x03, 0x04
8983 };
8984
8985 static hda_nid_t alc662_adc_nids[1] = {
8986 /* ADC1-2 */
8987 0x09,
8988 };
8989 /* input MUX */
8990 /* FIXME: should be a matrix-type input source selection */
8991
8992 static struct hda_input_mux alc662_capture_source = {
8993 .num_items = 4,
8994 .items = {
8995 { "Mic", 0x0 },
8996 { "Front Mic", 0x1 },
8997 { "Line", 0x2 },
8998 { "CD", 0x4 },
8999 },
9000 };
9001
9002 static struct hda_input_mux alc662_lenovo_101e_capture_source = {
9003 .num_items = 2,
9004 .items = {
9005 { "Mic", 0x1 },
9006 { "Line", 0x2 },
9007 },
9008 };
9009 #define alc662_mux_enum_info alc_mux_enum_info
9010 #define alc662_mux_enum_get alc_mux_enum_get
9011
9012 static int alc662_mux_enum_put(struct snd_kcontrol *kcontrol,
9013 struct snd_ctl_elem_value *ucontrol)
9014 {
9015 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
9016 struct alc_spec *spec = codec->spec;
9017 const struct hda_input_mux *imux = spec->input_mux;
9018 unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
9019 static hda_nid_t capture_mixers[3] = { 0x24, 0x23, 0x22 };
9020 hda_nid_t nid = capture_mixers[adc_idx];
9021 unsigned int *cur_val = &spec->cur_mux[adc_idx];
9022 unsigned int i, idx;
9023
9024 idx = ucontrol->value.enumerated.item[0];
9025 if (idx >= imux->num_items)
9026 idx = imux->num_items - 1;
9027 if (*cur_val == idx && ! codec->in_resume)
9028 return 0;
9029 for (i = 0; i < imux->num_items; i++) {
9030 unsigned int v = (i == idx) ? 0x7000 : 0x7080;
9031 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE,
9032 v | (imux->items[i].index << 8));
9033 }
9034 *cur_val = idx;
9035 return 1;
9036 }
9037 /*
9038 * 2ch mode
9039 */
9040 static struct hda_channel_mode alc662_3ST_2ch_modes[1] = {
9041 { 2, NULL }
9042 };
9043
9044 /*
9045 * 2ch mode
9046 */
9047 static struct hda_verb alc662_3ST_ch2_init[] = {
9048 { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
9049 { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
9050 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
9051 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
9052 { } /* end */
9053 };
9054
9055 /*
9056 * 6ch mode
9057 */
9058 static struct hda_verb alc662_3ST_ch6_init[] = {
9059 { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
9060 { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
9061 { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
9062 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
9063 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
9064 { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
9065 { } /* end */
9066 };
9067
9068 static struct hda_channel_mode alc662_3ST_6ch_modes[2] = {
9069 { 2, alc662_3ST_ch2_init },
9070 { 6, alc662_3ST_ch6_init },
9071 };
9072
9073 /*
9074 * 2ch mode
9075 */
9076 static struct hda_verb alc662_sixstack_ch6_init[] = {
9077 { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
9078 { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
9079 { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
9080 { } /* end */
9081 };
9082
9083 /*
9084 * 6ch mode
9085 */
9086 static struct hda_verb alc662_sixstack_ch8_init[] = {
9087 { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
9088 { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
9089 { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
9090 { } /* end */
9091 };
9092
9093 static struct hda_channel_mode alc662_5stack_modes[2] = {
9094 { 2, alc662_sixstack_ch6_init },
9095 { 6, alc662_sixstack_ch8_init },
9096 };
9097
9098 /* Pin assignment: Front=0x14, Rear=0x15, CLFE=0x16, Side=0x17
9099 * Mic=0x18, Front Mic=0x19, Line-In=0x1a, HP=0x1b
9100 */
9101
9102 static struct snd_kcontrol_new alc662_base_mixer[] = {
9103 /* output mixer control */
9104 HDA_CODEC_VOLUME("Front Playback Volume", 0x2, 0x0, HDA_OUTPUT),
9105 HDA_CODEC_MUTE("Front Playback Switch", 0x02, 0x0, HDA_OUTPUT),
9106 HDA_CODEC_VOLUME("Surround Playback Volume", 0x3, 0x0, HDA_OUTPUT),
9107 HDA_CODEC_MUTE("Surround Playback Switch", 0x03, 0x0, HDA_OUTPUT),
9108 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0, HDA_OUTPUT),
9109 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0, HDA_OUTPUT),
9110 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x04, 1, 2, HDA_INPUT),
9111 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x04, 2, 2, HDA_INPUT),
9112 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
9113
9114 /*Input mixer control */
9115 HDA_CODEC_VOLUME("CD Playback Volume", 0xb, 0x4, HDA_INPUT),
9116 HDA_CODEC_MUTE("CD Playback Switch", 0xb, 0x4, HDA_INPUT),
9117 HDA_CODEC_VOLUME("Line Playback Volume", 0xb, 0x02, HDA_INPUT),
9118 HDA_CODEC_MUTE("Line Playback Switch", 0xb, 0x02, HDA_INPUT),
9119 HDA_CODEC_VOLUME("Mic Playback Volume", 0xb, 0x0, HDA_INPUT),
9120 HDA_CODEC_MUTE("Mic Playback Switch", 0xb, 0x0, HDA_INPUT),
9121 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0xb, 0x01, HDA_INPUT),
9122 HDA_CODEC_MUTE("Front Mic Playback Switch", 0xb, 0x01, HDA_INPUT),
9123
9124 /* Capture mixer control */
9125 HDA_CODEC_VOLUME("Capture Volume", 0x09, 0x0, HDA_INPUT),
9126 HDA_CODEC_MUTE("Capture Switch", 0x09, 0x0, HDA_INPUT),
9127 {
9128 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
9129 .name = "Capture Source",
9130 .count = 1,
9131 .info = alc_mux_enum_info,
9132 .get = alc_mux_enum_get,
9133 .put = alc_mux_enum_put,
9134 },
9135 { } /* end */
9136 };
9137
9138 static struct snd_kcontrol_new alc662_3ST_2ch_mixer[] = {
9139 HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
9140 HDA_BIND_MUTE("Front Playback Switch", 0x02, 2, HDA_INPUT),
9141 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
9142 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
9143 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
9144 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
9145 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
9146 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9147 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9148 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
9149 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
9150 HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
9151 HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
9152 HDA_CODEC_VOLUME("Capture Volume", 0x09, 0x0, HDA_INPUT),
9153 HDA_CODEC_MUTE("Capture Switch", 0x09, 0x0, HDA_INPUT),
9154 {
9155 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
9156 /* .name = "Capture Source", */
9157 .name = "Input Source",
9158 .count = 1,
9159 .info = alc662_mux_enum_info,
9160 .get = alc662_mux_enum_get,
9161 .put = alc662_mux_enum_put,
9162 },
9163 { } /* end */
9164 };
9165
9166 static struct snd_kcontrol_new alc662_3ST_6ch_mixer[] = {
9167 HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
9168 HDA_BIND_MUTE("Front Playback Switch", 0x02, 2, HDA_INPUT),
9169 HDA_CODEC_VOLUME("Surround Playback Volume", 0x03, 0x0, HDA_OUTPUT),
9170 HDA_BIND_MUTE("Surround Playback Switch", 0x03, 2, HDA_INPUT),
9171 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0, HDA_OUTPUT),
9172 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0, HDA_OUTPUT),
9173 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x04, 1, 2, HDA_INPUT),
9174 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x04, 2, 2, HDA_INPUT),
9175 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
9176 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
9177 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
9178 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
9179 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
9180 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9181 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9182 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
9183 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
9184 HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
9185 HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
9186 HDA_CODEC_VOLUME("Capture Volume", 0x09, 0x0, HDA_INPUT),
9187 HDA_CODEC_MUTE("Capture Switch", 0x09, 0x0, HDA_INPUT),
9188 {
9189 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
9190 /* .name = "Capture Source", */
9191 .name = "Input Source",
9192 .count = 1,
9193 .info = alc662_mux_enum_info,
9194 .get = alc662_mux_enum_get,
9195 .put = alc662_mux_enum_put,
9196 },
9197 { } /* end */
9198 };
9199
9200 static struct snd_kcontrol_new alc662_lenovo_101e_mixer[] = {
9201 HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
9202 HDA_BIND_MUTE("Front Playback Switch", 0x02, 2, HDA_INPUT),
9203 HDA_CODEC_VOLUME("iSpeaker Playback Volume", 0x03, 0x0, HDA_OUTPUT),
9204 HDA_BIND_MUTE("iSpeaker Playback Switch", 0x03, 2, HDA_INPUT),
9205 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
9206 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
9207 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
9208 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
9209 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
9210 HDA_CODEC_VOLUME("Capture Volume", 0x09, 0x0, HDA_INPUT),
9211 HDA_CODEC_MUTE("Capture Switch", 0x09, 0x0, HDA_INPUT),
9212 {
9213 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
9214 /* .name = "Capture Source", */
9215 .name = "Input Source",
9216 .count = 1,
9217 .info = alc662_mux_enum_info,
9218 .get = alc662_mux_enum_get,
9219 .put = alc662_mux_enum_put,
9220 },
9221 { } /* end */
9222 };
9223
9224 static struct snd_kcontrol_new alc662_chmode_mixer[] = {
9225 {
9226 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
9227 .name = "Channel Mode",
9228 .info = alc_ch_mode_info,
9229 .get = alc_ch_mode_get,
9230 .put = alc_ch_mode_put,
9231 },
9232 { } /* end */
9233 };
9234
9235 static struct hda_verb alc662_init_verbs[] = {
9236 /* ADC: mute amp left and right */
9237 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
9238 {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
9239 /* Front mixer: unmute input/output amp left and right (volume = 0) */
9240
9241 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9242 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9243 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
9244 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
9245 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
9246
9247 {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9248 {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9249 {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9250 {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9251 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9252 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9253
9254 /* Front Pin: output 0 (0x0c) */
9255 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9256 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
9257
9258 /* Rear Pin: output 1 (0x0d) */
9259 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9260 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
9261
9262 /* CLFE Pin: output 2 (0x0e) */
9263 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9264 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
9265
9266 /* Mic (rear) pin: input vref at 80% */
9267 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
9268 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
9269 /* Front Mic pin: input vref at 80% */
9270 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
9271 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
9272 /* Line In pin: input */
9273 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
9274 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
9275 /* Line-2 In: Headphone output (output 0 - 0x0c) */
9276 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9277 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
9278 {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
9279 /* CD pin widget for input */
9280 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
9281
9282 /* FIXME: use matrix-type input source selection */
9283 /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
9284 /* Input mixer */
9285 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9286 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9287 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
9288 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
9289 { }
9290 };
9291
9292 static struct hda_verb alc662_sue_init_verbs[] = {
9293 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_FRONT_EVENT},
9294 {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_HP_EVENT},
9295 {}
9296 };
9297
9298 /*
9299 * generic initialization of ADC, input mixers and output mixers
9300 */
9301 static struct hda_verb alc662_auto_init_verbs[] = {
9302 /*
9303 * Unmute ADC and set the default input to mic-in
9304 */
9305 {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
9306 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9307
9308 /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
9309 * mixer widget
9310 * Note: PASD motherboards uses the Line In 2 as the input for front
9311 * panel mic (mic 2)
9312 */
9313 /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
9314 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9315 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9316 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
9317 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
9318 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
9319
9320 /*
9321 * Set up output mixers (0x0c - 0x0f)
9322 */
9323 /* set vol=0 to output mixers */
9324 {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
9325 {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
9326 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
9327
9328 /* set up input amps for analog loopback */
9329 /* Amp Indices: DAC = 0, mixer = 1 */
9330 {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9331 {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9332 {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9333 {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9334 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9335 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9336
9337
9338 /* FIXME: use matrix-type input source selection */
9339 /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
9340 /* Input mixer */
9341 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9342 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9343 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
9344 /*{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},*/
9345 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
9346
9347 { }
9348 };
9349
9350 /* capture mixer elements */
9351 static struct snd_kcontrol_new alc662_capture_mixer[] = {
9352 HDA_CODEC_VOLUME("Capture Volume", 0x09, 0x0, HDA_INPUT),
9353 HDA_CODEC_MUTE("Capture Switch", 0x09, 0x0, HDA_INPUT),
9354 {
9355 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
9356 /* The multiple "Capture Source" controls confuse alsamixer
9357 * So call somewhat different..
9358 * FIXME: the controls appear in the "playback" view!
9359 */
9360 /* .name = "Capture Source", */
9361 .name = "Input Source",
9362 .count = 1,
9363 .info = alc882_mux_enum_info,
9364 .get = alc882_mux_enum_get,
9365 .put = alc882_mux_enum_put,
9366 },
9367 { } /* end */
9368 };
9369
9370 static void alc662_lenovo_101e_ispeaker_automute(struct hda_codec *codec)
9371 {
9372 unsigned int present;
9373
9374 present = snd_hda_codec_read(codec, 0x14, 0,
9375 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
9376
9377 snd_hda_codec_amp_update(codec, 0x15, 0, HDA_OUTPUT, 0,
9378 0x80, present ? 0x80 : 0);
9379 snd_hda_codec_amp_update(codec, 0x15, 1, HDA_OUTPUT, 0,
9380 0x80, present ? 0x80 : 0);
9381 }
9382
9383 static void alc662_lenovo_101e_all_automute(struct hda_codec *codec)
9384 {
9385 unsigned int present;
9386
9387 present = snd_hda_codec_read(codec, 0x1b, 0,
9388 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
9389
9390 snd_hda_codec_amp_update(codec, 0x15, 0, HDA_OUTPUT, 0,
9391 0x80, present ? 0x80 : 0);
9392 snd_hda_codec_amp_update(codec, 0x15, 1, HDA_OUTPUT, 0,
9393 0x80, present ? 0x80 : 0);
9394 snd_hda_codec_amp_update(codec, 0x14, 0, HDA_OUTPUT, 0,
9395 0x80, present ? 0x80 : 0);
9396 snd_hda_codec_amp_update(codec, 0x14, 1, HDA_OUTPUT, 0,
9397 0x80, present ? 0x80 : 0);
9398 }
9399
9400 static void alc662_lenovo_101e_unsol_event(struct hda_codec *codec,
9401 unsigned int res)
9402 {
9403 if ((res >> 26) == ALC880_HP_EVENT)
9404 alc662_lenovo_101e_all_automute(codec);
9405 if ((res >> 26) == ALC880_FRONT_EVENT)
9406 alc662_lenovo_101e_ispeaker_automute(codec);
9407 }
9408
9409
9410 /* pcm configuration: identiacal with ALC880 */
9411 #define alc662_pcm_analog_playback alc880_pcm_analog_playback
9412 #define alc662_pcm_analog_capture alc880_pcm_analog_capture
9413 #define alc662_pcm_digital_playback alc880_pcm_digital_playback
9414 #define alc662_pcm_digital_capture alc880_pcm_digital_capture
9415
9416 /*
9417 * configuration and preset
9418 */
9419 static const char *alc662_models[ALC662_MODEL_LAST] = {
9420 [ALC662_3ST_2ch_DIG] = "3stack-dig",
9421 [ALC662_3ST_6ch_DIG] = "3stack-6ch-dig",
9422 [ALC662_3ST_6ch] = "3stack-6ch",
9423 [ALC662_5ST_DIG] = "6stack-dig",
9424 [ALC662_LENOVO_101E] = "lenovo-101e",
9425 [ALC662_AUTO] = "auto",
9426 };
9427
9428 static struct snd_pci_quirk alc662_cfg_tbl[] = {
9429 SND_PCI_QUIRK(0x17aa, 0x101e, "Lenovo", ALC662_LENOVO_101E),
9430 {}
9431 };
9432
9433 static struct alc_config_preset alc662_presets[] = {
9434 [ALC662_3ST_2ch_DIG] = {
9435 .mixers = { alc662_3ST_2ch_mixer },
9436 .init_verbs = { alc662_init_verbs },
9437 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
9438 .dac_nids = alc662_dac_nids,
9439 .dig_out_nid = ALC662_DIGOUT_NID,
9440 .num_adc_nids = ARRAY_SIZE(alc662_adc_nids),
9441 .adc_nids = alc662_adc_nids,
9442 .dig_in_nid = ALC662_DIGIN_NID,
9443 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
9444 .channel_mode = alc662_3ST_2ch_modes,
9445 .input_mux = &alc662_capture_source,
9446 },
9447 [ALC662_3ST_6ch_DIG] = {
9448 .mixers = { alc662_3ST_6ch_mixer, alc662_chmode_mixer },
9449 .init_verbs = { alc662_init_verbs },
9450 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
9451 .dac_nids = alc662_dac_nids,
9452 .dig_out_nid = ALC662_DIGOUT_NID,
9453 .num_adc_nids = ARRAY_SIZE(alc662_adc_nids),
9454 .adc_nids = alc662_adc_nids,
9455 .dig_in_nid = ALC662_DIGIN_NID,
9456 .num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes),
9457 .channel_mode = alc662_3ST_6ch_modes,
9458 .need_dac_fix = 1,
9459 .input_mux = &alc662_capture_source,
9460 },
9461 [ALC662_3ST_6ch] = {
9462 .mixers = { alc662_3ST_6ch_mixer, alc662_chmode_mixer },
9463 .init_verbs = { alc662_init_verbs },
9464 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
9465 .dac_nids = alc662_dac_nids,
9466 .num_adc_nids = ARRAY_SIZE(alc662_adc_nids),
9467 .adc_nids = alc662_adc_nids,
9468 .num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes),
9469 .channel_mode = alc662_3ST_6ch_modes,
9470 .need_dac_fix = 1,
9471 .input_mux = &alc662_capture_source,
9472 },
9473 [ALC662_5ST_DIG] = {
9474 .mixers = { alc662_base_mixer, alc662_chmode_mixer },
9475 .init_verbs = { alc662_init_verbs },
9476 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
9477 .dac_nids = alc662_dac_nids,
9478 .dig_out_nid = ALC662_DIGOUT_NID,
9479 .num_adc_nids = ARRAY_SIZE(alc662_adc_nids),
9480 .adc_nids = alc662_adc_nids,
9481 .dig_in_nid = ALC662_DIGIN_NID,
9482 .num_channel_mode = ARRAY_SIZE(alc662_5stack_modes),
9483 .channel_mode = alc662_5stack_modes,
9484 .input_mux = &alc662_capture_source,
9485 },
9486 [ALC662_LENOVO_101E] = {
9487 .mixers = { alc662_lenovo_101e_mixer },
9488 .init_verbs = { alc662_init_verbs, alc662_sue_init_verbs },
9489 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
9490 .dac_nids = alc662_dac_nids,
9491 .num_adc_nids = ARRAY_SIZE(alc662_adc_nids),
9492 .adc_nids = alc662_adc_nids,
9493 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
9494 .channel_mode = alc662_3ST_2ch_modes,
9495 .input_mux = &alc662_lenovo_101e_capture_source,
9496 .unsol_event = alc662_lenovo_101e_unsol_event,
9497 .init_hook = alc662_lenovo_101e_all_automute,
9498 },
9499
9500 };
9501
9502
9503 /*
9504 * BIOS auto configuration
9505 */
9506
9507 /* add playback controls from the parsed DAC table */
9508 static int alc662_auto_create_multi_out_ctls(struct alc_spec *spec,
9509 const struct auto_pin_cfg *cfg)
9510 {
9511 char name[32];
9512 static const char *chname[4] = {
9513 "Front", "Surround", NULL /*CLFE*/, "Side"
9514 };
9515 hda_nid_t nid;
9516 int i, err;
9517
9518 for (i = 0; i < cfg->line_outs; i++) {
9519 if (!spec->multiout.dac_nids[i])
9520 continue;
9521 nid = alc880_idx_to_dac(i);
9522 if (i == 2) {
9523 /* Center/LFE */
9524 err = add_control(spec, ALC_CTL_WIDGET_VOL,
9525 "Center Playback Volume",
9526 HDA_COMPOSE_AMP_VAL(nid, 1, 0, HDA_OUTPUT));
9527 if (err < 0)
9528 return err;
9529 err = add_control(spec, ALC_CTL_WIDGET_VOL,
9530 "LFE Playback Volume",
9531 HDA_COMPOSE_AMP_VAL(nid, 2, 0, HDA_OUTPUT));
9532 if (err < 0)
9533 return err;
9534 err = add_control(spec, ALC_CTL_BIND_MUTE,
9535 "Center Playback Switch",
9536 HDA_COMPOSE_AMP_VAL(nid, 1, 2, HDA_INPUT));
9537 if (err < 0)
9538 return err;
9539 err = add_control(spec, ALC_CTL_BIND_MUTE,
9540 "LFE Playback Switch",
9541 HDA_COMPOSE_AMP_VAL(nid, 2, 2, HDA_INPUT));
9542 if (err < 0)
9543 return err;
9544 } else {
9545 sprintf(name, "%s Playback Volume", chname[i]);
9546 err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
9547 HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT));
9548 if (err < 0)
9549 return err;
9550 sprintf(name, "%s Playback Switch", chname[i]);
9551 err = add_control(spec, ALC_CTL_BIND_MUTE, name,
9552 HDA_COMPOSE_AMP_VAL(nid, 3, 2, HDA_INPUT));
9553 if (err < 0)
9554 return err;
9555 }
9556 }
9557 return 0;
9558 }
9559
9560 /* add playback controls for speaker and HP outputs */
9561 static int alc662_auto_create_extra_out(struct alc_spec *spec, hda_nid_t pin,
9562 const char *pfx)
9563 {
9564 hda_nid_t nid;
9565 int err;
9566 char name[32];
9567
9568 if (!pin)
9569 return 0;
9570
9571 if (alc880_is_fixed_pin(pin)) {
9572 nid = alc880_idx_to_dac(alc880_fixed_pin_idx(pin));
9573 /* printk("DAC nid=%x\n",nid); */
9574 /* specify the DAC as the extra output */
9575 if (!spec->multiout.hp_nid)
9576 spec->multiout.hp_nid = nid;
9577 else
9578 spec->multiout.extra_out_nid[0] = nid;
9579 /* control HP volume/switch on the output mixer amp */
9580 nid = alc880_idx_to_dac(alc880_fixed_pin_idx(pin));
9581 sprintf(name, "%s Playback Volume", pfx);
9582 err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
9583 HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT));
9584 if (err < 0)
9585 return err;
9586 sprintf(name, "%s Playback Switch", pfx);
9587 err = add_control(spec, ALC_CTL_BIND_MUTE, name,
9588 HDA_COMPOSE_AMP_VAL(nid, 3, 2, HDA_INPUT));
9589 if (err < 0)
9590 return err;
9591 } else if (alc880_is_multi_pin(pin)) {
9592 /* set manual connection */
9593 /* we have only a switch on HP-out PIN */
9594 sprintf(name, "%s Playback Switch", pfx);
9595 err = add_control(spec, ALC_CTL_WIDGET_MUTE, name,
9596 HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
9597 if (err < 0)
9598 return err;
9599 }
9600 return 0;
9601 }
9602
9603 /* create playback/capture controls for input pins */
9604 static int alc662_auto_create_analog_input_ctls(struct alc_spec *spec,
9605 const struct auto_pin_cfg *cfg)
9606 {
9607 struct hda_input_mux *imux = &spec->private_imux;
9608 int i, err, idx;
9609
9610 for (i = 0; i < AUTO_PIN_LAST; i++) {
9611 if (alc880_is_input_pin(cfg->input_pins[i])) {
9612 idx = alc880_input_pin_idx(cfg->input_pins[i]);
9613 err = new_analog_input(spec, cfg->input_pins[i],
9614 auto_pin_cfg_labels[i],
9615 idx, 0x0b);
9616 if (err < 0)
9617 return err;
9618 imux->items[imux->num_items].label =
9619 auto_pin_cfg_labels[i];
9620 imux->items[imux->num_items].index =
9621 alc880_input_pin_idx(cfg->input_pins[i]);
9622 imux->num_items++;
9623 }
9624 }
9625 return 0;
9626 }
9627
9628 static void alc662_auto_set_output_and_unmute(struct hda_codec *codec,
9629 hda_nid_t nid, int pin_type,
9630 int dac_idx)
9631 {
9632 /* set as output */
9633 snd_hda_codec_write(codec, nid, 0,
9634 AC_VERB_SET_PIN_WIDGET_CONTROL, pin_type);
9635 snd_hda_codec_write(codec, nid, 0,
9636 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE);
9637 /* need the manual connection? */
9638 if (alc880_is_multi_pin(nid)) {
9639 struct alc_spec *spec = codec->spec;
9640 int idx = alc880_multi_pin_idx(nid);
9641 snd_hda_codec_write(codec, alc880_idx_to_selector(idx), 0,
9642 AC_VERB_SET_CONNECT_SEL,
9643 alc880_dac_to_idx(spec->multiout.dac_nids[dac_idx]));
9644 }
9645 }
9646
9647 static void alc662_auto_init_multi_out(struct hda_codec *codec)
9648 {
9649 struct alc_spec *spec = codec->spec;
9650 int i;
9651
9652 for (i = 0; i <= HDA_SIDE; i++) {
9653 hda_nid_t nid = spec->autocfg.line_out_pins[i];
9654 if (nid)
9655 alc662_auto_set_output_and_unmute(codec, nid, PIN_OUT,
9656 i);
9657 }
9658 }
9659
9660 static void alc662_auto_init_hp_out(struct hda_codec *codec)
9661 {
9662 struct alc_spec *spec = codec->spec;
9663 hda_nid_t pin;
9664
9665 pin = spec->autocfg.hp_pins[0];
9666 if (pin) /* connect to front */
9667 /* use dac 0 */
9668 alc662_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
9669 }
9670
9671 #define alc662_is_input_pin(nid) alc880_is_input_pin(nid)
9672 #define ALC662_PIN_CD_NID ALC880_PIN_CD_NID
9673
9674 static void alc662_auto_init_analog_input(struct hda_codec *codec)
9675 {
9676 struct alc_spec *spec = codec->spec;
9677 int i;
9678
9679 for (i = 0; i < AUTO_PIN_LAST; i++) {
9680 hda_nid_t nid = spec->autocfg.input_pins[i];
9681 if (alc662_is_input_pin(nid)) {
9682 snd_hda_codec_write(codec, nid, 0,
9683 AC_VERB_SET_PIN_WIDGET_CONTROL,
9684 (i <= AUTO_PIN_FRONT_MIC ?
9685 PIN_VREF80 : PIN_IN));
9686 if (nid != ALC662_PIN_CD_NID)
9687 snd_hda_codec_write(codec, nid, 0,
9688 AC_VERB_SET_AMP_GAIN_MUTE,
9689 AMP_OUT_MUTE);
9690 }
9691 }
9692 }
9693
9694 static int alc662_parse_auto_config(struct hda_codec *codec)
9695 {
9696 struct alc_spec *spec = codec->spec;
9697 int err;
9698 static hda_nid_t alc662_ignore[] = { 0x1d, 0 };
9699
9700 err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
9701 alc662_ignore);
9702 if (err < 0)
9703 return err;
9704 if (!spec->autocfg.line_outs)
9705 return 0; /* can't find valid BIOS pin config */
9706
9707 if ((err = alc880_auto_fill_dac_nids(spec, &spec->autocfg)) < 0 ||
9708 (err = alc662_auto_create_multi_out_ctls(spec, &spec->autocfg)) < 0 ||
9709 (err = alc662_auto_create_extra_out(spec,
9710 spec->autocfg.speaker_pins[0],
9711 "Speaker")) < 0 ||
9712 (err = alc662_auto_create_extra_out(spec, spec->autocfg.hp_pins[0],
9713 "Headphone")) < 0 ||
9714 (err = alc662_auto_create_analog_input_ctls(spec, &spec->autocfg)) < 0)
9715 return err;
9716
9717 spec->multiout.max_channels = spec->multiout.num_dacs * 2;
9718
9719 if (spec->autocfg.dig_out_pin)
9720 spec->multiout.dig_out_nid = ALC880_DIGOUT_NID;
9721
9722 if (spec->kctl_alloc)
9723 spec->mixers[spec->num_mixers++] = spec->kctl_alloc;
9724
9725 spec->num_mux_defs = 1;
9726 spec->input_mux = &spec->private_imux;
9727
9728 if (err < 0)
9729 return err;
9730 else if (err > 0)
9731 /* hack - override the init verbs */
9732 spec->init_verbs[0] = alc662_auto_init_verbs;
9733 spec->mixers[spec->num_mixers] = alc662_capture_mixer;
9734 spec->num_mixers++;
9735 return err;
9736 }
9737
9738 /* additional initialization for auto-configuration model */
9739 static void alc662_auto_init(struct hda_codec *codec)
9740 {
9741 alc662_auto_init_multi_out(codec);
9742 alc662_auto_init_hp_out(codec);
9743 alc662_auto_init_analog_input(codec);
9744 }
9745
9746 static int patch_alc662(struct hda_codec *codec)
9747 {
9748 struct alc_spec *spec;
9749 int err, board_config;
9750
9751 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
9752 if (!spec)
9753 return -ENOMEM;
9754
9755 codec->spec = spec;
9756
9757 board_config = snd_hda_check_board_config(codec, ALC662_MODEL_LAST,
9758 alc662_models,
9759 alc662_cfg_tbl);
9760 if (board_config < 0) {
9761 printk(KERN_INFO "hda_codec: Unknown model for ALC662, "
9762 "trying auto-probe from BIOS...\n");
9763 board_config = ALC662_AUTO;
9764 }
9765
9766 if (board_config == ALC662_AUTO) {
9767 /* automatic parse from the BIOS config */
9768 err = alc662_parse_auto_config(codec);
9769 if (err < 0) {
9770 alc_free(codec);
9771 return err;
9772 } else if (err) {
9773 printk(KERN_INFO
9774 "hda_codec: Cannot set up configuration "
9775 "from BIOS. Using base mode...\n");
9776 board_config = ALC662_3ST_2ch_DIG;
9777 }
9778 }
9779
9780 if (board_config != ALC662_AUTO)
9781 setup_preset(spec, &alc662_presets[board_config]);
9782
9783 spec->stream_name_analog = "ALC662 Analog";
9784 spec->stream_analog_playback = &alc662_pcm_analog_playback;
9785 spec->stream_analog_capture = &alc662_pcm_analog_capture;
9786
9787 spec->stream_name_digital = "ALC662 Digital";
9788 spec->stream_digital_playback = &alc662_pcm_digital_playback;
9789 spec->stream_digital_capture = &alc662_pcm_digital_capture;
9790
9791 if (!spec->adc_nids && spec->input_mux) {
9792 spec->adc_nids = alc662_adc_nids;
9793 spec->num_adc_nids = ARRAY_SIZE(alc662_adc_nids);
9794 }
9795
9796 codec->patch_ops = alc_patch_ops;
9797 if (board_config == ALC662_AUTO)
9798 spec->init_hook = alc662_auto_init;
9799
9800 return 0;
9801 }
9802
9803 /*
9804 * patch entries
9805 */
9806 struct hda_codec_preset snd_hda_preset_realtek[] = {
9807 { .id = 0x10ec0260, .name = "ALC260", .patch = patch_alc260 },
9808 { .id = 0x10ec0262, .name = "ALC262", .patch = patch_alc262 },
9809 { .id = 0x10ec0861, .rev = 0x100340, .name = "ALC660",
9810 .patch = patch_alc861 },
9811 { .id = 0x10ec0660, .name = "ALC660-VD", .patch = patch_alc861vd },
9812 { .id = 0x10ec0861, .name = "ALC861", .patch = patch_alc861 },
9813 { .id = 0x10ec0862, .name = "ALC861-VD", .patch = patch_alc861vd },
9814 { .id = 0x10ec0662, .rev = 0x100002, .name = "ALC662 rev2",
9815 .patch = patch_alc883 },
9816 { .id = 0x10ec0662, .rev = 0x100101, .name = "ALC662 rev1",
9817 .patch = patch_alc662 },
9818 { .id = 0x10ec0880, .name = "ALC880", .patch = patch_alc880 },
9819 { .id = 0x10ec0882, .name = "ALC882", .patch = patch_alc882 },
9820 { .id = 0x10ec0883, .name = "ALC883", .patch = patch_alc883 },
9821 { .id = 0x10ec0885, .name = "ALC885", .patch = patch_alc882 },
9822 { .id = 0x10ec0888, .name = "ALC888", .patch = patch_alc883 },
9823 {} /* terminator */
9824 };
Linux kernel - Deliverables
This page took 0.293687 seconds and 5 git commands to generate.