]> git.ipfire.org Git - thirdparty/linux.git/blob - sound/pci/hda/patch_realtek.c
projects / thirdparty / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
ALSA: hda - Fix a compile error in patch_ca0132.c for the recent SPDIF change
[thirdparty/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 <linux/init.h>
27 #include <linux/delay.h>
28 #include <linux/slab.h>
29 #include <linux/pci.h>
30 #include <sound/core.h>
31 #include <sound/jack.h>
32 #include "hda_codec.h"
33 #include "hda_local.h"
34 #include "hda_beep.h"
35
36 #define ALC880_FRONT_EVENT 0x01
37 #define ALC880_DCVOL_EVENT 0x02
38 #define ALC880_HP_EVENT 0x04
39 #define ALC880_MIC_EVENT 0x08
40
41 /* ALC880 board config type */
42 enum {
43 ALC880_3ST,
44 ALC880_3ST_DIG,
45 ALC880_5ST,
46 ALC880_5ST_DIG,
47 ALC880_W810,
48 ALC880_Z71V,
49 ALC880_6ST,
50 ALC880_6ST_DIG,
51 ALC880_F1734,
52 ALC880_ASUS,
53 ALC880_ASUS_DIG,
54 ALC880_ASUS_W1V,
55 ALC880_ASUS_DIG2,
56 ALC880_FUJITSU,
57 ALC880_UNIWILL_DIG,
58 ALC880_UNIWILL,
59 ALC880_UNIWILL_P53,
60 ALC880_CLEVO,
61 ALC880_TCL_S700,
62 ALC880_LG,
63 ALC880_LG_LW,
64 ALC880_MEDION_RIM,
65 #ifdef CONFIG_SND_DEBUG
66 ALC880_TEST,
67 #endif
68 ALC880_AUTO,
69 ALC880_MODEL_LAST /* last tag */
70 };
71
72 /* ALC260 models */
73 enum {
74 ALC260_BASIC,
75 ALC260_HP,
76 ALC260_HP_DC7600,
77 ALC260_HP_3013,
78 ALC260_FUJITSU_S702X,
79 ALC260_ACER,
80 ALC260_WILL,
81 ALC260_REPLACER_672V,
82 ALC260_FAVORIT100,
83 #ifdef CONFIG_SND_DEBUG
84 ALC260_TEST,
85 #endif
86 ALC260_AUTO,
87 ALC260_MODEL_LAST /* last tag */
88 };
89
90 /* ALC262 models */
91 enum {
92 ALC262_BASIC,
93 ALC262_HIPPO,
94 ALC262_HIPPO_1,
95 ALC262_FUJITSU,
96 ALC262_HP_BPC,
97 ALC262_HP_BPC_D7000_WL,
98 ALC262_HP_BPC_D7000_WF,
99 ALC262_HP_TC_T5735,
100 ALC262_HP_RP5700,
101 ALC262_BENQ_ED8,
102 ALC262_SONY_ASSAMD,
103 ALC262_BENQ_T31,
104 ALC262_ULTRA,
105 ALC262_LENOVO_3000,
106 ALC262_NEC,
107 ALC262_TOSHIBA_S06,
108 ALC262_TOSHIBA_RX1,
109 ALC262_TYAN,
110 ALC262_AUTO,
111 ALC262_MODEL_LAST /* last tag */
112 };
113
114 /* ALC268 models */
115 enum {
116 ALC267_QUANTA_IL1,
117 ALC268_3ST,
118 ALC268_TOSHIBA,
119 ALC268_ACER,
120 ALC268_ACER_DMIC,
121 ALC268_ACER_ASPIRE_ONE,
122 ALC268_DELL,
123 ALC268_ZEPTO,
124 #ifdef CONFIG_SND_DEBUG
125 ALC268_TEST,
126 #endif
127 ALC268_AUTO,
128 ALC268_MODEL_LAST /* last tag */
129 };
130
131 /* ALC269 models */
132 enum {
133 ALC269_BASIC,
134 ALC269_QUANTA_FL1,
135 ALC269_AMIC,
136 ALC269_DMIC,
137 ALC269VB_AMIC,
138 ALC269VB_DMIC,
139 ALC269_FUJITSU,
140 ALC269_LIFEBOOK,
141 ALC271_ACER,
142 ALC269_AUTO,
143 ALC269_MODEL_LAST /* last tag */
144 };
145
146 /* ALC861 models */
147 enum {
148 ALC861_3ST,
149 ALC660_3ST,
150 ALC861_3ST_DIG,
151 ALC861_6ST_DIG,
152 ALC861_UNIWILL_M31,
153 ALC861_TOSHIBA,
154 ALC861_ASUS,
155 ALC861_ASUS_LAPTOP,
156 ALC861_AUTO,
157 ALC861_MODEL_LAST,
158 };
159
160 /* ALC861-VD models */
161 enum {
162 ALC660VD_3ST,
163 ALC660VD_3ST_DIG,
164 ALC660VD_ASUS_V1S,
165 ALC861VD_3ST,
166 ALC861VD_3ST_DIG,
167 ALC861VD_6ST_DIG,
168 ALC861VD_LENOVO,
169 ALC861VD_DALLAS,
170 ALC861VD_HP,
171 ALC861VD_AUTO,
172 ALC861VD_MODEL_LAST,
173 };
174
175 /* ALC662 models */
176 enum {
177 ALC662_3ST_2ch_DIG,
178 ALC662_3ST_6ch_DIG,
179 ALC662_3ST_6ch,
180 ALC662_5ST_DIG,
181 ALC662_LENOVO_101E,
182 ALC662_ASUS_EEEPC_P701,
183 ALC662_ASUS_EEEPC_EP20,
184 ALC663_ASUS_M51VA,
185 ALC663_ASUS_G71V,
186 ALC663_ASUS_H13,
187 ALC663_ASUS_G50V,
188 ALC662_ECS,
189 ALC663_ASUS_MODE1,
190 ALC662_ASUS_MODE2,
191 ALC663_ASUS_MODE3,
192 ALC663_ASUS_MODE4,
193 ALC663_ASUS_MODE5,
194 ALC663_ASUS_MODE6,
195 ALC663_ASUS_MODE7,
196 ALC663_ASUS_MODE8,
197 ALC272_DELL,
198 ALC272_DELL_ZM1,
199 ALC272_SAMSUNG_NC10,
200 ALC662_AUTO,
201 ALC662_MODEL_LAST,
202 };
203
204 /* ALC882 models */
205 enum {
206 ALC882_3ST_DIG,
207 ALC882_6ST_DIG,
208 ALC882_ARIMA,
209 ALC882_W2JC,
210 ALC882_TARGA,
211 ALC882_ASUS_A7J,
212 ALC882_ASUS_A7M,
213 ALC885_MACPRO,
214 ALC885_MBA21,
215 ALC885_MBP3,
216 ALC885_MB5,
217 ALC885_MACMINI3,
218 ALC885_IMAC24,
219 ALC885_IMAC91,
220 ALC883_3ST_2ch_DIG,
221 ALC883_3ST_6ch_DIG,
222 ALC883_3ST_6ch,
223 ALC883_6ST_DIG,
224 ALC883_TARGA_DIG,
225 ALC883_TARGA_2ch_DIG,
226 ALC883_TARGA_8ch_DIG,
227 ALC883_ACER,
228 ALC883_ACER_ASPIRE,
229 ALC888_ACER_ASPIRE_4930G,
230 ALC888_ACER_ASPIRE_6530G,
231 ALC888_ACER_ASPIRE_8930G,
232 ALC888_ACER_ASPIRE_7730G,
233 ALC883_MEDION,
234 ALC883_MEDION_WIM2160,
235 ALC883_LAPTOP_EAPD,
236 ALC883_LENOVO_101E_2ch,
237 ALC883_LENOVO_NB0763,
238 ALC888_LENOVO_MS7195_DIG,
239 ALC888_LENOVO_SKY,
240 ALC883_HAIER_W66,
241 ALC888_3ST_HP,
242 ALC888_6ST_DELL,
243 ALC883_MITAC,
244 ALC883_CLEVO_M540R,
245 ALC883_CLEVO_M720,
246 ALC883_FUJITSU_PI2515,
247 ALC888_FUJITSU_XA3530,
248 ALC883_3ST_6ch_INTEL,
249 ALC889A_INTEL,
250 ALC889_INTEL,
251 ALC888_ASUS_M90V,
252 ALC888_ASUS_EEE1601,
253 ALC889A_MB31,
254 ALC1200_ASUS_P5Q,
255 ALC883_SONY_VAIO_TT,
256 ALC882_AUTO,
257 ALC882_MODEL_LAST,
258 };
259
260 /* ALC680 models */
261 enum {
262 ALC680_BASE,
263 ALC680_AUTO,
264 ALC680_MODEL_LAST,
265 };
266
267 /* for GPIO Poll */
268 #define GPIO_MASK 0x03
269
270 /* extra amp-initialization sequence types */
271 enum {
272 ALC_INIT_NONE,
273 ALC_INIT_DEFAULT,
274 ALC_INIT_GPIO1,
275 ALC_INIT_GPIO2,
276 ALC_INIT_GPIO3,
277 };
278
279 struct alc_mic_route {
280 hda_nid_t pin;
281 unsigned char mux_idx;
282 unsigned char amix_idx;
283 };
284
285 #define MUX_IDX_UNDEF ((unsigned char)-1)
286
287 struct alc_customize_define {
288 unsigned int sku_cfg;
289 unsigned char port_connectivity;
290 unsigned char check_sum;
291 unsigned char customization;
292 unsigned char external_amp;
293 unsigned int enable_pcbeep:1;
294 unsigned int platform_type:1;
295 unsigned int swap:1;
296 unsigned int override:1;
297 unsigned int fixup:1; /* Means that this sku is set by driver, not read from hw */
298 };
299
300 struct alc_fixup;
301
302 struct alc_multi_io {
303 hda_nid_t pin; /* multi-io widget pin NID */
304 hda_nid_t dac; /* DAC to be connected */
305 unsigned int ctl_in; /* cached input-pin control value */
306 };
307
308 enum {
309 ALC_AUTOMUTE_PIN, /* change the pin control */
310 ALC_AUTOMUTE_AMP, /* mute/unmute the pin AMP */
311 ALC_AUTOMUTE_MIXER, /* mute/unmute mixer widget AMP */
312 };
313
314 struct alc_spec {
315 /* codec parameterization */
316 const struct snd_kcontrol_new *mixers[5]; /* mixer arrays */
317 unsigned int num_mixers;
318 const struct snd_kcontrol_new *cap_mixer; /* capture mixer */
319 unsigned int beep_amp; /* beep amp value, set via set_beep_amp() */
320
321 const struct hda_verb *init_verbs[10]; /* initialization verbs
322 * don't forget NULL
323 * termination!
324 */
325 unsigned int num_init_verbs;
326
327 char stream_name_analog[32]; /* analog PCM stream */
328 const struct hda_pcm_stream *stream_analog_playback;
329 const struct hda_pcm_stream *stream_analog_capture;
330 const struct hda_pcm_stream *stream_analog_alt_playback;
331 const struct hda_pcm_stream *stream_analog_alt_capture;
332
333 char stream_name_digital[32]; /* digital PCM stream */
334 const struct hda_pcm_stream *stream_digital_playback;
335 const struct hda_pcm_stream *stream_digital_capture;
336
337 /* playback */
338 struct hda_multi_out multiout; /* playback set-up
339 * max_channels, dacs must be set
340 * dig_out_nid and hp_nid are optional
341 */
342 hda_nid_t alt_dac_nid;
343 hda_nid_t slave_dig_outs[3]; /* optional - for auto-parsing */
344 int dig_out_type;
345
346 /* capture */
347 unsigned int num_adc_nids;
348 const hda_nid_t *adc_nids;
349 const hda_nid_t *capsrc_nids;
350 hda_nid_t dig_in_nid; /* digital-in NID; optional */
351
352 /* capture setup for dynamic dual-adc switch */
353 unsigned int cur_adc_idx;
354 hda_nid_t cur_adc;
355 unsigned int cur_adc_stream_tag;
356 unsigned int cur_adc_format;
357
358 /* capture source */
359 unsigned int num_mux_defs;
360 const struct hda_input_mux *input_mux;
361 unsigned int cur_mux[3];
362 struct alc_mic_route ext_mic;
363 struct alc_mic_route dock_mic;
364 struct alc_mic_route int_mic;
365
366 /* channel model */
367 const struct hda_channel_mode *channel_mode;
368 int num_channel_mode;
369 int need_dac_fix;
370 int const_channel_count;
371 int ext_channel_count;
372
373 /* PCM information */
374 struct hda_pcm pcm_rec[3]; /* used in alc_build_pcms() */
375
376 /* dynamic controls, init_verbs and input_mux */
377 struct auto_pin_cfg autocfg;
378 struct alc_customize_define cdefine;
379 struct snd_array kctls;
380 struct hda_input_mux private_imux[3];
381 hda_nid_t private_dac_nids[AUTO_CFG_MAX_OUTS];
382 hda_nid_t private_adc_nids[AUTO_CFG_MAX_OUTS];
383 hda_nid_t private_capsrc_nids[AUTO_CFG_MAX_OUTS];
384
385 /* hooks */
386 void (*init_hook)(struct hda_codec *codec);
387 void (*unsol_event)(struct hda_codec *codec, unsigned int res);
388 #ifdef CONFIG_SND_HDA_POWER_SAVE
389 void (*power_hook)(struct hda_codec *codec);
390 #endif
391 void (*shutup)(struct hda_codec *codec);
392
393 /* for pin sensing */
394 unsigned int jack_present: 1;
395 unsigned int line_jack_present:1;
396 unsigned int master_mute:1;
397 unsigned int auto_mic:1;
398 unsigned int automute:1; /* HP automute enabled */
399 unsigned int detect_line:1; /* Line-out detection enabled */
400 unsigned int automute_lines:1; /* automute line-out as well */
401 unsigned int automute_hp_lo:1; /* both HP and LO available */
402
403 /* other flags */
404 unsigned int no_analog :1; /* digital I/O only */
405 unsigned int dual_adc_switch:1; /* switch ADCs (for ALC275) */
406 unsigned int single_input_src:1;
407
408 /* auto-mute control */
409 int automute_mode;
410 hda_nid_t automute_mixer_nid[AUTO_CFG_MAX_OUTS];
411
412 int init_amp;
413 int codec_variant; /* flag for other variants */
414
415 /* for virtual master */
416 hda_nid_t vmaster_nid;
417 #ifdef CONFIG_SND_HDA_POWER_SAVE
418 struct hda_loopback_check loopback;
419 #endif
420
421 /* for PLL fix */
422 hda_nid_t pll_nid;
423 unsigned int pll_coef_idx, pll_coef_bit;
424
425 /* fix-up list */
426 int fixup_id;
427 const struct alc_fixup *fixup_list;
428 const char *fixup_name;
429
430 /* multi-io */
431 int multi_ios;
432 struct alc_multi_io multi_io[4];
433 };
434
435 /*
436 * configuration template - to be copied to the spec instance
437 */
438 struct alc_config_preset {
439 const struct snd_kcontrol_new *mixers[5]; /* should be identical size
440 * with spec
441 */
442 const struct snd_kcontrol_new *cap_mixer; /* capture mixer */
443 const struct hda_verb *init_verbs[5];
444 unsigned int num_dacs;
445 const hda_nid_t *dac_nids;
446 hda_nid_t dig_out_nid; /* optional */
447 hda_nid_t hp_nid; /* optional */
448 const hda_nid_t *slave_dig_outs;
449 unsigned int num_adc_nids;
450 const hda_nid_t *adc_nids;
451 const hda_nid_t *capsrc_nids;
452 hda_nid_t dig_in_nid;
453 unsigned int num_channel_mode;
454 const struct hda_channel_mode *channel_mode;
455 int need_dac_fix;
456 int const_channel_count;
457 unsigned int num_mux_defs;
458 const struct hda_input_mux *input_mux;
459 void (*unsol_event)(struct hda_codec *, unsigned int);
460 void (*setup)(struct hda_codec *);
461 void (*init_hook)(struct hda_codec *);
462 #ifdef CONFIG_SND_HDA_POWER_SAVE
463 const struct hda_amp_list *loopbacks;
464 void (*power_hook)(struct hda_codec *codec);
465 #endif
466 };
467
468
469 /*
470 * input MUX handling
471 */
472 static int alc_mux_enum_info(struct snd_kcontrol *kcontrol,
473 struct snd_ctl_elem_info *uinfo)
474 {
475 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
476 struct alc_spec *spec = codec->spec;
477 unsigned int mux_idx = snd_ctl_get_ioffidx(kcontrol, &uinfo->id);
478 if (mux_idx >= spec->num_mux_defs)
479 mux_idx = 0;
480 if (!spec->input_mux[mux_idx].num_items && mux_idx > 0)
481 mux_idx = 0;
482 return snd_hda_input_mux_info(&spec->input_mux[mux_idx], uinfo);
483 }
484
485 static int alc_mux_enum_get(struct snd_kcontrol *kcontrol,
486 struct snd_ctl_elem_value *ucontrol)
487 {
488 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
489 struct alc_spec *spec = codec->spec;
490 unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
491
492 ucontrol->value.enumerated.item[0] = spec->cur_mux[adc_idx];
493 return 0;
494 }
495
496 static int alc_mux_enum_put(struct snd_kcontrol *kcontrol,
497 struct snd_ctl_elem_value *ucontrol)
498 {
499 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
500 struct alc_spec *spec = codec->spec;
501 const struct hda_input_mux *imux;
502 unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
503 unsigned int mux_idx;
504 hda_nid_t nid = spec->capsrc_nids ?
505 spec->capsrc_nids[adc_idx] : spec->adc_nids[adc_idx];
506 unsigned int type;
507
508 mux_idx = adc_idx >= spec->num_mux_defs ? 0 : adc_idx;
509 imux = &spec->input_mux[mux_idx];
510 if (!imux->num_items && mux_idx > 0)
511 imux = &spec->input_mux[0];
512
513 type = get_wcaps_type(get_wcaps(codec, nid));
514 if (type == AC_WID_AUD_MIX) {
515 /* Matrix-mixer style (e.g. ALC882) */
516 unsigned int *cur_val = &spec->cur_mux[adc_idx];
517 unsigned int i, idx;
518
519 idx = ucontrol->value.enumerated.item[0];
520 if (idx >= imux->num_items)
521 idx = imux->num_items - 1;
522 if (*cur_val == idx)
523 return 0;
524 for (i = 0; i < imux->num_items; i++) {
525 unsigned int v = (i == idx) ? 0 : HDA_AMP_MUTE;
526 snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT,
527 imux->items[i].index,
528 HDA_AMP_MUTE, v);
529 }
530 *cur_val = idx;
531 return 1;
532 } else {
533 /* MUX style (e.g. ALC880) */
534 return snd_hda_input_mux_put(codec, imux, ucontrol, nid,
535 &spec->cur_mux[adc_idx]);
536 }
537 }
538
539 /*
540 * channel mode setting
541 */
542 static int alc_ch_mode_info(struct snd_kcontrol *kcontrol,
543 struct snd_ctl_elem_info *uinfo)
544 {
545 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
546 struct alc_spec *spec = codec->spec;
547 return snd_hda_ch_mode_info(codec, uinfo, spec->channel_mode,
548 spec->num_channel_mode);
549 }
550
551 static int alc_ch_mode_get(struct snd_kcontrol *kcontrol,
552 struct snd_ctl_elem_value *ucontrol)
553 {
554 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
555 struct alc_spec *spec = codec->spec;
556 return snd_hda_ch_mode_get(codec, ucontrol, spec->channel_mode,
557 spec->num_channel_mode,
558 spec->ext_channel_count);
559 }
560
561 static int alc_ch_mode_put(struct snd_kcontrol *kcontrol,
562 struct snd_ctl_elem_value *ucontrol)
563 {
564 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
565 struct alc_spec *spec = codec->spec;
566 int err = snd_hda_ch_mode_put(codec, ucontrol, spec->channel_mode,
567 spec->num_channel_mode,
568 &spec->ext_channel_count);
569 if (err >= 0 && !spec->const_channel_count) {
570 spec->multiout.max_channels = spec->ext_channel_count;
571 if (spec->need_dac_fix)
572 spec->multiout.num_dacs = spec->multiout.max_channels / 2;
573 }
574 return err;
575 }
576
577 /*
578 * Control the mode of pin widget settings via the mixer. "pc" is used
579 * instead of "%" to avoid consequences of accidentally treating the % as
580 * being part of a format specifier. Maximum allowed length of a value is
581 * 63 characters plus NULL terminator.
582 *
583 * Note: some retasking pin complexes seem to ignore requests for input
584 * states other than HiZ (eg: PIN_VREFxx) and revert to HiZ if any of these
585 * are requested. Therefore order this list so that this behaviour will not
586 * cause problems when mixer clients move through the enum sequentially.
587 * NIDs 0x0f and 0x10 have been observed to have this behaviour as of
588 * March 2006.
589 */
590 static const char * const alc_pin_mode_names[] = {
591 "Mic 50pc bias", "Mic 80pc bias",
592 "Line in", "Line out", "Headphone out",
593 };
594 static const unsigned char alc_pin_mode_values[] = {
595 PIN_VREF50, PIN_VREF80, PIN_IN, PIN_OUT, PIN_HP,
596 };
597 /* The control can present all 5 options, or it can limit the options based
598 * in the pin being assumed to be exclusively an input or an output pin. In
599 * addition, "input" pins may or may not process the mic bias option
600 * depending on actual widget capability (NIDs 0x0f and 0x10 don't seem to
601 * accept requests for bias as of chip versions up to March 2006) and/or
602 * wiring in the computer.
603 */
604 #define ALC_PIN_DIR_IN 0x00
605 #define ALC_PIN_DIR_OUT 0x01
606 #define ALC_PIN_DIR_INOUT 0x02
607 #define ALC_PIN_DIR_IN_NOMICBIAS 0x03
608 #define ALC_PIN_DIR_INOUT_NOMICBIAS 0x04
609
610 /* Info about the pin modes supported by the different pin direction modes.
611 * For each direction the minimum and maximum values are given.
612 */
613 static const signed char alc_pin_mode_dir_info[5][2] = {
614 { 0, 2 }, /* ALC_PIN_DIR_IN */
615 { 3, 4 }, /* ALC_PIN_DIR_OUT */
616 { 0, 4 }, /* ALC_PIN_DIR_INOUT */
617 { 2, 2 }, /* ALC_PIN_DIR_IN_NOMICBIAS */
618 { 2, 4 }, /* ALC_PIN_DIR_INOUT_NOMICBIAS */
619 };
620 #define alc_pin_mode_min(_dir) (alc_pin_mode_dir_info[_dir][0])
621 #define alc_pin_mode_max(_dir) (alc_pin_mode_dir_info[_dir][1])
622 #define alc_pin_mode_n_items(_dir) \
623 (alc_pin_mode_max(_dir)-alc_pin_mode_min(_dir)+1)
624
625 static int alc_pin_mode_info(struct snd_kcontrol *kcontrol,
626 struct snd_ctl_elem_info *uinfo)
627 {
628 unsigned int item_num = uinfo->value.enumerated.item;
629 unsigned char dir = (kcontrol->private_value >> 16) & 0xff;
630
631 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
632 uinfo->count = 1;
633 uinfo->value.enumerated.items = alc_pin_mode_n_items(dir);
634
635 if (item_num<alc_pin_mode_min(dir) || item_num>alc_pin_mode_max(dir))
636 item_num = alc_pin_mode_min(dir);
637 strcpy(uinfo->value.enumerated.name, alc_pin_mode_names[item_num]);
638 return 0;
639 }
640
641 static int alc_pin_mode_get(struct snd_kcontrol *kcontrol,
642 struct snd_ctl_elem_value *ucontrol)
643 {
644 unsigned int i;
645 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
646 hda_nid_t nid = kcontrol->private_value & 0xffff;
647 unsigned char dir = (kcontrol->private_value >> 16) & 0xff;
648 long *valp = ucontrol->value.integer.value;
649 unsigned int pinctl = snd_hda_codec_read(codec, nid, 0,
650 AC_VERB_GET_PIN_WIDGET_CONTROL,
651 0x00);
652
653 /* Find enumerated value for current pinctl setting */
654 i = alc_pin_mode_min(dir);
655 while (i <= alc_pin_mode_max(dir) && alc_pin_mode_values[i] != pinctl)
656 i++;
657 *valp = i <= alc_pin_mode_max(dir) ? i: alc_pin_mode_min(dir);
658 return 0;
659 }
660
661 static int alc_pin_mode_put(struct snd_kcontrol *kcontrol,
662 struct snd_ctl_elem_value *ucontrol)
663 {
664 signed int change;
665 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
666 hda_nid_t nid = kcontrol->private_value & 0xffff;
667 unsigned char dir = (kcontrol->private_value >> 16) & 0xff;
668 long val = *ucontrol->value.integer.value;
669 unsigned int pinctl = snd_hda_codec_read(codec, nid, 0,
670 AC_VERB_GET_PIN_WIDGET_CONTROL,
671 0x00);
672
673 if (val < alc_pin_mode_min(dir) || val > alc_pin_mode_max(dir))
674 val = alc_pin_mode_min(dir);
675
676 change = pinctl != alc_pin_mode_values[val];
677 if (change) {
678 /* Set pin mode to that requested */
679 snd_hda_codec_write_cache(codec, nid, 0,
680 AC_VERB_SET_PIN_WIDGET_CONTROL,
681 alc_pin_mode_values[val]);
682
683 /* Also enable the retasking pin's input/output as required
684 * for the requested pin mode. Enum values of 2 or less are
685 * input modes.
686 *
687 * Dynamically switching the input/output buffers probably
688 * reduces noise slightly (particularly on input) so we'll
689 * do it. However, having both input and output buffers
690 * enabled simultaneously doesn't seem to be problematic if
691 * this turns out to be necessary in the future.
692 */
693 if (val <= 2) {
694 snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
695 HDA_AMP_MUTE, HDA_AMP_MUTE);
696 snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT, 0,
697 HDA_AMP_MUTE, 0);
698 } else {
699 snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT, 0,
700 HDA_AMP_MUTE, HDA_AMP_MUTE);
701 snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
702 HDA_AMP_MUTE, 0);
703 }
704 }
705 return change;
706 }
707
708 #define ALC_PIN_MODE(xname, nid, dir) \
709 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0, \
710 .subdevice = HDA_SUBDEV_NID_FLAG | nid, \
711 .info = alc_pin_mode_info, \
712 .get = alc_pin_mode_get, \
713 .put = alc_pin_mode_put, \
714 .private_value = nid | (dir<<16) }
715
716 /* A switch control for ALC260 GPIO pins. Multiple GPIOs can be ganged
717 * together using a mask with more than one bit set. This control is
718 * currently used only by the ALC260 test model. At this stage they are not
719 * needed for any "production" models.
720 */
721 #ifdef CONFIG_SND_DEBUG
722 #define alc_gpio_data_info snd_ctl_boolean_mono_info
723
724 static int alc_gpio_data_get(struct snd_kcontrol *kcontrol,
725 struct snd_ctl_elem_value *ucontrol)
726 {
727 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
728 hda_nid_t nid = kcontrol->private_value & 0xffff;
729 unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
730 long *valp = ucontrol->value.integer.value;
731 unsigned int val = snd_hda_codec_read(codec, nid, 0,
732 AC_VERB_GET_GPIO_DATA, 0x00);
733
734 *valp = (val & mask) != 0;
735 return 0;
736 }
737 static int alc_gpio_data_put(struct snd_kcontrol *kcontrol,
738 struct snd_ctl_elem_value *ucontrol)
739 {
740 signed int change;
741 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
742 hda_nid_t nid = kcontrol->private_value & 0xffff;
743 unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
744 long val = *ucontrol->value.integer.value;
745 unsigned int gpio_data = snd_hda_codec_read(codec, nid, 0,
746 AC_VERB_GET_GPIO_DATA,
747 0x00);
748
749 /* Set/unset the masked GPIO bit(s) as needed */
750 change = (val == 0 ? 0 : mask) != (gpio_data & mask);
751 if (val == 0)
752 gpio_data &= ~mask;
753 else
754 gpio_data |= mask;
755 snd_hda_codec_write_cache(codec, nid, 0,
756 AC_VERB_SET_GPIO_DATA, gpio_data);
757
758 return change;
759 }
760 #define ALC_GPIO_DATA_SWITCH(xname, nid, mask) \
761 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0, \
762 .subdevice = HDA_SUBDEV_NID_FLAG | nid, \
763 .info = alc_gpio_data_info, \
764 .get = alc_gpio_data_get, \
765 .put = alc_gpio_data_put, \
766 .private_value = nid | (mask<<16) }
767 #endif /* CONFIG_SND_DEBUG */
768
769 /* A switch control to allow the enabling of the digital IO pins on the
770 * ALC260. This is incredibly simplistic; the intention of this control is
771 * to provide something in the test model allowing digital outputs to be
772 * identified if present. If models are found which can utilise these
773 * outputs a more complete mixer control can be devised for those models if
774 * necessary.
775 */
776 #ifdef CONFIG_SND_DEBUG
777 #define alc_spdif_ctrl_info snd_ctl_boolean_mono_info
778
779 static int alc_spdif_ctrl_get(struct snd_kcontrol *kcontrol,
780 struct snd_ctl_elem_value *ucontrol)
781 {
782 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
783 hda_nid_t nid = kcontrol->private_value & 0xffff;
784 unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
785 long *valp = ucontrol->value.integer.value;
786 unsigned int val = snd_hda_codec_read(codec, nid, 0,
787 AC_VERB_GET_DIGI_CONVERT_1, 0x00);
788
789 *valp = (val & mask) != 0;
790 return 0;
791 }
792 static int alc_spdif_ctrl_put(struct snd_kcontrol *kcontrol,
793 struct snd_ctl_elem_value *ucontrol)
794 {
795 signed int change;
796 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
797 hda_nid_t nid = kcontrol->private_value & 0xffff;
798 unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
799 long val = *ucontrol->value.integer.value;
800 unsigned int ctrl_data = snd_hda_codec_read(codec, nid, 0,
801 AC_VERB_GET_DIGI_CONVERT_1,
802 0x00);
803
804 /* Set/unset the masked control bit(s) as needed */
805 change = (val == 0 ? 0 : mask) != (ctrl_data & mask);
806 if (val==0)
807 ctrl_data &= ~mask;
808 else
809 ctrl_data |= mask;
810 snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_DIGI_CONVERT_1,
811 ctrl_data);
812
813 return change;
814 }
815 #define ALC_SPDIF_CTRL_SWITCH(xname, nid, mask) \
816 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0, \
817 .subdevice = HDA_SUBDEV_NID_FLAG | nid, \
818 .info = alc_spdif_ctrl_info, \
819 .get = alc_spdif_ctrl_get, \
820 .put = alc_spdif_ctrl_put, \
821 .private_value = nid | (mask<<16) }
822 #endif /* CONFIG_SND_DEBUG */
823
824 /* A switch control to allow the enabling EAPD digital outputs on the ALC26x.
825 * Again, this is only used in the ALC26x test models to help identify when
826 * the EAPD line must be asserted for features to work.
827 */
828 #ifdef CONFIG_SND_DEBUG
829 #define alc_eapd_ctrl_info snd_ctl_boolean_mono_info
830
831 static int alc_eapd_ctrl_get(struct snd_kcontrol *kcontrol,
832 struct snd_ctl_elem_value *ucontrol)
833 {
834 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
835 hda_nid_t nid = kcontrol->private_value & 0xffff;
836 unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
837 long *valp = ucontrol->value.integer.value;
838 unsigned int val = snd_hda_codec_read(codec, nid, 0,
839 AC_VERB_GET_EAPD_BTLENABLE, 0x00);
840
841 *valp = (val & mask) != 0;
842 return 0;
843 }
844
845 static int alc_eapd_ctrl_put(struct snd_kcontrol *kcontrol,
846 struct snd_ctl_elem_value *ucontrol)
847 {
848 int change;
849 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
850 hda_nid_t nid = kcontrol->private_value & 0xffff;
851 unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
852 long val = *ucontrol->value.integer.value;
853 unsigned int ctrl_data = snd_hda_codec_read(codec, nid, 0,
854 AC_VERB_GET_EAPD_BTLENABLE,
855 0x00);
856
857 /* Set/unset the masked control bit(s) as needed */
858 change = (!val ? 0 : mask) != (ctrl_data & mask);
859 if (!val)
860 ctrl_data &= ~mask;
861 else
862 ctrl_data |= mask;
863 snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_EAPD_BTLENABLE,
864 ctrl_data);
865
866 return change;
867 }
868
869 #define ALC_EAPD_CTRL_SWITCH(xname, nid, mask) \
870 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0, \
871 .subdevice = HDA_SUBDEV_NID_FLAG | nid, \
872 .info = alc_eapd_ctrl_info, \
873 .get = alc_eapd_ctrl_get, \
874 .put = alc_eapd_ctrl_put, \
875 .private_value = nid | (mask<<16) }
876 #endif /* CONFIG_SND_DEBUG */
877
878 /*
879 * set up the input pin config (depending on the given auto-pin type)
880 */
881 static void alc_set_input_pin(struct hda_codec *codec, hda_nid_t nid,
882 int auto_pin_type)
883 {
884 unsigned int val = PIN_IN;
885
886 if (auto_pin_type == AUTO_PIN_MIC) {
887 unsigned int pincap;
888 unsigned int oldval;
889 oldval = snd_hda_codec_read(codec, nid, 0,
890 AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
891 pincap = snd_hda_query_pin_caps(codec, nid);
892 pincap = (pincap & AC_PINCAP_VREF) >> AC_PINCAP_VREF_SHIFT;
893 /* if the default pin setup is vref50, we give it priority */
894 if ((pincap & AC_PINCAP_VREF_80) && oldval != PIN_VREF50)
895 val = PIN_VREF80;
896 else if (pincap & AC_PINCAP_VREF_50)
897 val = PIN_VREF50;
898 else if (pincap & AC_PINCAP_VREF_100)
899 val = PIN_VREF100;
900 else if (pincap & AC_PINCAP_VREF_GRD)
901 val = PIN_VREFGRD;
902 }
903 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, val);
904 }
905
906 static void alc_fixup_autocfg_pin_nums(struct hda_codec *codec)
907 {
908 struct alc_spec *spec = codec->spec;
909 struct auto_pin_cfg *cfg = &spec->autocfg;
910
911 if (!cfg->line_outs) {
912 while (cfg->line_outs < AUTO_CFG_MAX_OUTS &&
913 cfg->line_out_pins[cfg->line_outs])
914 cfg->line_outs++;
915 }
916 if (!cfg->speaker_outs) {
917 while (cfg->speaker_outs < AUTO_CFG_MAX_OUTS &&
918 cfg->speaker_pins[cfg->speaker_outs])
919 cfg->speaker_outs++;
920 }
921 if (!cfg->hp_outs) {
922 while (cfg->hp_outs < AUTO_CFG_MAX_OUTS &&
923 cfg->hp_pins[cfg->hp_outs])
924 cfg->hp_outs++;
925 }
926 }
927
928 /*
929 */
930 static void add_mixer(struct alc_spec *spec, const struct snd_kcontrol_new *mix)
931 {
932 if (snd_BUG_ON(spec->num_mixers >= ARRAY_SIZE(spec->mixers)))
933 return;
934 spec->mixers[spec->num_mixers++] = mix;
935 }
936
937 static void add_verb(struct alc_spec *spec, const struct hda_verb *verb)
938 {
939 if (snd_BUG_ON(spec->num_init_verbs >= ARRAY_SIZE(spec->init_verbs)))
940 return;
941 spec->init_verbs[spec->num_init_verbs++] = verb;
942 }
943
944 /*
945 * set up from the preset table
946 */
947 static void setup_preset(struct hda_codec *codec,
948 const struct alc_config_preset *preset)
949 {
950 struct alc_spec *spec = codec->spec;
951 int i;
952
953 for (i = 0; i < ARRAY_SIZE(preset->mixers) && preset->mixers[i]; i++)
954 add_mixer(spec, preset->mixers[i]);
955 spec->cap_mixer = preset->cap_mixer;
956 for (i = 0; i < ARRAY_SIZE(preset->init_verbs) && preset->init_verbs[i];
957 i++)
958 add_verb(spec, preset->init_verbs[i]);
959
960 spec->channel_mode = preset->channel_mode;
961 spec->num_channel_mode = preset->num_channel_mode;
962 spec->need_dac_fix = preset->need_dac_fix;
963 spec->const_channel_count = preset->const_channel_count;
964
965 if (preset->const_channel_count)
966 spec->multiout.max_channels = preset->const_channel_count;
967 else
968 spec->multiout.max_channels = spec->channel_mode[0].channels;
969 spec->ext_channel_count = spec->channel_mode[0].channels;
970
971 spec->multiout.num_dacs = preset->num_dacs;
972 spec->multiout.dac_nids = preset->dac_nids;
973 spec->multiout.dig_out_nid = preset->dig_out_nid;
974 spec->multiout.slave_dig_outs = preset->slave_dig_outs;
975 spec->multiout.hp_nid = preset->hp_nid;
976
977 spec->num_mux_defs = preset->num_mux_defs;
978 if (!spec->num_mux_defs)
979 spec->num_mux_defs = 1;
980 spec->input_mux = preset->input_mux;
981
982 spec->num_adc_nids = preset->num_adc_nids;
983 spec->adc_nids = preset->adc_nids;
984 spec->capsrc_nids = preset->capsrc_nids;
985 spec->dig_in_nid = preset->dig_in_nid;
986
987 spec->unsol_event = preset->unsol_event;
988 spec->init_hook = preset->init_hook;
989 #ifdef CONFIG_SND_HDA_POWER_SAVE
990 spec->power_hook = preset->power_hook;
991 spec->loopback.amplist = preset->loopbacks;
992 #endif
993
994 if (preset->setup)
995 preset->setup(codec);
996
997 alc_fixup_autocfg_pin_nums(codec);
998 }
999
1000 /* Enable GPIO mask and set output */
1001 static const struct hda_verb alc_gpio1_init_verbs[] = {
1002 {0x01, AC_VERB_SET_GPIO_MASK, 0x01},
1003 {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
1004 {0x01, AC_VERB_SET_GPIO_DATA, 0x01},
1005 { }
1006 };
1007
1008 static const struct hda_verb alc_gpio2_init_verbs[] = {
1009 {0x01, AC_VERB_SET_GPIO_MASK, 0x02},
1010 {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x02},
1011 {0x01, AC_VERB_SET_GPIO_DATA, 0x02},
1012 { }
1013 };
1014
1015 static const struct hda_verb alc_gpio3_init_verbs[] = {
1016 {0x01, AC_VERB_SET_GPIO_MASK, 0x03},
1017 {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x03},
1018 {0x01, AC_VERB_SET_GPIO_DATA, 0x03},
1019 { }
1020 };
1021
1022 /*
1023 * Fix hardware PLL issue
1024 * On some codecs, the analog PLL gating control must be off while
1025 * the default value is 1.
1026 */
1027 static void alc_fix_pll(struct hda_codec *codec)
1028 {
1029 struct alc_spec *spec = codec->spec;
1030 unsigned int val;
1031
1032 if (!spec->pll_nid)
1033 return;
1034 snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_COEF_INDEX,
1035 spec->pll_coef_idx);
1036 val = snd_hda_codec_read(codec, spec->pll_nid, 0,
1037 AC_VERB_GET_PROC_COEF, 0);
1038 snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_COEF_INDEX,
1039 spec->pll_coef_idx);
1040 snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_PROC_COEF,
1041 val & ~(1 << spec->pll_coef_bit));
1042 }
1043
1044 static void alc_fix_pll_init(struct hda_codec *codec, hda_nid_t nid,
1045 unsigned int coef_idx, unsigned int coef_bit)
1046 {
1047 struct alc_spec *spec = codec->spec;
1048 spec->pll_nid = nid;
1049 spec->pll_coef_idx = coef_idx;
1050 spec->pll_coef_bit = coef_bit;
1051 alc_fix_pll(codec);
1052 }
1053
1054 static int alc_init_jacks(struct hda_codec *codec)
1055 {
1056 #ifdef CONFIG_SND_HDA_INPUT_JACK
1057 struct alc_spec *spec = codec->spec;
1058 int err;
1059 unsigned int hp_nid = spec->autocfg.hp_pins[0];
1060 unsigned int mic_nid = spec->ext_mic.pin;
1061 unsigned int dock_nid = spec->dock_mic.pin;
1062
1063 if (hp_nid) {
1064 err = snd_hda_input_jack_add(codec, hp_nid,
1065 SND_JACK_HEADPHONE, NULL);
1066 if (err < 0)
1067 return err;
1068 snd_hda_input_jack_report(codec, hp_nid);
1069 }
1070
1071 if (mic_nid) {
1072 err = snd_hda_input_jack_add(codec, mic_nid,
1073 SND_JACK_MICROPHONE, NULL);
1074 if (err < 0)
1075 return err;
1076 snd_hda_input_jack_report(codec, mic_nid);
1077 }
1078 if (dock_nid) {
1079 err = snd_hda_input_jack_add(codec, dock_nid,
1080 SND_JACK_MICROPHONE, NULL);
1081 if (err < 0)
1082 return err;
1083 snd_hda_input_jack_report(codec, dock_nid);
1084 }
1085 #endif /* CONFIG_SND_HDA_INPUT_JACK */
1086 return 0;
1087 }
1088
1089 static int detect_jacks(struct hda_codec *codec, int num_pins, hda_nid_t *pins)
1090 {
1091 int i, present = 0;
1092
1093 for (i = 0; i < num_pins; i++) {
1094 hda_nid_t nid = pins[i];
1095 if (!nid)
1096 break;
1097 snd_hda_input_jack_report(codec, nid);
1098 present |= snd_hda_jack_detect(codec, nid);
1099 }
1100 return present;
1101 }
1102
1103 static void do_automute(struct hda_codec *codec, int num_pins, hda_nid_t *pins,
1104 bool mute, bool hp_out)
1105 {
1106 struct alc_spec *spec = codec->spec;
1107 unsigned int mute_bits = mute ? HDA_AMP_MUTE : 0;
1108 unsigned int pin_bits = mute ? 0 : (hp_out ? PIN_HP : PIN_OUT);
1109 int i;
1110
1111 for (i = 0; i < num_pins; i++) {
1112 hda_nid_t nid = pins[i];
1113 if (!nid)
1114 break;
1115 switch (spec->automute_mode) {
1116 case ALC_AUTOMUTE_PIN:
1117 snd_hda_codec_write(codec, nid, 0,
1118 AC_VERB_SET_PIN_WIDGET_CONTROL,
1119 pin_bits);
1120 break;
1121 case ALC_AUTOMUTE_AMP:
1122 snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
1123 HDA_AMP_MUTE, mute_bits);
1124 break;
1125 case ALC_AUTOMUTE_MIXER:
1126 nid = spec->automute_mixer_nid[i];
1127 if (!nid)
1128 break;
1129 snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT, 0,
1130 HDA_AMP_MUTE, mute_bits);
1131 snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT, 1,
1132 HDA_AMP_MUTE, mute_bits);
1133 break;
1134 }
1135 }
1136 }
1137
1138 /* Toggle internal speakers muting */
1139 static void update_speakers(struct hda_codec *codec)
1140 {
1141 struct alc_spec *spec = codec->spec;
1142 int on;
1143
1144 /* Control HP pins/amps depending on master_mute state;
1145 * in general, HP pins/amps control should be enabled in all cases,
1146 * but currently set only for master_mute, just to be safe
1147 */
1148 do_automute(codec, ARRAY_SIZE(spec->autocfg.hp_pins),
1149 spec->autocfg.hp_pins, spec->master_mute, true);
1150
1151 if (!spec->automute)
1152 on = 0;
1153 else
1154 on = spec->jack_present | spec->line_jack_present;
1155 on |= spec->master_mute;
1156 do_automute(codec, ARRAY_SIZE(spec->autocfg.speaker_pins),
1157 spec->autocfg.speaker_pins, on, false);
1158
1159 /* toggle line-out mutes if needed, too */
1160 /* if LO is a copy of either HP or Speaker, don't need to handle it */
1161 if (spec->autocfg.line_out_pins[0] == spec->autocfg.hp_pins[0] ||
1162 spec->autocfg.line_out_pins[0] == spec->autocfg.speaker_pins[0])
1163 return;
1164 if (!spec->automute_lines || !spec->automute)
1165 on = 0;
1166 else
1167 on = spec->jack_present;
1168 on |= spec->master_mute;
1169 do_automute(codec, ARRAY_SIZE(spec->autocfg.line_out_pins),
1170 spec->autocfg.line_out_pins, on, false);
1171 }
1172
1173 static void alc_hp_automute(struct hda_codec *codec)
1174 {
1175 struct alc_spec *spec = codec->spec;
1176
1177 if (!spec->automute)
1178 return;
1179 spec->jack_present =
1180 detect_jacks(codec, ARRAY_SIZE(spec->autocfg.hp_pins),
1181 spec->autocfg.hp_pins);
1182 update_speakers(codec);
1183 }
1184
1185 static void alc_line_automute(struct hda_codec *codec)
1186 {
1187 struct alc_spec *spec = codec->spec;
1188
1189 if (!spec->automute || !spec->detect_line)
1190 return;
1191 spec->line_jack_present =
1192 detect_jacks(codec, ARRAY_SIZE(spec->autocfg.line_out_pins),
1193 spec->autocfg.line_out_pins);
1194 update_speakers(codec);
1195 }
1196
1197 static int get_connection_index(struct hda_codec *codec, hda_nid_t mux,
1198 hda_nid_t nid)
1199 {
1200 hda_nid_t conn[HDA_MAX_NUM_INPUTS];
1201 int i, nums;
1202
1203 nums = snd_hda_get_connections(codec, mux, conn, ARRAY_SIZE(conn));
1204 for (i = 0; i < nums; i++)
1205 if (conn[i] == nid)
1206 return i;
1207 return -1;
1208 }
1209
1210 /* switch the current ADC according to the jack state */
1211 static void alc_dual_mic_adc_auto_switch(struct hda_codec *codec)
1212 {
1213 struct alc_spec *spec = codec->spec;
1214 unsigned int present;
1215 hda_nid_t new_adc;
1216
1217 present = snd_hda_jack_detect(codec, spec->ext_mic.pin);
1218 if (present)
1219 spec->cur_adc_idx = 1;
1220 else
1221 spec->cur_adc_idx = 0;
1222 new_adc = spec->adc_nids[spec->cur_adc_idx];
1223 if (spec->cur_adc && spec->cur_adc != new_adc) {
1224 /* stream is running, let's swap the current ADC */
1225 __snd_hda_codec_cleanup_stream(codec, spec->cur_adc, 1);
1226 spec->cur_adc = new_adc;
1227 snd_hda_codec_setup_stream(codec, new_adc,
1228 spec->cur_adc_stream_tag, 0,
1229 spec->cur_adc_format);
1230 }
1231 }
1232
1233 static void alc_mic_automute(struct hda_codec *codec)
1234 {
1235 struct alc_spec *spec = codec->spec;
1236 struct alc_mic_route *dead1, *dead2, *alive;
1237 unsigned int present, type;
1238 hda_nid_t cap_nid;
1239
1240 if (!spec->auto_mic)
1241 return;
1242 if (!spec->int_mic.pin || !spec->ext_mic.pin)
1243 return;
1244 if (snd_BUG_ON(!spec->adc_nids))
1245 return;
1246
1247 if (spec->dual_adc_switch) {
1248 alc_dual_mic_adc_auto_switch(codec);
1249 return;
1250 }
1251
1252 cap_nid = spec->capsrc_nids ? spec->capsrc_nids[0] : spec->adc_nids[0];
1253
1254 alive = &spec->int_mic;
1255 dead1 = &spec->ext_mic;
1256 dead2 = &spec->dock_mic;
1257
1258 present = snd_hda_jack_detect(codec, spec->ext_mic.pin);
1259 if (present) {
1260 alive = &spec->ext_mic;
1261 dead1 = &spec->int_mic;
1262 dead2 = &spec->dock_mic;
1263 }
1264 if (!present && spec->dock_mic.pin > 0) {
1265 present = snd_hda_jack_detect(codec, spec->dock_mic.pin);
1266 if (present) {
1267 alive = &spec->dock_mic;
1268 dead1 = &spec->int_mic;
1269 dead2 = &spec->ext_mic;
1270 }
1271 snd_hda_input_jack_report(codec, spec->dock_mic.pin);
1272 }
1273
1274 type = get_wcaps_type(get_wcaps(codec, cap_nid));
1275 if (type == AC_WID_AUD_MIX) {
1276 /* Matrix-mixer style (e.g. ALC882) */
1277 snd_hda_codec_amp_stereo(codec, cap_nid, HDA_INPUT,
1278 alive->mux_idx,
1279 HDA_AMP_MUTE, 0);
1280 if (dead1->pin > 0)
1281 snd_hda_codec_amp_stereo(codec, cap_nid, HDA_INPUT,
1282 dead1->mux_idx,
1283 HDA_AMP_MUTE, HDA_AMP_MUTE);
1284 if (dead2->pin > 0)
1285 snd_hda_codec_amp_stereo(codec, cap_nid, HDA_INPUT,
1286 dead2->mux_idx,
1287 HDA_AMP_MUTE, HDA_AMP_MUTE);
1288 } else {
1289 /* MUX style (e.g. ALC880) */
1290 snd_hda_codec_write_cache(codec, cap_nid, 0,
1291 AC_VERB_SET_CONNECT_SEL,
1292 alive->mux_idx);
1293 }
1294 snd_hda_input_jack_report(codec, spec->ext_mic.pin);
1295
1296 /* FIXME: analog mixer */
1297 }
1298
1299 /* unsolicited event for HP jack sensing */
1300 static void alc_sku_unsol_event(struct hda_codec *codec, unsigned int res)
1301 {
1302 if (codec->vendor_id == 0x10ec0880)
1303 res >>= 28;
1304 else
1305 res >>= 26;
1306 switch (res) {
1307 case ALC880_HP_EVENT:
1308 alc_hp_automute(codec);
1309 break;
1310 case ALC880_FRONT_EVENT:
1311 alc_line_automute(codec);
1312 break;
1313 case ALC880_MIC_EVENT:
1314 alc_mic_automute(codec);
1315 break;
1316 }
1317 }
1318
1319 static void alc_inithook(struct hda_codec *codec)
1320 {
1321 alc_hp_automute(codec);
1322 alc_line_automute(codec);
1323 alc_mic_automute(codec);
1324 }
1325
1326 /* additional initialization for ALC888 variants */
1327 static void alc888_coef_init(struct hda_codec *codec)
1328 {
1329 unsigned int tmp;
1330
1331 snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 0);
1332 tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0);
1333 snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 7);
1334 if ((tmp & 0xf0) == 0x20)
1335 /* alc888S-VC */
1336 snd_hda_codec_read(codec, 0x20, 0,
1337 AC_VERB_SET_PROC_COEF, 0x830);
1338 else
1339 /* alc888-VB */
1340 snd_hda_codec_read(codec, 0x20, 0,
1341 AC_VERB_SET_PROC_COEF, 0x3030);
1342 }
1343
1344 static void alc889_coef_init(struct hda_codec *codec)
1345 {
1346 unsigned int tmp;
1347
1348 snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 7);
1349 tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0);
1350 snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 7);
1351 snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_PROC_COEF, tmp|0x2010);
1352 }
1353
1354 /* turn on/off EAPD control (only if available) */
1355 static void set_eapd(struct hda_codec *codec, hda_nid_t nid, int on)
1356 {
1357 if (get_wcaps_type(get_wcaps(codec, nid)) != AC_WID_PIN)
1358 return;
1359 if (snd_hda_query_pin_caps(codec, nid) & AC_PINCAP_EAPD)
1360 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_EAPD_BTLENABLE,
1361 on ? 2 : 0);
1362 }
1363
1364 /* turn on/off EAPD controls of the codec */
1365 static void alc_auto_setup_eapd(struct hda_codec *codec, bool on)
1366 {
1367 /* We currently only handle front, HP */
1368 switch (codec->vendor_id) {
1369 case 0x10ec0260:
1370 set_eapd(codec, 0x0f, on);
1371 set_eapd(codec, 0x10, on);
1372 break;
1373 case 0x10ec0262:
1374 case 0x10ec0267:
1375 case 0x10ec0268:
1376 case 0x10ec0269:
1377 case 0x10ec0270:
1378 case 0x10ec0272:
1379 case 0x10ec0660:
1380 case 0x10ec0662:
1381 case 0x10ec0663:
1382 case 0x10ec0665:
1383 case 0x10ec0862:
1384 case 0x10ec0889:
1385 case 0x10ec0892:
1386 set_eapd(codec, 0x14, on);
1387 set_eapd(codec, 0x15, on);
1388 break;
1389 }
1390 }
1391
1392 /* generic shutup callback;
1393 * just turning off EPAD and a little pause for avoiding pop-noise
1394 */
1395 static void alc_eapd_shutup(struct hda_codec *codec)
1396 {
1397 alc_auto_setup_eapd(codec, false);
1398 msleep(200);
1399 }
1400
1401 static void alc_auto_init_amp(struct hda_codec *codec, int type)
1402 {
1403 unsigned int tmp;
1404
1405 switch (type) {
1406 case ALC_INIT_GPIO1:
1407 snd_hda_sequence_write(codec, alc_gpio1_init_verbs);
1408 break;
1409 case ALC_INIT_GPIO2:
1410 snd_hda_sequence_write(codec, alc_gpio2_init_verbs);
1411 break;
1412 case ALC_INIT_GPIO3:
1413 snd_hda_sequence_write(codec, alc_gpio3_init_verbs);
1414 break;
1415 case ALC_INIT_DEFAULT:
1416 alc_auto_setup_eapd(codec, true);
1417 switch (codec->vendor_id) {
1418 case 0x10ec0260:
1419 snd_hda_codec_write(codec, 0x1a, 0,
1420 AC_VERB_SET_COEF_INDEX, 7);
1421 tmp = snd_hda_codec_read(codec, 0x1a, 0,
1422 AC_VERB_GET_PROC_COEF, 0);
1423 snd_hda_codec_write(codec, 0x1a, 0,
1424 AC_VERB_SET_COEF_INDEX, 7);
1425 snd_hda_codec_write(codec, 0x1a, 0,
1426 AC_VERB_SET_PROC_COEF,
1427 tmp | 0x2010);
1428 break;
1429 case 0x10ec0262:
1430 case 0x10ec0880:
1431 case 0x10ec0882:
1432 case 0x10ec0883:
1433 case 0x10ec0885:
1434 case 0x10ec0887:
1435 /*case 0x10ec0889:*/ /* this causes an SPDIF problem */
1436 alc889_coef_init(codec);
1437 break;
1438 case 0x10ec0888:
1439 alc888_coef_init(codec);
1440 break;
1441 #if 0 /* XXX: This may cause the silent output on speaker on some machines */
1442 case 0x10ec0267:
1443 case 0x10ec0268:
1444 snd_hda_codec_write(codec, 0x20, 0,
1445 AC_VERB_SET_COEF_INDEX, 7);
1446 tmp = snd_hda_codec_read(codec, 0x20, 0,
1447 AC_VERB_GET_PROC_COEF, 0);
1448 snd_hda_codec_write(codec, 0x20, 0,
1449 AC_VERB_SET_COEF_INDEX, 7);
1450 snd_hda_codec_write(codec, 0x20, 0,
1451 AC_VERB_SET_PROC_COEF,
1452 tmp | 0x3000);
1453 break;
1454 #endif /* XXX */
1455 }
1456 break;
1457 }
1458 }
1459
1460 static int alc_automute_mode_info(struct snd_kcontrol *kcontrol,
1461 struct snd_ctl_elem_info *uinfo)
1462 {
1463 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1464 struct alc_spec *spec = codec->spec;
1465 static const char * const texts2[] = {
1466 "Disabled", "Enabled"
1467 };
1468 static const char * const texts3[] = {
1469 "Disabled", "Speaker Only", "Line-Out+Speaker"
1470 };
1471 const char * const *texts;
1472
1473 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
1474 uinfo->count = 1;
1475 if (spec->automute_hp_lo) {
1476 uinfo->value.enumerated.items = 3;
1477 texts = texts3;
1478 } else {
1479 uinfo->value.enumerated.items = 2;
1480 texts = texts2;
1481 }
1482 if (uinfo->value.enumerated.item >= uinfo->value.enumerated.items)
1483 uinfo->value.enumerated.item = uinfo->value.enumerated.items - 1;
1484 strcpy(uinfo->value.enumerated.name,
1485 texts[uinfo->value.enumerated.item]);
1486 return 0;
1487 }
1488
1489 static int alc_automute_mode_get(struct snd_kcontrol *kcontrol,
1490 struct snd_ctl_elem_value *ucontrol)
1491 {
1492 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1493 struct alc_spec *spec = codec->spec;
1494 unsigned int val;
1495 if (!spec->automute)
1496 val = 0;
1497 else if (!spec->automute_lines)
1498 val = 1;
1499 else
1500 val = 2;
1501 ucontrol->value.enumerated.item[0] = val;
1502 return 0;
1503 }
1504
1505 static int alc_automute_mode_put(struct snd_kcontrol *kcontrol,
1506 struct snd_ctl_elem_value *ucontrol)
1507 {
1508 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1509 struct alc_spec *spec = codec->spec;
1510
1511 switch (ucontrol->value.enumerated.item[0]) {
1512 case 0:
1513 if (!spec->automute)
1514 return 0;
1515 spec->automute = 0;
1516 break;
1517 case 1:
1518 if (spec->automute && !spec->automute_lines)
1519 return 0;
1520 spec->automute = 1;
1521 spec->automute_lines = 0;
1522 break;
1523 case 2:
1524 if (!spec->automute_hp_lo)
1525 return -EINVAL;
1526 if (spec->automute && spec->automute_lines)
1527 return 0;
1528 spec->automute = 1;
1529 spec->automute_lines = 1;
1530 break;
1531 default:
1532 return -EINVAL;
1533 }
1534 update_speakers(codec);
1535 return 1;
1536 }
1537
1538 static const struct snd_kcontrol_new alc_automute_mode_enum = {
1539 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1540 .name = "Auto-Mute Mode",
1541 .info = alc_automute_mode_info,
1542 .get = alc_automute_mode_get,
1543 .put = alc_automute_mode_put,
1544 };
1545
1546 static struct snd_kcontrol_new *alc_kcontrol_new(struct alc_spec *spec);
1547
1548 static int alc_add_automute_mode_enum(struct hda_codec *codec)
1549 {
1550 struct alc_spec *spec = codec->spec;
1551 struct snd_kcontrol_new *knew;
1552
1553 knew = alc_kcontrol_new(spec);
1554 if (!knew)
1555 return -ENOMEM;
1556 *knew = alc_automute_mode_enum;
1557 knew->name = kstrdup("Auto-Mute Mode", GFP_KERNEL);
1558 if (!knew->name)
1559 return -ENOMEM;
1560 return 0;
1561 }
1562
1563 static void alc_init_auto_hp(struct hda_codec *codec)
1564 {
1565 struct alc_spec *spec = codec->spec;
1566 struct auto_pin_cfg *cfg = &spec->autocfg;
1567 int present = 0;
1568 int i;
1569
1570 if (cfg->hp_pins[0])
1571 present++;
1572 if (cfg->line_out_pins[0])
1573 present++;
1574 if (cfg->speaker_pins[0])
1575 present++;
1576 if (present < 2) /* need two different output types */
1577 return;
1578 if (present == 3)
1579 spec->automute_hp_lo = 1; /* both HP and LO automute */
1580
1581 if (!cfg->speaker_pins[0]) {
1582 memcpy(cfg->speaker_pins, cfg->line_out_pins,
1583 sizeof(cfg->speaker_pins));
1584 cfg->speaker_outs = cfg->line_outs;
1585 }
1586
1587 if (!cfg->hp_pins[0]) {
1588 memcpy(cfg->hp_pins, cfg->line_out_pins,
1589 sizeof(cfg->hp_pins));
1590 cfg->hp_outs = cfg->line_outs;
1591 }
1592
1593 for (i = 0; i < cfg->hp_outs; i++) {
1594 hda_nid_t nid = cfg->hp_pins[i];
1595 if (!is_jack_detectable(codec, nid))
1596 continue;
1597 snd_printdd("realtek: Enable HP auto-muting on NID 0x%x\n",
1598 nid);
1599 snd_hda_codec_write_cache(codec, nid, 0,
1600 AC_VERB_SET_UNSOLICITED_ENABLE,
1601 AC_USRSP_EN | ALC880_HP_EVENT);
1602 spec->automute = 1;
1603 spec->automute_mode = ALC_AUTOMUTE_PIN;
1604 }
1605 if (spec->automute && cfg->line_out_pins[0] &&
1606 cfg->line_out_pins[0] != cfg->hp_pins[0] &&
1607 cfg->line_out_pins[0] != cfg->speaker_pins[0]) {
1608 for (i = 0; i < cfg->line_outs; i++) {
1609 hda_nid_t nid = cfg->line_out_pins[i];
1610 if (!is_jack_detectable(codec, nid))
1611 continue;
1612 snd_printdd("realtek: Enable Line-Out auto-muting "
1613 "on NID 0x%x\n", nid);
1614 snd_hda_codec_write_cache(codec, nid, 0,
1615 AC_VERB_SET_UNSOLICITED_ENABLE,
1616 AC_USRSP_EN | ALC880_FRONT_EVENT);
1617 spec->detect_line = 1;
1618 }
1619 spec->automute_lines = spec->detect_line;
1620 }
1621
1622 if (spec->automute) {
1623 /* create a control for automute mode */
1624 alc_add_automute_mode_enum(codec);
1625 spec->unsol_event = alc_sku_unsol_event;
1626 }
1627 }
1628
1629 static void alc_init_auto_mic(struct hda_codec *codec)
1630 {
1631 struct alc_spec *spec = codec->spec;
1632 struct auto_pin_cfg *cfg = &spec->autocfg;
1633 hda_nid_t fixed, ext, dock;
1634 int i;
1635
1636 fixed = ext = dock = 0;
1637 for (i = 0; i < cfg->num_inputs; i++) {
1638 hda_nid_t nid = cfg->inputs[i].pin;
1639 unsigned int defcfg;
1640 defcfg = snd_hda_codec_get_pincfg(codec, nid);
1641 switch (snd_hda_get_input_pin_attr(defcfg)) {
1642 case INPUT_PIN_ATTR_INT:
1643 if (fixed)
1644 return; /* already occupied */
1645 if (cfg->inputs[i].type != AUTO_PIN_MIC)
1646 return; /* invalid type */
1647 fixed = nid;
1648 break;
1649 case INPUT_PIN_ATTR_UNUSED:
1650 return; /* invalid entry */
1651 case INPUT_PIN_ATTR_DOCK:
1652 if (dock)
1653 return; /* already occupied */
1654 if (cfg->inputs[i].type > AUTO_PIN_LINE_IN)
1655 return; /* invalid type */
1656 dock = nid;
1657 break;
1658 default:
1659 if (ext)
1660 return; /* already occupied */
1661 if (cfg->inputs[i].type != AUTO_PIN_MIC)
1662 return; /* invalid type */
1663 ext = nid;
1664 break;
1665 }
1666 }
1667 if (!ext && dock) {
1668 ext = dock;
1669 dock = 0;
1670 }
1671 if (!ext || !fixed)
1672 return;
1673 if (!is_jack_detectable(codec, ext))
1674 return; /* no unsol support */
1675 if (dock && !is_jack_detectable(codec, dock))
1676 return; /* no unsol support */
1677 snd_printdd("realtek: Enable auto-mic switch on NID 0x%x/0x%x/0x%x\n",
1678 ext, fixed, dock);
1679 spec->ext_mic.pin = ext;
1680 spec->dock_mic.pin = dock;
1681 spec->int_mic.pin = fixed;
1682 spec->ext_mic.mux_idx = MUX_IDX_UNDEF; /* set later */
1683 spec->dock_mic.mux_idx = MUX_IDX_UNDEF; /* set later */
1684 spec->int_mic.mux_idx = MUX_IDX_UNDEF; /* set later */
1685 spec->auto_mic = 1;
1686 snd_hda_codec_write_cache(codec, spec->ext_mic.pin, 0,
1687 AC_VERB_SET_UNSOLICITED_ENABLE,
1688 AC_USRSP_EN | ALC880_MIC_EVENT);
1689 spec->unsol_event = alc_sku_unsol_event;
1690 }
1691
1692 /* Could be any non-zero and even value. When used as fixup, tells
1693 * the driver to ignore any present sku defines.
1694 */
1695 #define ALC_FIXUP_SKU_IGNORE (2)
1696
1697 static int alc_auto_parse_customize_define(struct hda_codec *codec)
1698 {
1699 unsigned int ass, tmp, i;
1700 unsigned nid = 0;
1701 struct alc_spec *spec = codec->spec;
1702
1703 spec->cdefine.enable_pcbeep = 1; /* assume always enabled */
1704
1705 if (spec->cdefine.fixup) {
1706 ass = spec->cdefine.sku_cfg;
1707 if (ass == ALC_FIXUP_SKU_IGNORE)
1708 return -1;
1709 goto do_sku;
1710 }
1711
1712 ass = codec->subsystem_id & 0xffff;
1713 if (ass != codec->bus->pci->subsystem_device && (ass & 1))
1714 goto do_sku;
1715
1716 nid = 0x1d;
1717 if (codec->vendor_id == 0x10ec0260)
1718 nid = 0x17;
1719 ass = snd_hda_codec_get_pincfg(codec, nid);
1720
1721 if (!(ass & 1)) {
1722 printk(KERN_INFO "hda_codec: %s: SKU not ready 0x%08x\n",
1723 codec->chip_name, ass);
1724 return -1;
1725 }
1726
1727 /* check sum */
1728 tmp = 0;
1729 for (i = 1; i < 16; i++) {
1730 if ((ass >> i) & 1)
1731 tmp++;
1732 }
1733 if (((ass >> 16) & 0xf) != tmp)
1734 return -1;
1735
1736 spec->cdefine.port_connectivity = ass >> 30;
1737 spec->cdefine.enable_pcbeep = (ass & 0x100000) >> 20;
1738 spec->cdefine.check_sum = (ass >> 16) & 0xf;
1739 spec->cdefine.customization = ass >> 8;
1740 do_sku:
1741 spec->cdefine.sku_cfg = ass;
1742 spec->cdefine.external_amp = (ass & 0x38) >> 3;
1743 spec->cdefine.platform_type = (ass & 0x4) >> 2;
1744 spec->cdefine.swap = (ass & 0x2) >> 1;
1745 spec->cdefine.override = ass & 0x1;
1746
1747 snd_printd("SKU: Nid=0x%x sku_cfg=0x%08x\n",
1748 nid, spec->cdefine.sku_cfg);
1749 snd_printd("SKU: port_connectivity=0x%x\n",
1750 spec->cdefine.port_connectivity);
1751 snd_printd("SKU: enable_pcbeep=0x%x\n", spec->cdefine.enable_pcbeep);
1752 snd_printd("SKU: check_sum=0x%08x\n", spec->cdefine.check_sum);
1753 snd_printd("SKU: customization=0x%08x\n", spec->cdefine.customization);
1754 snd_printd("SKU: external_amp=0x%x\n", spec->cdefine.external_amp);
1755 snd_printd("SKU: platform_type=0x%x\n", spec->cdefine.platform_type);
1756 snd_printd("SKU: swap=0x%x\n", spec->cdefine.swap);
1757 snd_printd("SKU: override=0x%x\n", spec->cdefine.override);
1758
1759 return 0;
1760 }
1761
1762 /* check subsystem ID and set up device-specific initialization;
1763 * return 1 if initialized, 0 if invalid SSID
1764 */
1765 /* 32-bit subsystem ID for BIOS loading in HD Audio codec.
1766 * 31 ~ 16 : Manufacture ID
1767 * 15 ~ 8 : SKU ID
1768 * 7 ~ 0 : Assembly ID
1769 * port-A --> pin 39/41, port-E --> pin 14/15, port-D --> pin 35/36
1770 */
1771 static int alc_subsystem_id(struct hda_codec *codec,
1772 hda_nid_t porta, hda_nid_t porte,
1773 hda_nid_t portd, hda_nid_t porti)
1774 {
1775 unsigned int ass, tmp, i;
1776 unsigned nid;
1777 struct alc_spec *spec = codec->spec;
1778
1779 if (spec->cdefine.fixup) {
1780 ass = spec->cdefine.sku_cfg;
1781 if (ass == ALC_FIXUP_SKU_IGNORE)
1782 return 0;
1783 goto do_sku;
1784 }
1785
1786 ass = codec->subsystem_id & 0xffff;
1787 if ((ass != codec->bus->pci->subsystem_device) && (ass & 1))
1788 goto do_sku;
1789
1790 /* invalid SSID, check the special NID pin defcfg instead */
1791 /*
1792 * 31~30 : port connectivity
1793 * 29~21 : reserve
1794 * 20 : PCBEEP input
1795 * 19~16 : Check sum (15:1)
1796 * 15~1 : Custom
1797 * 0 : override
1798 */
1799 nid = 0x1d;
1800 if (codec->vendor_id == 0x10ec0260)
1801 nid = 0x17;
1802 ass = snd_hda_codec_get_pincfg(codec, nid);
1803 snd_printd("realtek: No valid SSID, "
1804 "checking pincfg 0x%08x for NID 0x%x\n",
1805 ass, nid);
1806 if (!(ass & 1))
1807 return 0;
1808 if ((ass >> 30) != 1) /* no physical connection */
1809 return 0;
1810
1811 /* check sum */
1812 tmp = 0;
1813 for (i = 1; i < 16; i++) {
1814 if ((ass >> i) & 1)
1815 tmp++;
1816 }
1817 if (((ass >> 16) & 0xf) != tmp)
1818 return 0;
1819 do_sku:
1820 snd_printd("realtek: Enabling init ASM_ID=0x%04x CODEC_ID=%08x\n",
1821 ass & 0xffff, codec->vendor_id);
1822 /*
1823 * 0 : override
1824 * 1 : Swap Jack
1825 * 2 : 0 --> Desktop, 1 --> Laptop
1826 * 3~5 : External Amplifier control
1827 * 7~6 : Reserved
1828 */
1829 tmp = (ass & 0x38) >> 3; /* external Amp control */
1830 switch (tmp) {
1831 case 1:
1832 spec->init_amp = ALC_INIT_GPIO1;
1833 break;
1834 case 3:
1835 spec->init_amp = ALC_INIT_GPIO2;
1836 break;
1837 case 7:
1838 spec->init_amp = ALC_INIT_GPIO3;
1839 break;
1840 case 5:
1841 default:
1842 spec->init_amp = ALC_INIT_DEFAULT;
1843 break;
1844 }
1845
1846 /* is laptop or Desktop and enable the function "Mute internal speaker
1847 * when the external headphone out jack is plugged"
1848 */
1849 if (!(ass & 0x8000))
1850 return 1;
1851 /*
1852 * 10~8 : Jack location
1853 * 12~11: Headphone out -> 00: PortA, 01: PortE, 02: PortD, 03: Resvered
1854 * 14~13: Resvered
1855 * 15 : 1 --> enable the function "Mute internal speaker
1856 * when the external headphone out jack is plugged"
1857 */
1858 if (!spec->autocfg.hp_pins[0]) {
1859 hda_nid_t nid;
1860 tmp = (ass >> 11) & 0x3; /* HP to chassis */
1861 if (tmp == 0)
1862 nid = porta;
1863 else if (tmp == 1)
1864 nid = porte;
1865 else if (tmp == 2)
1866 nid = portd;
1867 else if (tmp == 3)
1868 nid = porti;
1869 else
1870 return 1;
1871 for (i = 0; i < spec->autocfg.line_outs; i++)
1872 if (spec->autocfg.line_out_pins[i] == nid)
1873 return 1;
1874 spec->autocfg.hp_pins[0] = nid;
1875 }
1876 return 1;
1877 }
1878
1879 static void alc_ssid_check(struct hda_codec *codec,
1880 hda_nid_t porta, hda_nid_t porte,
1881 hda_nid_t portd, hda_nid_t porti)
1882 {
1883 if (!alc_subsystem_id(codec, porta, porte, portd, porti)) {
1884 struct alc_spec *spec = codec->spec;
1885 snd_printd("realtek: "
1886 "Enable default setup for auto mode as fallback\n");
1887 spec->init_amp = ALC_INIT_DEFAULT;
1888 }
1889
1890 alc_init_auto_hp(codec);
1891 alc_init_auto_mic(codec);
1892 }
1893
1894 /*
1895 * Fix-up pin default configurations and add default verbs
1896 */
1897
1898 struct alc_pincfg {
1899 hda_nid_t nid;
1900 u32 val;
1901 };
1902
1903 struct alc_model_fixup {
1904 const int id;
1905 const char *name;
1906 };
1907
1908 struct alc_fixup {
1909 int type;
1910 bool chained;
1911 int chain_id;
1912 union {
1913 unsigned int sku;
1914 const struct alc_pincfg *pins;
1915 const struct hda_verb *verbs;
1916 void (*func)(struct hda_codec *codec,
1917 const struct alc_fixup *fix,
1918 int action);
1919 } v;
1920 };
1921
1922 enum {
1923 ALC_FIXUP_INVALID,
1924 ALC_FIXUP_SKU,
1925 ALC_FIXUP_PINS,
1926 ALC_FIXUP_VERBS,
1927 ALC_FIXUP_FUNC,
1928 };
1929
1930 enum {
1931 ALC_FIXUP_ACT_PRE_PROBE,
1932 ALC_FIXUP_ACT_PROBE,
1933 ALC_FIXUP_ACT_INIT,
1934 };
1935
1936 static void alc_apply_fixup(struct hda_codec *codec, int action)
1937 {
1938 struct alc_spec *spec = codec->spec;
1939 int id = spec->fixup_id;
1940 #ifdef CONFIG_SND_DEBUG_VERBOSE
1941 const char *modelname = spec->fixup_name;
1942 #endif
1943 int depth = 0;
1944
1945 if (!spec->fixup_list)
1946 return;
1947
1948 while (id >= 0) {
1949 const struct alc_fixup *fix = spec->fixup_list + id;
1950 const struct alc_pincfg *cfg;
1951
1952 switch (fix->type) {
1953 case ALC_FIXUP_SKU:
1954 if (action != ALC_FIXUP_ACT_PRE_PROBE || !fix->v.sku)
1955 break;;
1956 snd_printdd(KERN_INFO "hda_codec: %s: "
1957 "Apply sku override for %s\n",
1958 codec->chip_name, modelname);
1959 spec->cdefine.sku_cfg = fix->v.sku;
1960 spec->cdefine.fixup = 1;
1961 break;
1962 case ALC_FIXUP_PINS:
1963 cfg = fix->v.pins;
1964 if (action != ALC_FIXUP_ACT_PRE_PROBE || !cfg)
1965 break;
1966 snd_printdd(KERN_INFO "hda_codec: %s: "
1967 "Apply pincfg for %s\n",
1968 codec->chip_name, modelname);
1969 for (; cfg->nid; cfg++)
1970 snd_hda_codec_set_pincfg(codec, cfg->nid,
1971 cfg->val);
1972 break;
1973 case ALC_FIXUP_VERBS:
1974 if (action != ALC_FIXUP_ACT_PROBE || !fix->v.verbs)
1975 break;
1976 snd_printdd(KERN_INFO "hda_codec: %s: "
1977 "Apply fix-verbs for %s\n",
1978 codec->chip_name, modelname);
1979 add_verb(codec->spec, fix->v.verbs);
1980 break;
1981 case ALC_FIXUP_FUNC:
1982 if (!fix->v.func)
1983 break;
1984 snd_printdd(KERN_INFO "hda_codec: %s: "
1985 "Apply fix-func for %s\n",
1986 codec->chip_name, modelname);
1987 fix->v.func(codec, fix, action);
1988 break;
1989 default:
1990 snd_printk(KERN_ERR "hda_codec: %s: "
1991 "Invalid fixup type %d\n",
1992 codec->chip_name, fix->type);
1993 break;
1994 }
1995 if (!fix->chained)
1996 break;
1997 if (++depth > 10)
1998 break;
1999 id = fix->chain_id;
2000 }
2001 }
2002
2003 static void alc_pick_fixup(struct hda_codec *codec,
2004 const struct alc_model_fixup *models,
2005 const struct snd_pci_quirk *quirk,
2006 const struct alc_fixup *fixlist)
2007 {
2008 struct alc_spec *spec = codec->spec;
2009 int id = -1;
2010 const char *name = NULL;
2011
2012 if (codec->modelname && models) {
2013 while (models->name) {
2014 if (!strcmp(codec->modelname, models->name)) {
2015 id = models->id;
2016 name = models->name;
2017 break;
2018 }
2019 models++;
2020 }
2021 }
2022 if (id < 0) {
2023 quirk = snd_pci_quirk_lookup(codec->bus->pci, quirk);
2024 if (quirk) {
2025 id = quirk->value;
2026 #ifdef CONFIG_SND_DEBUG_VERBOSE
2027 name = quirk->name;
2028 #endif
2029 }
2030 }
2031
2032 spec->fixup_id = id;
2033 if (id >= 0) {
2034 spec->fixup_list = fixlist;
2035 spec->fixup_name = name;
2036 }
2037 }
2038
2039 static int alc_read_coef_idx(struct hda_codec *codec,
2040 unsigned int coef_idx)
2041 {
2042 unsigned int val;
2043 snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX,
2044 coef_idx);
2045 val = snd_hda_codec_read(codec, 0x20, 0,
2046 AC_VERB_GET_PROC_COEF, 0);
2047 return val;
2048 }
2049
2050 static void alc_write_coef_idx(struct hda_codec *codec, unsigned int coef_idx,
2051 unsigned int coef_val)
2052 {
2053 snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX,
2054 coef_idx);
2055 snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_PROC_COEF,
2056 coef_val);
2057 }
2058
2059 /* set right pin controls for digital I/O */
2060 static void alc_auto_init_digital(struct hda_codec *codec)
2061 {
2062 struct alc_spec *spec = codec->spec;
2063 int i;
2064 hda_nid_t pin;
2065
2066 for (i = 0; i < spec->autocfg.dig_outs; i++) {
2067 pin = spec->autocfg.dig_out_pins[i];
2068 if (pin) {
2069 snd_hda_codec_write(codec, pin, 0,
2070 AC_VERB_SET_PIN_WIDGET_CONTROL,
2071 PIN_OUT);
2072 }
2073 }
2074 pin = spec->autocfg.dig_in_pin;
2075 if (pin)
2076 snd_hda_codec_write(codec, pin, 0,
2077 AC_VERB_SET_PIN_WIDGET_CONTROL,
2078 PIN_IN);
2079 }
2080
2081 /* parse digital I/Os and set up NIDs in BIOS auto-parse mode */
2082 static void alc_auto_parse_digital(struct hda_codec *codec)
2083 {
2084 struct alc_spec *spec = codec->spec;
2085 int i, err;
2086 hda_nid_t dig_nid;
2087
2088 /* support multiple SPDIFs; the secondary is set up as a slave */
2089 for (i = 0; i < spec->autocfg.dig_outs; i++) {
2090 err = snd_hda_get_connections(codec,
2091 spec->autocfg.dig_out_pins[i],
2092 &dig_nid, 1);
2093 if (err < 0)
2094 continue;
2095 if (!i) {
2096 spec->multiout.dig_out_nid = dig_nid;
2097 spec->dig_out_type = spec->autocfg.dig_out_type[0];
2098 } else {
2099 spec->multiout.slave_dig_outs = spec->slave_dig_outs;
2100 if (i >= ARRAY_SIZE(spec->slave_dig_outs) - 1)
2101 break;
2102 spec->slave_dig_outs[i - 1] = dig_nid;
2103 }
2104 }
2105
2106 if (spec->autocfg.dig_in_pin) {
2107 dig_nid = codec->start_nid;
2108 for (i = 0; i < codec->num_nodes; i++, dig_nid++) {
2109 unsigned int wcaps = get_wcaps(codec, dig_nid);
2110 if (get_wcaps_type(wcaps) != AC_WID_AUD_IN)
2111 continue;
2112 if (!(wcaps & AC_WCAP_DIGITAL))
2113 continue;
2114 if (!(wcaps & AC_WCAP_CONN_LIST))
2115 continue;
2116 err = get_connection_index(codec, dig_nid,
2117 spec->autocfg.dig_in_pin);
2118 if (err >= 0) {
2119 spec->dig_in_nid = dig_nid;
2120 break;
2121 }
2122 }
2123 }
2124 }
2125
2126 /*
2127 * ALC888
2128 */
2129
2130 /*
2131 * 2ch mode
2132 */
2133 static const struct hda_verb alc888_4ST_ch2_intel_init[] = {
2134 /* Mic-in jack as mic in */
2135 { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
2136 { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
2137 /* Line-in jack as Line in */
2138 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
2139 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
2140 /* Line-Out as Front */
2141 { 0x17, AC_VERB_SET_CONNECT_SEL, 0x00},
2142 { } /* end */
2143 };
2144
2145 /*
2146 * 4ch mode
2147 */
2148 static const struct hda_verb alc888_4ST_ch4_intel_init[] = {
2149 /* Mic-in jack as mic in */
2150 { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
2151 { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
2152 /* Line-in jack as Surround */
2153 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
2154 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
2155 /* Line-Out as Front */
2156 { 0x17, AC_VERB_SET_CONNECT_SEL, 0x00},
2157 { } /* end */
2158 };
2159
2160 /*
2161 * 6ch mode
2162 */
2163 static const struct hda_verb alc888_4ST_ch6_intel_init[] = {
2164 /* Mic-in jack as CLFE */
2165 { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
2166 { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
2167 /* Line-in jack as Surround */
2168 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
2169 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
2170 /* Line-Out as CLFE (workaround because Mic-in is not loud enough) */
2171 { 0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
2172 { } /* end */
2173 };
2174
2175 /*
2176 * 8ch mode
2177 */
2178 static const struct hda_verb alc888_4ST_ch8_intel_init[] = {
2179 /* Mic-in jack as CLFE */
2180 { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
2181 { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
2182 /* Line-in jack as Surround */
2183 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
2184 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
2185 /* Line-Out as Side */
2186 { 0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
2187 { } /* end */
2188 };
2189
2190 static const struct hda_channel_mode alc888_4ST_8ch_intel_modes[4] = {
2191 { 2, alc888_4ST_ch2_intel_init },
2192 { 4, alc888_4ST_ch4_intel_init },
2193 { 6, alc888_4ST_ch6_intel_init },
2194 { 8, alc888_4ST_ch8_intel_init },
2195 };
2196
2197 /*
2198 * ALC888 Fujitsu Siemens Amillo xa3530
2199 */
2200
2201 static const struct hda_verb alc888_fujitsu_xa3530_verbs[] = {
2202 /* Front Mic: set to PIN_IN (empty by default) */
2203 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2204 /* Connect Internal HP to Front */
2205 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2206 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2207 {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
2208 /* Connect Bass HP to Front */
2209 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2210 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2211 {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
2212 /* Connect Line-Out side jack (SPDIF) to Side */
2213 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2214 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2215 {0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
2216 /* Connect Mic jack to CLFE */
2217 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2218 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2219 {0x18, AC_VERB_SET_CONNECT_SEL, 0x02},
2220 /* Connect Line-in jack to Surround */
2221 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2222 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2223 {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01},
2224 /* Connect HP out jack to Front */
2225 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2226 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2227 {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
2228 /* Enable unsolicited event for HP jack and Line-out jack */
2229 {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
2230 {0x17, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
2231 {}
2232 };
2233
2234 static void alc889_automute_setup(struct hda_codec *codec)
2235 {
2236 struct alc_spec *spec = codec->spec;
2237
2238 spec->autocfg.hp_pins[0] = 0x15;
2239 spec->autocfg.speaker_pins[0] = 0x14;
2240 spec->autocfg.speaker_pins[1] = 0x16;
2241 spec->autocfg.speaker_pins[2] = 0x17;
2242 spec->autocfg.speaker_pins[3] = 0x19;
2243 spec->autocfg.speaker_pins[4] = 0x1a;
2244 spec->automute = 1;
2245 spec->automute_mode = ALC_AUTOMUTE_AMP;
2246 }
2247
2248 static void alc889_intel_init_hook(struct hda_codec *codec)
2249 {
2250 alc889_coef_init(codec);
2251 alc_hp_automute(codec);
2252 }
2253
2254 static void alc888_fujitsu_xa3530_setup(struct hda_codec *codec)
2255 {
2256 struct alc_spec *spec = codec->spec;
2257
2258 spec->autocfg.hp_pins[0] = 0x17; /* line-out */
2259 spec->autocfg.hp_pins[1] = 0x1b; /* hp */
2260 spec->autocfg.speaker_pins[0] = 0x14; /* speaker */
2261 spec->autocfg.speaker_pins[1] = 0x15; /* bass */
2262 spec->automute = 1;
2263 spec->automute_mode = ALC_AUTOMUTE_AMP;
2264 }
2265
2266 /*
2267 * ALC888 Acer Aspire 4930G model
2268 */
2269
2270 static const struct hda_verb alc888_acer_aspire_4930g_verbs[] = {
2271 /* Front Mic: set to PIN_IN (empty by default) */
2272 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2273 /* Unselect Front Mic by default in input mixer 3 */
2274 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0xb)},
2275 /* Enable unsolicited event for HP jack */
2276 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
2277 /* Connect Internal HP to front */
2278 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2279 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2280 {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
2281 /* Connect HP out to front */
2282 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2283 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2284 {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
2285 {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
2286 { }
2287 };
2288
2289 /*
2290 * ALC888 Acer Aspire 6530G model
2291 */
2292
2293 static const struct hda_verb alc888_acer_aspire_6530g_verbs[] = {
2294 /* Route to built-in subwoofer as well as speakers */
2295 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2296 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
2297 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2298 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
2299 /* Bias voltage on for external mic port */
2300 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN | PIN_VREF80},
2301 /* Front Mic: set to PIN_IN (empty by default) */
2302 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2303 /* Unselect Front Mic by default in input mixer 3 */
2304 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0xb)},
2305 /* Enable unsolicited event for HP jack */
2306 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
2307 /* Enable speaker output */
2308 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2309 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2310 {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
2311 /* Enable headphone output */
2312 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | PIN_HP},
2313 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2314 {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
2315 {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
2316 { }
2317 };
2318
2319 /*
2320 *ALC888 Acer Aspire 7730G model
2321 */
2322
2323 static const struct hda_verb alc888_acer_aspire_7730G_verbs[] = {
2324 /* Bias voltage on for external mic port */
2325 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN | PIN_VREF80},
2326 /* Front Mic: set to PIN_IN (empty by default) */
2327 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2328 /* Unselect Front Mic by default in input mixer 3 */
2329 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0xb)},
2330 /* Enable unsolicited event for HP jack */
2331 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
2332 /* Enable speaker output */
2333 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2334 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2335 {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
2336 /* Enable headphone output */
2337 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | PIN_HP},
2338 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2339 {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
2340 {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
2341 /*Enable internal subwoofer */
2342 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2343 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2344 {0x17, AC_VERB_SET_CONNECT_SEL, 0x02},
2345 {0x17, AC_VERB_SET_EAPD_BTLENABLE, 2},
2346 { }
2347 };
2348
2349 /*
2350 * ALC889 Acer Aspire 8930G model
2351 */
2352
2353 static const struct hda_verb alc889_acer_aspire_8930g_verbs[] = {
2354 /* Front Mic: set to PIN_IN (empty by default) */
2355 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2356 /* Unselect Front Mic by default in input mixer 3 */
2357 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0xb)},
2358 /* Enable unsolicited event for HP jack */
2359 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
2360 /* Connect Internal Front to Front */
2361 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2362 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2363 {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
2364 /* Connect Internal Rear to Rear */
2365 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2366 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2367 {0x1b, AC_VERB_SET_CONNECT_SEL, 0x01},
2368 /* Connect Internal CLFE to CLFE */
2369 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2370 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2371 {0x16, AC_VERB_SET_CONNECT_SEL, 0x02},
2372 /* Connect HP out to Front */
2373 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | PIN_HP},
2374 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2375 {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
2376 /* Enable all DACs */
2377 /* DAC DISABLE/MUTE 1? */
2378 /* setting bits 1-5 disables DAC nids 0x02-0x06 apparently. Init=0x38 */
2379 {0x20, AC_VERB_SET_COEF_INDEX, 0x03},
2380 {0x20, AC_VERB_SET_PROC_COEF, 0x0000},
2381 /* DAC DISABLE/MUTE 2? */
2382 /* some bit here disables the other DACs. Init=0x4900 */
2383 {0x20, AC_VERB_SET_COEF_INDEX, 0x08},
2384 {0x20, AC_VERB_SET_PROC_COEF, 0x0000},
2385 /* DMIC fix
2386 * This laptop has a stereo digital microphone. The mics are only 1cm apart
2387 * which makes the stereo useless. However, either the mic or the ALC889
2388 * makes the signal become a difference/sum signal instead of standard
2389 * stereo, which is annoying. So instead we flip this bit which makes the
2390 * codec replicate the sum signal to both channels, turning it into a
2391 * normal mono mic.
2392 */
2393 /* DMIC_CONTROL? Init value = 0x0001 */
2394 {0x20, AC_VERB_SET_COEF_INDEX, 0x0b},
2395 {0x20, AC_VERB_SET_PROC_COEF, 0x0003},
2396 { }
2397 };
2398
2399 static const struct hda_input_mux alc888_2_capture_sources[2] = {
2400 /* Front mic only available on one ADC */
2401 {
2402 .num_items = 4,
2403 .items = {
2404 { "Mic", 0x0 },
2405 { "Line", 0x2 },
2406 { "CD", 0x4 },
2407 { "Front Mic", 0xb },
2408 },
2409 },
2410 {
2411 .num_items = 3,
2412 .items = {
2413 { "Mic", 0x0 },
2414 { "Line", 0x2 },
2415 { "CD", 0x4 },
2416 },
2417 }
2418 };
2419
2420 static const struct hda_input_mux alc888_acer_aspire_6530_sources[2] = {
2421 /* Interal mic only available on one ADC */
2422 {
2423 .num_items = 5,
2424 .items = {
2425 { "Mic", 0x0 },
2426 { "Line In", 0x2 },
2427 { "CD", 0x4 },
2428 { "Input Mix", 0xa },
2429 { "Internal Mic", 0xb },
2430 },
2431 },
2432 {
2433 .num_items = 4,
2434 .items = {
2435 { "Mic", 0x0 },
2436 { "Line In", 0x2 },
2437 { "CD", 0x4 },
2438 { "Input Mix", 0xa },
2439 },
2440 }
2441 };
2442
2443 static const struct hda_input_mux alc889_capture_sources[3] = {
2444 /* Digital mic only available on first "ADC" */
2445 {
2446 .num_items = 5,
2447 .items = {
2448 { "Mic", 0x0 },
2449 { "Line", 0x2 },
2450 { "CD", 0x4 },
2451 { "Front Mic", 0xb },
2452 { "Input Mix", 0xa },
2453 },
2454 },
2455 {
2456 .num_items = 4,
2457 .items = {
2458 { "Mic", 0x0 },
2459 { "Line", 0x2 },
2460 { "CD", 0x4 },
2461 { "Input Mix", 0xa },
2462 },
2463 },
2464 {
2465 .num_items = 4,
2466 .items = {
2467 { "Mic", 0x0 },
2468 { "Line", 0x2 },
2469 { "CD", 0x4 },
2470 { "Input Mix", 0xa },
2471 },
2472 }
2473 };
2474
2475 static const struct snd_kcontrol_new alc888_base_mixer[] = {
2476 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2477 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
2478 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2479 HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
2480 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0,
2481 HDA_OUTPUT),
2482 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
2483 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
2484 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
2485 HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
2486 HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
2487 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
2488 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
2489 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
2490 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
2491 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2492 HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
2493 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2494 { } /* end */
2495 };
2496
2497 static const struct snd_kcontrol_new alc888_acer_aspire_4930g_mixer[] = {
2498 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2499 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
2500 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2501 HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
2502 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0,
2503 HDA_OUTPUT),
2504 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
2505 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
2506 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
2507 HDA_CODEC_VOLUME_MONO("Internal LFE Playback Volume", 0x0f, 1, 0x0, HDA_OUTPUT),
2508 HDA_BIND_MUTE_MONO("Internal LFE Playback Switch", 0x0f, 1, 2, HDA_INPUT),
2509 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
2510 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
2511 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
2512 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
2513 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2514 HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
2515 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2516 { } /* end */
2517 };
2518
2519 static const struct snd_kcontrol_new alc889_acer_aspire_8930g_mixer[] = {
2520 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2521 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
2522 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2523 HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
2524 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0,
2525 HDA_OUTPUT),
2526 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
2527 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
2528 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
2529 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
2530 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
2531 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2532 HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
2533 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2534 { } /* end */
2535 };
2536
2537
2538 static void alc888_acer_aspire_4930g_setup(struct hda_codec *codec)
2539 {
2540 struct alc_spec *spec = codec->spec;
2541
2542 spec->autocfg.hp_pins[0] = 0x15;
2543 spec->autocfg.speaker_pins[0] = 0x14;
2544 spec->autocfg.speaker_pins[1] = 0x16;
2545 spec->autocfg.speaker_pins[2] = 0x17;
2546 spec->automute = 1;
2547 spec->automute_mode = ALC_AUTOMUTE_AMP;
2548 }
2549
2550 static void alc888_acer_aspire_6530g_setup(struct hda_codec *codec)
2551 {
2552 struct alc_spec *spec = codec->spec;
2553
2554 spec->autocfg.hp_pins[0] = 0x15;
2555 spec->autocfg.speaker_pins[0] = 0x14;
2556 spec->autocfg.speaker_pins[1] = 0x16;
2557 spec->autocfg.speaker_pins[2] = 0x17;
2558 spec->automute = 1;
2559 spec->automute_mode = ALC_AUTOMUTE_AMP;
2560 }
2561
2562 static void alc888_acer_aspire_7730g_setup(struct hda_codec *codec)
2563 {
2564 struct alc_spec *spec = codec->spec;
2565
2566 spec->autocfg.hp_pins[0] = 0x15;
2567 spec->autocfg.speaker_pins[0] = 0x14;
2568 spec->autocfg.speaker_pins[1] = 0x16;
2569 spec->autocfg.speaker_pins[2] = 0x17;
2570 spec->automute = 1;
2571 spec->automute_mode = ALC_AUTOMUTE_AMP;
2572 }
2573
2574 static void alc889_acer_aspire_8930g_setup(struct hda_codec *codec)
2575 {
2576 struct alc_spec *spec = codec->spec;
2577
2578 spec->autocfg.hp_pins[0] = 0x15;
2579 spec->autocfg.speaker_pins[0] = 0x14;
2580 spec->autocfg.speaker_pins[1] = 0x16;
2581 spec->autocfg.speaker_pins[2] = 0x1b;
2582 spec->automute = 1;
2583 spec->automute_mode = ALC_AUTOMUTE_AMP;
2584 }
2585
2586 /*
2587 * ALC880 3-stack model
2588 *
2589 * DAC: Front = 0x02 (0x0c), Surr = 0x05 (0x0f), CLFE = 0x04 (0x0e)
2590 * Pin assignment: Front = 0x14, Line-In/Surr = 0x1a, Mic/CLFE = 0x18,
2591 * F-Mic = 0x1b, HP = 0x19
2592 */
2593
2594 static const hda_nid_t alc880_dac_nids[4] = {
2595 /* front, rear, clfe, rear_surr */
2596 0x02, 0x05, 0x04, 0x03
2597 };
2598
2599 static const hda_nid_t alc880_adc_nids[3] = {
2600 /* ADC0-2 */
2601 0x07, 0x08, 0x09,
2602 };
2603
2604 /* The datasheet says the node 0x07 is connected from inputs,
2605 * but it shows zero connection in the real implementation on some devices.
2606 * Note: this is a 915GAV bug, fixed on 915GLV
2607 */
2608 static const hda_nid_t alc880_adc_nids_alt[2] = {
2609 /* ADC1-2 */
2610 0x08, 0x09,
2611 };
2612
2613 #define ALC880_DIGOUT_NID 0x06
2614 #define ALC880_DIGIN_NID 0x0a
2615
2616 static const struct hda_input_mux alc880_capture_source = {
2617 .num_items = 4,
2618 .items = {
2619 { "Mic", 0x0 },
2620 { "Front Mic", 0x3 },
2621 { "Line", 0x2 },
2622 { "CD", 0x4 },
2623 },
2624 };
2625
2626 /* channel source setting (2/6 channel selection for 3-stack) */
2627 /* 2ch mode */
2628 static const struct hda_verb alc880_threestack_ch2_init[] = {
2629 /* set line-in to input, mute it */
2630 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
2631 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
2632 /* set mic-in to input vref 80%, mute it */
2633 { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
2634 { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
2635 { } /* end */
2636 };
2637
2638 /* 6ch mode */
2639 static const struct hda_verb alc880_threestack_ch6_init[] = {
2640 /* set line-in to output, unmute it */
2641 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
2642 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
2643 /* set mic-in to output, unmute it */
2644 { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
2645 { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
2646 { } /* end */
2647 };
2648
2649 static const struct hda_channel_mode alc880_threestack_modes[2] = {
2650 { 2, alc880_threestack_ch2_init },
2651 { 6, alc880_threestack_ch6_init },
2652 };
2653
2654 static const struct snd_kcontrol_new alc880_three_stack_mixer[] = {
2655 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2656 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
2657 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
2658 HDA_BIND_MUTE("Surround Playback Switch", 0x0f, 2, HDA_INPUT),
2659 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
2660 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
2661 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
2662 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
2663 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
2664 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
2665 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
2666 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
2667 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2668 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2669 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x3, HDA_INPUT),
2670 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x3, HDA_INPUT),
2671 HDA_CODEC_MUTE("Headphone Playback Switch", 0x19, 0x0, HDA_OUTPUT),
2672 {
2673 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2674 .name = "Channel Mode",
2675 .info = alc_ch_mode_info,
2676 .get = alc_ch_mode_get,
2677 .put = alc_ch_mode_put,
2678 },
2679 { } /* end */
2680 };
2681
2682 /* capture mixer elements */
2683 static int alc_cap_vol_info(struct snd_kcontrol *kcontrol,
2684 struct snd_ctl_elem_info *uinfo)
2685 {
2686 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2687 struct alc_spec *spec = codec->spec;
2688 int err;
2689
2690 mutex_lock(&codec->control_mutex);
2691 kcontrol->private_value = HDA_COMPOSE_AMP_VAL(spec->adc_nids[0], 3, 0,
2692 HDA_INPUT);
2693 err = snd_hda_mixer_amp_volume_info(kcontrol, uinfo);
2694 mutex_unlock(&codec->control_mutex);
2695 return err;
2696 }
2697
2698 static int alc_cap_vol_tlv(struct snd_kcontrol *kcontrol, int op_flag,
2699 unsigned int size, unsigned int __user *tlv)
2700 {
2701 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2702 struct alc_spec *spec = codec->spec;
2703 int err;
2704
2705 mutex_lock(&codec->control_mutex);
2706 kcontrol->private_value = HDA_COMPOSE_AMP_VAL(spec->adc_nids[0], 3, 0,
2707 HDA_INPUT);
2708 err = snd_hda_mixer_amp_tlv(kcontrol, op_flag, size, tlv);
2709 mutex_unlock(&codec->control_mutex);
2710 return err;
2711 }
2712
2713 typedef int (*getput_call_t)(struct snd_kcontrol *kcontrol,
2714 struct snd_ctl_elem_value *ucontrol);
2715
2716 static int alc_cap_getput_caller(struct snd_kcontrol *kcontrol,
2717 struct snd_ctl_elem_value *ucontrol,
2718 getput_call_t func)
2719 {
2720 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2721 struct alc_spec *spec = codec->spec;
2722 unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
2723 int err;
2724
2725 mutex_lock(&codec->control_mutex);
2726 kcontrol->private_value = HDA_COMPOSE_AMP_VAL(spec->adc_nids[adc_idx],
2727 3, 0, HDA_INPUT);
2728 err = func(kcontrol, ucontrol);
2729 mutex_unlock(&codec->control_mutex);
2730 return err;
2731 }
2732
2733 static int alc_cap_vol_get(struct snd_kcontrol *kcontrol,
2734 struct snd_ctl_elem_value *ucontrol)
2735 {
2736 return alc_cap_getput_caller(kcontrol, ucontrol,
2737 snd_hda_mixer_amp_volume_get);
2738 }
2739
2740 static int alc_cap_vol_put(struct snd_kcontrol *kcontrol,
2741 struct snd_ctl_elem_value *ucontrol)
2742 {
2743 return alc_cap_getput_caller(kcontrol, ucontrol,
2744 snd_hda_mixer_amp_volume_put);
2745 }
2746
2747 /* capture mixer elements */
2748 #define alc_cap_sw_info snd_ctl_boolean_stereo_info
2749
2750 static int alc_cap_sw_get(struct snd_kcontrol *kcontrol,
2751 struct snd_ctl_elem_value *ucontrol)
2752 {
2753 return alc_cap_getput_caller(kcontrol, ucontrol,
2754 snd_hda_mixer_amp_switch_get);
2755 }
2756
2757 static int alc_cap_sw_put(struct snd_kcontrol *kcontrol,
2758 struct snd_ctl_elem_value *ucontrol)
2759 {
2760 return alc_cap_getput_caller(kcontrol, ucontrol,
2761 snd_hda_mixer_amp_switch_put);
2762 }
2763
2764 #define _DEFINE_CAPMIX(num) \
2765 { \
2766 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
2767 .name = "Capture Switch", \
2768 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE, \
2769 .count = num, \
2770 .info = alc_cap_sw_info, \
2771 .get = alc_cap_sw_get, \
2772 .put = alc_cap_sw_put, \
2773 }, \
2774 { \
2775 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
2776 .name = "Capture Volume", \
2777 .access = (SNDRV_CTL_ELEM_ACCESS_READWRITE | \
2778 SNDRV_CTL_ELEM_ACCESS_TLV_READ | \
2779 SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK), \
2780 .count = num, \
2781 .info = alc_cap_vol_info, \
2782 .get = alc_cap_vol_get, \
2783 .put = alc_cap_vol_put, \
2784 .tlv = { .c = alc_cap_vol_tlv }, \
2785 }
2786
2787 #define _DEFINE_CAPSRC(num) \
2788 { \
2789 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
2790 /* .name = "Capture Source", */ \
2791 .name = "Input Source", \
2792 .count = num, \
2793 .info = alc_mux_enum_info, \
2794 .get = alc_mux_enum_get, \
2795 .put = alc_mux_enum_put, \
2796 }
2797
2798 #define DEFINE_CAPMIX(num) \
2799 static const struct snd_kcontrol_new alc_capture_mixer ## num[] = { \
2800 _DEFINE_CAPMIX(num), \
2801 _DEFINE_CAPSRC(num), \
2802 { } /* end */ \
2803 }
2804
2805 #define DEFINE_CAPMIX_NOSRC(num) \
2806 static const struct snd_kcontrol_new alc_capture_mixer_nosrc ## num[] = { \
2807 _DEFINE_CAPMIX(num), \
2808 { } /* end */ \
2809 }
2810
2811 /* up to three ADCs */
2812 DEFINE_CAPMIX(1);
2813 DEFINE_CAPMIX(2);
2814 DEFINE_CAPMIX(3);
2815 DEFINE_CAPMIX_NOSRC(1);
2816 DEFINE_CAPMIX_NOSRC(2);
2817 DEFINE_CAPMIX_NOSRC(3);
2818
2819 /*
2820 * ALC880 5-stack model
2821 *
2822 * DAC: Front = 0x02 (0x0c), Surr = 0x05 (0x0f), CLFE = 0x04 (0x0d),
2823 * Side = 0x02 (0xd)
2824 * Pin assignment: Front = 0x14, Surr = 0x17, CLFE = 0x16
2825 * Line-In/Side = 0x1a, Mic = 0x18, F-Mic = 0x1b, HP = 0x19
2826 */
2827
2828 /* additional mixers to alc880_three_stack_mixer */
2829 static const struct snd_kcontrol_new alc880_five_stack_mixer[] = {
2830 HDA_CODEC_VOLUME("Side Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2831 HDA_BIND_MUTE("Side Playback Switch", 0x0d, 2, HDA_INPUT),
2832 { } /* end */
2833 };
2834
2835 /* channel source setting (6/8 channel selection for 5-stack) */
2836 /* 6ch mode */
2837 static const struct hda_verb alc880_fivestack_ch6_init[] = {
2838 /* set line-in to input, mute it */
2839 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
2840 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
2841 { } /* end */
2842 };
2843
2844 /* 8ch mode */
2845 static const struct hda_verb alc880_fivestack_ch8_init[] = {
2846 /* set line-in to output, unmute it */
2847 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
2848 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
2849 { } /* end */
2850 };
2851
2852 static const struct hda_channel_mode alc880_fivestack_modes[2] = {
2853 { 6, alc880_fivestack_ch6_init },
2854 { 8, alc880_fivestack_ch8_init },
2855 };
2856
2857
2858 /*
2859 * ALC880 6-stack model
2860 *
2861 * DAC: Front = 0x02 (0x0c), Surr = 0x03 (0x0d), CLFE = 0x04 (0x0e),
2862 * Side = 0x05 (0x0f)
2863 * Pin assignment: Front = 0x14, Surr = 0x15, CLFE = 0x16, Side = 0x17,
2864 * Mic = 0x18, F-Mic = 0x19, Line = 0x1a, HP = 0x1b
2865 */
2866
2867 static const hda_nid_t alc880_6st_dac_nids[4] = {
2868 /* front, rear, clfe, rear_surr */
2869 0x02, 0x03, 0x04, 0x05
2870 };
2871
2872 static const struct hda_input_mux alc880_6stack_capture_source = {
2873 .num_items = 4,
2874 .items = {
2875 { "Mic", 0x0 },
2876 { "Front Mic", 0x1 },
2877 { "Line", 0x2 },
2878 { "CD", 0x4 },
2879 },
2880 };
2881
2882 /* fixed 8-channels */
2883 static const struct hda_channel_mode alc880_sixstack_modes[1] = {
2884 { 8, NULL },
2885 };
2886
2887 static const struct snd_kcontrol_new alc880_six_stack_mixer[] = {
2888 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2889 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
2890 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2891 HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
2892 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
2893 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
2894 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
2895 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
2896 HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
2897 HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
2898 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
2899 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
2900 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
2901 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
2902 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2903 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2904 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
2905 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
2906 {
2907 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2908 .name = "Channel Mode",
2909 .info = alc_ch_mode_info,
2910 .get = alc_ch_mode_get,
2911 .put = alc_ch_mode_put,
2912 },
2913 { } /* end */
2914 };
2915
2916
2917 /*
2918 * ALC880 W810 model
2919 *
2920 * W810 has rear IO for:
2921 * Front (DAC 02)
2922 * Surround (DAC 03)
2923 * Center/LFE (DAC 04)
2924 * Digital out (06)
2925 *
2926 * The system also has a pair of internal speakers, and a headphone jack.
2927 * These are both connected to Line2 on the codec, hence to DAC 02.
2928 *
2929 * There is a variable resistor to control the speaker or headphone
2930 * volume. This is a hardware-only device without a software API.
2931 *
2932 * Plugging headphones in will disable the internal speakers. This is
2933 * implemented in hardware, not via the driver using jack sense. In
2934 * a similar fashion, plugging into the rear socket marked "front" will
2935 * disable both the speakers and headphones.
2936 *
2937 * For input, there's a microphone jack, and an "audio in" jack.
2938 * These may not do anything useful with this driver yet, because I
2939 * haven't setup any initialization verbs for these yet...
2940 */
2941
2942 static const hda_nid_t alc880_w810_dac_nids[3] = {
2943 /* front, rear/surround, clfe */
2944 0x02, 0x03, 0x04
2945 };
2946
2947 /* fixed 6 channels */
2948 static const struct hda_channel_mode alc880_w810_modes[1] = {
2949 { 6, NULL }
2950 };
2951
2952 /* Pin assignment: Front = 0x14, Surr = 0x15, CLFE = 0x16, HP = 0x1b */
2953 static const struct snd_kcontrol_new alc880_w810_base_mixer[] = {
2954 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2955 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
2956 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2957 HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
2958 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
2959 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
2960 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
2961 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
2962 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
2963 { } /* end */
2964 };
2965
2966
2967 /*
2968 * Z710V model
2969 *
2970 * DAC: Front = 0x02 (0x0c), HP = 0x03 (0x0d)
2971 * Pin assignment: Front = 0x14, HP = 0x15, Mic = 0x18, Mic2 = 0x19(?),
2972 * Line = 0x1a
2973 */
2974
2975 static const hda_nid_t alc880_z71v_dac_nids[1] = {
2976 0x02
2977 };
2978 #define ALC880_Z71V_HP_DAC 0x03
2979
2980 /* fixed 2 channels */
2981 static const struct hda_channel_mode alc880_2_jack_modes[1] = {
2982 { 2, NULL }
2983 };
2984
2985 static const struct snd_kcontrol_new alc880_z71v_mixer[] = {
2986 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2987 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
2988 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2989 HDA_BIND_MUTE("Headphone Playback Switch", 0x0d, 2, HDA_INPUT),
2990 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
2991 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
2992 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2993 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2994 { } /* end */
2995 };
2996
2997
2998 /*
2999 * ALC880 F1734 model
3000 *
3001 * DAC: HP = 0x02 (0x0c), Front = 0x03 (0x0d)
3002 * Pin assignment: HP = 0x14, Front = 0x15, Mic = 0x18
3003 */
3004
3005 static const hda_nid_t alc880_f1734_dac_nids[1] = {
3006 0x03
3007 };
3008 #define ALC880_F1734_HP_DAC 0x02
3009
3010 static const struct snd_kcontrol_new alc880_f1734_mixer[] = {
3011 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
3012 HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
3013 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
3014 HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
3015 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
3016 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
3017 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
3018 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
3019 { } /* end */
3020 };
3021
3022 static const struct hda_input_mux alc880_f1734_capture_source = {
3023 .num_items = 2,
3024 .items = {
3025 { "Mic", 0x1 },
3026 { "CD", 0x4 },
3027 },
3028 };
3029
3030
3031 /*
3032 * ALC880 ASUS model
3033 *
3034 * DAC: HP/Front = 0x02 (0x0c), Surr = 0x03 (0x0d), CLFE = 0x04 (0x0e)
3035 * Pin assignment: HP/Front = 0x14, Surr = 0x15, CLFE = 0x16,
3036 * Mic = 0x18, Line = 0x1a
3037 */
3038
3039 #define alc880_asus_dac_nids alc880_w810_dac_nids /* identical with w810 */
3040 #define alc880_asus_modes alc880_threestack_modes /* 2/6 channel mode */
3041
3042 static const struct snd_kcontrol_new alc880_asus_mixer[] = {
3043 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
3044 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
3045 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
3046 HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
3047 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
3048 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
3049 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
3050 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
3051 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
3052 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
3053 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
3054 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
3055 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
3056 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
3057 {
3058 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3059 .name = "Channel Mode",
3060 .info = alc_ch_mode_info,
3061 .get = alc_ch_mode_get,
3062 .put = alc_ch_mode_put,
3063 },
3064 { } /* end */
3065 };
3066
3067 /*
3068 * ALC880 ASUS W1V model
3069 *
3070 * DAC: HP/Front = 0x02 (0x0c), Surr = 0x03 (0x0d), CLFE = 0x04 (0x0e)
3071 * Pin assignment: HP/Front = 0x14, Surr = 0x15, CLFE = 0x16,
3072 * Mic = 0x18, Line = 0x1a, Line2 = 0x1b
3073 */
3074
3075 /* additional mixers to alc880_asus_mixer */
3076 static const struct snd_kcontrol_new alc880_asus_w1v_mixer[] = {
3077 HDA_CODEC_VOLUME("Line2 Playback Volume", 0x0b, 0x03, HDA_INPUT),
3078 HDA_CODEC_MUTE("Line2 Playback Switch", 0x0b, 0x03, HDA_INPUT),
3079 { } /* end */
3080 };
3081
3082 /* TCL S700 */
3083 static const struct snd_kcontrol_new alc880_tcl_s700_mixer[] = {
3084 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
3085 HDA_CODEC_MUTE("Front Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
3086 HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
3087 HDA_CODEC_VOLUME("CD Playback Volume", 0x0B, 0x04, HDA_INPUT),
3088 HDA_CODEC_MUTE("CD Playback Switch", 0x0B, 0x04, HDA_INPUT),
3089 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0B, 0x0, HDA_INPUT),
3090 HDA_CODEC_MUTE("Mic Playback Switch", 0x0B, 0x0, HDA_INPUT),
3091 HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
3092 HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
3093 { } /* end */
3094 };
3095
3096 /* Uniwill */
3097 static const struct snd_kcontrol_new alc880_uniwill_mixer[] = {
3098 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
3099 HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
3100 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
3101 HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
3102 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
3103 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
3104 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
3105 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
3106 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
3107 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
3108 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
3109 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
3110 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
3111 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
3112 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
3113 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
3114 {
3115 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3116 .name = "Channel Mode",
3117 .info = alc_ch_mode_info,
3118 .get = alc_ch_mode_get,
3119 .put = alc_ch_mode_put,
3120 },
3121 { } /* end */
3122 };
3123
3124 static const struct snd_kcontrol_new alc880_fujitsu_mixer[] = {
3125 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
3126 HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
3127 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
3128 HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
3129 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
3130 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
3131 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
3132 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
3133 HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
3134 HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
3135 { } /* end */
3136 };
3137
3138 static const struct snd_kcontrol_new alc880_uniwill_p53_mixer[] = {
3139 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
3140 HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
3141 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
3142 HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
3143 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
3144 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
3145 { } /* end */
3146 };
3147
3148 /*
3149 * virtual master controls
3150 */
3151
3152 /*
3153 * slave controls for virtual master
3154 */
3155 static const char * const alc_slave_vols[] = {
3156 "Front Playback Volume",
3157 "Surround Playback Volume",
3158 "Center Playback Volume",
3159 "LFE Playback Volume",
3160 "Side Playback Volume",
3161 "Headphone Playback Volume",
3162 "Speaker Playback Volume",
3163 "Mono Playback Volume",
3164 "Line-Out Playback Volume",
3165 NULL,
3166 };
3167
3168 static const char * const alc_slave_sws[] = {
3169 "Front Playback Switch",
3170 "Surround Playback Switch",
3171 "Center Playback Switch",
3172 "LFE Playback Switch",
3173 "Side Playback Switch",
3174 "Headphone Playback Switch",
3175 "Speaker Playback Switch",
3176 "Mono Playback Switch",
3177 "IEC958 Playback Switch",
3178 "Line-Out Playback Switch",
3179 NULL,
3180 };
3181
3182 /*
3183 * build control elements
3184 */
3185
3186 #define NID_MAPPING (-1)
3187
3188 #define SUBDEV_SPEAKER_ (0 << 6)
3189 #define SUBDEV_HP_ (1 << 6)
3190 #define SUBDEV_LINE_ (2 << 6)
3191 #define SUBDEV_SPEAKER(x) (SUBDEV_SPEAKER_ | ((x) & 0x3f))
3192 #define SUBDEV_HP(x) (SUBDEV_HP_ | ((x) & 0x3f))
3193 #define SUBDEV_LINE(x) (SUBDEV_LINE_ | ((x) & 0x3f))
3194
3195 static void alc_free_kctls(struct hda_codec *codec);
3196
3197 #ifdef CONFIG_SND_HDA_INPUT_BEEP
3198 /* additional beep mixers; the actual parameters are overwritten at build */
3199 static const struct snd_kcontrol_new alc_beep_mixer[] = {
3200 HDA_CODEC_VOLUME("Beep Playback Volume", 0, 0, HDA_INPUT),
3201 HDA_CODEC_MUTE_BEEP("Beep Playback Switch", 0, 0, HDA_INPUT),
3202 { } /* end */
3203 };
3204 #endif
3205
3206 static int alc_build_controls(struct hda_codec *codec)
3207 {
3208 struct alc_spec *spec = codec->spec;
3209 struct snd_kcontrol *kctl = NULL;
3210 const struct snd_kcontrol_new *knew;
3211 int i, j, err;
3212 unsigned int u;
3213 hda_nid_t nid;
3214
3215 for (i = 0; i < spec->num_mixers; i++) {
3216 err = snd_hda_add_new_ctls(codec, spec->mixers[i]);
3217 if (err < 0)
3218 return err;
3219 }
3220 if (spec->cap_mixer) {
3221 err = snd_hda_add_new_ctls(codec, spec->cap_mixer);
3222 if (err < 0)
3223 return err;
3224 }
3225 if (spec->multiout.dig_out_nid) {
3226 err = snd_hda_create_spdif_out_ctls(codec,
3227 spec->multiout.dig_out_nid,
3228 spec->multiout.dig_out_nid);
3229 if (err < 0)
3230 return err;
3231 if (!spec->no_analog) {
3232 err = snd_hda_create_spdif_share_sw(codec,
3233 &spec->multiout);
3234 if (err < 0)
3235 return err;
3236 spec->multiout.share_spdif = 1;
3237 }
3238 }
3239 if (spec->dig_in_nid) {
3240 err = snd_hda_create_spdif_in_ctls(codec, spec->dig_in_nid);
3241 if (err < 0)
3242 return err;
3243 }
3244
3245 #ifdef CONFIG_SND_HDA_INPUT_BEEP
3246 /* create beep controls if needed */
3247 if (spec->beep_amp) {
3248 const struct snd_kcontrol_new *knew;
3249 for (knew = alc_beep_mixer; knew->name; knew++) {
3250 struct snd_kcontrol *kctl;
3251 kctl = snd_ctl_new1(knew, codec);
3252 if (!kctl)
3253 return -ENOMEM;
3254 kctl->private_value = spec->beep_amp;
3255 err = snd_hda_ctl_add(codec, 0, kctl);
3256 if (err < 0)
3257 return err;
3258 }
3259 }
3260 #endif
3261
3262 /* if we have no master control, let's create it */
3263 if (!spec->no_analog &&
3264 !snd_hda_find_mixer_ctl(codec, "Master Playback Volume")) {
3265 unsigned int vmaster_tlv[4];
3266 snd_hda_set_vmaster_tlv(codec, spec->vmaster_nid,
3267 HDA_OUTPUT, vmaster_tlv);
3268 err = snd_hda_add_vmaster(codec, "Master Playback Volume",
3269 vmaster_tlv, alc_slave_vols);
3270 if (err < 0)
3271 return err;
3272 }
3273 if (!spec->no_analog &&
3274 !snd_hda_find_mixer_ctl(codec, "Master Playback Switch")) {
3275 err = snd_hda_add_vmaster(codec, "Master Playback Switch",
3276 NULL, alc_slave_sws);
3277 if (err < 0)
3278 return err;
3279 }
3280
3281 /* assign Capture Source enums to NID */
3282 if (spec->capsrc_nids || spec->adc_nids) {
3283 kctl = snd_hda_find_mixer_ctl(codec, "Capture Source");
3284 if (!kctl)
3285 kctl = snd_hda_find_mixer_ctl(codec, "Input Source");
3286 for (i = 0; kctl && i < kctl->count; i++) {
3287 const hda_nid_t *nids = spec->capsrc_nids;
3288 if (!nids)
3289 nids = spec->adc_nids;
3290 err = snd_hda_add_nid(codec, kctl, i, nids[i]);
3291 if (err < 0)
3292 return err;
3293 }
3294 }
3295 if (spec->cap_mixer) {
3296 const char *kname = kctl ? kctl->id.name : NULL;
3297 for (knew = spec->cap_mixer; knew->name; knew++) {
3298 if (kname && strcmp(knew->name, kname) == 0)
3299 continue;
3300 kctl = snd_hda_find_mixer_ctl(codec, knew->name);
3301 for (i = 0; kctl && i < kctl->count; i++) {
3302 err = snd_hda_add_nid(codec, kctl, i,
3303 spec->adc_nids[i]);
3304 if (err < 0)
3305 return err;
3306 }
3307 }
3308 }
3309
3310 /* other nid->control mapping */
3311 for (i = 0; i < spec->num_mixers; i++) {
3312 for (knew = spec->mixers[i]; knew->name; knew++) {
3313 if (knew->iface != NID_MAPPING)
3314 continue;
3315 kctl = snd_hda_find_mixer_ctl(codec, knew->name);
3316 if (kctl == NULL)
3317 continue;
3318 u = knew->subdevice;
3319 for (j = 0; j < 4; j++, u >>= 8) {
3320 nid = u & 0x3f;
3321 if (nid == 0)
3322 continue;
3323 switch (u & 0xc0) {
3324 case SUBDEV_SPEAKER_:
3325 nid = spec->autocfg.speaker_pins[nid];
3326 break;
3327 case SUBDEV_LINE_:
3328 nid = spec->autocfg.line_out_pins[nid];
3329 break;
3330 case SUBDEV_HP_:
3331 nid = spec->autocfg.hp_pins[nid];
3332 break;
3333 default:
3334 continue;
3335 }
3336 err = snd_hda_add_nid(codec, kctl, 0, nid);
3337 if (err < 0)
3338 return err;
3339 }
3340 u = knew->private_value;
3341 for (j = 0; j < 4; j++, u >>= 8) {
3342 nid = u & 0xff;
3343 if (nid == 0)
3344 continue;
3345 err = snd_hda_add_nid(codec, kctl, 0, nid);
3346 if (err < 0)
3347 return err;
3348 }
3349 }
3350 }
3351
3352 alc_free_kctls(codec); /* no longer needed */
3353
3354 return 0;
3355 }
3356
3357
3358 /*
3359 * initialize the codec volumes, etc
3360 */
3361
3362 /*
3363 * generic initialization of ADC, input mixers and output mixers
3364 */
3365 static const struct hda_verb alc880_volume_init_verbs[] = {
3366 /*
3367 * Unmute ADC0-2 and set the default input to mic-in
3368 */
3369 {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
3370 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3371 {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
3372 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3373 {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
3374 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3375
3376 /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
3377 * mixer widget
3378 * Note: PASD motherboards uses the Line In 2 as the input for front
3379 * panel mic (mic 2)
3380 */
3381 /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
3382 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3383 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
3384 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
3385 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
3386 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
3387 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
3388 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
3389
3390 /*
3391 * Set up output mixers (0x0c - 0x0f)
3392 */
3393 /* set vol=0 to output mixers */
3394 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3395 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3396 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3397 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3398 /* set up input amps for analog loopback */
3399 /* Amp Indices: DAC = 0, mixer = 1 */
3400 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3401 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
3402 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3403 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
3404 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3405 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
3406 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3407 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
3408
3409 { }
3410 };
3411
3412 /*
3413 * 3-stack pin configuration:
3414 * front = 0x14, mic/clfe = 0x18, HP = 0x19, line/surr = 0x1a, f-mic = 0x1b
3415 */
3416 static const struct hda_verb alc880_pin_3stack_init_verbs[] = {
3417 /*
3418 * preset connection lists of input pins
3419 * 0 = front, 1 = rear_surr, 2 = CLFE, 3 = surround
3420 */
3421 {0x10, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
3422 {0x11, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
3423 {0x12, AC_VERB_SET_CONNECT_SEL, 0x03}, /* line/surround */
3424
3425 /*
3426 * Set pin mode and muting
3427 */
3428 /* set front pin widgets 0x14 for output */
3429 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3430 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3431 /* Mic1 (rear panel) pin widget for input and vref at 80% */
3432 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3433 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3434 /* Mic2 (as headphone out) for HP output */
3435 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3436 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3437 /* Line In pin widget for input */
3438 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3439 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3440 /* Line2 (as front mic) pin widget for input and vref at 80% */
3441 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3442 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3443 /* CD pin widget for input */
3444 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3445
3446 { }
3447 };
3448
3449 /*
3450 * 5-stack pin configuration:
3451 * front = 0x14, surround = 0x17, clfe = 0x16, mic = 0x18, HP = 0x19,
3452 * line-in/side = 0x1a, f-mic = 0x1b
3453 */
3454 static const struct hda_verb alc880_pin_5stack_init_verbs[] = {
3455 /*
3456 * preset connection lists of input pins
3457 * 0 = front, 1 = rear_surr, 2 = CLFE, 3 = surround
3458 */
3459 {0x11, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
3460 {0x12, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/side */
3461
3462 /*
3463 * Set pin mode and muting
3464 */
3465 /* set pin widgets 0x14-0x17 for output */
3466 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3467 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3468 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3469 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3470 /* unmute pins for output (no gain on this amp) */
3471 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3472 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3473 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3474 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3475
3476 /* Mic1 (rear panel) pin widget for input and vref at 80% */
3477 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3478 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3479 /* Mic2 (as headphone out) for HP output */
3480 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3481 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3482 /* Line In pin widget for input */
3483 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3484 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3485 /* Line2 (as front mic) pin widget for input and vref at 80% */
3486 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3487 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3488 /* CD pin widget for input */
3489 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3490
3491 { }
3492 };
3493
3494 /*
3495 * W810 pin configuration:
3496 * front = 0x14, surround = 0x15, clfe = 0x16, HP = 0x1b
3497 */
3498 static const struct hda_verb alc880_pin_w810_init_verbs[] = {
3499 /* hphone/speaker input selector: front DAC */
3500 {0x13, AC_VERB_SET_CONNECT_SEL, 0x0},
3501
3502 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3503 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3504 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3505 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3506 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3507 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3508
3509 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3510 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3511
3512 { }
3513 };
3514
3515 /*
3516 * Z71V pin configuration:
3517 * Speaker-out = 0x14, HP = 0x15, Mic = 0x18, Line-in = 0x1a, Mic2 = 0x1b (?)
3518 */
3519 static const struct hda_verb alc880_pin_z71v_init_verbs[] = {
3520 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3521 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3522 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3523 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3524
3525 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3526 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3527 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3528 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3529
3530 { }
3531 };
3532
3533 /*
3534 * 6-stack pin configuration:
3535 * front = 0x14, surr = 0x15, clfe = 0x16, side = 0x17, mic = 0x18,
3536 * f-mic = 0x19, line = 0x1a, HP = 0x1b
3537 */
3538 static const struct hda_verb alc880_pin_6stack_init_verbs[] = {
3539 {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
3540
3541 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3542 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3543 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3544 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3545 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3546 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3547 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3548 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3549
3550 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3551 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3552 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3553 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3554 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3555 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3556 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3557 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3558 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3559
3560 { }
3561 };
3562
3563 /*
3564 * Uniwill pin configuration:
3565 * HP = 0x14, InternalSpeaker = 0x15, mic = 0x18, internal mic = 0x19,
3566 * line = 0x1a
3567 */
3568 static const struct hda_verb alc880_uniwill_init_verbs[] = {
3569 {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
3570
3571 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3572 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3573 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3574 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3575 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3576 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3577 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3578 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3579 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
3580 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
3581 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
3582 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
3583 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
3584 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
3585
3586 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3587 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3588 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3589 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3590 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3591 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3592 /* {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, */
3593 /* {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, */
3594 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3595
3596 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
3597 {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
3598
3599 { }
3600 };
3601
3602 /*
3603 * Uniwill P53
3604 * HP = 0x14, InternalSpeaker = 0x15, mic = 0x19,
3605 */
3606 static const struct hda_verb alc880_uniwill_p53_init_verbs[] = {
3607 {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
3608
3609 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3610 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3611 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3612 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3613 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3614 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3615 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
3616 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
3617 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
3618 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
3619 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
3620 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
3621
3622 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3623 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3624 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3625 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3626 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3627 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3628
3629 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
3630 {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_DCVOL_EVENT},
3631
3632 { }
3633 };
3634
3635 static const struct hda_verb alc880_beep_init_verbs[] = {
3636 { 0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(5) },
3637 { }
3638 };
3639
3640 /* auto-toggle front mic */
3641 static void alc88x_simple_mic_automute(struct hda_codec *codec)
3642 {
3643 unsigned int present;
3644 unsigned char bits;
3645
3646 present = snd_hda_jack_detect(codec, 0x18);
3647 bits = present ? HDA_AMP_MUTE : 0;
3648 snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1, HDA_AMP_MUTE, bits);
3649 }
3650
3651 static void alc880_uniwill_setup(struct hda_codec *codec)
3652 {
3653 struct alc_spec *spec = codec->spec;
3654
3655 spec->autocfg.hp_pins[0] = 0x14;
3656 spec->autocfg.speaker_pins[0] = 0x15;
3657 spec->autocfg.speaker_pins[0] = 0x16;
3658 spec->automute = 1;
3659 spec->automute_mode = ALC_AUTOMUTE_AMP;
3660 }
3661
3662 static void alc880_uniwill_init_hook(struct hda_codec *codec)
3663 {
3664 alc_hp_automute(codec);
3665 alc88x_simple_mic_automute(codec);
3666 }
3667
3668 static void alc880_uniwill_unsol_event(struct hda_codec *codec,
3669 unsigned int res)
3670 {
3671 /* Looks like the unsol event is incompatible with the standard
3672 * definition. 4bit tag is placed at 28 bit!
3673 */
3674 switch (res >> 28) {
3675 case ALC880_MIC_EVENT:
3676 alc88x_simple_mic_automute(codec);
3677 break;
3678 default:
3679 alc_sku_unsol_event(codec, res);
3680 break;
3681 }
3682 }
3683
3684 static void alc880_uniwill_p53_setup(struct hda_codec *codec)
3685 {
3686 struct alc_spec *spec = codec->spec;
3687
3688 spec->autocfg.hp_pins[0] = 0x14;
3689 spec->autocfg.speaker_pins[0] = 0x15;
3690 spec->automute = 1;
3691 spec->automute_mode = ALC_AUTOMUTE_AMP;
3692 }
3693
3694 static void alc880_uniwill_p53_dcvol_automute(struct hda_codec *codec)
3695 {
3696 unsigned int present;
3697
3698 present = snd_hda_codec_read(codec, 0x21, 0,
3699 AC_VERB_GET_VOLUME_KNOB_CONTROL, 0);
3700 present &= HDA_AMP_VOLMASK;
3701 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_OUTPUT, 0,
3702 HDA_AMP_VOLMASK, present);
3703 snd_hda_codec_amp_stereo(codec, 0x0d, HDA_OUTPUT, 0,
3704 HDA_AMP_VOLMASK, present);
3705 }
3706
3707 static void alc880_uniwill_p53_unsol_event(struct hda_codec *codec,
3708 unsigned int res)
3709 {
3710 /* Looks like the unsol event is incompatible with the standard
3711 * definition. 4bit tag is placed at 28 bit!
3712 */
3713 if ((res >> 28) == ALC880_DCVOL_EVENT)
3714 alc880_uniwill_p53_dcvol_automute(codec);
3715 else
3716 alc_sku_unsol_event(codec, res);
3717 }
3718
3719 /*
3720 * F1734 pin configuration:
3721 * HP = 0x14, speaker-out = 0x15, mic = 0x18
3722 */
3723 static const struct hda_verb alc880_pin_f1734_init_verbs[] = {
3724 {0x07, AC_VERB_SET_CONNECT_SEL, 0x01},
3725 {0x10, AC_VERB_SET_CONNECT_SEL, 0x02},
3726 {0x11, AC_VERB_SET_CONNECT_SEL, 0x00},
3727 {0x12, AC_VERB_SET_CONNECT_SEL, 0x01},
3728 {0x13, AC_VERB_SET_CONNECT_SEL, 0x00},
3729
3730 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3731 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3732 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3733 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3734
3735 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3736 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3737 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
3738 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3739 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3740 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3741 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3742 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3743 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3744
3745 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_HP_EVENT},
3746 {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_DCVOL_EVENT},
3747
3748 { }
3749 };
3750
3751 /*
3752 * ASUS pin configuration:
3753 * HP/front = 0x14, surr = 0x15, clfe = 0x16, mic = 0x18, line = 0x1a
3754 */
3755 static const struct hda_verb alc880_pin_asus_init_verbs[] = {
3756 {0x10, AC_VERB_SET_CONNECT_SEL, 0x02},
3757 {0x11, AC_VERB_SET_CONNECT_SEL, 0x00},
3758 {0x12, AC_VERB_SET_CONNECT_SEL, 0x01},
3759 {0x13, AC_VERB_SET_CONNECT_SEL, 0x00},
3760
3761 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3762 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3763 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3764 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3765 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3766 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3767 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3768 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3769
3770 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3771 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3772 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3773 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3774 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3775 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3776 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3777 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3778 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3779
3780 { }
3781 };
3782
3783 /* Enable GPIO mask and set output */
3784 #define alc880_gpio1_init_verbs alc_gpio1_init_verbs
3785 #define alc880_gpio2_init_verbs alc_gpio2_init_verbs
3786 #define alc880_gpio3_init_verbs alc_gpio3_init_verbs
3787
3788 /* Clevo m520g init */
3789 static const struct hda_verb alc880_pin_clevo_init_verbs[] = {
3790 /* headphone output */
3791 {0x11, AC_VERB_SET_CONNECT_SEL, 0x01},
3792 /* line-out */
3793 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3794 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3795 /* Line-in */
3796 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3797 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3798 /* CD */
3799 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3800 {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3801 /* Mic1 (rear panel) */
3802 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3803 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3804 /* Mic2 (front panel) */
3805 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3806 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3807 /* headphone */
3808 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3809 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3810 /* change to EAPD mode */
3811 {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
3812 {0x20, AC_VERB_SET_PROC_COEF, 0x3060},
3813
3814 { }
3815 };
3816
3817 static const struct hda_verb alc880_pin_tcl_S700_init_verbs[] = {
3818 /* change to EAPD mode */
3819 {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
3820 {0x20, AC_VERB_SET_PROC_COEF, 0x3060},
3821
3822 /* Headphone output */
3823 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3824 /* Front output*/
3825 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3826 {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
3827
3828 /* Line In pin widget for input */
3829 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3830 /* CD pin widget for input */
3831 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3832 /* Mic1 (rear panel) pin widget for input and vref at 80% */
3833 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3834
3835 /* change to EAPD mode */
3836 {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
3837 {0x20, AC_VERB_SET_PROC_COEF, 0x3070},
3838
3839 { }
3840 };
3841
3842 /*
3843 * LG m1 express dual
3844 *
3845 * Pin assignment:
3846 * Rear Line-In/Out (blue): 0x14
3847 * Build-in Mic-In: 0x15
3848 * Speaker-out: 0x17
3849 * HP-Out (green): 0x1b
3850 * Mic-In/Out (red): 0x19
3851 * SPDIF-Out: 0x1e
3852 */
3853
3854 /* To make 5.1 output working (green=Front, blue=Surr, red=CLFE) */
3855 static const hda_nid_t alc880_lg_dac_nids[3] = {
3856 0x05, 0x02, 0x03
3857 };
3858
3859 /* seems analog CD is not working */
3860 static const struct hda_input_mux alc880_lg_capture_source = {
3861 .num_items = 3,
3862 .items = {
3863 { "Mic", 0x1 },
3864 { "Line", 0x5 },
3865 { "Internal Mic", 0x6 },
3866 },
3867 };
3868
3869 /* 2,4,6 channel modes */
3870 static const struct hda_verb alc880_lg_ch2_init[] = {
3871 /* set line-in and mic-in to input */
3872 { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
3873 { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
3874 { }
3875 };
3876
3877 static const struct hda_verb alc880_lg_ch4_init[] = {
3878 /* set line-in to out and mic-in to input */
3879 { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },
3880 { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
3881 { }
3882 };
3883
3884 static const struct hda_verb alc880_lg_ch6_init[] = {
3885 /* set line-in and mic-in to output */
3886 { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },
3887 { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },
3888 { }
3889 };
3890
3891 static const struct hda_channel_mode alc880_lg_ch_modes[3] = {
3892 { 2, alc880_lg_ch2_init },
3893 { 4, alc880_lg_ch4_init },
3894 { 6, alc880_lg_ch6_init },
3895 };
3896
3897 static const struct snd_kcontrol_new alc880_lg_mixer[] = {
3898 HDA_CODEC_VOLUME("Front Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
3899 HDA_BIND_MUTE("Front Playback Switch", 0x0f, 2, HDA_INPUT),
3900 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
3901 HDA_BIND_MUTE("Surround Playback Switch", 0x0c, 2, HDA_INPUT),
3902 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0d, 1, 0x0, HDA_OUTPUT),
3903 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0d, 2, 0x0, HDA_OUTPUT),
3904 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0d, 1, 2, HDA_INPUT),
3905 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0d, 2, 2, HDA_INPUT),
3906 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
3907 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
3908 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x06, HDA_INPUT),
3909 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x06, HDA_INPUT),
3910 HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x07, HDA_INPUT),
3911 HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x07, HDA_INPUT),
3912 {
3913 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3914 .name = "Channel Mode",
3915 .info = alc_ch_mode_info,
3916 .get = alc_ch_mode_get,
3917 .put = alc_ch_mode_put,
3918 },
3919 { } /* end */
3920 };
3921
3922 static const struct hda_verb alc880_lg_init_verbs[] = {
3923 /* set capture source to mic-in */
3924 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3925 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3926 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3927 /* mute all amp mixer inputs */
3928 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(5)},
3929 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
3930 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
3931 /* line-in to input */
3932 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3933 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3934 /* built-in mic */
3935 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3936 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3937 /* speaker-out */
3938 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3939 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3940 /* mic-in to input */
3941 {0x11, AC_VERB_SET_CONNECT_SEL, 0x01},
3942 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3943 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3944 /* HP-out */
3945 {0x13, AC_VERB_SET_CONNECT_SEL, 0x03},
3946 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3947 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3948 /* jack sense */
3949 {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
3950 { }
3951 };
3952
3953 /* toggle speaker-output according to the hp-jack state */
3954 static void alc880_lg_setup(struct hda_codec *codec)
3955 {
3956 struct alc_spec *spec = codec->spec;
3957
3958 spec->autocfg.hp_pins[0] = 0x1b;
3959 spec->autocfg.speaker_pins[0] = 0x17;
3960 spec->automute = 1;
3961 spec->automute_mode = ALC_AUTOMUTE_AMP;
3962 }
3963
3964 /*
3965 * LG LW20
3966 *
3967 * Pin assignment:
3968 * Speaker-out: 0x14
3969 * Mic-In: 0x18
3970 * Built-in Mic-In: 0x19
3971 * Line-In: 0x1b
3972 * HP-Out: 0x1a
3973 * SPDIF-Out: 0x1e
3974 */
3975
3976 static const struct hda_input_mux alc880_lg_lw_capture_source = {
3977 .num_items = 3,
3978 .items = {
3979 { "Mic", 0x0 },
3980 { "Internal Mic", 0x1 },
3981 { "Line In", 0x2 },
3982 },
3983 };
3984
3985 #define alc880_lg_lw_modes alc880_threestack_modes
3986
3987 static const struct snd_kcontrol_new alc880_lg_lw_mixer[] = {
3988 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
3989 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
3990 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
3991 HDA_BIND_MUTE("Surround Playback Switch", 0x0f, 2, HDA_INPUT),
3992 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
3993 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
3994 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
3995 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
3996 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
3997 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
3998 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
3999 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
4000 HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
4001 HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
4002 {
4003 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
4004 .name = "Channel Mode",
4005 .info = alc_ch_mode_info,
4006 .get = alc_ch_mode_get,
4007 .put = alc_ch_mode_put,
4008 },
4009 { } /* end */
4010 };
4011
4012 static const struct hda_verb alc880_lg_lw_init_verbs[] = {
4013 {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
4014 {0x10, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
4015 {0x12, AC_VERB_SET_CONNECT_SEL, 0x03}, /* line/surround */
4016
4017 /* set capture source to mic-in */
4018 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4019 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4020 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4021 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
4022 /* speaker-out */
4023 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
4024 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4025 /* HP-out */
4026 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
4027 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4028 /* mic-in to input */
4029 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
4030 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4031 /* built-in mic */
4032 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
4033 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4034 /* jack sense */
4035 {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
4036 { }
4037 };
4038
4039 /* toggle speaker-output according to the hp-jack state */
4040 static void alc880_lg_lw_setup(struct hda_codec *codec)
4041 {
4042 struct alc_spec *spec = codec->spec;
4043
4044 spec->autocfg.hp_pins[0] = 0x1b;
4045 spec->autocfg.speaker_pins[0] = 0x14;
4046 spec->automute = 1;
4047 spec->automute_mode = ALC_AUTOMUTE_AMP;
4048 }
4049
4050 static const struct snd_kcontrol_new alc880_medion_rim_mixer[] = {
4051 HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
4052 HDA_BIND_MUTE("Master Playback Switch", 0x0c, 2, HDA_INPUT),
4053 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
4054 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
4055 HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
4056 HDA_CODEC_MUTE("Internal Playback Switch", 0x0b, 0x1, HDA_INPUT),
4057 { } /* end */
4058 };
4059
4060 static const struct hda_input_mux alc880_medion_rim_capture_source = {
4061 .num_items = 2,
4062 .items = {
4063 { "Mic", 0x0 },
4064 { "Internal Mic", 0x1 },
4065 },
4066 };
4067
4068 static const struct hda_verb alc880_medion_rim_init_verbs[] = {
4069 {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
4070
4071 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
4072 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4073
4074 /* Mic1 (rear panel) pin widget for input and vref at 80% */
4075 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
4076 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
4077 /* Mic2 (as headphone out) for HP output */
4078 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
4079 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
4080 /* Internal Speaker */
4081 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4082 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4083
4084 {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
4085 {0x20, AC_VERB_SET_PROC_COEF, 0x3060},
4086
4087 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
4088 { }
4089 };
4090
4091 /* toggle speaker-output according to the hp-jack state */
4092 static void alc880_medion_rim_automute(struct hda_codec *codec)
4093 {
4094 struct alc_spec *spec = codec->spec;
4095 alc_hp_automute(codec);
4096 /* toggle EAPD */
4097 if (spec->jack_present)
4098 snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA, 0);
4099 else
4100 snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA, 2);
4101 }
4102
4103 static void alc880_medion_rim_unsol_event(struct hda_codec *codec,
4104 unsigned int res)
4105 {
4106 /* Looks like the unsol event is incompatible with the standard
4107 * definition. 4bit tag is placed at 28 bit!
4108 */
4109 if ((res >> 28) == ALC880_HP_EVENT)
4110 alc880_medion_rim_automute(codec);
4111 }
4112
4113 static void alc880_medion_rim_setup(struct hda_codec *codec)
4114 {
4115 struct alc_spec *spec = codec->spec;
4116
4117 spec->autocfg.hp_pins[0] = 0x14;
4118 spec->autocfg.speaker_pins[0] = 0x1b;
4119 spec->automute = 1;
4120 spec->automute_mode = ALC_AUTOMUTE_AMP;
4121 }
4122
4123 #ifdef CONFIG_SND_HDA_POWER_SAVE
4124 static const struct hda_amp_list alc880_loopbacks[] = {
4125 { 0x0b, HDA_INPUT, 0 },
4126 { 0x0b, HDA_INPUT, 1 },
4127 { 0x0b, HDA_INPUT, 2 },
4128 { 0x0b, HDA_INPUT, 3 },
4129 { 0x0b, HDA_INPUT, 4 },
4130 { } /* end */
4131 };
4132
4133 static const struct hda_amp_list alc880_lg_loopbacks[] = {
4134 { 0x0b, HDA_INPUT, 1 },
4135 { 0x0b, HDA_INPUT, 6 },
4136 { 0x0b, HDA_INPUT, 7 },
4137 { } /* end */
4138 };
4139 #endif
4140
4141 /*
4142 * Common callbacks
4143 */
4144
4145 static void alc_init_special_input_src(struct hda_codec *codec);
4146
4147 static int alc_init(struct hda_codec *codec)
4148 {
4149 struct alc_spec *spec = codec->spec;
4150 unsigned int i;
4151
4152 alc_fix_pll(codec);
4153 alc_auto_init_amp(codec, spec->init_amp);
4154
4155 for (i = 0; i < spec->num_init_verbs; i++)
4156 snd_hda_sequence_write(codec, spec->init_verbs[i]);
4157 alc_init_special_input_src(codec);
4158
4159 if (spec->init_hook)
4160 spec->init_hook(codec);
4161
4162 alc_apply_fixup(codec, ALC_FIXUP_ACT_INIT);
4163
4164 hda_call_check_power_status(codec, 0x01);
4165 return 0;
4166 }
4167
4168 static void alc_unsol_event(struct hda_codec *codec, unsigned int res)
4169 {
4170 struct alc_spec *spec = codec->spec;
4171
4172 if (spec->unsol_event)
4173 spec->unsol_event(codec, res);
4174 }
4175
4176 #ifdef CONFIG_SND_HDA_POWER_SAVE
4177 static int alc_check_power_status(struct hda_codec *codec, hda_nid_t nid)
4178 {
4179 struct alc_spec *spec = codec->spec;
4180 return snd_hda_check_amp_list_power(codec, &spec->loopback, nid);
4181 }
4182 #endif
4183
4184 /*
4185 * Analog playback callbacks
4186 */
4187 static int alc880_playback_pcm_open(struct hda_pcm_stream *hinfo,
4188 struct hda_codec *codec,
4189 struct snd_pcm_substream *substream)
4190 {
4191 struct alc_spec *spec = codec->spec;
4192 return snd_hda_multi_out_analog_open(codec, &spec->multiout, substream,
4193 hinfo);
4194 }
4195
4196 static int alc880_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
4197 struct hda_codec *codec,
4198 unsigned int stream_tag,
4199 unsigned int format,
4200 struct snd_pcm_substream *substream)
4201 {
4202 struct alc_spec *spec = codec->spec;
4203 return snd_hda_multi_out_analog_prepare(codec, &spec->multiout,
4204 stream_tag, format, substream);
4205 }
4206
4207 static int alc880_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
4208 struct hda_codec *codec,
4209 struct snd_pcm_substream *substream)
4210 {
4211 struct alc_spec *spec = codec->spec;
4212 return snd_hda_multi_out_analog_cleanup(codec, &spec->multiout);
4213 }
4214
4215 /*
4216 * Digital out
4217 */
4218 static int alc880_dig_playback_pcm_open(struct hda_pcm_stream *hinfo,
4219 struct hda_codec *codec,
4220 struct snd_pcm_substream *substream)
4221 {
4222 struct alc_spec *spec = codec->spec;
4223 return snd_hda_multi_out_dig_open(codec, &spec->multiout);
4224 }
4225
4226 static int alc880_dig_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
4227 struct hda_codec *codec,
4228 unsigned int stream_tag,
4229 unsigned int format,
4230 struct snd_pcm_substream *substream)
4231 {
4232 struct alc_spec *spec = codec->spec;
4233 return snd_hda_multi_out_dig_prepare(codec, &spec->multiout,
4234 stream_tag, format, substream);
4235 }
4236
4237 static int alc880_dig_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
4238 struct hda_codec *codec,
4239 struct snd_pcm_substream *substream)
4240 {
4241 struct alc_spec *spec = codec->spec;
4242 return snd_hda_multi_out_dig_cleanup(codec, &spec->multiout);
4243 }
4244
4245 static int alc880_dig_playback_pcm_close(struct hda_pcm_stream *hinfo,
4246 struct hda_codec *codec,
4247 struct snd_pcm_substream *substream)
4248 {
4249 struct alc_spec *spec = codec->spec;
4250 return snd_hda_multi_out_dig_close(codec, &spec->multiout);
4251 }
4252
4253 /*
4254 * Analog capture
4255 */
4256 static int alc880_alt_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
4257 struct hda_codec *codec,
4258 unsigned int stream_tag,
4259 unsigned int format,
4260 struct snd_pcm_substream *substream)
4261 {
4262 struct alc_spec *spec = codec->spec;
4263
4264 snd_hda_codec_setup_stream(codec, spec->adc_nids[substream->number + 1],
4265 stream_tag, 0, format);
4266 return 0;
4267 }
4268
4269 static int alc880_alt_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
4270 struct hda_codec *codec,
4271 struct snd_pcm_substream *substream)
4272 {
4273 struct alc_spec *spec = codec->spec;
4274
4275 snd_hda_codec_cleanup_stream(codec,
4276 spec->adc_nids[substream->number + 1]);
4277 return 0;
4278 }
4279
4280 /* analog capture with dynamic dual-adc changes */
4281 static int dualmic_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
4282 struct hda_codec *codec,
4283 unsigned int stream_tag,
4284 unsigned int format,
4285 struct snd_pcm_substream *substream)
4286 {
4287 struct alc_spec *spec = codec->spec;
4288 spec->cur_adc = spec->adc_nids[spec->cur_adc_idx];
4289 spec->cur_adc_stream_tag = stream_tag;
4290 spec->cur_adc_format = format;
4291 snd_hda_codec_setup_stream(codec, spec->cur_adc, stream_tag, 0, format);
4292 return 0;
4293 }
4294
4295 static int dualmic_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
4296 struct hda_codec *codec,
4297 struct snd_pcm_substream *substream)
4298 {
4299 struct alc_spec *spec = codec->spec;
4300 snd_hda_codec_cleanup_stream(codec, spec->cur_adc);
4301 spec->cur_adc = 0;
4302 return 0;
4303 }
4304
4305 static const struct hda_pcm_stream dualmic_pcm_analog_capture = {
4306 .substreams = 1,
4307 .channels_min = 2,
4308 .channels_max = 2,
4309 .nid = 0, /* fill later */
4310 .ops = {
4311 .prepare = dualmic_capture_pcm_prepare,
4312 .cleanup = dualmic_capture_pcm_cleanup
4313 },
4314 };
4315
4316 /*
4317 */
4318 static const struct hda_pcm_stream alc880_pcm_analog_playback = {
4319 .substreams = 1,
4320 .channels_min = 2,
4321 .channels_max = 8,
4322 /* NID is set in alc_build_pcms */
4323 .ops = {
4324 .open = alc880_playback_pcm_open,
4325 .prepare = alc880_playback_pcm_prepare,
4326 .cleanup = alc880_playback_pcm_cleanup
4327 },
4328 };
4329
4330 static const struct hda_pcm_stream alc880_pcm_analog_capture = {
4331 .substreams = 1,
4332 .channels_min = 2,
4333 .channels_max = 2,
4334 /* NID is set in alc_build_pcms */
4335 };
4336
4337 static const struct hda_pcm_stream alc880_pcm_analog_alt_playback = {
4338 .substreams = 1,
4339 .channels_min = 2,
4340 .channels_max = 2,
4341 /* NID is set in alc_build_pcms */
4342 };
4343
4344 static const struct hda_pcm_stream alc880_pcm_analog_alt_capture = {
4345 .substreams = 2, /* can be overridden */
4346 .channels_min = 2,
4347 .channels_max = 2,
4348 /* NID is set in alc_build_pcms */
4349 .ops = {
4350 .prepare = alc880_alt_capture_pcm_prepare,
4351 .cleanup = alc880_alt_capture_pcm_cleanup
4352 },
4353 };
4354
4355 static const struct hda_pcm_stream alc880_pcm_digital_playback = {
4356 .substreams = 1,
4357 .channels_min = 2,
4358 .channels_max = 2,
4359 /* NID is set in alc_build_pcms */
4360 .ops = {
4361 .open = alc880_dig_playback_pcm_open,
4362 .close = alc880_dig_playback_pcm_close,
4363 .prepare = alc880_dig_playback_pcm_prepare,
4364 .cleanup = alc880_dig_playback_pcm_cleanup
4365 },
4366 };
4367
4368 static const struct hda_pcm_stream alc880_pcm_digital_capture = {
4369 .substreams = 1,
4370 .channels_min = 2,
4371 .channels_max = 2,
4372 /* NID is set in alc_build_pcms */
4373 };
4374
4375 /* Used by alc_build_pcms to flag that a PCM has no playback stream */
4376 static const struct hda_pcm_stream alc_pcm_null_stream = {
4377 .substreams = 0,
4378 .channels_min = 0,
4379 .channels_max = 0,
4380 };
4381
4382 static int alc_build_pcms(struct hda_codec *codec)
4383 {
4384 struct alc_spec *spec = codec->spec;
4385 struct hda_pcm *info = spec->pcm_rec;
4386 int i;
4387
4388 codec->num_pcms = 1;
4389 codec->pcm_info = info;
4390
4391 if (spec->no_analog)
4392 goto skip_analog;
4393
4394 snprintf(spec->stream_name_analog, sizeof(spec->stream_name_analog),
4395 "%s Analog", codec->chip_name);
4396 info->name = spec->stream_name_analog;
4397
4398 if (spec->stream_analog_playback) {
4399 if (snd_BUG_ON(!spec->multiout.dac_nids))
4400 return -EINVAL;
4401 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *(spec->stream_analog_playback);
4402 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dac_nids[0];
4403 }
4404 if (spec->stream_analog_capture) {
4405 if (snd_BUG_ON(!spec->adc_nids))
4406 return -EINVAL;
4407 info->stream[SNDRV_PCM_STREAM_CAPTURE] = *(spec->stream_analog_capture);
4408 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adc_nids[0];
4409 }
4410
4411 if (spec->channel_mode) {
4412 info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max = 0;
4413 for (i = 0; i < spec->num_channel_mode; i++) {
4414 if (spec->channel_mode[i].channels > info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max) {
4415 info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max = spec->channel_mode[i].channels;
4416 }
4417 }
4418 }
4419
4420 skip_analog:
4421 /* SPDIF for stream index #1 */
4422 if (spec->multiout.dig_out_nid || spec->dig_in_nid) {
4423 snprintf(spec->stream_name_digital,
4424 sizeof(spec->stream_name_digital),
4425 "%s Digital", codec->chip_name);
4426 codec->num_pcms = 2;
4427 codec->slave_dig_outs = spec->multiout.slave_dig_outs;
4428 info = spec->pcm_rec + 1;
4429 info->name = spec->stream_name_digital;
4430 if (spec->dig_out_type)
4431 info->pcm_type = spec->dig_out_type;
4432 else
4433 info->pcm_type = HDA_PCM_TYPE_SPDIF;
4434 if (spec->multiout.dig_out_nid &&
4435 spec->stream_digital_playback) {
4436 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *(spec->stream_digital_playback);
4437 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dig_out_nid;
4438 }
4439 if (spec->dig_in_nid &&
4440 spec->stream_digital_capture) {
4441 info->stream[SNDRV_PCM_STREAM_CAPTURE] = *(spec->stream_digital_capture);
4442 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->dig_in_nid;
4443 }
4444 /* FIXME: do we need this for all Realtek codec models? */
4445 codec->spdif_status_reset = 1;
4446 }
4447
4448 if (spec->no_analog)
4449 return 0;
4450
4451 /* If the use of more than one ADC is requested for the current
4452 * model, configure a second analog capture-only PCM.
4453 */
4454 /* Additional Analaog capture for index #2 */
4455 if ((spec->alt_dac_nid && spec->stream_analog_alt_playback) ||
4456 (spec->num_adc_nids > 1 && spec->stream_analog_alt_capture)) {
4457 codec->num_pcms = 3;
4458 info = spec->pcm_rec + 2;
4459 info->name = spec->stream_name_analog;
4460 if (spec->alt_dac_nid) {
4461 info->stream[SNDRV_PCM_STREAM_PLAYBACK] =
4462 *spec->stream_analog_alt_playback;
4463 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid =
4464 spec->alt_dac_nid;
4465 } else {
4466 info->stream[SNDRV_PCM_STREAM_PLAYBACK] =
4467 alc_pcm_null_stream;
4468 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = 0;
4469 }
4470 if (spec->num_adc_nids > 1 && spec->stream_analog_alt_capture) {
4471 info->stream[SNDRV_PCM_STREAM_CAPTURE] =
4472 *spec->stream_analog_alt_capture;
4473 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid =
4474 spec->adc_nids[1];
4475 info->stream[SNDRV_PCM_STREAM_CAPTURE].substreams =
4476 spec->num_adc_nids - 1;
4477 } else {
4478 info->stream[SNDRV_PCM_STREAM_CAPTURE] =
4479 alc_pcm_null_stream;
4480 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = 0;
4481 }
4482 }
4483
4484 return 0;
4485 }
4486
4487 static inline void alc_shutup(struct hda_codec *codec)
4488 {
4489 struct alc_spec *spec = codec->spec;
4490
4491 if (spec && spec->shutup)
4492 spec->shutup(codec);
4493 snd_hda_shutup_pins(codec);
4494 }
4495
4496 static void alc_free_kctls(struct hda_codec *codec)
4497 {
4498 struct alc_spec *spec = codec->spec;
4499
4500 if (spec->kctls.list) {
4501 struct snd_kcontrol_new *kctl = spec->kctls.list;
4502 int i;
4503 for (i = 0; i < spec->kctls.used; i++)
4504 kfree(kctl[i].name);
4505 }
4506 snd_array_free(&spec->kctls);
4507 }
4508
4509 static void alc_free(struct hda_codec *codec)
4510 {
4511 struct alc_spec *spec = codec->spec;
4512
4513 if (!spec)
4514 return;
4515
4516 alc_shutup(codec);
4517 snd_hda_input_jack_free(codec);
4518 alc_free_kctls(codec);
4519 kfree(spec);
4520 snd_hda_detach_beep_device(codec);
4521 }
4522
4523 #ifdef CONFIG_SND_HDA_POWER_SAVE
4524 static void alc_power_eapd(struct hda_codec *codec)
4525 {
4526 alc_auto_setup_eapd(codec, false);
4527 }
4528
4529 static int alc_suspend(struct hda_codec *codec, pm_message_t state)
4530 {
4531 struct alc_spec *spec = codec->spec;
4532 alc_shutup(codec);
4533 if (spec && spec->power_hook)
4534 spec->power_hook(codec);
4535 return 0;
4536 }
4537 #endif
4538
4539 #ifdef SND_HDA_NEEDS_RESUME
4540 static int alc_resume(struct hda_codec *codec)
4541 {
4542 msleep(150); /* to avoid pop noise */
4543 codec->patch_ops.init(codec);
4544 snd_hda_codec_resume_amp(codec);
4545 snd_hda_codec_resume_cache(codec);
4546 hda_call_check_power_status(codec, 0x01);
4547 return 0;
4548 }
4549 #endif
4550
4551 /*
4552 */
4553 static const struct hda_codec_ops alc_patch_ops = {
4554 .build_controls = alc_build_controls,
4555 .build_pcms = alc_build_pcms,
4556 .init = alc_init,
4557 .free = alc_free,
4558 .unsol_event = alc_unsol_event,
4559 #ifdef SND_HDA_NEEDS_RESUME
4560 .resume = alc_resume,
4561 #endif
4562 #ifdef CONFIG_SND_HDA_POWER_SAVE
4563 .suspend = alc_suspend,
4564 .check_power_status = alc_check_power_status,
4565 #endif
4566 .reboot_notify = alc_shutup,
4567 };
4568
4569 /* replace the codec chip_name with the given string */
4570 static int alc_codec_rename(struct hda_codec *codec, const char *name)
4571 {
4572 kfree(codec->chip_name);
4573 codec->chip_name = kstrdup(name, GFP_KERNEL);
4574 if (!codec->chip_name) {
4575 alc_free(codec);
4576 return -ENOMEM;
4577 }
4578 return 0;
4579 }
4580
4581 /*
4582 * Test configuration for debugging
4583 *
4584 * Almost all inputs/outputs are enabled. I/O pins can be configured via
4585 * enum controls.
4586 */
4587 #ifdef CONFIG_SND_DEBUG
4588 static const hda_nid_t alc880_test_dac_nids[4] = {
4589 0x02, 0x03, 0x04, 0x05
4590 };
4591
4592 static const struct hda_input_mux alc880_test_capture_source = {
4593 .num_items = 7,
4594 .items = {
4595 { "In-1", 0x0 },
4596 { "In-2", 0x1 },
4597 { "In-3", 0x2 },
4598 { "In-4", 0x3 },
4599 { "CD", 0x4 },
4600 { "Front", 0x5 },
4601 { "Surround", 0x6 },
4602 },
4603 };
4604
4605 static const struct hda_channel_mode alc880_test_modes[4] = {
4606 { 2, NULL },
4607 { 4, NULL },
4608 { 6, NULL },
4609 { 8, NULL },
4610 };
4611
4612 static int alc_test_pin_ctl_info(struct snd_kcontrol *kcontrol,
4613 struct snd_ctl_elem_info *uinfo)
4614 {
4615 static const char * const texts[] = {
4616 "N/A", "Line Out", "HP Out",
4617 "In Hi-Z", "In 50%", "In Grd", "In 80%", "In 100%"
4618 };
4619 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
4620 uinfo->count = 1;
4621 uinfo->value.enumerated.items = 8;
4622 if (uinfo->value.enumerated.item >= 8)
4623 uinfo->value.enumerated.item = 7;
4624 strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
4625 return 0;
4626 }
4627
4628 static int alc_test_pin_ctl_get(struct snd_kcontrol *kcontrol,
4629 struct snd_ctl_elem_value *ucontrol)
4630 {
4631 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
4632 hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
4633 unsigned int pin_ctl, item = 0;
4634
4635 pin_ctl = snd_hda_codec_read(codec, nid, 0,
4636 AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
4637 if (pin_ctl & AC_PINCTL_OUT_EN) {
4638 if (pin_ctl & AC_PINCTL_HP_EN)
4639 item = 2;
4640 else
4641 item = 1;
4642 } else if (pin_ctl & AC_PINCTL_IN_EN) {
4643 switch (pin_ctl & AC_PINCTL_VREFEN) {
4644 case AC_PINCTL_VREF_HIZ: item = 3; break;
4645 case AC_PINCTL_VREF_50: item = 4; break;
4646 case AC_PINCTL_VREF_GRD: item = 5; break;
4647 case AC_PINCTL_VREF_80: item = 6; break;
4648 case AC_PINCTL_VREF_100: item = 7; break;
4649 }
4650 }
4651 ucontrol->value.enumerated.item[0] = item;
4652 return 0;
4653 }
4654
4655 static int alc_test_pin_ctl_put(struct snd_kcontrol *kcontrol,
4656 struct snd_ctl_elem_value *ucontrol)
4657 {
4658 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
4659 hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
4660 static const unsigned int ctls[] = {
4661 0, AC_PINCTL_OUT_EN, AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN,
4662 AC_PINCTL_IN_EN | AC_PINCTL_VREF_HIZ,
4663 AC_PINCTL_IN_EN | AC_PINCTL_VREF_50,
4664 AC_PINCTL_IN_EN | AC_PINCTL_VREF_GRD,
4665 AC_PINCTL_IN_EN | AC_PINCTL_VREF_80,
4666 AC_PINCTL_IN_EN | AC_PINCTL_VREF_100,
4667 };
4668 unsigned int old_ctl, new_ctl;
4669
4670 old_ctl = snd_hda_codec_read(codec, nid, 0,
4671 AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
4672 new_ctl = ctls[ucontrol->value.enumerated.item[0]];
4673 if (old_ctl != new_ctl) {
4674 int val;
4675 snd_hda_codec_write_cache(codec, nid, 0,
4676 AC_VERB_SET_PIN_WIDGET_CONTROL,
4677 new_ctl);
4678 val = ucontrol->value.enumerated.item[0] >= 3 ?
4679 HDA_AMP_MUTE : 0;
4680 snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
4681 HDA_AMP_MUTE, val);
4682 return 1;
4683 }
4684 return 0;
4685 }
4686
4687 static int alc_test_pin_src_info(struct snd_kcontrol *kcontrol,
4688 struct snd_ctl_elem_info *uinfo)
4689 {
4690 static const char * const texts[] = {
4691 "Front", "Surround", "CLFE", "Side"
4692 };
4693 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
4694 uinfo->count = 1;
4695 uinfo->value.enumerated.items = 4;
4696 if (uinfo->value.enumerated.item >= 4)
4697 uinfo->value.enumerated.item = 3;
4698 strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
4699 return 0;
4700 }
4701
4702 static int alc_test_pin_src_get(struct snd_kcontrol *kcontrol,
4703 struct snd_ctl_elem_value *ucontrol)
4704 {
4705 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
4706 hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
4707 unsigned int sel;
4708
4709 sel = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_CONNECT_SEL, 0);
4710 ucontrol->value.enumerated.item[0] = sel & 3;
4711 return 0;
4712 }
4713
4714 static int alc_test_pin_src_put(struct snd_kcontrol *kcontrol,
4715 struct snd_ctl_elem_value *ucontrol)
4716 {
4717 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
4718 hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
4719 unsigned int sel;
4720
4721 sel = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_CONNECT_SEL, 0) & 3;
4722 if (ucontrol->value.enumerated.item[0] != sel) {
4723 sel = ucontrol->value.enumerated.item[0] & 3;
4724 snd_hda_codec_write_cache(codec, nid, 0,
4725 AC_VERB_SET_CONNECT_SEL, sel);
4726 return 1;
4727 }
4728 return 0;
4729 }
4730
4731 #define PIN_CTL_TEST(xname,nid) { \
4732 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
4733 .name = xname, \
4734 .subdevice = HDA_SUBDEV_NID_FLAG | nid, \
4735 .info = alc_test_pin_ctl_info, \
4736 .get = alc_test_pin_ctl_get, \
4737 .put = alc_test_pin_ctl_put, \
4738 .private_value = nid \
4739 }
4740
4741 #define PIN_SRC_TEST(xname,nid) { \
4742 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
4743 .name = xname, \
4744 .subdevice = HDA_SUBDEV_NID_FLAG | nid, \
4745 .info = alc_test_pin_src_info, \
4746 .get = alc_test_pin_src_get, \
4747 .put = alc_test_pin_src_put, \
4748 .private_value = nid \
4749 }
4750
4751 static const struct snd_kcontrol_new alc880_test_mixer[] = {
4752 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
4753 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
4754 HDA_CODEC_VOLUME("CLFE Playback Volume", 0x0e, 0x0, HDA_OUTPUT),
4755 HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
4756 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
4757 HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
4758 HDA_BIND_MUTE("CLFE Playback Switch", 0x0e, 2, HDA_INPUT),
4759 HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
4760 PIN_CTL_TEST("Front Pin Mode", 0x14),
4761 PIN_CTL_TEST("Surround Pin Mode", 0x15),
4762 PIN_CTL_TEST("CLFE Pin Mode", 0x16),
4763 PIN_CTL_TEST("Side Pin Mode", 0x17),
4764 PIN_CTL_TEST("In-1 Pin Mode", 0x18),
4765 PIN_CTL_TEST("In-2 Pin Mode", 0x19),
4766 PIN_CTL_TEST("In-3 Pin Mode", 0x1a),
4767 PIN_CTL_TEST("In-4 Pin Mode", 0x1b),
4768 PIN_SRC_TEST("In-1 Pin Source", 0x18),
4769 PIN_SRC_TEST("In-2 Pin Source", 0x19),
4770 PIN_SRC_TEST("In-3 Pin Source", 0x1a),
4771 PIN_SRC_TEST("In-4 Pin Source", 0x1b),
4772 HDA_CODEC_VOLUME("In-1 Playback Volume", 0x0b, 0x0, HDA_INPUT),
4773 HDA_CODEC_MUTE("In-1 Playback Switch", 0x0b, 0x0, HDA_INPUT),
4774 HDA_CODEC_VOLUME("In-2 Playback Volume", 0x0b, 0x1, HDA_INPUT),
4775 HDA_CODEC_MUTE("In-2 Playback Switch", 0x0b, 0x1, HDA_INPUT),
4776 HDA_CODEC_VOLUME("In-3 Playback Volume", 0x0b, 0x2, HDA_INPUT),
4777 HDA_CODEC_MUTE("In-3 Playback Switch", 0x0b, 0x2, HDA_INPUT),
4778 HDA_CODEC_VOLUME("In-4 Playback Volume", 0x0b, 0x3, HDA_INPUT),
4779 HDA_CODEC_MUTE("In-4 Playback Switch", 0x0b, 0x3, HDA_INPUT),
4780 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x4, HDA_INPUT),
4781 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x4, HDA_INPUT),
4782 {
4783 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
4784 .name = "Channel Mode",
4785 .info = alc_ch_mode_info,
4786 .get = alc_ch_mode_get,
4787 .put = alc_ch_mode_put,
4788 },
4789 { } /* end */
4790 };
4791
4792 static const struct hda_verb alc880_test_init_verbs[] = {
4793 /* Unmute inputs of 0x0c - 0x0f */
4794 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4795 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
4796 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4797 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
4798 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4799 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
4800 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4801 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
4802 /* Vol output for 0x0c-0x0f */
4803 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4804 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4805 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4806 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4807 /* Set output pins 0x14-0x17 */
4808 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4809 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4810 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4811 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4812 /* Unmute output pins 0x14-0x17 */
4813 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4814 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4815 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4816 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4817 /* Set input pins 0x18-0x1c */
4818 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
4819 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
4820 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
4821 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
4822 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
4823 /* Mute input pins 0x18-0x1b */
4824 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
4825 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
4826 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
4827 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
4828 /* ADC set up */
4829 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4830 {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
4831 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4832 {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
4833 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4834 {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
4835 /* Analog input/passthru */
4836 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4837 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4838 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
4839 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
4840 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
4841 { }
4842 };
4843 #endif
4844
4845 /*
4846 */
4847
4848 static const char * const alc880_models[ALC880_MODEL_LAST] = {
4849 [ALC880_3ST] = "3stack",
4850 [ALC880_TCL_S700] = "tcl",
4851 [ALC880_3ST_DIG] = "3stack-digout",
4852 [ALC880_CLEVO] = "clevo",
4853 [ALC880_5ST] = "5stack",
4854 [ALC880_5ST_DIG] = "5stack-digout",
4855 [ALC880_W810] = "w810",
4856 [ALC880_Z71V] = "z71v",
4857 [ALC880_6ST] = "6stack",
4858 [ALC880_6ST_DIG] = "6stack-digout",
4859 [ALC880_ASUS] = "asus",
4860 [ALC880_ASUS_W1V] = "asus-w1v",
4861 [ALC880_ASUS_DIG] = "asus-dig",
4862 [ALC880_ASUS_DIG2] = "asus-dig2",
4863 [ALC880_UNIWILL_DIG] = "uniwill",
4864 [ALC880_UNIWILL_P53] = "uniwill-p53",
4865 [ALC880_FUJITSU] = "fujitsu",
4866 [ALC880_F1734] = "F1734",
4867 [ALC880_LG] = "lg",
4868 [ALC880_LG_LW] = "lg-lw",
4869 [ALC880_MEDION_RIM] = "medion",
4870 #ifdef CONFIG_SND_DEBUG
4871 [ALC880_TEST] = "test",
4872 #endif
4873 [ALC880_AUTO] = "auto",
4874 };
4875
4876 static const struct snd_pci_quirk alc880_cfg_tbl[] = {
4877 SND_PCI_QUIRK(0x1019, 0x0f69, "Coeus G610P", ALC880_W810),
4878 SND_PCI_QUIRK(0x1019, 0xa880, "ECS", ALC880_5ST_DIG),
4879 SND_PCI_QUIRK(0x1019, 0xa884, "Acer APFV", ALC880_6ST),
4880 SND_PCI_QUIRK(0x1025, 0x0070, "ULI", ALC880_3ST_DIG),
4881 SND_PCI_QUIRK(0x1025, 0x0077, "ULI", ALC880_6ST_DIG),
4882 SND_PCI_QUIRK(0x1025, 0x0078, "ULI", ALC880_6ST_DIG),
4883 SND_PCI_QUIRK(0x1025, 0x0087, "ULI", ALC880_6ST_DIG),
4884 SND_PCI_QUIRK(0x1025, 0xe309, "ULI", ALC880_3ST_DIG),
4885 SND_PCI_QUIRK(0x1025, 0xe310, "ULI", ALC880_3ST),
4886 SND_PCI_QUIRK(0x1039, 0x1234, NULL, ALC880_6ST_DIG),
4887 SND_PCI_QUIRK(0x103c, 0x2a09, "HP", ALC880_5ST),
4888 SND_PCI_QUIRK(0x1043, 0x10b3, "ASUS W1V", ALC880_ASUS_W1V),
4889 SND_PCI_QUIRK(0x1043, 0x10c2, "ASUS W6A", ALC880_ASUS_DIG),
4890 SND_PCI_QUIRK(0x1043, 0x10c3, "ASUS Wxx", ALC880_ASUS_DIG),
4891 SND_PCI_QUIRK(0x1043, 0x1113, "ASUS", ALC880_ASUS_DIG),
4892 SND_PCI_QUIRK(0x1043, 0x1123, "ASUS", ALC880_ASUS_DIG),
4893 SND_PCI_QUIRK(0x1043, 0x1173, "ASUS", ALC880_ASUS_DIG),
4894 SND_PCI_QUIRK(0x1043, 0x1964, "ASUS Z71V", ALC880_Z71V),
4895 /* SND_PCI_QUIRK(0x1043, 0x1964, "ASUS", ALC880_ASUS_DIG), */
4896 SND_PCI_QUIRK(0x1043, 0x1973, "ASUS", ALC880_ASUS_DIG),
4897 SND_PCI_QUIRK(0x1043, 0x19b3, "ASUS", ALC880_ASUS_DIG),
4898 SND_PCI_QUIRK(0x1043, 0x814e, "ASUS P5GD1 w/SPDIF", ALC880_6ST_DIG),
4899 SND_PCI_QUIRK(0x1043, 0x8181, "ASUS P4GPL", ALC880_ASUS_DIG),
4900 SND_PCI_QUIRK(0x1043, 0x8196, "ASUS P5GD1", ALC880_6ST),
4901 SND_PCI_QUIRK(0x1043, 0x81b4, "ASUS", ALC880_6ST),
4902 SND_PCI_QUIRK_VENDOR(0x1043, "ASUS", ALC880_ASUS), /* default ASUS */
4903 SND_PCI_QUIRK(0x104d, 0x81a0, "Sony", ALC880_3ST),
4904 SND_PCI_QUIRK(0x104d, 0x81d6, "Sony", ALC880_3ST),
4905 SND_PCI_QUIRK(0x107b, 0x3032, "Gateway", ALC880_5ST),
4906 SND_PCI_QUIRK(0x107b, 0x3033, "Gateway", ALC880_5ST),
4907 SND_PCI_QUIRK(0x107b, 0x4039, "Gateway", ALC880_5ST),
4908 SND_PCI_QUIRK(0x1297, 0xc790, "Shuttle ST20G5", ALC880_6ST_DIG),
4909 SND_PCI_QUIRK(0x1458, 0xa102, "Gigabyte K8", ALC880_6ST_DIG),
4910 SND_PCI_QUIRK(0x1462, 0x1150, "MSI", ALC880_6ST_DIG),
4911 SND_PCI_QUIRK(0x1509, 0x925d, "FIC P4M", ALC880_6ST_DIG),
4912 SND_PCI_QUIRK(0x1558, 0x0520, "Clevo m520G", ALC880_CLEVO),
4913 SND_PCI_QUIRK(0x1558, 0x0660, "Clevo m655n", ALC880_CLEVO),
4914 SND_PCI_QUIRK(0x1558, 0x5401, "ASUS", ALC880_ASUS_DIG2),
4915 SND_PCI_QUIRK(0x1565, 0x8202, "Biostar", ALC880_5ST_DIG),
4916 SND_PCI_QUIRK(0x1584, 0x9050, "Uniwill", ALC880_UNIWILL_DIG),
4917 SND_PCI_QUIRK(0x1584, 0x9054, "Uniwill", ALC880_F1734),
4918 SND_PCI_QUIRK(0x1584, 0x9070, "Uniwill", ALC880_UNIWILL),
4919 SND_PCI_QUIRK(0x1584, 0x9077, "Uniwill P53", ALC880_UNIWILL_P53),
4920 SND_PCI_QUIRK(0x161f, 0x203d, "W810", ALC880_W810),
4921 SND_PCI_QUIRK(0x161f, 0x205d, "Medion Rim 2150", ALC880_MEDION_RIM),
4922 SND_PCI_QUIRK(0x1695, 0x400d, "EPoX", ALC880_5ST_DIG),
4923 SND_PCI_QUIRK(0x1695, 0x4012, "EPox EP-5LDA", ALC880_5ST_DIG),
4924 SND_PCI_QUIRK(0x1734, 0x107c, "FSC F1734", ALC880_F1734),
4925 SND_PCI_QUIRK(0x1734, 0x1094, "FSC Amilo M1451G", ALC880_FUJITSU),
4926 SND_PCI_QUIRK(0x1734, 0x10ac, "FSC AMILO Xi 1526", ALC880_F1734),
4927 SND_PCI_QUIRK(0x1734, 0x10b0, "Fujitsu", ALC880_FUJITSU),
4928 SND_PCI_QUIRK(0x1854, 0x0018, "LG LW20", ALC880_LG_LW),
4929 SND_PCI_QUIRK(0x1854, 0x003b, "LG", ALC880_LG),
4930 SND_PCI_QUIRK(0x1854, 0x005f, "LG P1 Express", ALC880_LG),
4931 SND_PCI_QUIRK(0x1854, 0x0068, "LG w1", ALC880_LG),
4932 SND_PCI_QUIRK(0x1854, 0x0077, "LG LW25", ALC880_LG_LW),
4933 SND_PCI_QUIRK(0x19db, 0x4188, "TCL S700", ALC880_TCL_S700),
4934 SND_PCI_QUIRK(0x2668, 0x8086, NULL, ALC880_6ST_DIG), /* broken BIOS */
4935 SND_PCI_QUIRK(0x8086, 0x2668, NULL, ALC880_6ST_DIG),
4936 SND_PCI_QUIRK(0x8086, 0xa100, "Intel mobo", ALC880_5ST_DIG),
4937 SND_PCI_QUIRK(0x8086, 0xd400, "Intel mobo", ALC880_5ST_DIG),
4938 SND_PCI_QUIRK(0x8086, 0xd401, "Intel mobo", ALC880_5ST_DIG),
4939 SND_PCI_QUIRK(0x8086, 0xd402, "Intel mobo", ALC880_3ST_DIG),
4940 SND_PCI_QUIRK(0x8086, 0xe224, "Intel mobo", ALC880_5ST_DIG),
4941 SND_PCI_QUIRK(0x8086, 0xe305, "Intel mobo", ALC880_3ST_DIG),
4942 SND_PCI_QUIRK(0x8086, 0xe308, "Intel mobo", ALC880_3ST_DIG),
4943 SND_PCI_QUIRK(0x8086, 0xe400, "Intel mobo", ALC880_5ST_DIG),
4944 SND_PCI_QUIRK(0x8086, 0xe401, "Intel mobo", ALC880_5ST_DIG),
4945 SND_PCI_QUIRK(0x8086, 0xe402, "Intel mobo", ALC880_5ST_DIG),
4946 /* default Intel */
4947 SND_PCI_QUIRK_VENDOR(0x8086, "Intel mobo", ALC880_3ST),
4948 SND_PCI_QUIRK(0xa0a0, 0x0560, "AOpen i915GMm-HFS", ALC880_5ST_DIG),
4949 SND_PCI_QUIRK(0xe803, 0x1019, NULL, ALC880_6ST_DIG),
4950 {}
4951 };
4952
4953 /*
4954 * ALC880 codec presets
4955 */
4956 static const struct alc_config_preset alc880_presets[] = {
4957 [ALC880_3ST] = {
4958 .mixers = { alc880_three_stack_mixer },
4959 .init_verbs = { alc880_volume_init_verbs,
4960 alc880_pin_3stack_init_verbs },
4961 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
4962 .dac_nids = alc880_dac_nids,
4963 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
4964 .channel_mode = alc880_threestack_modes,
4965 .need_dac_fix = 1,
4966 .input_mux = &alc880_capture_source,
4967 },
4968 [ALC880_3ST_DIG] = {
4969 .mixers = { alc880_three_stack_mixer },
4970 .init_verbs = { alc880_volume_init_verbs,
4971 alc880_pin_3stack_init_verbs },
4972 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
4973 .dac_nids = alc880_dac_nids,
4974 .dig_out_nid = ALC880_DIGOUT_NID,
4975 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
4976 .channel_mode = alc880_threestack_modes,
4977 .need_dac_fix = 1,
4978 .input_mux = &alc880_capture_source,
4979 },
4980 [ALC880_TCL_S700] = {
4981 .mixers = { alc880_tcl_s700_mixer },
4982 .init_verbs = { alc880_volume_init_verbs,
4983 alc880_pin_tcl_S700_init_verbs,
4984 alc880_gpio2_init_verbs },
4985 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
4986 .dac_nids = alc880_dac_nids,
4987 .adc_nids = alc880_adc_nids_alt, /* FIXME: correct? */
4988 .num_adc_nids = 1, /* single ADC */
4989 .hp_nid = 0x03,
4990 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
4991 .channel_mode = alc880_2_jack_modes,
4992 .input_mux = &alc880_capture_source,
4993 },
4994 [ALC880_5ST] = {
4995 .mixers = { alc880_three_stack_mixer,
4996 alc880_five_stack_mixer},
4997 .init_verbs = { alc880_volume_init_verbs,
4998 alc880_pin_5stack_init_verbs },
4999 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
5000 .dac_nids = alc880_dac_nids,
5001 .num_channel_mode = ARRAY_SIZE(alc880_fivestack_modes),
5002 .channel_mode = alc880_fivestack_modes,
5003 .input_mux = &alc880_capture_source,
5004 },
5005 [ALC880_5ST_DIG] = {
5006 .mixers = { alc880_three_stack_mixer,
5007 alc880_five_stack_mixer },
5008 .init_verbs = { alc880_volume_init_verbs,
5009 alc880_pin_5stack_init_verbs },
5010 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
5011 .dac_nids = alc880_dac_nids,
5012 .dig_out_nid = ALC880_DIGOUT_NID,
5013 .num_channel_mode = ARRAY_SIZE(alc880_fivestack_modes),
5014 .channel_mode = alc880_fivestack_modes,
5015 .input_mux = &alc880_capture_source,
5016 },
5017 [ALC880_6ST] = {
5018 .mixers = { alc880_six_stack_mixer },
5019 .init_verbs = { alc880_volume_init_verbs,
5020 alc880_pin_6stack_init_verbs },
5021 .num_dacs = ARRAY_SIZE(alc880_6st_dac_nids),
5022 .dac_nids = alc880_6st_dac_nids,
5023 .num_channel_mode = ARRAY_SIZE(alc880_sixstack_modes),
5024 .channel_mode = alc880_sixstack_modes,
5025 .input_mux = &alc880_6stack_capture_source,
5026 },
5027 [ALC880_6ST_DIG] = {
5028 .mixers = { alc880_six_stack_mixer },
5029 .init_verbs = { alc880_volume_init_verbs,
5030 alc880_pin_6stack_init_verbs },
5031 .num_dacs = ARRAY_SIZE(alc880_6st_dac_nids),
5032 .dac_nids = alc880_6st_dac_nids,
5033 .dig_out_nid = ALC880_DIGOUT_NID,
5034 .num_channel_mode = ARRAY_SIZE(alc880_sixstack_modes),
5035 .channel_mode = alc880_sixstack_modes,
5036 .input_mux = &alc880_6stack_capture_source,
5037 },
5038 [ALC880_W810] = {
5039 .mixers = { alc880_w810_base_mixer },
5040 .init_verbs = { alc880_volume_init_verbs,
5041 alc880_pin_w810_init_verbs,
5042 alc880_gpio2_init_verbs },
5043 .num_dacs = ARRAY_SIZE(alc880_w810_dac_nids),
5044 .dac_nids = alc880_w810_dac_nids,
5045 .dig_out_nid = ALC880_DIGOUT_NID,
5046 .num_channel_mode = ARRAY_SIZE(alc880_w810_modes),
5047 .channel_mode = alc880_w810_modes,
5048 .input_mux = &alc880_capture_source,
5049 },
5050 [ALC880_Z71V] = {
5051 .mixers = { alc880_z71v_mixer },
5052 .init_verbs = { alc880_volume_init_verbs,
5053 alc880_pin_z71v_init_verbs },
5054 .num_dacs = ARRAY_SIZE(alc880_z71v_dac_nids),
5055 .dac_nids = alc880_z71v_dac_nids,
5056 .dig_out_nid = ALC880_DIGOUT_NID,
5057 .hp_nid = 0x03,
5058 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
5059 .channel_mode = alc880_2_jack_modes,
5060 .input_mux = &alc880_capture_source,
5061 },
5062 [ALC880_F1734] = {
5063 .mixers = { alc880_f1734_mixer },
5064 .init_verbs = { alc880_volume_init_verbs,
5065 alc880_pin_f1734_init_verbs },
5066 .num_dacs = ARRAY_SIZE(alc880_f1734_dac_nids),
5067 .dac_nids = alc880_f1734_dac_nids,
5068 .hp_nid = 0x02,
5069 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
5070 .channel_mode = alc880_2_jack_modes,
5071 .input_mux = &alc880_f1734_capture_source,
5072 .unsol_event = alc880_uniwill_p53_unsol_event,
5073 .setup = alc880_uniwill_p53_setup,
5074 .init_hook = alc_hp_automute,
5075 },
5076 [ALC880_ASUS] = {
5077 .mixers = { alc880_asus_mixer },
5078 .init_verbs = { alc880_volume_init_verbs,
5079 alc880_pin_asus_init_verbs,
5080 alc880_gpio1_init_verbs },
5081 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
5082 .dac_nids = alc880_asus_dac_nids,
5083 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
5084 .channel_mode = alc880_asus_modes,
5085 .need_dac_fix = 1,
5086 .input_mux = &alc880_capture_source,
5087 },
5088 [ALC880_ASUS_DIG] = {
5089 .mixers = { alc880_asus_mixer },
5090 .init_verbs = { alc880_volume_init_verbs,
5091 alc880_pin_asus_init_verbs,
5092 alc880_gpio1_init_verbs },
5093 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
5094 .dac_nids = alc880_asus_dac_nids,
5095 .dig_out_nid = ALC880_DIGOUT_NID,
5096 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
5097 .channel_mode = alc880_asus_modes,
5098 .need_dac_fix = 1,
5099 .input_mux = &alc880_capture_source,
5100 },
5101 [ALC880_ASUS_DIG2] = {
5102 .mixers = { alc880_asus_mixer },
5103 .init_verbs = { alc880_volume_init_verbs,
5104 alc880_pin_asus_init_verbs,
5105 alc880_gpio2_init_verbs }, /* use GPIO2 */
5106 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
5107 .dac_nids = alc880_asus_dac_nids,
5108 .dig_out_nid = ALC880_DIGOUT_NID,
5109 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
5110 .channel_mode = alc880_asus_modes,
5111 .need_dac_fix = 1,
5112 .input_mux = &alc880_capture_source,
5113 },
5114 [ALC880_ASUS_W1V] = {
5115 .mixers = { alc880_asus_mixer, alc880_asus_w1v_mixer },
5116 .init_verbs = { alc880_volume_init_verbs,
5117 alc880_pin_asus_init_verbs,
5118 alc880_gpio1_init_verbs },
5119 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
5120 .dac_nids = alc880_asus_dac_nids,
5121 .dig_out_nid = ALC880_DIGOUT_NID,
5122 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
5123 .channel_mode = alc880_asus_modes,
5124 .need_dac_fix = 1,
5125 .input_mux = &alc880_capture_source,
5126 },
5127 [ALC880_UNIWILL_DIG] = {
5128 .mixers = { alc880_asus_mixer },
5129 .init_verbs = { alc880_volume_init_verbs,
5130 alc880_pin_asus_init_verbs },
5131 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
5132 .dac_nids = alc880_asus_dac_nids,
5133 .dig_out_nid = ALC880_DIGOUT_NID,
5134 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
5135 .channel_mode = alc880_asus_modes,
5136 .need_dac_fix = 1,
5137 .input_mux = &alc880_capture_source,
5138 },
5139 [ALC880_UNIWILL] = {
5140 .mixers = { alc880_uniwill_mixer },
5141 .init_verbs = { alc880_volume_init_verbs,
5142 alc880_uniwill_init_verbs },
5143 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
5144 .dac_nids = alc880_asus_dac_nids,
5145 .dig_out_nid = ALC880_DIGOUT_NID,
5146 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
5147 .channel_mode = alc880_threestack_modes,
5148 .need_dac_fix = 1,
5149 .input_mux = &alc880_capture_source,
5150 .unsol_event = alc880_uniwill_unsol_event,
5151 .setup = alc880_uniwill_setup,
5152 .init_hook = alc880_uniwill_init_hook,
5153 },
5154 [ALC880_UNIWILL_P53] = {
5155 .mixers = { alc880_uniwill_p53_mixer },
5156 .init_verbs = { alc880_volume_init_verbs,
5157 alc880_uniwill_p53_init_verbs },
5158 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
5159 .dac_nids = alc880_asus_dac_nids,
5160 .num_channel_mode = ARRAY_SIZE(alc880_w810_modes),
5161 .channel_mode = alc880_threestack_modes,
5162 .input_mux = &alc880_capture_source,
5163 .unsol_event = alc880_uniwill_p53_unsol_event,
5164 .setup = alc880_uniwill_p53_setup,
5165 .init_hook = alc_hp_automute,
5166 },
5167 [ALC880_FUJITSU] = {
5168 .mixers = { alc880_fujitsu_mixer },
5169 .init_verbs = { alc880_volume_init_verbs,
5170 alc880_uniwill_p53_init_verbs,
5171 alc880_beep_init_verbs },
5172 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
5173 .dac_nids = alc880_dac_nids,
5174 .dig_out_nid = ALC880_DIGOUT_NID,
5175 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
5176 .channel_mode = alc880_2_jack_modes,
5177 .input_mux = &alc880_capture_source,
5178 .unsol_event = alc880_uniwill_p53_unsol_event,
5179 .setup = alc880_uniwill_p53_setup,
5180 .init_hook = alc_hp_automute,
5181 },
5182 [ALC880_CLEVO] = {
5183 .mixers = { alc880_three_stack_mixer },
5184 .init_verbs = { alc880_volume_init_verbs,
5185 alc880_pin_clevo_init_verbs },
5186 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
5187 .dac_nids = alc880_dac_nids,
5188 .hp_nid = 0x03,
5189 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
5190 .channel_mode = alc880_threestack_modes,
5191 .need_dac_fix = 1,
5192 .input_mux = &alc880_capture_source,
5193 },
5194 [ALC880_LG] = {
5195 .mixers = { alc880_lg_mixer },
5196 .init_verbs = { alc880_volume_init_verbs,
5197 alc880_lg_init_verbs },
5198 .num_dacs = ARRAY_SIZE(alc880_lg_dac_nids),
5199 .dac_nids = alc880_lg_dac_nids,
5200 .dig_out_nid = ALC880_DIGOUT_NID,
5201 .num_channel_mode = ARRAY_SIZE(alc880_lg_ch_modes),
5202 .channel_mode = alc880_lg_ch_modes,
5203 .need_dac_fix = 1,
5204 .input_mux = &alc880_lg_capture_source,
5205 .unsol_event = alc_sku_unsol_event,
5206 .setup = alc880_lg_setup,
5207 .init_hook = alc_hp_automute,
5208 #ifdef CONFIG_SND_HDA_POWER_SAVE
5209 .loopbacks = alc880_lg_loopbacks,
5210 #endif
5211 },
5212 [ALC880_LG_LW] = {
5213 .mixers = { alc880_lg_lw_mixer },
5214 .init_verbs = { alc880_volume_init_verbs,
5215 alc880_lg_lw_init_verbs },
5216 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
5217 .dac_nids = alc880_dac_nids,
5218 .dig_out_nid = ALC880_DIGOUT_NID,
5219 .num_channel_mode = ARRAY_SIZE(alc880_lg_lw_modes),
5220 .channel_mode = alc880_lg_lw_modes,
5221 .input_mux = &alc880_lg_lw_capture_source,
5222 .unsol_event = alc_sku_unsol_event,
5223 .setup = alc880_lg_lw_setup,
5224 .init_hook = alc_hp_automute,
5225 },
5226 [ALC880_MEDION_RIM] = {
5227 .mixers = { alc880_medion_rim_mixer },
5228 .init_verbs = { alc880_volume_init_verbs,
5229 alc880_medion_rim_init_verbs,
5230 alc_gpio2_init_verbs },
5231 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
5232 .dac_nids = alc880_dac_nids,
5233 .dig_out_nid = ALC880_DIGOUT_NID,
5234 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
5235 .channel_mode = alc880_2_jack_modes,
5236 .input_mux = &alc880_medion_rim_capture_source,
5237 .unsol_event = alc880_medion_rim_unsol_event,
5238 .setup = alc880_medion_rim_setup,
5239 .init_hook = alc880_medion_rim_automute,
5240 },
5241 #ifdef CONFIG_SND_DEBUG
5242 [ALC880_TEST] = {
5243 .mixers = { alc880_test_mixer },
5244 .init_verbs = { alc880_test_init_verbs },
5245 .num_dacs = ARRAY_SIZE(alc880_test_dac_nids),
5246 .dac_nids = alc880_test_dac_nids,
5247 .dig_out_nid = ALC880_DIGOUT_NID,
5248 .num_channel_mode = ARRAY_SIZE(alc880_test_modes),
5249 .channel_mode = alc880_test_modes,
5250 .input_mux = &alc880_test_capture_source,
5251 },
5252 #endif
5253 };
5254
5255 /*
5256 * Automatic parse of I/O pins from the BIOS configuration
5257 */
5258
5259 enum {
5260 ALC_CTL_WIDGET_VOL,
5261 ALC_CTL_WIDGET_MUTE,
5262 ALC_CTL_BIND_MUTE,
5263 };
5264 static const struct snd_kcontrol_new alc880_control_templates[] = {
5265 HDA_CODEC_VOLUME(NULL, 0, 0, 0),
5266 HDA_CODEC_MUTE(NULL, 0, 0, 0),
5267 HDA_BIND_MUTE(NULL, 0, 0, 0),
5268 };
5269
5270 static struct snd_kcontrol_new *alc_kcontrol_new(struct alc_spec *spec)
5271 {
5272 snd_array_init(&spec->kctls, sizeof(struct snd_kcontrol_new), 32);
5273 return snd_array_new(&spec->kctls);
5274 }
5275
5276 /* add dynamic controls */
5277 static int add_control(struct alc_spec *spec, int type, const char *name,
5278 int cidx, unsigned long val)
5279 {
5280 struct snd_kcontrol_new *knew;
5281
5282 knew = alc_kcontrol_new(spec);
5283 if (!knew)
5284 return -ENOMEM;
5285 *knew = alc880_control_templates[type];
5286 knew->name = kstrdup(name, GFP_KERNEL);
5287 if (!knew->name)
5288 return -ENOMEM;
5289 knew->index = cidx;
5290 if (get_amp_nid_(val))
5291 knew->subdevice = HDA_SUBDEV_AMP_FLAG;
5292 knew->private_value = val;
5293 return 0;
5294 }
5295
5296 static int add_control_with_pfx(struct alc_spec *spec, int type,
5297 const char *pfx, const char *dir,
5298 const char *sfx, int cidx, unsigned long val)
5299 {
5300 char name[32];
5301 snprintf(name, sizeof(name), "%s %s %s", pfx, dir, sfx);
5302 return add_control(spec, type, name, cidx, val);
5303 }
5304
5305 #define add_pb_vol_ctrl(spec, type, pfx, val) \
5306 add_control_with_pfx(spec, type, pfx, "Playback", "Volume", 0, val)
5307 #define add_pb_sw_ctrl(spec, type, pfx, val) \
5308 add_control_with_pfx(spec, type, pfx, "Playback", "Switch", 0, val)
5309 #define __add_pb_vol_ctrl(spec, type, pfx, cidx, val) \
5310 add_control_with_pfx(spec, type, pfx, "Playback", "Volume", cidx, val)
5311 #define __add_pb_sw_ctrl(spec, type, pfx, cidx, val) \
5312 add_control_with_pfx(spec, type, pfx, "Playback", "Switch", cidx, val)
5313
5314 #define alc880_is_fixed_pin(nid) ((nid) >= 0x14 && (nid) <= 0x17)
5315 #define alc880_fixed_pin_idx(nid) ((nid) - 0x14)
5316 #define alc880_is_multi_pin(nid) ((nid) >= 0x18)
5317 #define alc880_multi_pin_idx(nid) ((nid) - 0x18)
5318 #define alc880_idx_to_dac(nid) ((nid) + 0x02)
5319 #define alc880_dac_to_idx(nid) ((nid) - 0x02)
5320 #define alc880_idx_to_mixer(nid) ((nid) + 0x0c)
5321 #define alc880_idx_to_selector(nid) ((nid) + 0x10)
5322 #define ALC880_PIN_CD_NID 0x1c
5323
5324 /* fill in the dac_nids table from the parsed pin configuration */
5325 static int alc880_auto_fill_dac_nids(struct alc_spec *spec,
5326 const struct auto_pin_cfg *cfg)
5327 {
5328 hda_nid_t nid;
5329 int assigned[4];
5330 int i, j;
5331
5332 memset(assigned, 0, sizeof(assigned));
5333 spec->multiout.dac_nids = spec->private_dac_nids;
5334
5335 /* check the pins hardwired to audio widget */
5336 for (i = 0; i < cfg->line_outs; i++) {
5337 nid = cfg->line_out_pins[i];
5338 if (alc880_is_fixed_pin(nid)) {
5339 int idx = alc880_fixed_pin_idx(nid);
5340 spec->private_dac_nids[i] = alc880_idx_to_dac(idx);
5341 assigned[idx] = 1;
5342 }
5343 }
5344 /* left pins can be connect to any audio widget */
5345 for (i = 0; i < cfg->line_outs; i++) {
5346 nid = cfg->line_out_pins[i];
5347 if (alc880_is_fixed_pin(nid))
5348 continue;
5349 /* search for an empty channel */
5350 for (j = 0; j < cfg->line_outs; j++) {
5351 if (!assigned[j]) {
5352 spec->private_dac_nids[i] =
5353 alc880_idx_to_dac(j);
5354 assigned[j] = 1;
5355 break;
5356 }
5357 }
5358 }
5359 spec->multiout.num_dacs = cfg->line_outs;
5360 return 0;
5361 }
5362
5363 static const char *alc_get_line_out_pfx(struct alc_spec *spec,
5364 bool can_be_master)
5365 {
5366 struct auto_pin_cfg *cfg = &spec->autocfg;
5367
5368 if (cfg->line_outs == 1 && !spec->multi_ios &&
5369 !cfg->hp_outs && !cfg->speaker_outs && can_be_master)
5370 return "Master";
5371
5372 switch (cfg->line_out_type) {
5373 case AUTO_PIN_SPEAKER_OUT:
5374 if (cfg->line_outs == 1)
5375 return "Speaker";
5376 break;
5377 case AUTO_PIN_HP_OUT:
5378 return "Headphone";
5379 default:
5380 if (cfg->line_outs == 1 && !spec->multi_ios)
5381 return "PCM";
5382 break;
5383 }
5384 return NULL;
5385 }
5386
5387 /* add playback controls from the parsed DAC table */
5388 static int alc880_auto_create_multi_out_ctls(struct alc_spec *spec,
5389 const struct auto_pin_cfg *cfg)
5390 {
5391 static const char * const chname[4] = {
5392 "Front", "Surround", NULL /*CLFE*/, "Side"
5393 };
5394 const char *pfx = alc_get_line_out_pfx(spec, false);
5395 hda_nid_t nid;
5396 int i, err, noutputs;
5397
5398 noutputs = cfg->line_outs;
5399 if (spec->multi_ios > 0)
5400 noutputs += spec->multi_ios;
5401
5402 for (i = 0; i < noutputs; i++) {
5403 if (!spec->multiout.dac_nids[i])
5404 continue;
5405 nid = alc880_idx_to_mixer(alc880_dac_to_idx(spec->multiout.dac_nids[i]));
5406 if (!pfx && i == 2) {
5407 /* Center/LFE */
5408 err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL,
5409 "Center",
5410 HDA_COMPOSE_AMP_VAL(nid, 1, 0,
5411 HDA_OUTPUT));
5412 if (err < 0)
5413 return err;
5414 err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL,
5415 "LFE",
5416 HDA_COMPOSE_AMP_VAL(nid, 2, 0,
5417 HDA_OUTPUT));
5418 if (err < 0)
5419 return err;
5420 err = add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE,
5421 "Center",
5422 HDA_COMPOSE_AMP_VAL(nid, 1, 2,
5423 HDA_INPUT));
5424 if (err < 0)
5425 return err;
5426 err = add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE,
5427 "LFE",
5428 HDA_COMPOSE_AMP_VAL(nid, 2, 2,
5429 HDA_INPUT));
5430 if (err < 0)
5431 return err;
5432 } else {
5433 const char *name = pfx;
5434 int index = i;
5435 if (!name) {
5436 name = chname[i];
5437 index = 0;
5438 }
5439 err = __add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL,
5440 name, index,
5441 HDA_COMPOSE_AMP_VAL(nid, 3, 0,
5442 HDA_OUTPUT));
5443 if (err < 0)
5444 return err;
5445 err = __add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE,
5446 name, index,
5447 HDA_COMPOSE_AMP_VAL(nid, 3, 2,
5448 HDA_INPUT));
5449 if (err < 0)
5450 return err;
5451 }
5452 }
5453 return 0;
5454 }
5455
5456 /* add playback controls for speaker and HP outputs */
5457 static int alc880_auto_create_extra_out(struct alc_spec *spec, hda_nid_t pin,
5458 const char *pfx)
5459 {
5460 hda_nid_t nid;
5461 int err;
5462
5463 if (!pin)
5464 return 0;
5465
5466 if (alc880_is_fixed_pin(pin)) {
5467 nid = alc880_idx_to_dac(alc880_fixed_pin_idx(pin));
5468 /* specify the DAC as the extra output */
5469 if (!spec->multiout.hp_nid)
5470 spec->multiout.hp_nid = nid;
5471 else
5472 spec->multiout.extra_out_nid[0] = nid;
5473 /* control HP volume/switch on the output mixer amp */
5474 nid = alc880_idx_to_mixer(alc880_fixed_pin_idx(pin));
5475 err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, pfx,
5476 HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT));
5477 if (err < 0)
5478 return err;
5479 err = add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE, pfx,
5480 HDA_COMPOSE_AMP_VAL(nid, 3, 2, HDA_INPUT));
5481 if (err < 0)
5482 return err;
5483 } else if (alc880_is_multi_pin(pin)) {
5484 /* set manual connection */
5485 /* we have only a switch on HP-out PIN */
5486 err = add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, pfx,
5487 HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
5488 if (err < 0)
5489 return err;
5490 }
5491 return 0;
5492 }
5493
5494 /* create input playback/capture controls for the given pin */
5495 static int new_analog_input(struct alc_spec *spec, hda_nid_t pin,
5496 const char *ctlname, int ctlidx,
5497 int idx, hda_nid_t mix_nid)
5498 {
5499 int err;
5500
5501 err = __add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, ctlname, ctlidx,
5502 HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT));
5503 if (err < 0)
5504 return err;
5505 err = __add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, ctlname, ctlidx,
5506 HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT));
5507 if (err < 0)
5508 return err;
5509 return 0;
5510 }
5511
5512 static int alc_is_input_pin(struct hda_codec *codec, hda_nid_t nid)
5513 {
5514 unsigned int pincap = snd_hda_query_pin_caps(codec, nid);
5515 return (pincap & AC_PINCAP_IN) != 0;
5516 }
5517
5518 /* create playback/capture controls for input pins */
5519 static int alc_auto_create_input_ctls(struct hda_codec *codec,
5520 const struct auto_pin_cfg *cfg,
5521 hda_nid_t mixer,
5522 hda_nid_t cap1, hda_nid_t cap2)
5523 {
5524 struct alc_spec *spec = codec->spec;
5525 struct hda_input_mux *imux = &spec->private_imux[0];
5526 int i, err, idx, type_idx = 0;
5527 const char *prev_label = NULL;
5528
5529 for (i = 0; i < cfg->num_inputs; i++) {
5530 hda_nid_t pin;
5531 const char *label;
5532
5533 pin = cfg->inputs[i].pin;
5534 if (!alc_is_input_pin(codec, pin))
5535 continue;
5536
5537 label = hda_get_autocfg_input_label(codec, cfg, i);
5538 if (prev_label && !strcmp(label, prev_label))
5539 type_idx++;
5540 else
5541 type_idx = 0;
5542 prev_label = label;
5543
5544 if (mixer) {
5545 idx = get_connection_index(codec, mixer, pin);
5546 if (idx >= 0) {
5547 err = new_analog_input(spec, pin,
5548 label, type_idx,
5549 idx, mixer);
5550 if (err < 0)
5551 return err;
5552 }
5553 }
5554
5555 if (!cap1)
5556 continue;
5557 idx = get_connection_index(codec, cap1, pin);
5558 if (idx < 0 && cap2)
5559 idx = get_connection_index(codec, cap2, pin);
5560 if (idx >= 0)
5561 snd_hda_add_imux_item(imux, label, idx, NULL);
5562 }
5563 return 0;
5564 }
5565
5566 static int alc880_auto_create_input_ctls(struct hda_codec *codec,
5567 const struct auto_pin_cfg *cfg)
5568 {
5569 return alc_auto_create_input_ctls(codec, cfg, 0x0b, 0x08, 0x09);
5570 }
5571
5572 static void alc_set_pin_output(struct hda_codec *codec, hda_nid_t nid,
5573 unsigned int pin_type)
5574 {
5575 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
5576 pin_type);
5577 /* unmute pin */
5578 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE,
5579 AMP_OUT_UNMUTE);
5580 }
5581
5582 static void alc880_auto_set_output_and_unmute(struct hda_codec *codec,
5583 hda_nid_t nid, int pin_type,
5584 int dac_idx)
5585 {
5586 alc_set_pin_output(codec, nid, pin_type);
5587 /* need the manual connection? */
5588 if (alc880_is_multi_pin(nid)) {
5589 struct alc_spec *spec = codec->spec;
5590 int idx = alc880_multi_pin_idx(nid);
5591 snd_hda_codec_write(codec, alc880_idx_to_selector(idx), 0,
5592 AC_VERB_SET_CONNECT_SEL,
5593 alc880_dac_to_idx(spec->multiout.dac_nids[dac_idx]));
5594 }
5595 }
5596
5597 static int get_pin_type(int line_out_type)
5598 {
5599 if (line_out_type == AUTO_PIN_HP_OUT)
5600 return PIN_HP;
5601 else
5602 return PIN_OUT;
5603 }
5604
5605 static void alc880_auto_init_multi_out(struct hda_codec *codec)
5606 {
5607 struct alc_spec *spec = codec->spec;
5608 int i;
5609
5610 for (i = 0; i < spec->autocfg.line_outs; i++) {
5611 hda_nid_t nid = spec->autocfg.line_out_pins[i];
5612 int pin_type = get_pin_type(spec->autocfg.line_out_type);
5613 alc880_auto_set_output_and_unmute(codec, nid, pin_type, i);
5614 }
5615 }
5616
5617 static void alc880_auto_init_extra_out(struct hda_codec *codec)
5618 {
5619 struct alc_spec *spec = codec->spec;
5620 hda_nid_t pin;
5621
5622 pin = spec->autocfg.speaker_pins[0];
5623 if (pin) /* connect to front */
5624 alc880_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
5625 pin = spec->autocfg.hp_pins[0];
5626 if (pin) /* connect to front */
5627 alc880_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
5628 }
5629
5630 static void alc880_auto_init_analog_input(struct hda_codec *codec)
5631 {
5632 struct alc_spec *spec = codec->spec;
5633 struct auto_pin_cfg *cfg = &spec->autocfg;
5634 int i;
5635
5636 for (i = 0; i < cfg->num_inputs; i++) {
5637 hda_nid_t nid = cfg->inputs[i].pin;
5638 if (alc_is_input_pin(codec, nid)) {
5639 alc_set_input_pin(codec, nid, cfg->inputs[i].type);
5640 if (nid != ALC880_PIN_CD_NID &&
5641 (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP))
5642 snd_hda_codec_write(codec, nid, 0,
5643 AC_VERB_SET_AMP_GAIN_MUTE,
5644 AMP_OUT_MUTE);
5645 }
5646 }
5647 }
5648
5649 static void alc880_auto_init_input_src(struct hda_codec *codec)
5650 {
5651 struct alc_spec *spec = codec->spec;
5652 int c;
5653
5654 for (c = 0; c < spec->num_adc_nids; c++) {
5655 unsigned int mux_idx;
5656 const struct hda_input_mux *imux;
5657 mux_idx = c >= spec->num_mux_defs ? 0 : c;
5658 imux = &spec->input_mux[mux_idx];
5659 if (!imux->num_items && mux_idx > 0)
5660 imux = &spec->input_mux[0];
5661 if (imux)
5662 snd_hda_codec_write(codec, spec->adc_nids[c], 0,
5663 AC_VERB_SET_CONNECT_SEL,
5664 imux->items[0].index);
5665 }
5666 }
5667
5668 static int alc_auto_add_multi_channel_mode(struct hda_codec *codec);
5669
5670 /* parse the BIOS configuration and set up the alc_spec */
5671 /* return 1 if successful, 0 if the proper config is not found,
5672 * or a negative error code
5673 */
5674 static int alc880_parse_auto_config(struct hda_codec *codec)
5675 {
5676 struct alc_spec *spec = codec->spec;
5677 int err;
5678 static const hda_nid_t alc880_ignore[] = { 0x1d, 0 };
5679
5680 err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
5681 alc880_ignore);
5682 if (err < 0)
5683 return err;
5684 if (!spec->autocfg.line_outs)
5685 return 0; /* can't find valid BIOS pin config */
5686
5687 err = alc880_auto_fill_dac_nids(spec, &spec->autocfg);
5688 if (err < 0)
5689 return err;
5690 err = alc_auto_add_multi_channel_mode(codec);
5691 if (err < 0)
5692 return err;
5693 err = alc880_auto_create_multi_out_ctls(spec, &spec->autocfg);
5694 if (err < 0)
5695 return err;
5696 err = alc880_auto_create_extra_out(spec,
5697 spec->autocfg.speaker_pins[0],
5698 "Speaker");
5699 if (err < 0)
5700 return err;
5701 err = alc880_auto_create_extra_out(spec, spec->autocfg.hp_pins[0],
5702 "Headphone");
5703 if (err < 0)
5704 return err;
5705 err = alc880_auto_create_input_ctls(codec, &spec->autocfg);
5706 if (err < 0)
5707 return err;
5708
5709 spec->multiout.max_channels = spec->multiout.num_dacs * 2;
5710
5711 alc_auto_parse_digital(codec);
5712
5713 if (spec->kctls.list)
5714 add_mixer(spec, spec->kctls.list);
5715
5716 add_verb(spec, alc880_volume_init_verbs);
5717
5718 spec->num_mux_defs = 1;
5719 spec->input_mux = &spec->private_imux[0];
5720
5721 alc_ssid_check(codec, 0x15, 0x1b, 0x14, 0);
5722
5723 return 1;
5724 }
5725
5726 /* additional initialization for auto-configuration model */
5727 static void alc880_auto_init(struct hda_codec *codec)
5728 {
5729 struct alc_spec *spec = codec->spec;
5730 alc880_auto_init_multi_out(codec);
5731 alc880_auto_init_extra_out(codec);
5732 alc880_auto_init_analog_input(codec);
5733 alc880_auto_init_input_src(codec);
5734 alc_auto_init_digital(codec);
5735 if (spec->unsol_event)
5736 alc_inithook(codec);
5737 }
5738
5739 /* check the ADC/MUX contains all input pins; some ADC/MUX contains only
5740 * one of two digital mic pins, e.g. on ALC272
5741 */
5742 static void fixup_automic_adc(struct hda_codec *codec)
5743 {
5744 struct alc_spec *spec = codec->spec;
5745 int i;
5746
5747 for (i = 0; i < spec->num_adc_nids; i++) {
5748 hda_nid_t cap = spec->capsrc_nids ?
5749 spec->capsrc_nids[i] : spec->adc_nids[i];
5750 int iidx, eidx;
5751
5752 iidx = get_connection_index(codec, cap, spec->int_mic.pin);
5753 if (iidx < 0)
5754 continue;
5755 eidx = get_connection_index(codec, cap, spec->ext_mic.pin);
5756 if (eidx < 0)
5757 continue;
5758 spec->int_mic.mux_idx = iidx;
5759 spec->ext_mic.mux_idx = eidx;
5760 if (spec->capsrc_nids)
5761 spec->capsrc_nids += i;
5762 spec->adc_nids += i;
5763 spec->num_adc_nids = 1;
5764 /* optional dock-mic */
5765 eidx = get_connection_index(codec, cap, spec->dock_mic.pin);
5766 if (eidx < 0)
5767 spec->dock_mic.pin = 0;
5768 else
5769 spec->dock_mic.mux_idx = eidx;
5770 return;
5771 }
5772 snd_printd(KERN_INFO "hda_codec: %s: "
5773 "No ADC/MUX containing both 0x%x and 0x%x pins\n",
5774 codec->chip_name, spec->int_mic.pin, spec->ext_mic.pin);
5775 spec->auto_mic = 0; /* disable auto-mic to be sure */
5776 }
5777
5778 /* select or unmute the given capsrc route */
5779 static void select_or_unmute_capsrc(struct hda_codec *codec, hda_nid_t cap,
5780 int idx)
5781 {
5782 if (get_wcaps_type(get_wcaps(codec, cap)) == AC_WID_AUD_MIX) {
5783 snd_hda_codec_amp_stereo(codec, cap, HDA_INPUT, idx,
5784 HDA_AMP_MUTE, 0);
5785 } else {
5786 snd_hda_codec_write_cache(codec, cap, 0,
5787 AC_VERB_SET_CONNECT_SEL, idx);
5788 }
5789 }
5790
5791 /* set the default connection to that pin */
5792 static int init_capsrc_for_pin(struct hda_codec *codec, hda_nid_t pin)
5793 {
5794 struct alc_spec *spec = codec->spec;
5795 int i;
5796
5797 if (!pin)
5798 return 0;
5799 for (i = 0; i < spec->num_adc_nids; i++) {
5800 hda_nid_t cap = spec->capsrc_nids ?
5801 spec->capsrc_nids[i] : spec->adc_nids[i];
5802 int idx;
5803
5804 idx = get_connection_index(codec, cap, pin);
5805 if (idx < 0)
5806 continue;
5807 select_or_unmute_capsrc(codec, cap, idx);
5808 return i; /* return the found index */
5809 }
5810 return -1; /* not found */
5811 }
5812
5813 /* choose the ADC/MUX containing the input pin and initialize the setup */
5814 static void fixup_single_adc(struct hda_codec *codec)
5815 {
5816 struct alc_spec *spec = codec->spec;
5817 struct auto_pin_cfg *cfg = &spec->autocfg;
5818 int i;
5819
5820 /* search for the input pin; there must be only one */
5821 if (cfg->num_inputs != 1)
5822 return;
5823 i = init_capsrc_for_pin(codec, cfg->inputs[0].pin);
5824 if (i >= 0) {
5825 /* use only this ADC */
5826 if (spec->capsrc_nids)
5827 spec->capsrc_nids += i;
5828 spec->adc_nids += i;
5829 spec->num_adc_nids = 1;
5830 spec->single_input_src = 1;
5831 }
5832 }
5833
5834 /* initialize dual adcs */
5835 static void fixup_dual_adc_switch(struct hda_codec *codec)
5836 {
5837 struct alc_spec *spec = codec->spec;
5838 init_capsrc_for_pin(codec, spec->ext_mic.pin);
5839 init_capsrc_for_pin(codec, spec->dock_mic.pin);
5840 init_capsrc_for_pin(codec, spec->int_mic.pin);
5841 }
5842
5843 /* initialize some special cases for input sources */
5844 static void alc_init_special_input_src(struct hda_codec *codec)
5845 {
5846 struct alc_spec *spec = codec->spec;
5847 if (spec->dual_adc_switch)
5848 fixup_dual_adc_switch(codec);
5849 else if (spec->single_input_src)
5850 init_capsrc_for_pin(codec, spec->autocfg.inputs[0].pin);
5851 }
5852
5853 static void set_capture_mixer(struct hda_codec *codec)
5854 {
5855 struct alc_spec *spec = codec->spec;
5856 static const struct snd_kcontrol_new *caps[2][3] = {
5857 { alc_capture_mixer_nosrc1,
5858 alc_capture_mixer_nosrc2,
5859 alc_capture_mixer_nosrc3 },
5860 { alc_capture_mixer1,
5861 alc_capture_mixer2,
5862 alc_capture_mixer3 },
5863 };
5864 if (spec->num_adc_nids > 0 && spec->num_adc_nids <= 3) {
5865 int mux = 0;
5866 int num_adcs = spec->num_adc_nids;
5867 if (spec->dual_adc_switch)
5868 num_adcs = 1;
5869 else if (spec->auto_mic)
5870 fixup_automic_adc(codec);
5871 else if (spec->input_mux) {
5872 if (spec->input_mux->num_items > 1)
5873 mux = 1;
5874 else if (spec->input_mux->num_items == 1)
5875 fixup_single_adc(codec);
5876 }
5877 spec->cap_mixer = caps[mux][num_adcs - 1];
5878 }
5879 }
5880
5881 /* fill adc_nids (and capsrc_nids) containing all active input pins */
5882 static void fillup_priv_adc_nids(struct hda_codec *codec, const hda_nid_t *nids,
5883 int num_nids)
5884 {
5885 struct alc_spec *spec = codec->spec;
5886 struct auto_pin_cfg *cfg = &spec->autocfg;
5887 int n;
5888 hda_nid_t fallback_adc = 0, fallback_cap = 0;
5889
5890 for (n = 0; n < num_nids; n++) {
5891 hda_nid_t adc, cap;
5892 hda_nid_t conn[HDA_MAX_NUM_INPUTS];
5893 int nconns, i, j;
5894
5895 adc = nids[n];
5896 if (get_wcaps_type(get_wcaps(codec, adc)) != AC_WID_AUD_IN)
5897 continue;
5898 cap = adc;
5899 nconns = snd_hda_get_connections(codec, cap, conn,
5900 ARRAY_SIZE(conn));
5901 if (nconns == 1) {
5902 cap = conn[0];
5903 nconns = snd_hda_get_connections(codec, cap, conn,
5904 ARRAY_SIZE(conn));
5905 }
5906 if (nconns <= 0)
5907 continue;
5908 if (!fallback_adc) {
5909 fallback_adc = adc;
5910 fallback_cap = cap;
5911 }
5912 for (i = 0; i < cfg->num_inputs; i++) {
5913 hda_nid_t nid = cfg->inputs[i].pin;
5914 for (j = 0; j < nconns; j++) {
5915 if (conn[j] == nid)
5916 break;
5917 }
5918 if (j >= nconns)
5919 break;
5920 }
5921 if (i >= cfg->num_inputs) {
5922 int num_adcs = spec->num_adc_nids;
5923 spec->private_adc_nids[num_adcs] = adc;
5924 spec->private_capsrc_nids[num_adcs] = cap;
5925 spec->num_adc_nids++;
5926 spec->adc_nids = spec->private_adc_nids;
5927 if (adc != cap)
5928 spec->capsrc_nids = spec->private_capsrc_nids;
5929 }
5930 }
5931 if (!spec->num_adc_nids) {
5932 printk(KERN_WARNING "hda_codec: %s: no valid ADC found;"
5933 " using fallback 0x%x\n",
5934 codec->chip_name, fallback_adc);
5935 spec->private_adc_nids[0] = fallback_adc;
5936 spec->adc_nids = spec->private_adc_nids;
5937 if (fallback_adc != fallback_cap) {
5938 spec->private_capsrc_nids[0] = fallback_cap;
5939 spec->capsrc_nids = spec->private_adc_nids;
5940 }
5941 }
5942 }
5943
5944 #ifdef CONFIG_SND_HDA_INPUT_BEEP
5945 #define set_beep_amp(spec, nid, idx, dir) \
5946 ((spec)->beep_amp = HDA_COMPOSE_AMP_VAL(nid, 3, idx, dir))
5947
5948 static const struct snd_pci_quirk beep_white_list[] = {
5949 SND_PCI_QUIRK(0x1043, 0x829f, "ASUS", 1),
5950 SND_PCI_QUIRK(0x1043, 0x83ce, "EeePC", 1),
5951 SND_PCI_QUIRK(0x1043, 0x831a, "EeePC", 1),
5952 SND_PCI_QUIRK(0x1043, 0x834a, "EeePC", 1),
5953 SND_PCI_QUIRK(0x8086, 0xd613, "Intel", 1),
5954 {}
5955 };
5956
5957 static inline int has_cdefine_beep(struct hda_codec *codec)
5958 {
5959 struct alc_spec *spec = codec->spec;
5960 const struct snd_pci_quirk *q;
5961 q = snd_pci_quirk_lookup(codec->bus->pci, beep_white_list);
5962 if (q)
5963 return q->value;
5964 return spec->cdefine.enable_pcbeep;
5965 }
5966 #else
5967 #define set_beep_amp(spec, nid, idx, dir) /* NOP */
5968 #define has_cdefine_beep(codec) 0
5969 #endif
5970
5971 /*
5972 * OK, here we have finally the patch for ALC880
5973 */
5974
5975 static int patch_alc880(struct hda_codec *codec)
5976 {
5977 struct alc_spec *spec;
5978 int board_config;
5979 int err;
5980
5981 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
5982 if (spec == NULL)
5983 return -ENOMEM;
5984
5985 codec->spec = spec;
5986
5987 board_config = snd_hda_check_board_config(codec, ALC880_MODEL_LAST,
5988 alc880_models,
5989 alc880_cfg_tbl);
5990 if (board_config < 0) {
5991 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
5992 codec->chip_name);
5993 board_config = ALC880_AUTO;
5994 }
5995
5996 if (board_config == ALC880_AUTO) {
5997 /* automatic parse from the BIOS config */
5998 err = alc880_parse_auto_config(codec);
5999 if (err < 0) {
6000 alc_free(codec);
6001 return err;
6002 } else if (!err) {
6003 printk(KERN_INFO
6004 "hda_codec: Cannot set up configuration "
6005 "from BIOS. Using 3-stack mode...\n");
6006 board_config = ALC880_3ST;
6007 }
6008 }
6009
6010 err = snd_hda_attach_beep_device(codec, 0x1);
6011 if (err < 0) {
6012 alc_free(codec);
6013 return err;
6014 }
6015
6016 if (board_config != ALC880_AUTO)
6017 setup_preset(codec, &alc880_presets[board_config]);
6018
6019 spec->stream_analog_playback = &alc880_pcm_analog_playback;
6020 spec->stream_analog_capture = &alc880_pcm_analog_capture;
6021 spec->stream_analog_alt_capture = &alc880_pcm_analog_alt_capture;
6022
6023 spec->stream_digital_playback = &alc880_pcm_digital_playback;
6024 spec->stream_digital_capture = &alc880_pcm_digital_capture;
6025
6026 if (!spec->adc_nids && spec->input_mux) {
6027 /* check whether NID 0x07 is valid */
6028 unsigned int wcap = get_wcaps(codec, alc880_adc_nids[0]);
6029 /* get type */
6030 wcap = get_wcaps_type(wcap);
6031 if (wcap != AC_WID_AUD_IN) {
6032 spec->adc_nids = alc880_adc_nids_alt;
6033 spec->num_adc_nids = ARRAY_SIZE(alc880_adc_nids_alt);
6034 } else {
6035 spec->adc_nids = alc880_adc_nids;
6036 spec->num_adc_nids = ARRAY_SIZE(alc880_adc_nids);
6037 }
6038 }
6039 set_capture_mixer(codec);
6040 set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
6041
6042 spec->vmaster_nid = 0x0c;
6043
6044 codec->patch_ops = alc_patch_ops;
6045 if (board_config == ALC880_AUTO)
6046 spec->init_hook = alc880_auto_init;
6047 #ifdef CONFIG_SND_HDA_POWER_SAVE
6048 if (!spec->loopback.amplist)
6049 spec->loopback.amplist = alc880_loopbacks;
6050 #endif
6051
6052 return 0;
6053 }
6054
6055
6056 /*
6057 * ALC260 support
6058 */
6059
6060 static const hda_nid_t alc260_dac_nids[1] = {
6061 /* front */
6062 0x02,
6063 };
6064
6065 static const hda_nid_t alc260_adc_nids[1] = {
6066 /* ADC0 */
6067 0x04,
6068 };
6069
6070 static const hda_nid_t alc260_adc_nids_alt[1] = {
6071 /* ADC1 */
6072 0x05,
6073 };
6074
6075 /* NIDs used when simultaneous access to both ADCs makes sense. Note that
6076 * alc260_capture_mixer assumes ADC0 (nid 0x04) is the first ADC.
6077 */
6078 static const hda_nid_t alc260_dual_adc_nids[2] = {
6079 /* ADC0, ADC1 */
6080 0x04, 0x05
6081 };
6082
6083 #define ALC260_DIGOUT_NID 0x03
6084 #define ALC260_DIGIN_NID 0x06
6085
6086 static const struct hda_input_mux alc260_capture_source = {
6087 .num_items = 4,
6088 .items = {
6089 { "Mic", 0x0 },
6090 { "Front Mic", 0x1 },
6091 { "Line", 0x2 },
6092 { "CD", 0x4 },
6093 },
6094 };
6095
6096 /* On Fujitsu S702x laptops capture only makes sense from Mic/LineIn jack,
6097 * headphone jack and the internal CD lines since these are the only pins at
6098 * which audio can appear. For flexibility, also allow the option of
6099 * recording the mixer output on the second ADC (ADC0 doesn't have a
6100 * connection to the mixer output).
6101 */
6102 static const struct hda_input_mux alc260_fujitsu_capture_sources[2] = {
6103 {
6104 .num_items = 3,
6105 .items = {
6106 { "Mic/Line", 0x0 },
6107 { "CD", 0x4 },
6108 { "Headphone", 0x2 },
6109 },
6110 },
6111 {
6112 .num_items = 4,
6113 .items = {
6114 { "Mic/Line", 0x0 },
6115 { "CD", 0x4 },
6116 { "Headphone", 0x2 },
6117 { "Mixer", 0x5 },
6118 },
6119 },
6120
6121 };
6122
6123 /* Acer TravelMate(/Extensa/Aspire) notebooks have similar configuration to
6124 * the Fujitsu S702x, but jacks are marked differently.
6125 */
6126 static const struct hda_input_mux alc260_acer_capture_sources[2] = {
6127 {
6128 .num_items = 4,
6129 .items = {
6130 { "Mic", 0x0 },
6131 { "Line", 0x2 },
6132 { "CD", 0x4 },
6133 { "Headphone", 0x5 },
6134 },
6135 },
6136 {
6137 .num_items = 5,
6138 .items = {
6139 { "Mic", 0x0 },
6140 { "Line", 0x2 },
6141 { "CD", 0x4 },
6142 { "Headphone", 0x6 },
6143 { "Mixer", 0x5 },
6144 },
6145 },
6146 };
6147
6148 /* Maxdata Favorit 100XS */
6149 static const struct hda_input_mux alc260_favorit100_capture_sources[2] = {
6150 {
6151 .num_items = 2,
6152 .items = {
6153 { "Line/Mic", 0x0 },
6154 { "CD", 0x4 },
6155 },
6156 },
6157 {
6158 .num_items = 3,
6159 .items = {
6160 { "Line/Mic", 0x0 },
6161 { "CD", 0x4 },
6162 { "Mixer", 0x5 },
6163 },
6164 },
6165 };
6166
6167 /*
6168 * This is just place-holder, so there's something for alc_build_pcms to look
6169 * at when it calculates the maximum number of channels. ALC260 has no mixer
6170 * element which allows changing the channel mode, so the verb list is
6171 * never used.
6172 */
6173 static const struct hda_channel_mode alc260_modes[1] = {
6174 { 2, NULL },
6175 };
6176
6177
6178 /* Mixer combinations
6179 *
6180 * basic: base_output + input + pc_beep + capture
6181 * HP: base_output + input + capture_alt
6182 * HP_3013: hp_3013 + input + capture
6183 * fujitsu: fujitsu + capture
6184 * acer: acer + capture
6185 */
6186
6187 static const struct snd_kcontrol_new alc260_base_output_mixer[] = {
6188 HDA_CODEC_VOLUME("Front Playback Volume", 0x08, 0x0, HDA_OUTPUT),
6189 HDA_BIND_MUTE("Front Playback Switch", 0x08, 2, HDA_INPUT),
6190 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x09, 0x0, HDA_OUTPUT),
6191 HDA_BIND_MUTE("Headphone Playback Switch", 0x09, 2, HDA_INPUT),
6192 HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT),
6193 HDA_BIND_MUTE_MONO("Mono Playback Switch", 0x0a, 1, 2, HDA_INPUT),
6194 { } /* end */
6195 };
6196
6197 static const struct snd_kcontrol_new alc260_input_mixer[] = {
6198 HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
6199 HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
6200 HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
6201 HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
6202 HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
6203 HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
6204 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x07, 0x01, HDA_INPUT),
6205 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x07, 0x01, HDA_INPUT),
6206 { } /* end */
6207 };
6208
6209 /* update HP, line and mono out pins according to the master switch */
6210 static void alc260_hp_master_update(struct hda_codec *codec)
6211 {
6212 update_speakers(codec);
6213 }
6214
6215 static int alc260_hp_master_sw_get(struct snd_kcontrol *kcontrol,
6216 struct snd_ctl_elem_value *ucontrol)
6217 {
6218 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
6219 struct alc_spec *spec = codec->spec;
6220 *ucontrol->value.integer.value = !spec->master_mute;
6221 return 0;
6222 }
6223
6224 static int alc260_hp_master_sw_put(struct snd_kcontrol *kcontrol,
6225 struct snd_ctl_elem_value *ucontrol)
6226 {
6227 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
6228 struct alc_spec *spec = codec->spec;
6229 int val = !*ucontrol->value.integer.value;
6230
6231 if (val == spec->master_mute)
6232 return 0;
6233 spec->master_mute = val;
6234 alc260_hp_master_update(codec);
6235 return 1;
6236 }
6237
6238 static const struct snd_kcontrol_new alc260_hp_output_mixer[] = {
6239 {
6240 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
6241 .name = "Master Playback Switch",
6242 .subdevice = HDA_SUBDEV_NID_FLAG | 0x11,
6243 .info = snd_ctl_boolean_mono_info,
6244 .get = alc260_hp_master_sw_get,
6245 .put = alc260_hp_master_sw_put,
6246 },
6247 HDA_CODEC_VOLUME("Front Playback Volume", 0x08, 0x0, HDA_OUTPUT),
6248 HDA_BIND_MUTE("Front Playback Switch", 0x08, 2, HDA_INPUT),
6249 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x09, 0x0, HDA_OUTPUT),
6250 HDA_BIND_MUTE("Headphone Playback Switch", 0x09, 2, HDA_INPUT),
6251 HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0a, 1, 0x0,
6252 HDA_OUTPUT),
6253 HDA_BIND_MUTE_MONO("Speaker Playback Switch", 0x0a, 1, 2, HDA_INPUT),
6254 { } /* end */
6255 };
6256
6257 static const struct hda_verb alc260_hp_unsol_verbs[] = {
6258 {0x10, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
6259 {},
6260 };
6261
6262 static void alc260_hp_setup(struct hda_codec *codec)
6263 {
6264 struct alc_spec *spec = codec->spec;
6265
6266 spec->autocfg.hp_pins[0] = 0x0f;
6267 spec->autocfg.speaker_pins[0] = 0x10;
6268 spec->autocfg.speaker_pins[1] = 0x11;
6269 spec->automute = 1;
6270 spec->automute_mode = ALC_AUTOMUTE_PIN;
6271 }
6272
6273 static const struct snd_kcontrol_new alc260_hp_3013_mixer[] = {
6274 {
6275 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
6276 .name = "Master Playback Switch",
6277 .subdevice = HDA_SUBDEV_NID_FLAG | 0x11,
6278 .info = snd_ctl_boolean_mono_info,
6279 .get = alc260_hp_master_sw_get,
6280 .put = alc260_hp_master_sw_put,
6281 },
6282 HDA_CODEC_VOLUME("Front Playback Volume", 0x09, 0x0, HDA_OUTPUT),
6283 HDA_CODEC_MUTE("Front Playback Switch", 0x10, 0x0, HDA_OUTPUT),
6284 HDA_CODEC_VOLUME("Aux-In Playback Volume", 0x07, 0x06, HDA_INPUT),
6285 HDA_CODEC_MUTE("Aux-In Playback Switch", 0x07, 0x06, HDA_INPUT),
6286 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x08, 0x0, HDA_OUTPUT),
6287 HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
6288 HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT),
6289 HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x11, 1, 0x0, HDA_OUTPUT),
6290 { } /* end */
6291 };
6292
6293 static void alc260_hp_3013_setup(struct hda_codec *codec)
6294 {
6295 struct alc_spec *spec = codec->spec;
6296
6297 spec->autocfg.hp_pins[0] = 0x15;
6298 spec->autocfg.speaker_pins[0] = 0x10;
6299 spec->autocfg.speaker_pins[1] = 0x11;
6300 spec->automute = 1;
6301 spec->automute_mode = ALC_AUTOMUTE_PIN;
6302 }
6303
6304 static const struct hda_bind_ctls alc260_dc7600_bind_master_vol = {
6305 .ops = &snd_hda_bind_vol,
6306 .values = {
6307 HDA_COMPOSE_AMP_VAL(0x08, 3, 0, HDA_OUTPUT),
6308 HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_OUTPUT),
6309 HDA_COMPOSE_AMP_VAL(0x0a, 3, 0, HDA_OUTPUT),
6310 0
6311 },
6312 };
6313
6314 static const struct hda_bind_ctls alc260_dc7600_bind_switch = {
6315 .ops = &snd_hda_bind_sw,
6316 .values = {
6317 HDA_COMPOSE_AMP_VAL(0x11, 3, 0, HDA_OUTPUT),
6318 HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT),
6319 0
6320 },
6321 };
6322
6323 static const struct snd_kcontrol_new alc260_hp_dc7600_mixer[] = {
6324 HDA_BIND_VOL("Master Playback Volume", &alc260_dc7600_bind_master_vol),
6325 HDA_BIND_SW("LineOut Playback Switch", &alc260_dc7600_bind_switch),
6326 HDA_CODEC_MUTE("Speaker Playback Switch", 0x0f, 0x0, HDA_OUTPUT),
6327 HDA_CODEC_MUTE("Headphone Playback Switch", 0x10, 0x0, HDA_OUTPUT),
6328 { } /* end */
6329 };
6330
6331 static const struct hda_verb alc260_hp_3013_unsol_verbs[] = {
6332 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
6333 {},
6334 };
6335
6336 static void alc260_hp_3012_setup(struct hda_codec *codec)
6337 {
6338 struct alc_spec *spec = codec->spec;
6339
6340 spec->autocfg.hp_pins[0] = 0x10;
6341 spec->autocfg.speaker_pins[0] = 0x0f;
6342 spec->autocfg.speaker_pins[1] = 0x11;
6343 spec->autocfg.speaker_pins[2] = 0x15;
6344 spec->automute = 1;
6345 spec->automute_mode = ALC_AUTOMUTE_PIN;
6346 }
6347
6348 /* Fujitsu S702x series laptops. ALC260 pin usage: Mic/Line jack = 0x12,
6349 * HP jack = 0x14, CD audio = 0x16, internal speaker = 0x10.
6350 */
6351 static const struct snd_kcontrol_new alc260_fujitsu_mixer[] = {
6352 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x08, 0x0, HDA_OUTPUT),
6353 HDA_BIND_MUTE("Headphone Playback Switch", 0x08, 2, HDA_INPUT),
6354 ALC_PIN_MODE("Headphone Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
6355 HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
6356 HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
6357 HDA_CODEC_VOLUME("Mic/Line Playback Volume", 0x07, 0x0, HDA_INPUT),
6358 HDA_CODEC_MUTE("Mic/Line Playback Switch", 0x07, 0x0, HDA_INPUT),
6359 ALC_PIN_MODE("Mic/Line Jack Mode", 0x12, ALC_PIN_DIR_IN),
6360 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x09, 0x0, HDA_OUTPUT),
6361 HDA_BIND_MUTE("Speaker Playback Switch", 0x09, 2, HDA_INPUT),
6362 { } /* end */
6363 };
6364
6365 /* Mixer for Acer TravelMate(/Extensa/Aspire) notebooks. Note that current
6366 * versions of the ALC260 don't act on requests to enable mic bias from NID
6367 * 0x0f (used to drive the headphone jack in these laptops). The ALC260
6368 * datasheet doesn't mention this restriction. At this stage it's not clear
6369 * whether this behaviour is intentional or is a hardware bug in chip
6370 * revisions available in early 2006. Therefore for now allow the
6371 * "Headphone Jack Mode" control to span all choices, but if it turns out
6372 * that the lack of mic bias for this NID is intentional we could change the
6373 * mode from ALC_PIN_DIR_INOUT to ALC_PIN_DIR_INOUT_NOMICBIAS.
6374 *
6375 * In addition, Acer TravelMate(/Extensa/Aspire) notebooks in early 2006
6376 * don't appear to make the mic bias available from the "line" jack, even
6377 * though the NID used for this jack (0x14) can supply it. The theory is
6378 * that perhaps Acer have included blocking capacitors between the ALC260
6379 * and the output jack. If this turns out to be the case for all such
6380 * models the "Line Jack Mode" mode could be changed from ALC_PIN_DIR_INOUT
6381 * to ALC_PIN_DIR_INOUT_NOMICBIAS.
6382 *
6383 * The C20x Tablet series have a mono internal speaker which is controlled
6384 * via the chip's Mono sum widget and pin complex, so include the necessary
6385 * controls for such models. On models without a "mono speaker" the control
6386 * won't do anything.
6387 */
6388 static const struct snd_kcontrol_new alc260_acer_mixer[] = {
6389 HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT),
6390 HDA_BIND_MUTE("Master Playback Switch", 0x08, 2, HDA_INPUT),
6391 ALC_PIN_MODE("Headphone Jack Mode", 0x0f, ALC_PIN_DIR_INOUT),
6392 HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0a, 1, 0x0,
6393 HDA_OUTPUT),
6394 HDA_BIND_MUTE_MONO("Speaker Playback Switch", 0x0a, 1, 2,
6395 HDA_INPUT),
6396 HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
6397 HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
6398 HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
6399 HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
6400 ALC_PIN_MODE("Mic Jack Mode", 0x12, ALC_PIN_DIR_IN),
6401 HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
6402 HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
6403 ALC_PIN_MODE("Line Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
6404 { } /* end */
6405 };
6406
6407 /* Maxdata Favorit 100XS: one output and one input (0x12) jack
6408 */
6409 static const struct snd_kcontrol_new alc260_favorit100_mixer[] = {
6410 HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT),
6411 HDA_BIND_MUTE("Master Playback Switch", 0x08, 2, HDA_INPUT),
6412 ALC_PIN_MODE("Output Jack Mode", 0x0f, ALC_PIN_DIR_INOUT),
6413 HDA_CODEC_VOLUME("Line/Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
6414 HDA_CODEC_MUTE("Line/Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
6415 ALC_PIN_MODE("Line/Mic Jack Mode", 0x12, ALC_PIN_DIR_IN),
6416 { } /* end */
6417 };
6418
6419 /* Packard bell V7900 ALC260 pin usage: HP = 0x0f, Mic jack = 0x12,
6420 * Line In jack = 0x14, CD audio = 0x16, pc beep = 0x17.
6421 */
6422 static const struct snd_kcontrol_new alc260_will_mixer[] = {
6423 HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT),
6424 HDA_BIND_MUTE("Master Playback Switch", 0x08, 0x2, HDA_INPUT),
6425 HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
6426 HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
6427 ALC_PIN_MODE("Mic Jack Mode", 0x12, ALC_PIN_DIR_IN),
6428 HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
6429 HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
6430 ALC_PIN_MODE("Line Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
6431 HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
6432 HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
6433 { } /* end */
6434 };
6435
6436 /* Replacer 672V ALC260 pin usage: Mic jack = 0x12,
6437 * Line In jack = 0x14, ATAPI Mic = 0x13, speaker = 0x0f.
6438 */
6439 static const struct snd_kcontrol_new alc260_replacer_672v_mixer[] = {
6440 HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT),
6441 HDA_BIND_MUTE("Master Playback Switch", 0x08, 0x2, HDA_INPUT),
6442 HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
6443 HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
6444 ALC_PIN_MODE("Mic Jack Mode", 0x12, ALC_PIN_DIR_IN),
6445 HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x07, 0x1, HDA_INPUT),
6446 HDA_CODEC_MUTE("ATATI Mic Playback Switch", 0x07, 0x1, HDA_INPUT),
6447 HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
6448 HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
6449 ALC_PIN_MODE("Line Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
6450 { } /* end */
6451 };
6452
6453 /*
6454 * initialization verbs
6455 */
6456 static const struct hda_verb alc260_init_verbs[] = {
6457 /* Line In pin widget for input */
6458 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
6459 /* CD pin widget for input */
6460 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
6461 /* Mic1 (rear panel) pin widget for input and vref at 80% */
6462 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
6463 /* Mic2 (front panel) pin widget for input and vref at 80% */
6464 {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
6465 /* LINE-2 is used for line-out in rear */
6466 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6467 /* select line-out */
6468 {0x0e, AC_VERB_SET_CONNECT_SEL, 0x00},
6469 /* LINE-OUT pin */
6470 {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6471 /* enable HP */
6472 {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
6473 /* enable Mono */
6474 {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6475 /* mute capture amp left and right */
6476 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6477 /* set connection select to line in (default select for this ADC) */
6478 {0x04, AC_VERB_SET_CONNECT_SEL, 0x02},
6479 /* mute capture amp left and right */
6480 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6481 /* set connection select to line in (default select for this ADC) */
6482 {0x05, AC_VERB_SET_CONNECT_SEL, 0x02},
6483 /* set vol=0 Line-Out mixer amp left and right */
6484 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6485 /* unmute pin widget amp left and right (no gain on this amp) */
6486 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6487 /* set vol=0 HP mixer amp left and right */
6488 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6489 /* unmute pin widget amp left and right (no gain on this amp) */
6490 {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6491 /* set vol=0 Mono mixer amp left and right */
6492 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6493 /* unmute pin widget amp left and right (no gain on this amp) */
6494 {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6495 /* unmute LINE-2 out pin */
6496 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6497 /* Amp Indexes: CD = 0x04, Line In 1 = 0x02, Mic 1 = 0x00 &
6498 * Line In 2 = 0x03
6499 */
6500 /* mute analog inputs */
6501 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6502 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6503 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
6504 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
6505 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
6506 /* Amp Indexes: DAC = 0x01 & mixer = 0x00 */
6507 /* mute Front out path */
6508 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6509 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6510 /* mute Headphone out path */
6511 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6512 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6513 /* mute Mono out path */
6514 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6515 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6516 { }
6517 };
6518
6519 #if 0 /* should be identical with alc260_init_verbs? */
6520 static const struct hda_verb alc260_hp_init_verbs[] = {
6521 /* Headphone and output */
6522 {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
6523 /* mono output */
6524 {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
6525 /* Mic1 (rear panel) pin widget for input and vref at 80% */
6526 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
6527 /* Mic2 (front panel) pin widget for input and vref at 80% */
6528 {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
6529 /* Line In pin widget for input */
6530 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
6531 /* Line-2 pin widget for output */
6532 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
6533 /* CD pin widget for input */
6534 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
6535 /* unmute amp left and right */
6536 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000},
6537 /* set connection select to line in (default select for this ADC) */
6538 {0x04, AC_VERB_SET_CONNECT_SEL, 0x02},
6539 /* unmute Line-Out mixer amp left and right (volume = 0) */
6540 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
6541 /* mute pin widget amp left and right (no gain on this amp) */
6542 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
6543 /* unmute HP mixer amp left and right (volume = 0) */
6544 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
6545 /* mute pin widget amp left and right (no gain on this amp) */
6546 {0x10, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
6547 /* Amp Indexes: CD = 0x04, Line In 1 = 0x02, Mic 1 = 0x00 &
6548 * Line In 2 = 0x03
6549 */
6550 /* mute analog inputs */
6551 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6552 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6553 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
6554 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
6555 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
6556 /* Amp Indexes: DAC = 0x01 & mixer = 0x00 */
6557 /* Unmute Front out path */
6558 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
6559 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
6560 /* Unmute Headphone out path */
6561 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
6562 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
6563 /* Unmute Mono out path */
6564 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
6565 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
6566 { }
6567 };
6568 #endif
6569
6570 static const struct hda_verb alc260_hp_3013_init_verbs[] = {
6571 /* Line out and output */
6572 {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
6573 /* mono output */
6574 {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
6575 /* Mic1 (rear panel) pin widget for input and vref at 80% */
6576 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
6577 /* Mic2 (front panel) pin widget for input and vref at 80% */
6578 {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
6579 /* Line In pin widget for input */
6580 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
6581 /* Headphone pin widget for output */
6582 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
6583 /* CD pin widget for input */
6584 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
6585 /* unmute amp left and right */
6586 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000},
6587 /* set connection select to line in (default select for this ADC) */
6588 {0x04, AC_VERB_SET_CONNECT_SEL, 0x02},
6589 /* unmute Line-Out mixer amp left and right (volume = 0) */
6590 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
6591 /* mute pin widget amp left and right (no gain on this amp) */
6592 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
6593 /* unmute HP mixer amp left and right (volume = 0) */
6594 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
6595 /* mute pin widget amp left and right (no gain on this amp) */
6596 {0x10, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
6597 /* Amp Indexes: CD = 0x04, Line In 1 = 0x02, Mic 1 = 0x00 &
6598 * Line In 2 = 0x03
6599 */
6600 /* mute analog inputs */
6601 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6602 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6603 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
6604 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
6605 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
6606 /* Amp Indexes: DAC = 0x01 & mixer = 0x00 */
6607 /* Unmute Front out path */
6608 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
6609 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
6610 /* Unmute Headphone out path */
6611 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
6612 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
6613 /* Unmute Mono out path */
6614 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
6615 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
6616 { }
6617 };
6618
6619 /* Initialisation sequence for ALC260 as configured in Fujitsu S702x
6620 * laptops. ALC260 pin usage: Mic/Line jack = 0x12, HP jack = 0x14, CD
6621 * audio = 0x16, internal speaker = 0x10.
6622 */
6623 static const struct hda_verb alc260_fujitsu_init_verbs[] = {
6624 /* Disable all GPIOs */
6625 {0x01, AC_VERB_SET_GPIO_MASK, 0},
6626 /* Internal speaker is connected to headphone pin */
6627 {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
6628 /* Headphone/Line-out jack connects to Line1 pin; make it an output */
6629 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6630 /* Mic/Line-in jack is connected to mic1 pin, so make it an input */
6631 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
6632 /* Ensure all other unused pins are disabled and muted. */
6633 {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
6634 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6635 {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
6636 {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6637 {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
6638 {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6639 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
6640 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6641
6642 /* Disable digital (SPDIF) pins */
6643 {0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
6644 {0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
6645
6646 /* Ensure Line1 pin widget takes its input from the OUT1 sum bus
6647 * when acting as an output.
6648 */
6649 {0x0d, AC_VERB_SET_CONNECT_SEL, 0},
6650
6651 /* Start with output sum widgets muted and their output gains at min */
6652 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6653 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6654 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6655 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6656 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6657 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6658 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6659 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6660 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6661
6662 /* Unmute HP pin widget amp left and right (no equiv mixer ctrl) */
6663 {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6664 /* Unmute Line1 pin widget output buffer since it starts as an output.
6665 * If the pin mode is changed by the user the pin mode control will
6666 * take care of enabling the pin's input/output buffers as needed.
6667 * Therefore there's no need to enable the input buffer at this
6668 * stage.
6669 */
6670 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6671 /* Unmute input buffer of pin widget used for Line-in (no equiv
6672 * mixer ctrl)
6673 */
6674 {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6675
6676 /* Mute capture amp left and right */
6677 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6678 /* Set ADC connection select to match default mixer setting - line
6679 * in (on mic1 pin)
6680 */
6681 {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
6682
6683 /* Do the same for the second ADC: mute capture input amp and
6684 * set ADC connection to line in (on mic1 pin)
6685 */
6686 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6687 {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
6688
6689 /* Mute all inputs to mixer widget (even unconnected ones) */
6690 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
6691 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
6692 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
6693 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
6694 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
6695 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
6696 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
6697 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
6698
6699 { }
6700 };
6701
6702 /* Initialisation sequence for ALC260 as configured in Acer TravelMate and
6703 * similar laptops (adapted from Fujitsu init verbs).
6704 */
6705 static const struct hda_verb alc260_acer_init_verbs[] = {
6706 /* On TravelMate laptops, GPIO 0 enables the internal speaker and
6707 * the headphone jack. Turn this on and rely on the standard mute
6708 * methods whenever the user wants to turn these outputs off.
6709 */
6710 {0x01, AC_VERB_SET_GPIO_MASK, 0x01},
6711 {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
6712 {0x01, AC_VERB_SET_GPIO_DATA, 0x01},
6713 /* Internal speaker/Headphone jack is connected to Line-out pin */
6714 {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
6715 /* Internal microphone/Mic jack is connected to Mic1 pin */
6716 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
6717 /* Line In jack is connected to Line1 pin */
6718 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
6719 /* Some Acers (eg: C20x Tablets) use Mono pin for internal speaker */
6720 {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
6721 /* Ensure all other unused pins are disabled and muted. */
6722 {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
6723 {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6724 {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
6725 {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6726 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
6727 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6728 /* Disable digital (SPDIF) pins */
6729 {0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
6730 {0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
6731
6732 /* Ensure Mic1 and Line1 pin widgets take input from the OUT1 sum
6733 * bus when acting as outputs.
6734 */
6735 {0x0b, AC_VERB_SET_CONNECT_SEL, 0},
6736 {0x0d, AC_VERB_SET_CONNECT_SEL, 0},
6737
6738 /* Start with output sum widgets muted and their output gains at min */
6739 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6740 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6741 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6742 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6743 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6744 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6745 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6746 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6747 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6748
6749 /* Unmute Line-out pin widget amp left and right
6750 * (no equiv mixer ctrl)
6751 */
6752 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6753 /* Unmute mono pin widget amp output (no equiv mixer ctrl) */
6754 {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6755 /* Unmute Mic1 and Line1 pin widget input buffers since they start as
6756 * inputs. If the pin mode is changed by the user the pin mode control
6757 * will take care of enabling the pin's input/output buffers as needed.
6758 * Therefore there's no need to enable the input buffer at this
6759 * stage.
6760 */
6761 {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6762 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6763
6764 /* Mute capture amp left and right */
6765 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6766 /* Set ADC connection select to match default mixer setting - mic
6767 * (on mic1 pin)
6768 */
6769 {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
6770
6771 /* Do similar with the second ADC: mute capture input amp and
6772 * set ADC connection to mic to match ALSA's default state.
6773 */
6774 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6775 {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
6776
6777 /* Mute all inputs to mixer widget (even unconnected ones) */
6778 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
6779 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
6780 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
6781 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
6782 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
6783 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
6784 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
6785 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
6786
6787 { }
6788 };
6789
6790 /* Initialisation sequence for Maxdata Favorit 100XS
6791 * (adapted from Acer init verbs).
6792 */
6793 static const struct hda_verb alc260_favorit100_init_verbs[] = {
6794 /* GPIO 0 enables the output jack.
6795 * Turn this on and rely on the standard mute
6796 * methods whenever the user wants to turn these outputs off.
6797 */
6798 {0x01, AC_VERB_SET_GPIO_MASK, 0x01},
6799 {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
6800 {0x01, AC_VERB_SET_GPIO_DATA, 0x01},
6801 /* Line/Mic input jack is connected to Mic1 pin */
6802 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
6803 /* Ensure all other unused pins are disabled and muted. */
6804 {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
6805 {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6806 {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
6807 {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6808 {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
6809 {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6810 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
6811 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6812 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
6813 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6814 /* Disable digital (SPDIF) pins */
6815 {0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
6816 {0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
6817
6818 /* Ensure Mic1 and Line1 pin widgets take input from the OUT1 sum
6819 * bus when acting as outputs.
6820 */
6821 {0x0b, AC_VERB_SET_CONNECT_SEL, 0},
6822 {0x0d, AC_VERB_SET_CONNECT_SEL, 0},
6823
6824 /* Start with output sum widgets muted and their output gains at min */
6825 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6826 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6827 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6828 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6829 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6830 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6831 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6832 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6833 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6834
6835 /* Unmute Line-out pin widget amp left and right
6836 * (no equiv mixer ctrl)
6837 */
6838 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6839 /* Unmute Mic1 and Line1 pin widget input buffers since they start as
6840 * inputs. If the pin mode is changed by the user the pin mode control
6841 * will take care of enabling the pin's input/output buffers as needed.
6842 * Therefore there's no need to enable the input buffer at this
6843 * stage.
6844 */
6845 {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6846
6847 /* Mute capture amp left and right */
6848 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6849 /* Set ADC connection select to match default mixer setting - mic
6850 * (on mic1 pin)
6851 */
6852 {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
6853
6854 /* Do similar with the second ADC: mute capture input amp and
6855 * set ADC connection to mic to match ALSA's default state.
6856 */
6857 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6858 {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
6859
6860 /* Mute all inputs to mixer widget (even unconnected ones) */
6861 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
6862 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
6863 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
6864 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
6865 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
6866 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
6867 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
6868 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
6869
6870 { }
6871 };
6872
6873 static const struct hda_verb alc260_will_verbs[] = {
6874 {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
6875 {0x0b, AC_VERB_SET_CONNECT_SEL, 0x00},
6876 {0x0d, AC_VERB_SET_CONNECT_SEL, 0x00},
6877 {0x0f, AC_VERB_SET_EAPD_BTLENABLE, 0x02},
6878 {0x1a, AC_VERB_SET_COEF_INDEX, 0x07},
6879 {0x1a, AC_VERB_SET_PROC_COEF, 0x3040},
6880 {}
6881 };
6882
6883 static const struct hda_verb alc260_replacer_672v_verbs[] = {
6884 {0x0f, AC_VERB_SET_EAPD_BTLENABLE, 0x02},
6885 {0x1a, AC_VERB_SET_COEF_INDEX, 0x07},
6886 {0x1a, AC_VERB_SET_PROC_COEF, 0x3050},
6887
6888 {0x01, AC_VERB_SET_GPIO_MASK, 0x01},
6889 {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
6890 {0x01, AC_VERB_SET_GPIO_DATA, 0x00},
6891
6892 {0x0f, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
6893 {}
6894 };
6895
6896 /* toggle speaker-output according to the hp-jack state */
6897 static void alc260_replacer_672v_automute(struct hda_codec *codec)
6898 {
6899 unsigned int present;
6900
6901 /* speaker --> GPIO Data 0, hp or spdif --> GPIO data 1 */
6902 present = snd_hda_jack_detect(codec, 0x0f);
6903 if (present) {
6904 snd_hda_codec_write_cache(codec, 0x01, 0,
6905 AC_VERB_SET_GPIO_DATA, 1);
6906 snd_hda_codec_write_cache(codec, 0x0f, 0,
6907 AC_VERB_SET_PIN_WIDGET_CONTROL,
6908 PIN_HP);
6909 } else {
6910 snd_hda_codec_write_cache(codec, 0x01, 0,
6911 AC_VERB_SET_GPIO_DATA, 0);
6912 snd_hda_codec_write_cache(codec, 0x0f, 0,
6913 AC_VERB_SET_PIN_WIDGET_CONTROL,
6914 PIN_OUT);
6915 }
6916 }
6917
6918 static void alc260_replacer_672v_unsol_event(struct hda_codec *codec,
6919 unsigned int res)
6920 {
6921 if ((res >> 26) == ALC880_HP_EVENT)
6922 alc260_replacer_672v_automute(codec);
6923 }
6924
6925 static const struct hda_verb alc260_hp_dc7600_verbs[] = {
6926 {0x05, AC_VERB_SET_CONNECT_SEL, 0x01},
6927 {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
6928 {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6929 {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
6930 {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6931 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6932 {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
6933 {0x10, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
6934 {0x11, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
6935 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
6936 {}
6937 };
6938
6939 /* Test configuration for debugging, modelled after the ALC880 test
6940 * configuration.
6941 */
6942 #ifdef CONFIG_SND_DEBUG
6943 static const hda_nid_t alc260_test_dac_nids[1] = {
6944 0x02,
6945 };
6946 static const hda_nid_t alc260_test_adc_nids[2] = {
6947 0x04, 0x05,
6948 };
6949 /* For testing the ALC260, each input MUX needs its own definition since
6950 * the signal assignments are different. This assumes that the first ADC
6951 * is NID 0x04.
6952 */
6953 static const struct hda_input_mux alc260_test_capture_sources[2] = {
6954 {
6955 .num_items = 7,
6956 .items = {
6957 { "MIC1 pin", 0x0 },
6958 { "MIC2 pin", 0x1 },
6959 { "LINE1 pin", 0x2 },
6960 { "LINE2 pin", 0x3 },
6961 { "CD pin", 0x4 },
6962 { "LINE-OUT pin", 0x5 },
6963 { "HP-OUT pin", 0x6 },
6964 },
6965 },
6966 {
6967 .num_items = 8,
6968 .items = {
6969 { "MIC1 pin", 0x0 },
6970 { "MIC2 pin", 0x1 },
6971 { "LINE1 pin", 0x2 },
6972 { "LINE2 pin", 0x3 },
6973 { "CD pin", 0x4 },
6974 { "Mixer", 0x5 },
6975 { "LINE-OUT pin", 0x6 },
6976 { "HP-OUT pin", 0x7 },
6977 },
6978 },
6979 };
6980 static const struct snd_kcontrol_new alc260_test_mixer[] = {
6981 /* Output driver widgets */
6982 HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT),
6983 HDA_BIND_MUTE_MONO("Mono Playback Switch", 0x0a, 1, 2, HDA_INPUT),
6984 HDA_CODEC_VOLUME("LOUT2 Playback Volume", 0x09, 0x0, HDA_OUTPUT),
6985 HDA_BIND_MUTE("LOUT2 Playback Switch", 0x09, 2, HDA_INPUT),
6986 HDA_CODEC_VOLUME("LOUT1 Playback Volume", 0x08, 0x0, HDA_OUTPUT),
6987 HDA_BIND_MUTE("LOUT1 Playback Switch", 0x08, 2, HDA_INPUT),
6988
6989 /* Modes for retasking pin widgets
6990 * Note: the ALC260 doesn't seem to act on requests to enable mic
6991 * bias from NIDs 0x0f and 0x10. The ALC260 datasheet doesn't
6992 * mention this restriction. At this stage it's not clear whether
6993 * this behaviour is intentional or is a hardware bug in chip
6994 * revisions available at least up until early 2006. Therefore for
6995 * now allow the "HP-OUT" and "LINE-OUT" Mode controls to span all
6996 * choices, but if it turns out that the lack of mic bias for these
6997 * NIDs is intentional we could change their modes from
6998 * ALC_PIN_DIR_INOUT to ALC_PIN_DIR_INOUT_NOMICBIAS.
6999 */
7000 ALC_PIN_MODE("HP-OUT pin mode", 0x10, ALC_PIN_DIR_INOUT),
7001 ALC_PIN_MODE("LINE-OUT pin mode", 0x0f, ALC_PIN_DIR_INOUT),
7002 ALC_PIN_MODE("LINE2 pin mode", 0x15, ALC_PIN_DIR_INOUT),
7003 ALC_PIN_MODE("LINE1 pin mode", 0x14, ALC_PIN_DIR_INOUT),
7004 ALC_PIN_MODE("MIC2 pin mode", 0x13, ALC_PIN_DIR_INOUT),
7005 ALC_PIN_MODE("MIC1 pin mode", 0x12, ALC_PIN_DIR_INOUT),
7006
7007 /* Loopback mixer controls */
7008 HDA_CODEC_VOLUME("MIC1 Playback Volume", 0x07, 0x00, HDA_INPUT),
7009 HDA_CODEC_MUTE("MIC1 Playback Switch", 0x07, 0x00, HDA_INPUT),
7010 HDA_CODEC_VOLUME("MIC2 Playback Volume", 0x07, 0x01, HDA_INPUT),
7011 HDA_CODEC_MUTE("MIC2 Playback Switch", 0x07, 0x01, HDA_INPUT),
7012 HDA_CODEC_VOLUME("LINE1 Playback Volume", 0x07, 0x02, HDA_INPUT),
7013 HDA_CODEC_MUTE("LINE1 Playback Switch", 0x07, 0x02, HDA_INPUT),
7014 HDA_CODEC_VOLUME("LINE2 Playback Volume", 0x07, 0x03, HDA_INPUT),
7015 HDA_CODEC_MUTE("LINE2 Playback Switch", 0x07, 0x03, HDA_INPUT),
7016 HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
7017 HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
7018 HDA_CODEC_VOLUME("LINE-OUT loopback Playback Volume", 0x07, 0x06, HDA_INPUT),
7019 HDA_CODEC_MUTE("LINE-OUT loopback Playback Switch", 0x07, 0x06, HDA_INPUT),
7020 HDA_CODEC_VOLUME("HP-OUT loopback Playback Volume", 0x07, 0x7, HDA_INPUT),
7021 HDA_CODEC_MUTE("HP-OUT loopback Playback Switch", 0x07, 0x7, HDA_INPUT),
7022
7023 /* Controls for GPIO pins, assuming they are configured as outputs */
7024 ALC_GPIO_DATA_SWITCH("GPIO pin 0", 0x01, 0x01),
7025 ALC_GPIO_DATA_SWITCH("GPIO pin 1", 0x01, 0x02),
7026 ALC_GPIO_DATA_SWITCH("GPIO pin 2", 0x01, 0x04),
7027 ALC_GPIO_DATA_SWITCH("GPIO pin 3", 0x01, 0x08),
7028
7029 /* Switches to allow the digital IO pins to be enabled. The datasheet
7030 * is ambigious as to which NID is which; testing on laptops which
7031 * make this output available should provide clarification.
7032 */
7033 ALC_SPDIF_CTRL_SWITCH("SPDIF Playback Switch", 0x03, 0x01),
7034 ALC_SPDIF_CTRL_SWITCH("SPDIF Capture Switch", 0x06, 0x01),
7035
7036 /* A switch allowing EAPD to be enabled. Some laptops seem to use
7037 * this output to turn on an external amplifier.
7038 */
7039 ALC_EAPD_CTRL_SWITCH("LINE-OUT EAPD Enable Switch", 0x0f, 0x02),
7040 ALC_EAPD_CTRL_SWITCH("HP-OUT EAPD Enable Switch", 0x10, 0x02),
7041
7042 { } /* end */
7043 };
7044 static const struct hda_verb alc260_test_init_verbs[] = {
7045 /* Enable all GPIOs as outputs with an initial value of 0 */
7046 {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x0f},
7047 {0x01, AC_VERB_SET_GPIO_DATA, 0x00},
7048 {0x01, AC_VERB_SET_GPIO_MASK, 0x0f},
7049
7050 /* Enable retasking pins as output, initially without power amp */
7051 {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7052 {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7053 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7054 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7055 {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7056 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7057
7058 /* Disable digital (SPDIF) pins initially, but users can enable
7059 * them via a mixer switch. In the case of SPDIF-out, this initverb
7060 * payload also sets the generation to 0, output to be in "consumer"
7061 * PCM format, copyright asserted, no pre-emphasis and no validity
7062 * control.
7063 */
7064 {0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
7065 {0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
7066
7067 /* Ensure mic1, mic2, line1 and line2 pin widgets take input from the
7068 * OUT1 sum bus when acting as an output.
7069 */
7070 {0x0b, AC_VERB_SET_CONNECT_SEL, 0},
7071 {0x0c, AC_VERB_SET_CONNECT_SEL, 0},
7072 {0x0d, AC_VERB_SET_CONNECT_SEL, 0},
7073 {0x0e, AC_VERB_SET_CONNECT_SEL, 0},
7074
7075 /* Start with output sum widgets muted and their output gains at min */
7076 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7077 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7078 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7079 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7080 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7081 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7082 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7083 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7084 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7085
7086 /* Unmute retasking pin widget output buffers since the default
7087 * state appears to be output. As the pin mode is changed by the
7088 * user the pin mode control will take care of enabling the pin's
7089 * input/output buffers as needed.
7090 */
7091 {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7092 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7093 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7094 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7095 {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7096 {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7097 /* Also unmute the mono-out pin widget */
7098 {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7099
7100 /* Mute capture amp left and right */
7101 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7102 /* Set ADC connection select to match default mixer setting (mic1
7103 * pin)
7104 */
7105 {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
7106
7107 /* Do the same for the second ADC: mute capture input amp and
7108 * set ADC connection to mic1 pin
7109 */
7110 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7111 {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
7112
7113 /* Mute all inputs to mixer widget (even unconnected ones) */
7114 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
7115 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
7116 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
7117 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
7118 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
7119 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
7120 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
7121 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
7122
7123 { }
7124 };
7125 #endif
7126
7127 #define alc260_pcm_analog_playback alc880_pcm_analog_alt_playback
7128 #define alc260_pcm_analog_capture alc880_pcm_analog_capture
7129
7130 #define alc260_pcm_digital_playback alc880_pcm_digital_playback
7131 #define alc260_pcm_digital_capture alc880_pcm_digital_capture
7132
7133 /*
7134 * for BIOS auto-configuration
7135 */
7136
7137 static int alc260_add_playback_controls(struct alc_spec *spec, hda_nid_t nid,
7138 const char *pfx, int *vol_bits)
7139 {
7140 hda_nid_t nid_vol;
7141 unsigned long vol_val, sw_val;
7142 int err;
7143
7144 if (nid >= 0x0f && nid < 0x11) {
7145 nid_vol = nid - 0x7;
7146 vol_val = HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, HDA_OUTPUT);
7147 sw_val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
7148 } else if (nid == 0x11) {
7149 nid_vol = nid - 0x7;
7150 vol_val = HDA_COMPOSE_AMP_VAL(nid_vol, 2, 0, HDA_OUTPUT);
7151 sw_val = HDA_COMPOSE_AMP_VAL(nid, 2, 0, HDA_OUTPUT);
7152 } else if (nid >= 0x12 && nid <= 0x15) {
7153 nid_vol = 0x08;
7154 vol_val = HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, HDA_OUTPUT);
7155 sw_val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
7156 } else
7157 return 0; /* N/A */
7158
7159 if (!(*vol_bits & (1 << nid_vol))) {
7160 /* first control for the volume widget */
7161 err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, pfx, vol_val);
7162 if (err < 0)
7163 return err;
7164 *vol_bits |= (1 << nid_vol);
7165 }
7166 err = add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, pfx, sw_val);
7167 if (err < 0)
7168 return err;
7169 return 1;
7170 }
7171
7172 /* add playback controls from the parsed DAC table */
7173 static int alc260_auto_create_multi_out_ctls(struct alc_spec *spec,
7174 const struct auto_pin_cfg *cfg)
7175 {
7176 hda_nid_t nid;
7177 int err;
7178 int vols = 0;
7179
7180 spec->multiout.num_dacs = 1;
7181 spec->multiout.dac_nids = spec->private_dac_nids;
7182 spec->private_dac_nids[0] = 0x02;
7183
7184 nid = cfg->line_out_pins[0];
7185 if (nid) {
7186 const char *pfx;
7187 if (!cfg->speaker_pins[0] && !cfg->hp_pins[0])
7188 pfx = "Master";
7189 else if (cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
7190 pfx = "Speaker";
7191 else
7192 pfx = "Front";
7193 err = alc260_add_playback_controls(spec, nid, pfx, &vols);
7194 if (err < 0)
7195 return err;
7196 }
7197
7198 nid = cfg->speaker_pins[0];
7199 if (nid) {
7200 err = alc260_add_playback_controls(spec, nid, "Speaker", &vols);
7201 if (err < 0)
7202 return err;
7203 }
7204
7205 nid = cfg->hp_pins[0];
7206 if (nid) {
7207 err = alc260_add_playback_controls(spec, nid, "Headphone",
7208 &vols);
7209 if (err < 0)
7210 return err;
7211 }
7212 return 0;
7213 }
7214
7215 /* create playback/capture controls for input pins */
7216 static int alc260_auto_create_input_ctls(struct hda_codec *codec,
7217 const struct auto_pin_cfg *cfg)
7218 {
7219 return alc_auto_create_input_ctls(codec, cfg, 0x07, 0x04, 0x05);
7220 }
7221
7222 static void alc260_auto_set_output_and_unmute(struct hda_codec *codec,
7223 hda_nid_t nid, int pin_type,
7224 int sel_idx)
7225 {
7226 alc_set_pin_output(codec, nid, pin_type);
7227 /* need the manual connection? */
7228 if (nid >= 0x12) {
7229 int idx = nid - 0x12;
7230 snd_hda_codec_write(codec, idx + 0x0b, 0,
7231 AC_VERB_SET_CONNECT_SEL, sel_idx);
7232 }
7233 }
7234
7235 static void alc260_auto_init_multi_out(struct hda_codec *codec)
7236 {
7237 struct alc_spec *spec = codec->spec;
7238 hda_nid_t nid;
7239
7240 nid = spec->autocfg.line_out_pins[0];
7241 if (nid) {
7242 int pin_type = get_pin_type(spec->autocfg.line_out_type);
7243 alc260_auto_set_output_and_unmute(codec, nid, pin_type, 0);
7244 }
7245
7246 nid = spec->autocfg.speaker_pins[0];
7247 if (nid)
7248 alc260_auto_set_output_and_unmute(codec, nid, PIN_OUT, 0);
7249
7250 nid = spec->autocfg.hp_pins[0];
7251 if (nid)
7252 alc260_auto_set_output_and_unmute(codec, nid, PIN_HP, 0);
7253 }
7254
7255 #define ALC260_PIN_CD_NID 0x16
7256 static void alc260_auto_init_analog_input(struct hda_codec *codec)
7257 {
7258 struct alc_spec *spec = codec->spec;
7259 struct auto_pin_cfg *cfg = &spec->autocfg;
7260 int i;
7261
7262 for (i = 0; i < cfg->num_inputs; i++) {
7263 hda_nid_t nid = cfg->inputs[i].pin;
7264 if (nid >= 0x12) {
7265 alc_set_input_pin(codec, nid, cfg->inputs[i].type);
7266 if (nid != ALC260_PIN_CD_NID &&
7267 (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP))
7268 snd_hda_codec_write(codec, nid, 0,
7269 AC_VERB_SET_AMP_GAIN_MUTE,
7270 AMP_OUT_MUTE);
7271 }
7272 }
7273 }
7274
7275 #define alc260_auto_init_input_src alc880_auto_init_input_src
7276
7277 /*
7278 * generic initialization of ADC, input mixers and output mixers
7279 */
7280 static const struct hda_verb alc260_volume_init_verbs[] = {
7281 /*
7282 * Unmute ADC0-1 and set the default input to mic-in
7283 */
7284 {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
7285 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7286 {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
7287 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7288
7289 /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
7290 * mixer widget
7291 * Note: PASD motherboards uses the Line In 2 as the input for
7292 * front panel mic (mic 2)
7293 */
7294 /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
7295 /* mute analog inputs */
7296 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7297 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7298 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7299 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7300 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7301
7302 /*
7303 * Set up output mixers (0x08 - 0x0a)
7304 */
7305 /* set vol=0 to output mixers */
7306 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7307 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7308 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7309 /* set up input amps for analog loopback */
7310 /* Amp Indices: DAC = 0, mixer = 1 */
7311 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7312 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7313 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7314 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7315 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7316 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7317
7318 { }
7319 };
7320
7321 static int alc260_parse_auto_config(struct hda_codec *codec)
7322 {
7323 struct alc_spec *spec = codec->spec;
7324 int err;
7325 static const hda_nid_t alc260_ignore[] = { 0x17, 0 };
7326
7327 err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
7328 alc260_ignore);
7329 if (err < 0)
7330 return err;
7331 err = alc260_auto_create_multi_out_ctls(spec, &spec->autocfg);
7332 if (err < 0)
7333 return err;
7334 if (!spec->kctls.list)
7335 return 0; /* can't find valid BIOS pin config */
7336 err = alc260_auto_create_input_ctls(codec, &spec->autocfg);
7337 if (err < 0)
7338 return err;
7339
7340 spec->multiout.max_channels = 2;
7341
7342 if (spec->autocfg.dig_outs)
7343 spec->multiout.dig_out_nid = ALC260_DIGOUT_NID;
7344 if (spec->kctls.list)
7345 add_mixer(spec, spec->kctls.list);
7346
7347 add_verb(spec, alc260_volume_init_verbs);
7348
7349 spec->num_mux_defs = 1;
7350 spec->input_mux = &spec->private_imux[0];
7351
7352 alc_ssid_check(codec, 0x10, 0x15, 0x0f, 0);
7353
7354 return 1;
7355 }
7356
7357 /* additional initialization for auto-configuration model */
7358 static void alc260_auto_init(struct hda_codec *codec)
7359 {
7360 struct alc_spec *spec = codec->spec;
7361 alc260_auto_init_multi_out(codec);
7362 alc260_auto_init_analog_input(codec);
7363 alc260_auto_init_input_src(codec);
7364 alc_auto_init_digital(codec);
7365 if (spec->unsol_event)
7366 alc_inithook(codec);
7367 }
7368
7369 #ifdef CONFIG_SND_HDA_POWER_SAVE
7370 static const struct hda_amp_list alc260_loopbacks[] = {
7371 { 0x07, HDA_INPUT, 0 },
7372 { 0x07, HDA_INPUT, 1 },
7373 { 0x07, HDA_INPUT, 2 },
7374 { 0x07, HDA_INPUT, 3 },
7375 { 0x07, HDA_INPUT, 4 },
7376 { } /* end */
7377 };
7378 #endif
7379
7380 /*
7381 * Pin config fixes
7382 */
7383 enum {
7384 PINFIX_HP_DC5750,
7385 };
7386
7387 static const struct alc_fixup alc260_fixups[] = {
7388 [PINFIX_HP_DC5750] = {
7389 .type = ALC_FIXUP_PINS,
7390 .v.pins = (const struct alc_pincfg[]) {
7391 { 0x11, 0x90130110 }, /* speaker */
7392 { }
7393 }
7394 },
7395 };
7396
7397 static const struct snd_pci_quirk alc260_fixup_tbl[] = {
7398 SND_PCI_QUIRK(0x103c, 0x280a, "HP dc5750", PINFIX_HP_DC5750),
7399 {}
7400 };
7401
7402 /*
7403 * ALC260 configurations
7404 */
7405 static const char * const alc260_models[ALC260_MODEL_LAST] = {
7406 [ALC260_BASIC] = "basic",
7407 [ALC260_HP] = "hp",
7408 [ALC260_HP_3013] = "hp-3013",
7409 [ALC260_HP_DC7600] = "hp-dc7600",
7410 [ALC260_FUJITSU_S702X] = "fujitsu",
7411 [ALC260_ACER] = "acer",
7412 [ALC260_WILL] = "will",
7413 [ALC260_REPLACER_672V] = "replacer",
7414 [ALC260_FAVORIT100] = "favorit100",
7415 #ifdef CONFIG_SND_DEBUG
7416 [ALC260_TEST] = "test",
7417 #endif
7418 [ALC260_AUTO] = "auto",
7419 };
7420
7421 static const struct snd_pci_quirk alc260_cfg_tbl[] = {
7422 SND_PCI_QUIRK(0x1025, 0x007b, "Acer C20x", ALC260_ACER),
7423 SND_PCI_QUIRK(0x1025, 0x007f, "Acer", ALC260_WILL),
7424 SND_PCI_QUIRK(0x1025, 0x008f, "Acer", ALC260_ACER),
7425 SND_PCI_QUIRK(0x1509, 0x4540, "Favorit 100XS", ALC260_FAVORIT100),
7426 SND_PCI_QUIRK(0x103c, 0x2808, "HP d5700", ALC260_HP_3013),
7427 SND_PCI_QUIRK(0x103c, 0x280a, "HP d5750", ALC260_AUTO), /* no quirk */
7428 SND_PCI_QUIRK(0x103c, 0x3010, "HP", ALC260_HP_3013),
7429 SND_PCI_QUIRK(0x103c, 0x3011, "HP", ALC260_HP_3013),
7430 SND_PCI_QUIRK(0x103c, 0x3012, "HP", ALC260_HP_DC7600),
7431 SND_PCI_QUIRK(0x103c, 0x3013, "HP", ALC260_HP_3013),
7432 SND_PCI_QUIRK(0x103c, 0x3014, "HP", ALC260_HP),
7433 SND_PCI_QUIRK(0x103c, 0x3015, "HP", ALC260_HP),
7434 SND_PCI_QUIRK(0x103c, 0x3016, "HP", ALC260_HP),
7435 SND_PCI_QUIRK(0x104d, 0x81bb, "Sony VAIO", ALC260_BASIC),
7436 SND_PCI_QUIRK(0x104d, 0x81cc, "Sony VAIO", ALC260_BASIC),
7437 SND_PCI_QUIRK(0x104d, 0x81cd, "Sony VAIO", ALC260_BASIC),
7438 SND_PCI_QUIRK(0x10cf, 0x1326, "Fujitsu S702X", ALC260_FUJITSU_S702X),
7439 SND_PCI_QUIRK(0x152d, 0x0729, "CTL U553W", ALC260_BASIC),
7440 SND_PCI_QUIRK(0x161f, 0x2057, "Replacer 672V", ALC260_REPLACER_672V),
7441 SND_PCI_QUIRK(0x1631, 0xc017, "PB V7900", ALC260_WILL),
7442 {}
7443 };
7444
7445 static const struct alc_config_preset alc260_presets[] = {
7446 [ALC260_BASIC] = {
7447 .mixers = { alc260_base_output_mixer,
7448 alc260_input_mixer },
7449 .init_verbs = { alc260_init_verbs },
7450 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
7451 .dac_nids = alc260_dac_nids,
7452 .num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids),
7453 .adc_nids = alc260_dual_adc_nids,
7454 .num_channel_mode = ARRAY_SIZE(alc260_modes),
7455 .channel_mode = alc260_modes,
7456 .input_mux = &alc260_capture_source,
7457 },
7458 [ALC260_HP] = {
7459 .mixers = { alc260_hp_output_mixer,
7460 alc260_input_mixer },
7461 .init_verbs = { alc260_init_verbs,
7462 alc260_hp_unsol_verbs },
7463 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
7464 .dac_nids = alc260_dac_nids,
7465 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids_alt),
7466 .adc_nids = alc260_adc_nids_alt,
7467 .num_channel_mode = ARRAY_SIZE(alc260_modes),
7468 .channel_mode = alc260_modes,
7469 .input_mux = &alc260_capture_source,
7470 .unsol_event = alc_sku_unsol_event,
7471 .setup = alc260_hp_setup,
7472 .init_hook = alc_inithook,
7473 },
7474 [ALC260_HP_DC7600] = {
7475 .mixers = { alc260_hp_dc7600_mixer,
7476 alc260_input_mixer },
7477 .init_verbs = { alc260_init_verbs,
7478 alc260_hp_dc7600_verbs },
7479 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
7480 .dac_nids = alc260_dac_nids,
7481 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids_alt),
7482 .adc_nids = alc260_adc_nids_alt,
7483 .num_channel_mode = ARRAY_SIZE(alc260_modes),
7484 .channel_mode = alc260_modes,
7485 .input_mux = &alc260_capture_source,
7486 .unsol_event = alc_sku_unsol_event,
7487 .setup = alc260_hp_3012_setup,
7488 .init_hook = alc_inithook,
7489 },
7490 [ALC260_HP_3013] = {
7491 .mixers = { alc260_hp_3013_mixer,
7492 alc260_input_mixer },
7493 .init_verbs = { alc260_hp_3013_init_verbs,
7494 alc260_hp_3013_unsol_verbs },
7495 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
7496 .dac_nids = alc260_dac_nids,
7497 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids_alt),
7498 .adc_nids = alc260_adc_nids_alt,
7499 .num_channel_mode = ARRAY_SIZE(alc260_modes),
7500 .channel_mode = alc260_modes,
7501 .input_mux = &alc260_capture_source,
7502 .unsol_event = alc_sku_unsol_event,
7503 .setup = alc260_hp_3013_setup,
7504 .init_hook = alc_inithook,
7505 },
7506 [ALC260_FUJITSU_S702X] = {
7507 .mixers = { alc260_fujitsu_mixer },
7508 .init_verbs = { alc260_fujitsu_init_verbs },
7509 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
7510 .dac_nids = alc260_dac_nids,
7511 .num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids),
7512 .adc_nids = alc260_dual_adc_nids,
7513 .num_channel_mode = ARRAY_SIZE(alc260_modes),
7514 .channel_mode = alc260_modes,
7515 .num_mux_defs = ARRAY_SIZE(alc260_fujitsu_capture_sources),
7516 .input_mux = alc260_fujitsu_capture_sources,
7517 },
7518 [ALC260_ACER] = {
7519 .mixers = { alc260_acer_mixer },
7520 .init_verbs = { alc260_acer_init_verbs },
7521 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
7522 .dac_nids = alc260_dac_nids,
7523 .num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids),
7524 .adc_nids = alc260_dual_adc_nids,
7525 .num_channel_mode = ARRAY_SIZE(alc260_modes),
7526 .channel_mode = alc260_modes,
7527 .num_mux_defs = ARRAY_SIZE(alc260_acer_capture_sources),
7528 .input_mux = alc260_acer_capture_sources,
7529 },
7530 [ALC260_FAVORIT100] = {
7531 .mixers = { alc260_favorit100_mixer },
7532 .init_verbs = { alc260_favorit100_init_verbs },
7533 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
7534 .dac_nids = alc260_dac_nids,
7535 .num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids),
7536 .adc_nids = alc260_dual_adc_nids,
7537 .num_channel_mode = ARRAY_SIZE(alc260_modes),
7538 .channel_mode = alc260_modes,
7539 .num_mux_defs = ARRAY_SIZE(alc260_favorit100_capture_sources),
7540 .input_mux = alc260_favorit100_capture_sources,
7541 },
7542 [ALC260_WILL] = {
7543 .mixers = { alc260_will_mixer },
7544 .init_verbs = { alc260_init_verbs, alc260_will_verbs },
7545 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
7546 .dac_nids = alc260_dac_nids,
7547 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids),
7548 .adc_nids = alc260_adc_nids,
7549 .dig_out_nid = ALC260_DIGOUT_NID,
7550 .num_channel_mode = ARRAY_SIZE(alc260_modes),
7551 .channel_mode = alc260_modes,
7552 .input_mux = &alc260_capture_source,
7553 },
7554 [ALC260_REPLACER_672V] = {
7555 .mixers = { alc260_replacer_672v_mixer },
7556 .init_verbs = { alc260_init_verbs, alc260_replacer_672v_verbs },
7557 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
7558 .dac_nids = alc260_dac_nids,
7559 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids),
7560 .adc_nids = alc260_adc_nids,
7561 .dig_out_nid = ALC260_DIGOUT_NID,
7562 .num_channel_mode = ARRAY_SIZE(alc260_modes),
7563 .channel_mode = alc260_modes,
7564 .input_mux = &alc260_capture_source,
7565 .unsol_event = alc260_replacer_672v_unsol_event,
7566 .init_hook = alc260_replacer_672v_automute,
7567 },
7568 #ifdef CONFIG_SND_DEBUG
7569 [ALC260_TEST] = {
7570 .mixers = { alc260_test_mixer },
7571 .init_verbs = { alc260_test_init_verbs },
7572 .num_dacs = ARRAY_SIZE(alc260_test_dac_nids),
7573 .dac_nids = alc260_test_dac_nids,
7574 .num_adc_nids = ARRAY_SIZE(alc260_test_adc_nids),
7575 .adc_nids = alc260_test_adc_nids,
7576 .num_channel_mode = ARRAY_SIZE(alc260_modes),
7577 .channel_mode = alc260_modes,
7578 .num_mux_defs = ARRAY_SIZE(alc260_test_capture_sources),
7579 .input_mux = alc260_test_capture_sources,
7580 },
7581 #endif
7582 };
7583
7584 static int patch_alc260(struct hda_codec *codec)
7585 {
7586 struct alc_spec *spec;
7587 int err, board_config;
7588
7589 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
7590 if (spec == NULL)
7591 return -ENOMEM;
7592
7593 codec->spec = spec;
7594
7595 board_config = snd_hda_check_board_config(codec, ALC260_MODEL_LAST,
7596 alc260_models,
7597 alc260_cfg_tbl);
7598 if (board_config < 0) {
7599 snd_printd(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
7600 codec->chip_name);
7601 board_config = ALC260_AUTO;
7602 }
7603
7604 if (board_config == ALC260_AUTO) {
7605 alc_pick_fixup(codec, NULL, alc260_fixup_tbl, alc260_fixups);
7606 alc_apply_fixup(codec, ALC_FIXUP_ACT_PRE_PROBE);
7607 }
7608
7609 if (board_config == ALC260_AUTO) {
7610 /* automatic parse from the BIOS config */
7611 err = alc260_parse_auto_config(codec);
7612 if (err < 0) {
7613 alc_free(codec);
7614 return err;
7615 } else if (!err) {
7616 printk(KERN_INFO
7617 "hda_codec: Cannot set up configuration "
7618 "from BIOS. Using base mode...\n");
7619 board_config = ALC260_BASIC;
7620 }
7621 }
7622
7623 err = snd_hda_attach_beep_device(codec, 0x1);
7624 if (err < 0) {
7625 alc_free(codec);
7626 return err;
7627 }
7628
7629 if (board_config != ALC260_AUTO)
7630 setup_preset(codec, &alc260_presets[board_config]);
7631
7632 spec->stream_analog_playback = &alc260_pcm_analog_playback;
7633 spec->stream_analog_capture = &alc260_pcm_analog_capture;
7634 spec->stream_analog_alt_capture = &alc260_pcm_analog_capture;
7635
7636 spec->stream_digital_playback = &alc260_pcm_digital_playback;
7637 spec->stream_digital_capture = &alc260_pcm_digital_capture;
7638
7639 if (!spec->adc_nids && spec->input_mux) {
7640 /* check whether NID 0x04 is valid */
7641 unsigned int wcap = get_wcaps(codec, 0x04);
7642 wcap = get_wcaps_type(wcap);
7643 /* get type */
7644 if (wcap != AC_WID_AUD_IN || spec->input_mux->num_items == 1) {
7645 spec->adc_nids = alc260_adc_nids_alt;
7646 spec->num_adc_nids = ARRAY_SIZE(alc260_adc_nids_alt);
7647 } else {
7648 spec->adc_nids = alc260_adc_nids;
7649 spec->num_adc_nids = ARRAY_SIZE(alc260_adc_nids);
7650 }
7651 }
7652 set_capture_mixer(codec);
7653 set_beep_amp(spec, 0x07, 0x05, HDA_INPUT);
7654
7655 alc_apply_fixup(codec, ALC_FIXUP_ACT_PROBE);
7656
7657 spec->vmaster_nid = 0x08;
7658
7659 codec->patch_ops = alc_patch_ops;
7660 if (board_config == ALC260_AUTO)
7661 spec->init_hook = alc260_auto_init;
7662 spec->shutup = alc_eapd_shutup;
7663 #ifdef CONFIG_SND_HDA_POWER_SAVE
7664 if (!spec->loopback.amplist)
7665 spec->loopback.amplist = alc260_loopbacks;
7666 #endif
7667
7668 return 0;
7669 }
7670
7671
7672 /*
7673 * ALC882/883/885/888/889 support
7674 *
7675 * ALC882 is almost identical with ALC880 but has cleaner and more flexible
7676 * configuration. Each pin widget can choose any input DACs and a mixer.
7677 * Each ADC is connected from a mixer of all inputs. This makes possible
7678 * 6-channel independent captures.
7679 *
7680 * In addition, an independent DAC for the multi-playback (not used in this
7681 * driver yet).
7682 */
7683 #define ALC882_DIGOUT_NID 0x06
7684 #define ALC882_DIGIN_NID 0x0a
7685 #define ALC883_DIGOUT_NID ALC882_DIGOUT_NID
7686 #define ALC883_DIGIN_NID ALC882_DIGIN_NID
7687 #define ALC1200_DIGOUT_NID 0x10
7688
7689
7690 static const struct hda_channel_mode alc882_ch_modes[1] = {
7691 { 8, NULL }
7692 };
7693
7694 /* DACs */
7695 static const hda_nid_t alc882_dac_nids[4] = {
7696 /* front, rear, clfe, rear_surr */
7697 0x02, 0x03, 0x04, 0x05
7698 };
7699 #define alc883_dac_nids alc882_dac_nids
7700
7701 /* ADCs */
7702 #define alc882_adc_nids alc880_adc_nids
7703 #define alc882_adc_nids_alt alc880_adc_nids_alt
7704 #define alc883_adc_nids alc882_adc_nids_alt
7705 static const hda_nid_t alc883_adc_nids_alt[1] = { 0x08 };
7706 static const hda_nid_t alc883_adc_nids_rev[2] = { 0x09, 0x08 };
7707 #define alc889_adc_nids alc880_adc_nids
7708
7709 static const hda_nid_t alc882_capsrc_nids[3] = { 0x24, 0x23, 0x22 };
7710 static const hda_nid_t alc882_capsrc_nids_alt[2] = { 0x23, 0x22 };
7711 #define alc883_capsrc_nids alc882_capsrc_nids_alt
7712 static const hda_nid_t alc883_capsrc_nids_rev[2] = { 0x22, 0x23 };
7713 #define alc889_capsrc_nids alc882_capsrc_nids
7714
7715 /* input MUX */
7716 /* FIXME: should be a matrix-type input source selection */
7717
7718 static const struct hda_input_mux alc882_capture_source = {
7719 .num_items = 4,
7720 .items = {
7721 { "Mic", 0x0 },
7722 { "Front Mic", 0x1 },
7723 { "Line", 0x2 },
7724 { "CD", 0x4 },
7725 },
7726 };
7727
7728 #define alc883_capture_source alc882_capture_source
7729
7730 static const struct hda_input_mux alc889_capture_source = {
7731 .num_items = 3,
7732 .items = {
7733 { "Front Mic", 0x0 },
7734 { "Mic", 0x3 },
7735 { "Line", 0x2 },
7736 },
7737 };
7738
7739 static const struct hda_input_mux mb5_capture_source = {
7740 .num_items = 3,
7741 .items = {
7742 { "Mic", 0x1 },
7743 { "Line", 0x7 },
7744 { "CD", 0x4 },
7745 },
7746 };
7747
7748 static const struct hda_input_mux macmini3_capture_source = {
7749 .num_items = 2,
7750 .items = {
7751 { "Line", 0x2 },
7752 { "CD", 0x4 },
7753 },
7754 };
7755
7756 static const struct hda_input_mux alc883_3stack_6ch_intel = {
7757 .num_items = 4,
7758 .items = {
7759 { "Mic", 0x1 },
7760 { "Front Mic", 0x0 },
7761 { "Line", 0x2 },
7762 { "CD", 0x4 },
7763 },
7764 };
7765
7766 static const struct hda_input_mux alc883_lenovo_101e_capture_source = {
7767 .num_items = 2,
7768 .items = {
7769 { "Mic", 0x1 },
7770 { "Line", 0x2 },
7771 },
7772 };
7773
7774 static const struct hda_input_mux alc883_lenovo_nb0763_capture_source = {
7775 .num_items = 4,
7776 .items = {
7777 { "Mic", 0x0 },
7778 { "Internal Mic", 0x1 },
7779 { "Line", 0x2 },
7780 { "CD", 0x4 },
7781 },
7782 };
7783
7784 static const struct hda_input_mux alc883_fujitsu_pi2515_capture_source = {
7785 .num_items = 2,
7786 .items = {
7787 { "Mic", 0x0 },
7788 { "Internal Mic", 0x1 },
7789 },
7790 };
7791
7792 static const struct hda_input_mux alc883_lenovo_sky_capture_source = {
7793 .num_items = 3,
7794 .items = {
7795 { "Mic", 0x0 },
7796 { "Front Mic", 0x1 },
7797 { "Line", 0x4 },
7798 },
7799 };
7800
7801 static const struct hda_input_mux alc883_asus_eee1601_capture_source = {
7802 .num_items = 2,
7803 .items = {
7804 { "Mic", 0x0 },
7805 { "Line", 0x2 },
7806 },
7807 };
7808
7809 static const struct hda_input_mux alc889A_mb31_capture_source = {
7810 .num_items = 2,
7811 .items = {
7812 { "Mic", 0x0 },
7813 /* Front Mic (0x01) unused */
7814 { "Line", 0x2 },
7815 /* Line 2 (0x03) unused */
7816 /* CD (0x04) unused? */
7817 },
7818 };
7819
7820 static const struct hda_input_mux alc889A_imac91_capture_source = {
7821 .num_items = 2,
7822 .items = {
7823 { "Mic", 0x01 },
7824 { "Line", 0x2 }, /* Not sure! */
7825 },
7826 };
7827
7828 /*
7829 * 2ch mode
7830 */
7831 static const struct hda_channel_mode alc883_3ST_2ch_modes[1] = {
7832 { 2, NULL }
7833 };
7834
7835 /*
7836 * 2ch mode
7837 */
7838 static const struct hda_verb alc882_3ST_ch2_init[] = {
7839 { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
7840 { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7841 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
7842 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7843 { } /* end */
7844 };
7845
7846 /*
7847 * 4ch mode
7848 */
7849 static const struct hda_verb alc882_3ST_ch4_init[] = {
7850 { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
7851 { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7852 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7853 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7854 { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
7855 { } /* end */
7856 };
7857
7858 /*
7859 * 6ch mode
7860 */
7861 static const struct hda_verb alc882_3ST_ch6_init[] = {
7862 { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7863 { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7864 { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
7865 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7866 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7867 { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
7868 { } /* end */
7869 };
7870
7871 static const struct hda_channel_mode alc882_3ST_6ch_modes[3] = {
7872 { 2, alc882_3ST_ch2_init },
7873 { 4, alc882_3ST_ch4_init },
7874 { 6, alc882_3ST_ch6_init },
7875 };
7876
7877 #define alc883_3ST_6ch_modes alc882_3ST_6ch_modes
7878
7879 /*
7880 * 2ch mode
7881 */
7882 static const struct hda_verb alc883_3ST_ch2_clevo_init[] = {
7883 { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },
7884 { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
7885 { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7886 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
7887 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7888 { } /* end */
7889 };
7890
7891 /*
7892 * 4ch mode
7893 */
7894 static const struct hda_verb alc883_3ST_ch4_clevo_init[] = {
7895 { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7896 { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
7897 { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7898 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7899 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7900 { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
7901 { } /* end */
7902 };
7903
7904 /*
7905 * 6ch mode
7906 */
7907 static const struct hda_verb alc883_3ST_ch6_clevo_init[] = {
7908 { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7909 { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7910 { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7911 { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
7912 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7913 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7914 { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
7915 { } /* end */
7916 };
7917
7918 static const struct hda_channel_mode alc883_3ST_6ch_clevo_modes[3] = {
7919 { 2, alc883_3ST_ch2_clevo_init },
7920 { 4, alc883_3ST_ch4_clevo_init },
7921 { 6, alc883_3ST_ch6_clevo_init },
7922 };
7923
7924
7925 /*
7926 * 6ch mode
7927 */
7928 static const struct hda_verb alc882_sixstack_ch6_init[] = {
7929 { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
7930 { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7931 { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7932 { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7933 { } /* end */
7934 };
7935
7936 /*
7937 * 8ch mode
7938 */
7939 static const struct hda_verb alc882_sixstack_ch8_init[] = {
7940 { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7941 { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7942 { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7943 { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7944 { } /* end */
7945 };
7946
7947 static const struct hda_channel_mode alc882_sixstack_modes[2] = {
7948 { 6, alc882_sixstack_ch6_init },
7949 { 8, alc882_sixstack_ch8_init },
7950 };
7951
7952
7953 /* Macbook Air 2,1 */
7954
7955 static const struct hda_channel_mode alc885_mba21_ch_modes[1] = {
7956 { 2, NULL },
7957 };
7958
7959 /*
7960 * macbook pro ALC885 can switch LineIn to LineOut without losing Mic
7961 */
7962
7963 /*
7964 * 2ch mode
7965 */
7966 static const struct hda_verb alc885_mbp_ch2_init[] = {
7967 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
7968 { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7969 { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7970 { } /* end */
7971 };
7972
7973 /*
7974 * 4ch mode
7975 */
7976 static const struct hda_verb alc885_mbp_ch4_init[] = {
7977 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7978 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7979 { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
7980 { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7981 { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7982 { } /* end */
7983 };
7984
7985 static const struct hda_channel_mode alc885_mbp_4ch_modes[2] = {
7986 { 2, alc885_mbp_ch2_init },
7987 { 4, alc885_mbp_ch4_init },
7988 };
7989
7990 /*
7991 * 2ch
7992 * Speakers/Woofer/HP = Front
7993 * LineIn = Input
7994 */
7995 static const struct hda_verb alc885_mb5_ch2_init[] = {
7996 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
7997 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7998 { } /* end */
7999 };
8000
8001 /*
8002 * 6ch mode
8003 * Speakers/HP = Front
8004 * Woofer = LFE
8005 * LineIn = Surround
8006 */
8007 static const struct hda_verb alc885_mb5_ch6_init[] = {
8008 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8009 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8010 {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
8011 { } /* end */
8012 };
8013
8014 static const struct hda_channel_mode alc885_mb5_6ch_modes[2] = {
8015 { 2, alc885_mb5_ch2_init },
8016 { 6, alc885_mb5_ch6_init },
8017 };
8018
8019 #define alc885_macmini3_6ch_modes alc885_mb5_6ch_modes
8020
8021 /*
8022 * 2ch mode
8023 */
8024 static const struct hda_verb alc883_4ST_ch2_init[] = {
8025 { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
8026 { 0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
8027 { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
8028 { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
8029 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
8030 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
8031 { } /* end */
8032 };
8033
8034 /*
8035 * 4ch mode
8036 */
8037 static const struct hda_verb alc883_4ST_ch4_init[] = {
8038 { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
8039 { 0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
8040 { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
8041 { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
8042 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
8043 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
8044 { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
8045 { } /* end */
8046 };
8047
8048 /*
8049 * 6ch mode
8050 */
8051 static const struct hda_verb alc883_4ST_ch6_init[] = {
8052 { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
8053 { 0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
8054 { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
8055 { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
8056 { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
8057 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
8058 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
8059 { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
8060 { } /* end */
8061 };
8062
8063 /*
8064 * 8ch mode
8065 */
8066 static const struct hda_verb alc883_4ST_ch8_init[] = {
8067 { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
8068 { 0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
8069 { 0x17, AC_VERB_SET_CONNECT_SEL, 0x03 },
8070 { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
8071 { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
8072 { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
8073 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
8074 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
8075 { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
8076 { } /* end */
8077 };
8078
8079 static const struct hda_channel_mode alc883_4ST_8ch_modes[4] = {
8080 { 2, alc883_4ST_ch2_init },
8081 { 4, alc883_4ST_ch4_init },
8082 { 6, alc883_4ST_ch6_init },
8083 { 8, alc883_4ST_ch8_init },
8084 };
8085
8086
8087 /*
8088 * 2ch mode
8089 */
8090 static const struct hda_verb alc883_3ST_ch2_intel_init[] = {
8091 { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
8092 { 0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
8093 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
8094 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
8095 { } /* end */
8096 };
8097
8098 /*
8099 * 4ch mode
8100 */
8101 static const struct hda_verb alc883_3ST_ch4_intel_init[] = {
8102 { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
8103 { 0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
8104 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
8105 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
8106 { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
8107 { } /* end */
8108 };
8109
8110 /*
8111 * 6ch mode
8112 */
8113 static const struct hda_verb alc883_3ST_ch6_intel_init[] = {
8114 { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
8115 { 0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
8116 { 0x19, AC_VERB_SET_CONNECT_SEL, 0x02 },
8117 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
8118 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
8119 { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
8120 { } /* end */
8121 };
8122
8123 static const struct hda_channel_mode alc883_3ST_6ch_intel_modes[3] = {
8124 { 2, alc883_3ST_ch2_intel_init },
8125 { 4, alc883_3ST_ch4_intel_init },
8126 { 6, alc883_3ST_ch6_intel_init },
8127 };
8128
8129 /*
8130 * 2ch mode
8131 */
8132 static const struct hda_verb alc889_ch2_intel_init[] = {
8133 { 0x14, AC_VERB_SET_CONNECT_SEL, 0x00 },
8134 { 0x19, AC_VERB_SET_CONNECT_SEL, 0x00 },
8135 { 0x16, AC_VERB_SET_CONNECT_SEL, 0x00 },
8136 { 0x17, AC_VERB_SET_CONNECT_SEL, 0x00 },
8137 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
8138 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
8139 { } /* end */
8140 };
8141
8142 /*
8143 * 6ch mode
8144 */
8145 static const struct hda_verb alc889_ch6_intel_init[] = {
8146 { 0x14, AC_VERB_SET_CONNECT_SEL, 0x00 },
8147 { 0x19, AC_VERB_SET_CONNECT_SEL, 0x01 },
8148 { 0x16, AC_VERB_SET_CONNECT_SEL, 0x02 },
8149 { 0x17, AC_VERB_SET_CONNECT_SEL, 0x03 },
8150 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
8151 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
8152 { } /* end */
8153 };
8154
8155 /*
8156 * 8ch mode
8157 */
8158 static const struct hda_verb alc889_ch8_intel_init[] = {
8159 { 0x14, AC_VERB_SET_CONNECT_SEL, 0x00 },
8160 { 0x19, AC_VERB_SET_CONNECT_SEL, 0x01 },
8161 { 0x16, AC_VERB_SET_CONNECT_SEL, 0x02 },
8162 { 0x17, AC_VERB_SET_CONNECT_SEL, 0x03 },
8163 { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x03 },
8164 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
8165 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
8166 { } /* end */
8167 };
8168
8169 static const struct hda_channel_mode alc889_8ch_intel_modes[3] = {
8170 { 2, alc889_ch2_intel_init },
8171 { 6, alc889_ch6_intel_init },
8172 { 8, alc889_ch8_intel_init },
8173 };
8174
8175 /*
8176 * 6ch mode
8177 */
8178 static const struct hda_verb alc883_sixstack_ch6_init[] = {
8179 { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
8180 { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
8181 { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
8182 { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
8183 { } /* end */
8184 };
8185
8186 /*
8187 * 8ch mode
8188 */
8189 static const struct hda_verb alc883_sixstack_ch8_init[] = {
8190 { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
8191 { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
8192 { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
8193 { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
8194 { } /* end */
8195 };
8196
8197 static const struct hda_channel_mode alc883_sixstack_modes[2] = {
8198 { 6, alc883_sixstack_ch6_init },
8199 { 8, alc883_sixstack_ch8_init },
8200 };
8201
8202
8203 /* Pin assignment: Front=0x14, Rear=0x15, CLFE=0x16, Side=0x17
8204 * Mic=0x18, Front Mic=0x19, Line-In=0x1a, HP=0x1b
8205 */
8206 static const struct snd_kcontrol_new alc882_base_mixer[] = {
8207 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8208 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8209 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
8210 HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
8211 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
8212 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
8213 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
8214 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
8215 HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
8216 HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
8217 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
8218 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8219 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8220 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8221 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8222 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8223 HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
8224 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8225 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8226 HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x19, 0, HDA_INPUT),
8227 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8228 { } /* end */
8229 };
8230
8231 /* Macbook Air 2,1 same control for HP and internal Speaker */
8232
8233 static const struct snd_kcontrol_new alc885_mba21_mixer[] = {
8234 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
8235 HDA_BIND_MUTE("Speaker Playback Switch", 0x0c, 0x02, HDA_OUTPUT),
8236 { }
8237 };
8238
8239
8240 static const struct snd_kcontrol_new alc885_mbp3_mixer[] = {
8241 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
8242 HDA_BIND_MUTE ("Speaker Playback Switch", 0x0c, 0x02, HDA_INPUT),
8243 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0e, 0x00, HDA_OUTPUT),
8244 HDA_BIND_MUTE ("Headphone Playback Switch", 0x0e, 0x02, HDA_INPUT),
8245 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x00, HDA_OUTPUT),
8246 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8247 HDA_CODEC_MUTE ("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8248 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x00, HDA_INPUT),
8249 HDA_CODEC_MUTE ("Mic Playback Switch", 0x0b, 0x00, HDA_INPUT),
8250 HDA_CODEC_VOLUME("Line Boost Volume", 0x1a, 0x00, HDA_INPUT),
8251 HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0x00, HDA_INPUT),
8252 { } /* end */
8253 };
8254
8255 static const struct snd_kcontrol_new alc885_mb5_mixer[] = {
8256 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
8257 HDA_BIND_MUTE ("Front Playback Switch", 0x0c, 0x02, HDA_INPUT),
8258 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x00, HDA_OUTPUT),
8259 HDA_BIND_MUTE ("Surround Playback Switch", 0x0d, 0x02, HDA_INPUT),
8260 HDA_CODEC_VOLUME("LFE Playback Volume", 0x0e, 0x00, HDA_OUTPUT),
8261 HDA_BIND_MUTE ("LFE Playback Switch", 0x0e, 0x02, HDA_INPUT),
8262 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0f, 0x00, HDA_OUTPUT),
8263 HDA_BIND_MUTE ("Headphone Playback Switch", 0x0f, 0x02, HDA_INPUT),
8264 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x07, HDA_INPUT),
8265 HDA_CODEC_MUTE ("Line Playback Switch", 0x0b, 0x07, HDA_INPUT),
8266 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
8267 HDA_CODEC_MUTE ("Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
8268 HDA_CODEC_VOLUME("Line Boost Volume", 0x15, 0x00, HDA_INPUT),
8269 HDA_CODEC_VOLUME("Mic Boost Volume", 0x19, 0x00, HDA_INPUT),
8270 { } /* end */
8271 };
8272
8273 static const struct snd_kcontrol_new alc885_macmini3_mixer[] = {
8274 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
8275 HDA_BIND_MUTE ("Front Playback Switch", 0x0c, 0x02, HDA_INPUT),
8276 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x00, HDA_OUTPUT),
8277 HDA_BIND_MUTE ("Surround Playback Switch", 0x0d, 0x02, HDA_INPUT),
8278 HDA_CODEC_VOLUME("LFE Playback Volume", 0x0e, 0x00, HDA_OUTPUT),
8279 HDA_BIND_MUTE ("LFE Playback Switch", 0x0e, 0x02, HDA_INPUT),
8280 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0f, 0x00, HDA_OUTPUT),
8281 HDA_BIND_MUTE ("Headphone Playback Switch", 0x0f, 0x02, HDA_INPUT),
8282 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x07, HDA_INPUT),
8283 HDA_CODEC_MUTE ("Line Playback Switch", 0x0b, 0x07, HDA_INPUT),
8284 HDA_CODEC_VOLUME("Line Boost Volume", 0x15, 0x00, HDA_INPUT),
8285 { } /* end */
8286 };
8287
8288 static const struct snd_kcontrol_new alc885_imac91_mixer[] = {
8289 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
8290 HDA_BIND_MUTE("Speaker Playback Switch", 0x0c, 0x02, HDA_INPUT),
8291 { } /* end */
8292 };
8293
8294
8295 static const struct snd_kcontrol_new alc882_w2jc_mixer[] = {
8296 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8297 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8298 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8299 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8300 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8301 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8302 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8303 HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
8304 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8305 { } /* end */
8306 };
8307
8308 static const struct snd_kcontrol_new alc882_targa_mixer[] = {
8309 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8310 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8311 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
8312 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8313 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8314 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8315 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8316 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8317 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8318 HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
8319 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8320 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8321 HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x19, 0, HDA_INPUT),
8322 { } /* end */
8323 };
8324
8325 /* Pin assignment: Front=0x14, HP = 0x15, Front = 0x16, ???
8326 * Front Mic=0x18, Line In = 0x1a, Line In = 0x1b, CD = 0x1c
8327 */
8328 static const struct snd_kcontrol_new alc882_asus_a7j_mixer[] = {
8329 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8330 HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
8331 HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
8332 HDA_CODEC_MUTE("Mobile Front Playback Switch", 0x16, 0x0, HDA_OUTPUT),
8333 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8334 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8335 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8336 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8337 HDA_CODEC_VOLUME("Mobile Line Playback Volume", 0x0b, 0x03, HDA_INPUT),
8338 HDA_CODEC_MUTE("Mobile Line Playback Switch", 0x0b, 0x03, HDA_INPUT),
8339 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8340 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8341 HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
8342 { } /* end */
8343 };
8344
8345 static const struct snd_kcontrol_new alc882_asus_a7m_mixer[] = {
8346 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8347 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8348 HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
8349 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8350 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8351 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8352 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8353 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8354 HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
8355 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8356 { } /* end */
8357 };
8358
8359 static const struct snd_kcontrol_new alc882_chmode_mixer[] = {
8360 {
8361 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
8362 .name = "Channel Mode",
8363 .info = alc_ch_mode_info,
8364 .get = alc_ch_mode_get,
8365 .put = alc_ch_mode_put,
8366 },
8367 { } /* end */
8368 };
8369
8370 static const struct hda_verb alc882_base_init_verbs[] = {
8371 /* Front mixer: unmute input/output amp left and right (volume = 0) */
8372 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8373 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8374 /* Rear mixer */
8375 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8376 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8377 /* CLFE mixer */
8378 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8379 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8380 /* Side mixer */
8381 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8382 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8383
8384 /* Front Pin: output 0 (0x0c) */
8385 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8386 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8387 {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
8388 /* Rear Pin: output 1 (0x0d) */
8389 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8390 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8391 {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
8392 /* CLFE Pin: output 2 (0x0e) */
8393 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8394 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8395 {0x16, AC_VERB_SET_CONNECT_SEL, 0x02},
8396 /* Side Pin: output 3 (0x0f) */
8397 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8398 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8399 {0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
8400 /* Mic (rear) pin: input vref at 80% */
8401 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
8402 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8403 /* Front Mic pin: input vref at 80% */
8404 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
8405 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8406 /* Line In pin: input */
8407 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
8408 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8409 /* Line-2 In: Headphone output (output 0 - 0x0c) */
8410 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8411 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8412 {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
8413 /* CD pin widget for input */
8414 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
8415
8416 /* FIXME: use matrix-type input source selection */
8417 /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
8418 /* Input mixer2 */
8419 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8420 /* Input mixer3 */
8421 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8422 /* ADC2: mute amp left and right */
8423 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8424 {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
8425 /* ADC3: mute amp left and right */
8426 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8427 {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
8428
8429 { }
8430 };
8431
8432 static const struct hda_verb alc882_adc1_init_verbs[] = {
8433 /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
8434 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8435 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
8436 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
8437 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
8438 /* ADC1: mute amp left and right */
8439 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8440 {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
8441 { }
8442 };
8443
8444 static const struct hda_verb alc882_eapd_verbs[] = {
8445 /* change to EAPD mode */
8446 {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
8447 {0x20, AC_VERB_SET_PROC_COEF, 0x3060},
8448 { }
8449 };
8450
8451 static const struct hda_verb alc889_eapd_verbs[] = {
8452 {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
8453 {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
8454 { }
8455 };
8456
8457 static const struct hda_verb alc_hp15_unsol_verbs[] = {
8458 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
8459 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8460 {}
8461 };
8462
8463 static const struct hda_verb alc885_init_verbs[] = {
8464 /* Front mixer: unmute input/output amp left and right (volume = 0) */
8465 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8466 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8467 /* Rear mixer */
8468 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8469 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8470 /* CLFE mixer */
8471 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8472 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8473 /* Side mixer */
8474 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8475 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8476
8477 /* Front HP Pin: output 0 (0x0c) */
8478 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8479 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8480 {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
8481 /* Front Pin: output 0 (0x0c) */
8482 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8483 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8484 {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
8485 /* Rear Pin: output 1 (0x0d) */
8486 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8487 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8488 {0x19, AC_VERB_SET_CONNECT_SEL, 0x01},
8489 /* CLFE Pin: output 2 (0x0e) */
8490 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8491 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8492 {0x16, AC_VERB_SET_CONNECT_SEL, 0x02},
8493 /* Side Pin: output 3 (0x0f) */
8494 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8495 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8496 {0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
8497 /* Mic (rear) pin: input vref at 80% */
8498 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
8499 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8500 /* Front Mic pin: input vref at 80% */
8501 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
8502 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8503 /* Line In pin: input */
8504 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
8505 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8506
8507 /* Mixer elements: 0x18, , 0x1a, 0x1b */
8508 /* Input mixer1 */
8509 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8510 /* Input mixer2 */
8511 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8512 /* Input mixer3 */
8513 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8514 /* ADC2: mute amp left and right */
8515 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8516 /* ADC3: mute amp left and right */
8517 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8518
8519 { }
8520 };
8521
8522 static const struct hda_verb alc885_init_input_verbs[] = {
8523 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8524 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
8525 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
8526 { }
8527 };
8528
8529
8530 /* Unmute Selector 24h and set the default input to front mic */
8531 static const struct hda_verb alc889_init_input_verbs[] = {
8532 {0x24, AC_VERB_SET_CONNECT_SEL, 0x00},
8533 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8534 { }
8535 };
8536
8537
8538 #define alc883_init_verbs alc882_base_init_verbs
8539
8540 /* Mac Pro test */
8541 static const struct snd_kcontrol_new alc882_macpro_mixer[] = {
8542 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8543 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8544 HDA_CODEC_MUTE("Headphone Playback Switch", 0x18, 0x0, HDA_OUTPUT),
8545 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x01, HDA_INPUT),
8546 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x01, HDA_INPUT),
8547 /* FIXME: this looks suspicious...
8548 HDA_CODEC_VOLUME("Beep Playback Volume", 0x0b, 0x02, HDA_INPUT),
8549 HDA_CODEC_MUTE("Beep Playback Switch", 0x0b, 0x02, HDA_INPUT),
8550 */
8551 { } /* end */
8552 };
8553
8554 static const struct hda_verb alc882_macpro_init_verbs[] = {
8555 /* Front mixer: unmute input/output amp left and right (volume = 0) */
8556 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8557 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8558 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8559 /* Front Pin: output 0 (0x0c) */
8560 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8561 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8562 {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
8563 /* Front Mic pin: input vref at 80% */
8564 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
8565 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8566 /* Speaker: output */
8567 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8568 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8569 {0x1a, AC_VERB_SET_CONNECT_SEL, 0x04},
8570 /* Headphone output (output 0 - 0x0c) */
8571 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8572 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8573 {0x18, AC_VERB_SET_CONNECT_SEL, 0x00},
8574
8575 /* FIXME: use matrix-type input source selection */
8576 /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
8577 /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
8578 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8579 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
8580 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
8581 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
8582 /* Input mixer2 */
8583 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8584 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
8585 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
8586 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
8587 /* Input mixer3 */
8588 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8589 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
8590 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
8591 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
8592 /* ADC1: mute amp left and right */
8593 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8594 {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
8595 /* ADC2: mute amp left and right */
8596 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8597 {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
8598 /* ADC3: mute amp left and right */
8599 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8600 {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
8601
8602 { }
8603 };
8604
8605 /* Macbook 5,1 */
8606 static const struct hda_verb alc885_mb5_init_verbs[] = {
8607 /* DACs */
8608 {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8609 {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8610 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8611 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8612 /* Front mixer */
8613 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8614 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8615 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8616 /* Surround mixer */
8617 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8618 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8619 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8620 /* LFE mixer */
8621 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8622 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8623 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8624 /* HP mixer */
8625 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8626 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8627 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8628 /* Front Pin (0x0c) */
8629 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | 0x01},
8630 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8631 {0x18, AC_VERB_SET_CONNECT_SEL, 0x00},
8632 /* LFE Pin (0x0e) */
8633 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | 0x01},
8634 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8635 {0x1a, AC_VERB_SET_CONNECT_SEL, 0x02},
8636 /* HP Pin (0x0f) */
8637 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8638 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8639 {0x14, AC_VERB_SET_CONNECT_SEL, 0x03},
8640 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8641 /* Front Mic pin: input vref at 80% */
8642 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
8643 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8644 /* Line In pin */
8645 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
8646 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8647
8648 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0x1)},
8649 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0x7)},
8650 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0x4)},
8651 { }
8652 };
8653
8654 /* Macmini 3,1 */
8655 static const struct hda_verb alc885_macmini3_init_verbs[] = {
8656 /* DACs */
8657 {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8658 {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8659 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8660 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8661 /* Front mixer */
8662 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8663 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8664 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8665 /* Surround mixer */
8666 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8667 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8668 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8669 /* LFE mixer */
8670 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8671 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8672 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8673 /* HP mixer */
8674 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8675 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8676 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8677 /* Front Pin (0x0c) */
8678 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | 0x01},
8679 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8680 {0x18, AC_VERB_SET_CONNECT_SEL, 0x00},
8681 /* LFE Pin (0x0e) */
8682 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | 0x01},
8683 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8684 {0x1a, AC_VERB_SET_CONNECT_SEL, 0x02},
8685 /* HP Pin (0x0f) */
8686 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8687 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8688 {0x14, AC_VERB_SET_CONNECT_SEL, 0x03},
8689 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8690 /* Line In pin */
8691 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
8692 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8693
8694 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8695 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
8696 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
8697 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
8698 { }
8699 };
8700
8701
8702 static const struct hda_verb alc885_mba21_init_verbs[] = {
8703 /*Internal and HP Speaker Mixer*/
8704 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8705 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8706 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8707 /*Internal Speaker Pin (0x0c)*/
8708 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, (PIN_OUT | AC_PINCTL_VREF_50) },
8709 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8710 {0x18, AC_VERB_SET_CONNECT_SEL, 0x00},
8711 /* HP Pin: output 0 (0x0e) */
8712 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc4},
8713 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8714 {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
8715 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, (ALC880_HP_EVENT | AC_USRSP_EN)},
8716 /* Line in (is hp when jack connected)*/
8717 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, AC_PINCTL_VREF_50},
8718 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8719
8720 { }
8721 };
8722
8723
8724 /* Macbook Pro rev3 */
8725 static const struct hda_verb alc885_mbp3_init_verbs[] = {
8726 /* Front mixer: unmute input/output amp left and right (volume = 0) */
8727 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8728 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8729 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8730 /* Rear mixer */
8731 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8732 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8733 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8734 /* HP mixer */
8735 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8736 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8737 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8738 /* Front Pin: output 0 (0x0c) */
8739 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8740 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8741 {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
8742 /* HP Pin: output 0 (0x0e) */
8743 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc4},
8744 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8745 {0x15, AC_VERB_SET_CONNECT_SEL, 0x02},
8746 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8747 /* Mic (rear) pin: input vref at 80% */
8748 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
8749 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8750 /* Front Mic pin: input vref at 80% */
8751 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
8752 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8753 /* Line In pin: use output 1 when in LineOut mode */
8754 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
8755 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8756 {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01},
8757
8758 /* FIXME: use matrix-type input source selection */
8759 /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
8760 /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
8761 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8762 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
8763 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
8764 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
8765 /* Input mixer2 */
8766 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8767 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
8768 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
8769 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
8770 /* Input mixer3 */
8771 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8772 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
8773 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
8774 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
8775 /* ADC1: mute amp left and right */
8776 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8777 {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
8778 /* ADC2: mute amp left and right */
8779 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8780 {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
8781 /* ADC3: mute amp left and right */
8782 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8783 {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
8784
8785 { }
8786 };
8787
8788 /* iMac 9,1 */
8789 static const struct hda_verb alc885_imac91_init_verbs[] = {
8790 /* Internal Speaker Pin (0x0c) */
8791 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, (PIN_OUT | AC_PINCTL_VREF_50) },
8792 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8793 {0x18, AC_VERB_SET_CONNECT_SEL, 0x00},
8794 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, (PIN_OUT | AC_PINCTL_VREF_50) },
8795 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8796 {0x1a, AC_VERB_SET_CONNECT_SEL, 0x00},
8797 /* HP Pin: Rear */
8798 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8799 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8800 {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
8801 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, (ALC880_HP_EVENT | AC_USRSP_EN)},
8802 /* Line in Rear */
8803 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, AC_PINCTL_VREF_50},
8804 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8805 /* Front Mic pin: input vref at 80% */
8806 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
8807 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8808 /* Rear mixer */
8809 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8810 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8811 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8812 /* Line-Out mixer: unmute input/output amp left and right (volume = 0) */
8813 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8814 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8815 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8816 /* 0x24 [Audio Mixer] wcaps 0x20010b: Stereo Amp-In */
8817 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8818 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
8819 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
8820 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
8821 /* 0x23 [Audio Mixer] wcaps 0x20010b: Stereo Amp-In */
8822 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8823 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
8824 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
8825 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
8826 /* 0x22 [Audio Mixer] wcaps 0x20010b: Stereo Amp-In */
8827 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8828 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
8829 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
8830 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
8831 /* 0x07 [Audio Input] wcaps 0x10011b: Stereo Amp-In */
8832 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8833 {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
8834 /* 0x08 [Audio Input] wcaps 0x10011b: Stereo Amp-In */
8835 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8836 {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
8837 /* 0x09 [Audio Input] wcaps 0x10011b: Stereo Amp-In */
8838 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8839 {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
8840 { }
8841 };
8842
8843 /* iMac 24 mixer. */
8844 static const struct snd_kcontrol_new alc885_imac24_mixer[] = {
8845 HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
8846 HDA_CODEC_MUTE("Master Playback Switch", 0x0c, 0x00, HDA_INPUT),
8847 { } /* end */
8848 };
8849
8850 /* iMac 24 init verbs. */
8851 static const struct hda_verb alc885_imac24_init_verbs[] = {
8852 /* Internal speakers: output 0 (0x0c) */
8853 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8854 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8855 {0x18, AC_VERB_SET_CONNECT_SEL, 0x00},
8856 /* Internal speakers: output 0 (0x0c) */
8857 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8858 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8859 {0x1a, AC_VERB_SET_CONNECT_SEL, 0x00},
8860 /* Headphone: output 0 (0x0c) */
8861 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8862 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8863 {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
8864 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8865 /* Front Mic: input vref at 80% */
8866 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
8867 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8868 { }
8869 };
8870
8871 /* Toggle speaker-output according to the hp-jack state */
8872 static void alc885_imac24_setup(struct hda_codec *codec)
8873 {
8874 struct alc_spec *spec = codec->spec;
8875
8876 spec->autocfg.hp_pins[0] = 0x14;
8877 spec->autocfg.speaker_pins[0] = 0x18;
8878 spec->autocfg.speaker_pins[1] = 0x1a;
8879 spec->automute = 1;
8880 spec->automute_mode = ALC_AUTOMUTE_AMP;
8881 }
8882
8883 #define alc885_mb5_setup alc885_imac24_setup
8884 #define alc885_macmini3_setup alc885_imac24_setup
8885
8886 /* Macbook Air 2,1 */
8887 static void alc885_mba21_setup(struct hda_codec *codec)
8888 {
8889 struct alc_spec *spec = codec->spec;
8890
8891 spec->autocfg.hp_pins[0] = 0x14;
8892 spec->autocfg.speaker_pins[0] = 0x18;
8893 spec->automute = 1;
8894 spec->automute_mode = ALC_AUTOMUTE_AMP;
8895 }
8896
8897
8898
8899 static void alc885_mbp3_setup(struct hda_codec *codec)
8900 {
8901 struct alc_spec *spec = codec->spec;
8902
8903 spec->autocfg.hp_pins[0] = 0x15;
8904 spec->autocfg.speaker_pins[0] = 0x14;
8905 spec->automute = 1;
8906 spec->automute_mode = ALC_AUTOMUTE_AMP;
8907 }
8908
8909 static void alc885_imac91_setup(struct hda_codec *codec)
8910 {
8911 struct alc_spec *spec = codec->spec;
8912
8913 spec->autocfg.hp_pins[0] = 0x14;
8914 spec->autocfg.speaker_pins[0] = 0x18;
8915 spec->autocfg.speaker_pins[1] = 0x1a;
8916 spec->automute = 1;
8917 spec->automute_mode = ALC_AUTOMUTE_AMP;
8918 }
8919
8920 static const struct hda_verb alc882_targa_verbs[] = {
8921 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8922 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8923
8924 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8925 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8926
8927 {0x18, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
8928 {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/surround */
8929 {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
8930
8931 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8932 { } /* end */
8933 };
8934
8935 /* toggle speaker-output according to the hp-jack state */
8936 static void alc882_targa_automute(struct hda_codec *codec)
8937 {
8938 struct alc_spec *spec = codec->spec;
8939 alc_hp_automute(codec);
8940 snd_hda_codec_write_cache(codec, 1, 0, AC_VERB_SET_GPIO_DATA,
8941 spec->jack_present ? 1 : 3);
8942 }
8943
8944 static void alc882_targa_setup(struct hda_codec *codec)
8945 {
8946 struct alc_spec *spec = codec->spec;
8947
8948 spec->autocfg.hp_pins[0] = 0x14;
8949 spec->autocfg.speaker_pins[0] = 0x1b;
8950 spec->automute = 1;
8951 spec->automute_mode = ALC_AUTOMUTE_AMP;
8952 }
8953
8954 static void alc882_targa_unsol_event(struct hda_codec *codec, unsigned int res)
8955 {
8956 if ((res >> 26) == ALC880_HP_EVENT)
8957 alc882_targa_automute(codec);
8958 }
8959
8960 static const struct hda_verb alc882_asus_a7j_verbs[] = {
8961 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8962 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8963
8964 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8965 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8966 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8967
8968 {0x14, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */
8969 {0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
8970 {0x16, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */
8971
8972 {0x18, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
8973 {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/surround */
8974 {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
8975 { } /* end */
8976 };
8977
8978 static const struct hda_verb alc882_asus_a7m_verbs[] = {
8979 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8980 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8981
8982 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8983 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8984 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8985
8986 {0x14, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */
8987 {0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
8988 {0x16, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */
8989
8990 {0x18, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
8991 {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/surround */
8992 {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
8993 { } /* end */
8994 };
8995
8996 static void alc882_gpio_mute(struct hda_codec *codec, int pin, int muted)
8997 {
8998 unsigned int gpiostate, gpiomask, gpiodir;
8999
9000 gpiostate = snd_hda_codec_read(codec, codec->afg, 0,
9001 AC_VERB_GET_GPIO_DATA, 0);
9002
9003 if (!muted)
9004 gpiostate |= (1 << pin);
9005 else
9006 gpiostate &= ~(1 << pin);
9007
9008 gpiomask = snd_hda_codec_read(codec, codec->afg, 0,
9009 AC_VERB_GET_GPIO_MASK, 0);
9010 gpiomask |= (1 << pin);
9011
9012 gpiodir = snd_hda_codec_read(codec, codec->afg, 0,
9013 AC_VERB_GET_GPIO_DIRECTION, 0);
9014 gpiodir |= (1 << pin);
9015
9016
9017 snd_hda_codec_write(codec, codec->afg, 0,
9018 AC_VERB_SET_GPIO_MASK, gpiomask);
9019 snd_hda_codec_write(codec, codec->afg, 0,
9020 AC_VERB_SET_GPIO_DIRECTION, gpiodir);
9021
9022 msleep(1);
9023
9024 snd_hda_codec_write(codec, codec->afg, 0,
9025 AC_VERB_SET_GPIO_DATA, gpiostate);
9026 }
9027
9028 /* set up GPIO at initialization */
9029 static void alc885_macpro_init_hook(struct hda_codec *codec)
9030 {
9031 alc882_gpio_mute(codec, 0, 0);
9032 alc882_gpio_mute(codec, 1, 0);
9033 }
9034
9035 /* set up GPIO and update auto-muting at initialization */
9036 static void alc885_imac24_init_hook(struct hda_codec *codec)
9037 {
9038 alc885_macpro_init_hook(codec);
9039 alc_hp_automute(codec);
9040 }
9041
9042 /*
9043 * generic initialization of ADC, input mixers and output mixers
9044 */
9045 static const struct hda_verb alc883_auto_init_verbs[] = {
9046 /*
9047 * Unmute ADC0-2 and set the default input to mic-in
9048 */
9049 {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
9050 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9051 {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
9052 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9053
9054 /*
9055 * Set up output mixers (0x0c - 0x0f)
9056 */
9057 /* set vol=0 to output mixers */
9058 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
9059 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
9060 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
9061 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
9062 /* set up input amps for analog loopback */
9063 /* Amp Indices: DAC = 0, mixer = 1 */
9064 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9065 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9066 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9067 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9068 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9069 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9070 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9071 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9072 {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9073 {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9074
9075 /* FIXME: use matrix-type input source selection */
9076 /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
9077 /* Input mixer2 */
9078 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9079 /* Input mixer3 */
9080 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9081 { }
9082 };
9083
9084 /* 2ch mode (Speaker:front, Subwoofer:CLFE, Line:input, Headphones:front) */
9085 static const struct hda_verb alc889A_mb31_ch2_init[] = {
9086 {0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP as front */
9087 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Subwoofer on */
9088 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, /* Line as input */
9089 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, /* Line off */
9090 { } /* end */
9091 };
9092
9093 /* 4ch mode (Speaker:front, Subwoofer:CLFE, Line:CLFE, Headphones:front) */
9094 static const struct hda_verb alc889A_mb31_ch4_init[] = {
9095 {0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP as front */
9096 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Subwoofer on */
9097 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, /* Line as output */
9098 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Line on */
9099 { } /* end */
9100 };
9101
9102 /* 5ch mode (Speaker:front, Subwoofer:CLFE, Line:input, Headphones:rear) */
9103 static const struct hda_verb alc889A_mb31_ch5_init[] = {
9104 {0x15, AC_VERB_SET_CONNECT_SEL, 0x01}, /* HP as rear */
9105 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Subwoofer on */
9106 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, /* Line as input */
9107 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, /* Line off */
9108 { } /* end */
9109 };
9110
9111 /* 6ch mode (Speaker:front, Subwoofer:off, Line:CLFE, Headphones:Rear) */
9112 static const struct hda_verb alc889A_mb31_ch6_init[] = {
9113 {0x15, AC_VERB_SET_CONNECT_SEL, 0x01}, /* HP as front */
9114 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, /* Subwoofer off */
9115 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, /* Line as output */
9116 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Line on */
9117 { } /* end */
9118 };
9119
9120 static const struct hda_channel_mode alc889A_mb31_6ch_modes[4] = {
9121 { 2, alc889A_mb31_ch2_init },
9122 { 4, alc889A_mb31_ch4_init },
9123 { 5, alc889A_mb31_ch5_init },
9124 { 6, alc889A_mb31_ch6_init },
9125 };
9126
9127 static const struct hda_verb alc883_medion_eapd_verbs[] = {
9128 /* eanable EAPD on medion laptop */
9129 {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
9130 {0x20, AC_VERB_SET_PROC_COEF, 0x3070},
9131 { }
9132 };
9133
9134 #define alc883_base_mixer alc882_base_mixer
9135
9136 static const struct snd_kcontrol_new alc883_mitac_mixer[] = {
9137 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9138 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
9139 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
9140 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
9141 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
9142 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
9143 HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
9144 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9145 HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
9146 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9147 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
9148 HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x19, 0, HDA_INPUT),
9149 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
9150 { } /* end */
9151 };
9152
9153 static const struct snd_kcontrol_new alc883_clevo_m720_mixer[] = {
9154 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9155 HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
9156 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
9157 HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
9158 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9159 HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
9160 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9161 HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
9162 HDA_CODEC_VOLUME("Internal Mic Boost Volume", 0x19, 0, HDA_INPUT),
9163 HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
9164 { } /* end */
9165 };
9166
9167 static const struct snd_kcontrol_new alc883_2ch_fujitsu_pi2515_mixer[] = {
9168 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9169 HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
9170 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
9171 HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
9172 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9173 HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
9174 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9175 HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
9176 HDA_CODEC_VOLUME("Internal Mic Boost Volume", 0x19, 0, HDA_INPUT),
9177 HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
9178 { } /* end */
9179 };
9180
9181 static const struct snd_kcontrol_new alc883_3ST_2ch_mixer[] = {
9182 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9183 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
9184 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
9185 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
9186 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
9187 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
9188 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
9189 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9190 HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
9191 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9192 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
9193 HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x19, 0, HDA_INPUT),
9194 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
9195 { } /* end */
9196 };
9197
9198 static const struct snd_kcontrol_new alc883_3ST_6ch_mixer[] = {
9199 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9200 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
9201 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
9202 HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
9203 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
9204 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
9205 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
9206 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
9207 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
9208 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
9209 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
9210 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
9211 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
9212 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9213 HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
9214 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9215 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
9216 HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x19, 0, HDA_INPUT),
9217 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
9218 { } /* end */
9219 };
9220
9221 static const struct snd_kcontrol_new alc883_3ST_6ch_intel_mixer[] = {
9222 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9223 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
9224 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
9225 HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
9226 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0,
9227 HDA_OUTPUT),
9228 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
9229 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
9230 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
9231 HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
9232 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
9233 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
9234 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
9235 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
9236 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
9237 HDA_CODEC_VOLUME("Mic Boost Volume", 0x19, 0, HDA_INPUT),
9238 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
9239 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9240 HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x18, 0, HDA_INPUT),
9241 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9242 { } /* end */
9243 };
9244
9245 static const struct snd_kcontrol_new alc885_8ch_intel_mixer[] = {
9246 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9247 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
9248 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
9249 HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
9250 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0,
9251 HDA_OUTPUT),
9252 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
9253 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
9254 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
9255 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
9256 HDA_BIND_MUTE("Speaker Playback Switch", 0x0f, 2, HDA_INPUT),
9257 HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
9258 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
9259 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
9260 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x3, HDA_INPUT),
9261 HDA_CODEC_VOLUME("Mic Boost Volume", 0x1b, 0, HDA_INPUT),
9262 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x3, HDA_INPUT),
9263 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9264 HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x18, 0, HDA_INPUT),
9265 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9266 { } /* end */
9267 };
9268
9269 static const struct snd_kcontrol_new alc883_fivestack_mixer[] = {
9270 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9271 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
9272 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
9273 HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
9274 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
9275 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
9276 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
9277 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
9278 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
9279 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
9280 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
9281 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
9282 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
9283 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9284 HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
9285 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9286 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
9287 HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x19, 0, HDA_INPUT),
9288 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
9289 { } /* end */
9290 };
9291
9292 static const struct snd_kcontrol_new alc883_targa_mixer[] = {
9293 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9294 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
9295 HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
9296 HDA_CODEC_MUTE("Speaker Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
9297 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
9298 HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
9299 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
9300 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
9301 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
9302 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
9303 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
9304 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
9305 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
9306 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
9307 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9308 HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
9309 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9310 { } /* end */
9311 };
9312
9313 static const struct snd_kcontrol_new alc883_targa_2ch_mixer[] = {
9314 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9315 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
9316 HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
9317 HDA_CODEC_MUTE("Speaker Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
9318 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
9319 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
9320 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9321 HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
9322 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9323 HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
9324 HDA_CODEC_VOLUME("Internal Mic Boost Volume", 0x19, 0, HDA_INPUT),
9325 HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
9326 { } /* end */
9327 };
9328
9329 static const struct snd_kcontrol_new alc883_targa_8ch_mixer[] = {
9330 HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
9331 HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
9332 HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
9333 HDA_CODEC_VOLUME("Internal Mic Boost Volume", 0x19, 0, HDA_INPUT),
9334 HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
9335 { } /* end */
9336 };
9337
9338 static const struct snd_kcontrol_new alc883_lenovo_101e_2ch_mixer[] = {
9339 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9340 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
9341 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
9342 HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
9343 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
9344 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
9345 HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
9346 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
9347 { } /* end */
9348 };
9349
9350 static const struct snd_kcontrol_new alc883_lenovo_nb0763_mixer[] = {
9351 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9352 HDA_BIND_MUTE("Speaker Playback Switch", 0x0c, 2, HDA_INPUT),
9353 HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
9354 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
9355 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
9356 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9357 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9358 HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
9359 HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
9360 { } /* end */
9361 };
9362
9363 static const struct snd_kcontrol_new alc883_medion_wim2160_mixer[] = {
9364 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9365 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
9366 HDA_CODEC_MUTE("Speaker Playback Switch", 0x15, 0x0, HDA_OUTPUT),
9367 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x0, HDA_OUTPUT),
9368 HDA_CODEC_VOLUME("Line Playback Volume", 0x08, 0x0, HDA_INPUT),
9369 HDA_CODEC_MUTE("Line Playback Switch", 0x08, 0x0, HDA_INPUT),
9370 { } /* end */
9371 };
9372
9373 static const struct hda_verb alc883_medion_wim2160_verbs[] = {
9374 /* Unmute front mixer */
9375 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9376 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9377
9378 /* Set speaker pin to front mixer */
9379 {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
9380
9381 /* Init headphone pin */
9382 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9383 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
9384 {0x1a, AC_VERB_SET_CONNECT_SEL, 0x00},
9385 {0x1a, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9386
9387 { } /* end */
9388 };
9389
9390 /* toggle speaker-output according to the hp-jack state */
9391 static void alc883_medion_wim2160_setup(struct hda_codec *codec)
9392 {
9393 struct alc_spec *spec = codec->spec;
9394
9395 spec->autocfg.hp_pins[0] = 0x1a;
9396 spec->autocfg.speaker_pins[0] = 0x15;
9397 spec->automute = 1;
9398 spec->automute_mode = ALC_AUTOMUTE_AMP;
9399 }
9400
9401 static const struct snd_kcontrol_new alc883_acer_aspire_mixer[] = {
9402 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9403 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
9404 HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
9405 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
9406 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
9407 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9408 HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
9409 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9410 { } /* end */
9411 };
9412
9413 static const struct snd_kcontrol_new alc888_acer_aspire_6530_mixer[] = {
9414 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9415 HDA_CODEC_VOLUME("LFE Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
9416 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
9417 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
9418 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
9419 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
9420 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9421 HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
9422 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9423 { } /* end */
9424 };
9425
9426 static const struct snd_kcontrol_new alc888_lenovo_sky_mixer[] = {
9427 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9428 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
9429 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0e, 0x0, HDA_OUTPUT),
9430 HDA_BIND_MUTE("Surround Playback Switch", 0x0e, 2, HDA_INPUT),
9431 HDA_CODEC_VOLUME_MONO("Center Playback Volume",
9432 0x0d, 1, 0x0, HDA_OUTPUT),
9433 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0d, 2, 0x0, HDA_OUTPUT),
9434 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0d, 1, 2, HDA_INPUT),
9435 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0d, 2, 2, HDA_INPUT),
9436 HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
9437 HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
9438 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
9439 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
9440 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
9441 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
9442 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9443 HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
9444 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9445 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
9446 HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x19, 0, HDA_INPUT),
9447 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
9448 { } /* end */
9449 };
9450
9451 static const struct snd_kcontrol_new alc889A_mb31_mixer[] = {
9452 /* Output mixers */
9453 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
9454 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 0x02, HDA_INPUT),
9455 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x00, HDA_OUTPUT),
9456 HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 0x02, HDA_INPUT),
9457 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x00,
9458 HDA_OUTPUT),
9459 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 0x02, HDA_INPUT),
9460 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x00, HDA_OUTPUT),
9461 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 0x02, HDA_INPUT),
9462 /* Output switches */
9463 HDA_CODEC_MUTE("Enable Speaker", 0x14, 0x00, HDA_OUTPUT),
9464 HDA_CODEC_MUTE("Enable Headphones", 0x15, 0x00, HDA_OUTPUT),
9465 HDA_CODEC_MUTE_MONO("Enable LFE", 0x16, 2, 0x00, HDA_OUTPUT),
9466 /* Boost mixers */
9467 HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0x00, HDA_INPUT),
9468 HDA_CODEC_VOLUME("Line Boost Volume", 0x1a, 0x00, HDA_INPUT),
9469 /* Input mixers */
9470 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x00, HDA_INPUT),
9471 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x00, HDA_INPUT),
9472 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
9473 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
9474 { } /* end */
9475 };
9476
9477 static const struct snd_kcontrol_new alc883_vaiott_mixer[] = {
9478 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9479 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
9480 HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
9481 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
9482 HDA_CODEC_VOLUME("Mic Boost Volume", 0x19, 0, HDA_INPUT),
9483 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
9484 { } /* end */
9485 };
9486
9487 static const struct hda_bind_ctls alc883_bind_cap_vol = {
9488 .ops = &snd_hda_bind_vol,
9489 .values = {
9490 HDA_COMPOSE_AMP_VAL(0x08, 3, 0, HDA_INPUT),
9491 HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_INPUT),
9492 0
9493 },
9494 };
9495
9496 static const struct hda_bind_ctls alc883_bind_cap_switch = {
9497 .ops = &snd_hda_bind_sw,
9498 .values = {
9499 HDA_COMPOSE_AMP_VAL(0x08, 3, 0, HDA_INPUT),
9500 HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_INPUT),
9501 0
9502 },
9503 };
9504
9505 static const struct snd_kcontrol_new alc883_asus_eee1601_mixer[] = {
9506 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9507 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
9508 HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
9509 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
9510 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
9511 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9512 HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
9513 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9514 { } /* end */
9515 };
9516
9517 static const struct snd_kcontrol_new alc883_asus_eee1601_cap_mixer[] = {
9518 HDA_BIND_VOL("Capture Volume", &alc883_bind_cap_vol),
9519 HDA_BIND_SW("Capture Switch", &alc883_bind_cap_switch),
9520 {
9521 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
9522 /* .name = "Capture Source", */
9523 .name = "Input Source",
9524 .count = 1,
9525 .info = alc_mux_enum_info,
9526 .get = alc_mux_enum_get,
9527 .put = alc_mux_enum_put,
9528 },
9529 { } /* end */
9530 };
9531
9532 static const struct snd_kcontrol_new alc883_chmode_mixer[] = {
9533 {
9534 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
9535 .name = "Channel Mode",
9536 .info = alc_ch_mode_info,
9537 .get = alc_ch_mode_get,
9538 .put = alc_ch_mode_put,
9539 },
9540 { } /* end */
9541 };
9542
9543 /* toggle speaker-output according to the hp-jack state */
9544 static void alc883_mitac_setup(struct hda_codec *codec)
9545 {
9546 struct alc_spec *spec = codec->spec;
9547
9548 spec->autocfg.hp_pins[0] = 0x15;
9549 spec->autocfg.speaker_pins[0] = 0x14;
9550 spec->autocfg.speaker_pins[1] = 0x17;
9551 spec->automute = 1;
9552 spec->automute_mode = ALC_AUTOMUTE_AMP;
9553 }
9554
9555 static const struct hda_verb alc883_mitac_verbs[] = {
9556 /* HP */
9557 {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
9558 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9559 /* Subwoofer */
9560 {0x17, AC_VERB_SET_CONNECT_SEL, 0x02},
9561 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9562
9563 /* enable unsolicited event */
9564 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9565 /* {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN}, */
9566
9567 { } /* end */
9568 };
9569
9570 static const struct hda_verb alc883_clevo_m540r_verbs[] = {
9571 /* HP */
9572 {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
9573 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9574 /* Int speaker */
9575 /*{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},*/
9576
9577 /* enable unsolicited event */
9578 /*
9579 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9580 {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN},
9581 */
9582
9583 { } /* end */
9584 };
9585
9586 static const struct hda_verb alc883_clevo_m720_verbs[] = {
9587 /* HP */
9588 {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
9589 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9590 /* Int speaker */
9591 {0x14, AC_VERB_SET_CONNECT_SEL, 0x01},
9592 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9593
9594 /* enable unsolicited event */
9595 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9596 {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN},
9597
9598 { } /* end */
9599 };
9600
9601 static const struct hda_verb alc883_2ch_fujitsu_pi2515_verbs[] = {
9602 /* HP */
9603 {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
9604 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9605 /* Subwoofer */
9606 {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
9607 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9608
9609 /* enable unsolicited event */
9610 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9611
9612 { } /* end */
9613 };
9614
9615 static const struct hda_verb alc883_targa_verbs[] = {
9616 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9617 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9618
9619 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9620 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9621
9622 /* Connect Line-Out side jack (SPDIF) to Side */
9623 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9624 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
9625 {0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
9626 /* Connect Mic jack to CLFE */
9627 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9628 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
9629 {0x18, AC_VERB_SET_CONNECT_SEL, 0x02},
9630 /* Connect Line-in jack to Surround */
9631 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9632 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
9633 {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01},
9634 /* Connect HP out jack to Front */
9635 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9636 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
9637 {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
9638
9639 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9640
9641 { } /* end */
9642 };
9643
9644 static const struct hda_verb alc883_lenovo_101e_verbs[] = {
9645 {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
9646 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_FRONT_EVENT|AC_USRSP_EN},
9647 {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT|AC_USRSP_EN},
9648 { } /* end */
9649 };
9650
9651 static const struct hda_verb alc883_lenovo_nb0763_verbs[] = {
9652 {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
9653 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9654 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9655 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9656 { } /* end */
9657 };
9658
9659 static const struct hda_verb alc888_lenovo_ms7195_verbs[] = {
9660 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9661 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9662 {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
9663 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_FRONT_EVENT | AC_USRSP_EN},
9664 {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9665 { } /* end */
9666 };
9667
9668 static const struct hda_verb alc883_haier_w66_verbs[] = {
9669 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9670 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9671
9672 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9673
9674 {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
9675 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9676 {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9677 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9678 { } /* end */
9679 };
9680
9681 static const struct hda_verb alc888_lenovo_sky_verbs[] = {
9682 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9683 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9684 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9685 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9686 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9687 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9688 {0x1a, AC_VERB_SET_CONNECT_SEL, 0x00},
9689 {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9690 { } /* end */
9691 };
9692
9693 static const struct hda_verb alc888_6st_dell_verbs[] = {
9694 {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9695 { }
9696 };
9697
9698 static const struct hda_verb alc883_vaiott_verbs[] = {
9699 /* HP */
9700 {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
9701 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9702
9703 /* enable unsolicited event */
9704 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9705
9706 { } /* end */
9707 };
9708
9709 static void alc888_3st_hp_setup(struct hda_codec *codec)
9710 {
9711 struct alc_spec *spec = codec->spec;
9712
9713 spec->autocfg.hp_pins[0] = 0x1b;
9714 spec->autocfg.speaker_pins[0] = 0x14;
9715 spec->autocfg.speaker_pins[1] = 0x16;
9716 spec->autocfg.speaker_pins[2] = 0x18;
9717 spec->automute = 1;
9718 spec->automute_mode = ALC_AUTOMUTE_AMP;
9719 }
9720
9721 static const struct hda_verb alc888_3st_hp_verbs[] = {
9722 {0x14, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front: output 0 (0x0c) */
9723 {0x16, AC_VERB_SET_CONNECT_SEL, 0x01}, /* Rear : output 1 (0x0d) */
9724 {0x18, AC_VERB_SET_CONNECT_SEL, 0x02}, /* CLFE : output 2 (0x0e) */
9725 {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9726 { } /* end */
9727 };
9728
9729 /*
9730 * 2ch mode
9731 */
9732 static const struct hda_verb alc888_3st_hp_2ch_init[] = {
9733 { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
9734 { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
9735 { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
9736 { 0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
9737 { } /* end */
9738 };
9739
9740 /*
9741 * 4ch mode
9742 */
9743 static const struct hda_verb alc888_3st_hp_4ch_init[] = {
9744 { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
9745 { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
9746 { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
9747 { 0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
9748 { 0x16, AC_VERB_SET_CONNECT_SEL, 0x01 },
9749 { } /* end */
9750 };
9751
9752 /*
9753 * 6ch mode
9754 */
9755 static const struct hda_verb alc888_3st_hp_6ch_init[] = {
9756 { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
9757 { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
9758 { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
9759 { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
9760 { 0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
9761 { 0x16, AC_VERB_SET_CONNECT_SEL, 0x01 },
9762 { } /* end */
9763 };
9764
9765 static const struct hda_channel_mode alc888_3st_hp_modes[3] = {
9766 { 2, alc888_3st_hp_2ch_init },
9767 { 4, alc888_3st_hp_4ch_init },
9768 { 6, alc888_3st_hp_6ch_init },
9769 };
9770
9771 static void alc888_lenovo_ms7195_setup(struct hda_codec *codec)
9772 {
9773 struct alc_spec *spec = codec->spec;
9774
9775 spec->autocfg.hp_pins[0] = 0x1b;
9776 spec->autocfg.line_out_pins[0] = 0x14;
9777 spec->autocfg.speaker_pins[0] = 0x15;
9778 spec->automute = 1;
9779 spec->automute_mode = ALC_AUTOMUTE_AMP;
9780 }
9781
9782 /* toggle speaker-output according to the hp-jack state */
9783 static void alc883_lenovo_nb0763_setup(struct hda_codec *codec)
9784 {
9785 struct alc_spec *spec = codec->spec;
9786
9787 spec->autocfg.hp_pins[0] = 0x14;
9788 spec->autocfg.speaker_pins[0] = 0x15;
9789 spec->automute = 1;
9790 spec->automute_mode = ALC_AUTOMUTE_AMP;
9791 }
9792
9793 /* toggle speaker-output according to the hp-jack state */
9794 #define alc883_targa_init_hook alc882_targa_init_hook
9795 #define alc883_targa_unsol_event alc882_targa_unsol_event
9796
9797 static void alc883_clevo_m720_setup(struct hda_codec *codec)
9798 {
9799 struct alc_spec *spec = codec->spec;
9800
9801 spec->autocfg.hp_pins[0] = 0x15;
9802 spec->autocfg.speaker_pins[0] = 0x14;
9803 spec->automute = 1;
9804 spec->automute_mode = ALC_AUTOMUTE_AMP;
9805 }
9806
9807 static void alc883_clevo_m720_init_hook(struct hda_codec *codec)
9808 {
9809 alc_hp_automute(codec);
9810 alc88x_simple_mic_automute(codec);
9811 }
9812
9813 static void alc883_clevo_m720_unsol_event(struct hda_codec *codec,
9814 unsigned int res)
9815 {
9816 switch (res >> 26) {
9817 case ALC880_MIC_EVENT:
9818 alc88x_simple_mic_automute(codec);
9819 break;
9820 default:
9821 alc_sku_unsol_event(codec, res);
9822 break;
9823 }
9824 }
9825
9826 /* toggle speaker-output according to the hp-jack state */
9827 static void alc883_2ch_fujitsu_pi2515_setup(struct hda_codec *codec)
9828 {
9829 struct alc_spec *spec = codec->spec;
9830
9831 spec->autocfg.hp_pins[0] = 0x14;
9832 spec->autocfg.speaker_pins[0] = 0x15;
9833 spec->automute = 1;
9834 spec->automute_mode = ALC_AUTOMUTE_AMP;
9835 }
9836
9837 static void alc883_haier_w66_setup(struct hda_codec *codec)
9838 {
9839 struct alc_spec *spec = codec->spec;
9840
9841 spec->autocfg.hp_pins[0] = 0x1b;
9842 spec->autocfg.speaker_pins[0] = 0x14;
9843 spec->automute = 1;
9844 spec->automute_mode = ALC_AUTOMUTE_AMP;
9845 }
9846
9847 static void alc883_lenovo_101e_setup(struct hda_codec *codec)
9848 {
9849 struct alc_spec *spec = codec->spec;
9850
9851 spec->autocfg.hp_pins[0] = 0x1b;
9852 spec->autocfg.line_out_pins[0] = 0x14;
9853 spec->autocfg.speaker_pins[0] = 0x15;
9854 spec->automute = 1;
9855 spec->detect_line = 1;
9856 spec->automute_lines = 1;
9857 spec->automute_mode = ALC_AUTOMUTE_AMP;
9858 }
9859
9860 /* toggle speaker-output according to the hp-jack state */
9861 static void alc883_acer_aspire_setup(struct hda_codec *codec)
9862 {
9863 struct alc_spec *spec = codec->spec;
9864
9865 spec->autocfg.hp_pins[0] = 0x14;
9866 spec->autocfg.speaker_pins[0] = 0x15;
9867 spec->autocfg.speaker_pins[1] = 0x16;
9868 spec->automute = 1;
9869 spec->automute_mode = ALC_AUTOMUTE_AMP;
9870 }
9871
9872 static const struct hda_verb alc883_acer_eapd_verbs[] = {
9873 /* HP Pin: output 0 (0x0c) */
9874 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9875 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
9876 {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
9877 /* Front Pin: output 0 (0x0c) */
9878 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9879 {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
9880 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9881 {0x16, AC_VERB_SET_CONNECT_SEL, 0x00},
9882 /* eanable EAPD on medion laptop */
9883 {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
9884 {0x20, AC_VERB_SET_PROC_COEF, 0x3050},
9885 /* enable unsolicited event */
9886 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9887 { }
9888 };
9889
9890 static void alc888_6st_dell_setup(struct hda_codec *codec)
9891 {
9892 struct alc_spec *spec = codec->spec;
9893
9894 spec->autocfg.hp_pins[0] = 0x1b;
9895 spec->autocfg.speaker_pins[0] = 0x14;
9896 spec->autocfg.speaker_pins[1] = 0x15;
9897 spec->autocfg.speaker_pins[2] = 0x16;
9898 spec->autocfg.speaker_pins[3] = 0x17;
9899 spec->automute = 1;
9900 spec->automute_mode = ALC_AUTOMUTE_AMP;
9901 }
9902
9903 static void alc888_lenovo_sky_setup(struct hda_codec *codec)
9904 {
9905 struct alc_spec *spec = codec->spec;
9906
9907 spec->autocfg.hp_pins[0] = 0x1b;
9908 spec->autocfg.speaker_pins[0] = 0x14;
9909 spec->autocfg.speaker_pins[1] = 0x15;
9910 spec->autocfg.speaker_pins[2] = 0x16;
9911 spec->autocfg.speaker_pins[3] = 0x17;
9912 spec->autocfg.speaker_pins[4] = 0x1a;
9913 spec->automute = 1;
9914 spec->automute_mode = ALC_AUTOMUTE_AMP;
9915 }
9916
9917 static void alc883_vaiott_setup(struct hda_codec *codec)
9918 {
9919 struct alc_spec *spec = codec->spec;
9920
9921 spec->autocfg.hp_pins[0] = 0x15;
9922 spec->autocfg.speaker_pins[0] = 0x14;
9923 spec->autocfg.speaker_pins[1] = 0x17;
9924 spec->automute = 1;
9925 spec->automute_mode = ALC_AUTOMUTE_AMP;
9926 }
9927
9928 static const struct hda_verb alc888_asus_m90v_verbs[] = {
9929 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
9930 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
9931 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9932 /* enable unsolicited event */
9933 {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9934 {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN},
9935 { } /* end */
9936 };
9937
9938 static void alc883_mode2_setup(struct hda_codec *codec)
9939 {
9940 struct alc_spec *spec = codec->spec;
9941
9942 spec->autocfg.hp_pins[0] = 0x1b;
9943 spec->autocfg.speaker_pins[0] = 0x14;
9944 spec->autocfg.speaker_pins[1] = 0x15;
9945 spec->autocfg.speaker_pins[2] = 0x16;
9946 spec->ext_mic.pin = 0x18;
9947 spec->int_mic.pin = 0x19;
9948 spec->ext_mic.mux_idx = 0;
9949 spec->int_mic.mux_idx = 1;
9950 spec->auto_mic = 1;
9951 spec->automute = 1;
9952 spec->automute_mode = ALC_AUTOMUTE_AMP;
9953 }
9954
9955 static const struct hda_verb alc888_asus_eee1601_verbs[] = {
9956 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9957 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9958 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
9959 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9960 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
9961 {0x20, AC_VERB_SET_COEF_INDEX, 0x0b},
9962 {0x20, AC_VERB_SET_PROC_COEF, 0x0838},
9963 /* enable unsolicited event */
9964 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9965 { } /* end */
9966 };
9967
9968 static void alc883_eee1601_inithook(struct hda_codec *codec)
9969 {
9970 struct alc_spec *spec = codec->spec;
9971
9972 spec->autocfg.hp_pins[0] = 0x14;
9973 spec->autocfg.speaker_pins[0] = 0x1b;
9974 alc_hp_automute(codec);
9975 }
9976
9977 static const struct hda_verb alc889A_mb31_verbs[] = {
9978 /* Init rear pin (used as headphone output) */
9979 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc4}, /* Apple Headphones */
9980 {0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Connect to front */
9981 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9982 /* Init line pin (used as output in 4ch and 6ch mode) */
9983 {0x1a, AC_VERB_SET_CONNECT_SEL, 0x02}, /* Connect to CLFE */
9984 /* Init line 2 pin (used as headphone out by default) */
9985 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, /* Use as input */
9986 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, /* Mute output */
9987 { } /* end */
9988 };
9989
9990 /* Mute speakers according to the headphone jack state */
9991 static void alc889A_mb31_automute(struct hda_codec *codec)
9992 {
9993 unsigned int present;
9994
9995 /* Mute only in 2ch or 4ch mode */
9996 if (snd_hda_codec_read(codec, 0x15, 0, AC_VERB_GET_CONNECT_SEL, 0)
9997 == 0x00) {
9998 present = snd_hda_jack_detect(codec, 0x15);
9999 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
10000 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
10001 snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
10002 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
10003 }
10004 }
10005
10006 static void alc889A_mb31_unsol_event(struct hda_codec *codec, unsigned int res)
10007 {
10008 if ((res >> 26) == ALC880_HP_EVENT)
10009 alc889A_mb31_automute(codec);
10010 }
10011
10012
10013 #ifdef CONFIG_SND_HDA_POWER_SAVE
10014 #define alc882_loopbacks alc880_loopbacks
10015 #endif
10016
10017 /* pcm configuration: identical with ALC880 */
10018 #define alc882_pcm_analog_playback alc880_pcm_analog_playback
10019 #define alc882_pcm_analog_capture alc880_pcm_analog_capture
10020 #define alc882_pcm_digital_playback alc880_pcm_digital_playback
10021 #define alc882_pcm_digital_capture alc880_pcm_digital_capture
10022
10023 static const hda_nid_t alc883_slave_dig_outs[] = {
10024 ALC1200_DIGOUT_NID, 0,
10025 };
10026
10027 static const hda_nid_t alc1200_slave_dig_outs[] = {
10028 ALC883_DIGOUT_NID, 0,
10029 };
10030
10031 /*
10032 * configuration and preset
10033 */
10034 static const char * const alc882_models[ALC882_MODEL_LAST] = {
10035 [ALC882_3ST_DIG] = "3stack-dig",
10036 [ALC882_6ST_DIG] = "6stack-dig",
10037 [ALC882_ARIMA] = "arima",
10038 [ALC882_W2JC] = "w2jc",
10039 [ALC882_TARGA] = "targa",
10040 [ALC882_ASUS_A7J] = "asus-a7j",
10041 [ALC882_ASUS_A7M] = "asus-a7m",
10042 [ALC885_MACPRO] = "macpro",
10043 [ALC885_MB5] = "mb5",
10044 [ALC885_MACMINI3] = "macmini3",
10045 [ALC885_MBA21] = "mba21",
10046 [ALC885_MBP3] = "mbp3",
10047 [ALC885_IMAC24] = "imac24",
10048 [ALC885_IMAC91] = "imac91",
10049 [ALC883_3ST_2ch_DIG] = "3stack-2ch-dig",
10050 [ALC883_3ST_6ch_DIG] = "3stack-6ch-dig",
10051 [ALC883_3ST_6ch] = "3stack-6ch",
10052 [ALC883_6ST_DIG] = "alc883-6stack-dig",
10053 [ALC883_TARGA_DIG] = "targa-dig",
10054 [ALC883_TARGA_2ch_DIG] = "targa-2ch-dig",
10055 [ALC883_TARGA_8ch_DIG] = "targa-8ch-dig",
10056 [ALC883_ACER] = "acer",
10057 [ALC883_ACER_ASPIRE] = "acer-aspire",
10058 [ALC888_ACER_ASPIRE_4930G] = "acer-aspire-4930g",
10059 [ALC888_ACER_ASPIRE_6530G] = "acer-aspire-6530g",
10060 [ALC888_ACER_ASPIRE_8930G] = "acer-aspire-8930g",
10061 [ALC888_ACER_ASPIRE_7730G] = "acer-aspire-7730g",
10062 [ALC883_MEDION] = "medion",
10063 [ALC883_MEDION_WIM2160] = "medion-wim2160",
10064 [ALC883_LAPTOP_EAPD] = "laptop-eapd",
10065 [ALC883_LENOVO_101E_2ch] = "lenovo-101e",
10066 [ALC883_LENOVO_NB0763] = "lenovo-nb0763",
10067 [ALC888_LENOVO_MS7195_DIG] = "lenovo-ms7195-dig",
10068 [ALC888_LENOVO_SKY] = "lenovo-sky",
10069 [ALC883_HAIER_W66] = "haier-w66",
10070 [ALC888_3ST_HP] = "3stack-hp",
10071 [ALC888_6ST_DELL] = "6stack-dell",
10072 [ALC883_MITAC] = "mitac",
10073 [ALC883_CLEVO_M540R] = "clevo-m540r",
10074 [ALC883_CLEVO_M720] = "clevo-m720",
10075 [ALC883_FUJITSU_PI2515] = "fujitsu-pi2515",
10076 [ALC888_FUJITSU_XA3530] = "fujitsu-xa3530",
10077 [ALC883_3ST_6ch_INTEL] = "3stack-6ch-intel",
10078 [ALC889A_INTEL] = "intel-alc889a",
10079 [ALC889_INTEL] = "intel-x58",
10080 [ALC1200_ASUS_P5Q] = "asus-p5q",
10081 [ALC889A_MB31] = "mb31",
10082 [ALC883_SONY_VAIO_TT] = "sony-vaio-tt",
10083 [ALC882_AUTO] = "auto",
10084 };
10085
10086 static const struct snd_pci_quirk alc882_cfg_tbl[] = {
10087 SND_PCI_QUIRK(0x1019, 0x6668, "ECS", ALC882_6ST_DIG),
10088
10089 SND_PCI_QUIRK(0x1025, 0x006c, "Acer Aspire 9810", ALC883_ACER_ASPIRE),
10090 SND_PCI_QUIRK(0x1025, 0x0090, "Acer Aspire", ALC883_ACER_ASPIRE),
10091 SND_PCI_QUIRK(0x1025, 0x010a, "Acer Ferrari 5000", ALC883_ACER_ASPIRE),
10092 SND_PCI_QUIRK(0x1025, 0x0110, "Acer Aspire", ALC883_ACER_ASPIRE),
10093 SND_PCI_QUIRK(0x1025, 0x0112, "Acer Aspire 9303", ALC883_ACER_ASPIRE),
10094 SND_PCI_QUIRK(0x1025, 0x0121, "Acer Aspire 5920G", ALC883_ACER_ASPIRE),
10095 SND_PCI_QUIRK(0x1025, 0x013e, "Acer Aspire 4930G",
10096 ALC888_ACER_ASPIRE_4930G),
10097 SND_PCI_QUIRK(0x1025, 0x013f, "Acer Aspire 5930G",
10098 ALC888_ACER_ASPIRE_4930G),
10099 SND_PCI_QUIRK(0x1025, 0x0145, "Acer Aspire 8930G",
10100 ALC888_ACER_ASPIRE_8930G),
10101 SND_PCI_QUIRK(0x1025, 0x0146, "Acer Aspire 6935G",
10102 ALC888_ACER_ASPIRE_8930G),
10103 SND_PCI_QUIRK(0x1025, 0x0157, "Acer X3200", ALC882_AUTO),
10104 SND_PCI_QUIRK(0x1025, 0x0158, "Acer AX1700-U3700A", ALC882_AUTO),
10105 SND_PCI_QUIRK(0x1025, 0x015e, "Acer Aspire 6930G",
10106 ALC888_ACER_ASPIRE_6530G),
10107 SND_PCI_QUIRK(0x1025, 0x0166, "Acer Aspire 6530G",
10108 ALC888_ACER_ASPIRE_6530G),
10109 SND_PCI_QUIRK(0x1025, 0x0142, "Acer Aspire 7730G",
10110 ALC888_ACER_ASPIRE_7730G),
10111 /* default Acer -- disabled as it causes more problems.
10112 * model=auto should work fine now
10113 */
10114 /* SND_PCI_QUIRK_VENDOR(0x1025, "Acer laptop", ALC883_ACER), */
10115
10116 SND_PCI_QUIRK(0x1028, 0x020d, "Dell Inspiron 530", ALC888_6ST_DELL),
10117
10118 SND_PCI_QUIRK(0x103c, 0x2a3d, "HP Pavilion", ALC883_6ST_DIG),
10119 SND_PCI_QUIRK(0x103c, 0x2a4f, "HP Samba", ALC888_3ST_HP),
10120 SND_PCI_QUIRK(0x103c, 0x2a60, "HP Lucknow", ALC888_3ST_HP),
10121 SND_PCI_QUIRK(0x103c, 0x2a61, "HP Nettle", ALC883_6ST_DIG),
10122 SND_PCI_QUIRK(0x103c, 0x2a66, "HP Acacia", ALC888_3ST_HP),
10123 SND_PCI_QUIRK(0x103c, 0x2a72, "HP Educ.ar", ALC888_3ST_HP),
10124
10125 SND_PCI_QUIRK(0x1043, 0x060d, "Asus A7J", ALC882_ASUS_A7J),
10126 SND_PCI_QUIRK(0x1043, 0x1243, "Asus A7J", ALC882_ASUS_A7J),
10127 SND_PCI_QUIRK(0x1043, 0x13c2, "Asus A7M", ALC882_ASUS_A7M),
10128 SND_PCI_QUIRK(0x1043, 0x1873, "Asus M90V", ALC888_ASUS_M90V),
10129 SND_PCI_QUIRK(0x1043, 0x1971, "Asus W2JC", ALC882_W2JC),
10130 SND_PCI_QUIRK(0x1043, 0x817f, "Asus P5LD2", ALC882_6ST_DIG),
10131 SND_PCI_QUIRK(0x1043, 0x81d8, "Asus P5WD", ALC882_6ST_DIG),
10132 SND_PCI_QUIRK(0x1043, 0x8249, "Asus M2A-VM HDMI", ALC883_3ST_6ch_DIG),
10133 SND_PCI_QUIRK(0x1043, 0x8284, "Asus Z37E", ALC883_6ST_DIG),
10134 SND_PCI_QUIRK(0x1043, 0x82fe, "Asus P5Q-EM HDMI", ALC1200_ASUS_P5Q),
10135 SND_PCI_QUIRK(0x1043, 0x835f, "Asus Eee 1601", ALC888_ASUS_EEE1601),
10136
10137 SND_PCI_QUIRK(0x104d, 0x9047, "Sony Vaio TT", ALC883_SONY_VAIO_TT),
10138 SND_PCI_QUIRK(0x105b, 0x0ce8, "Foxconn P35AX-S", ALC883_6ST_DIG),
10139 SND_PCI_QUIRK(0x105b, 0x6668, "Foxconn", ALC882_6ST_DIG),
10140 SND_PCI_QUIRK(0x1071, 0x8227, "Mitac 82801H", ALC883_MITAC),
10141 SND_PCI_QUIRK(0x1071, 0x8253, "Mitac 8252d", ALC883_MITAC),
10142 SND_PCI_QUIRK(0x1071, 0x8258, "Evesham Voyaeger", ALC883_LAPTOP_EAPD),
10143 SND_PCI_QUIRK(0x10f1, 0x2350, "TYAN-S2350", ALC888_6ST_DELL),
10144 SND_PCI_QUIRK(0x108e, 0x534d, NULL, ALC883_3ST_6ch),
10145 SND_PCI_QUIRK(0x1458, 0xa002, "Gigabyte P35 DS3R", ALC882_6ST_DIG),
10146
10147 SND_PCI_QUIRK(0x1462, 0x0349, "MSI", ALC883_TARGA_2ch_DIG),
10148 SND_PCI_QUIRK(0x1462, 0x040d, "MSI", ALC883_TARGA_2ch_DIG),
10149 SND_PCI_QUIRK(0x1462, 0x0579, "MSI", ALC883_TARGA_2ch_DIG),
10150 SND_PCI_QUIRK(0x1462, 0x28fb, "Targa T8", ALC882_TARGA), /* MSI-1049 T8 */
10151 SND_PCI_QUIRK(0x1462, 0x2fb3, "MSI", ALC882_AUTO),
10152 SND_PCI_QUIRK(0x1462, 0x6668, "MSI", ALC882_6ST_DIG),
10153 SND_PCI_QUIRK(0x1462, 0x3729, "MSI S420", ALC883_TARGA_DIG),
10154 SND_PCI_QUIRK(0x1462, 0x3783, "NEC S970", ALC883_TARGA_DIG),
10155 SND_PCI_QUIRK(0x1462, 0x3b7f, "MSI", ALC883_TARGA_2ch_DIG),
10156 SND_PCI_QUIRK(0x1462, 0x3ef9, "MSI", ALC883_TARGA_DIG),
10157 SND_PCI_QUIRK(0x1462, 0x3fc1, "MSI", ALC883_TARGA_DIG),
10158 SND_PCI_QUIRK(0x1462, 0x3fc3, "MSI", ALC883_TARGA_DIG),
10159 SND_PCI_QUIRK(0x1462, 0x3fcc, "MSI", ALC883_TARGA_DIG),
10160 SND_PCI_QUIRK(0x1462, 0x3fdf, "MSI", ALC883_TARGA_DIG),
10161 SND_PCI_QUIRK(0x1462, 0x42cd, "MSI", ALC883_TARGA_DIG),
10162 SND_PCI_QUIRK(0x1462, 0x4314, "MSI", ALC883_TARGA_DIG),
10163 SND_PCI_QUIRK(0x1462, 0x4319, "MSI", ALC883_TARGA_DIG),
10164 SND_PCI_QUIRK(0x1462, 0x4324, "MSI", ALC883_TARGA_DIG),
10165 SND_PCI_QUIRK(0x1462, 0x4570, "MSI Wind Top AE2220", ALC883_TARGA_DIG),
10166 SND_PCI_QUIRK(0x1462, 0x6510, "MSI GX620", ALC883_TARGA_8ch_DIG),
10167 SND_PCI_QUIRK(0x1462, 0x6668, "MSI", ALC883_6ST_DIG),
10168 SND_PCI_QUIRK(0x1462, 0x7187, "MSI", ALC883_6ST_DIG),
10169 SND_PCI_QUIRK(0x1462, 0x7250, "MSI", ALC883_6ST_DIG),
10170 SND_PCI_QUIRK(0x1462, 0x7260, "MSI 7260", ALC883_TARGA_DIG),
10171 SND_PCI_QUIRK(0x1462, 0x7267, "MSI", ALC883_3ST_6ch_DIG),
10172 SND_PCI_QUIRK(0x1462, 0x7280, "MSI", ALC883_6ST_DIG),
10173 SND_PCI_QUIRK(0x1462, 0x7327, "MSI", ALC883_6ST_DIG),
10174 SND_PCI_QUIRK(0x1462, 0x7350, "MSI", ALC883_6ST_DIG),
10175 SND_PCI_QUIRK(0x1462, 0x7437, "MSI NetOn AP1900", ALC883_TARGA_DIG),
10176 SND_PCI_QUIRK(0x1462, 0xa422, "MSI", ALC883_TARGA_2ch_DIG),
10177 SND_PCI_QUIRK(0x1462, 0xaa08, "MSI", ALC883_TARGA_2ch_DIG),
10178
10179 SND_PCI_QUIRK(0x147b, 0x1083, "Abit IP35-PRO", ALC883_6ST_DIG),
10180 SND_PCI_QUIRK(0x1558, 0x0571, "Clevo laptop M570U", ALC883_3ST_6ch_DIG),
10181 SND_PCI_QUIRK(0x1558, 0x0721, "Clevo laptop M720R", ALC883_CLEVO_M720),
10182 SND_PCI_QUIRK(0x1558, 0x0722, "Clevo laptop M720SR", ALC883_CLEVO_M720),
10183 SND_PCI_QUIRK(0x1558, 0x5409, "Clevo laptop M540R", ALC883_CLEVO_M540R),
10184 SND_PCI_QUIRK_VENDOR(0x1558, "Clevo laptop", ALC883_LAPTOP_EAPD),
10185 SND_PCI_QUIRK(0x15d9, 0x8780, "Supermicro PDSBA", ALC883_3ST_6ch),
10186 /* SND_PCI_QUIRK(0x161f, 0x2054, "Arima W820", ALC882_ARIMA), */
10187 SND_PCI_QUIRK(0x161f, 0x2054, "Medion laptop", ALC883_MEDION),
10188 SND_PCI_QUIRK_MASK(0x1734, 0xfff0, 0x1100, "FSC AMILO Xi/Pi25xx",
10189 ALC883_FUJITSU_PI2515),
10190 SND_PCI_QUIRK_MASK(0x1734, 0xfff0, 0x1130, "Fujitsu AMILO Xa35xx",
10191 ALC888_FUJITSU_XA3530),
10192 SND_PCI_QUIRK(0x17aa, 0x101e, "Lenovo 101e", ALC883_LENOVO_101E_2ch),
10193 SND_PCI_QUIRK(0x17aa, 0x2085, "Lenovo NB0763", ALC883_LENOVO_NB0763),
10194 SND_PCI_QUIRK(0x17aa, 0x3bfc, "Lenovo NB0763", ALC883_LENOVO_NB0763),
10195 SND_PCI_QUIRK(0x17aa, 0x3bfd, "Lenovo NB0763", ALC883_LENOVO_NB0763),
10196 SND_PCI_QUIRK(0x17aa, 0x101d, "Lenovo Sky", ALC888_LENOVO_SKY),
10197 SND_PCI_QUIRK(0x17c0, 0x4085, "MEDION MD96630", ALC888_LENOVO_MS7195_DIG),
10198 SND_PCI_QUIRK(0x17f2, 0x5000, "Albatron KI690-AM2", ALC883_6ST_DIG),
10199 SND_PCI_QUIRK(0x1991, 0x5625, "Haier W66", ALC883_HAIER_W66),
10200
10201 SND_PCI_QUIRK(0x8086, 0x0001, "DG33BUC", ALC883_3ST_6ch_INTEL),
10202 SND_PCI_QUIRK(0x8086, 0x0002, "DG33FBC", ALC883_3ST_6ch_INTEL),
10203 SND_PCI_QUIRK(0x8086, 0x2503, "82801H", ALC883_MITAC),
10204 SND_PCI_QUIRK(0x8086, 0x0022, "DX58SO", ALC889_INTEL),
10205 SND_PCI_QUIRK(0x8086, 0x0021, "Intel IbexPeak", ALC889A_INTEL),
10206 SND_PCI_QUIRK(0x8086, 0x3b56, "Intel IbexPeak", ALC889A_INTEL),
10207 SND_PCI_QUIRK(0x8086, 0xd601, "D102GGC", ALC882_6ST_DIG),
10208
10209 {}
10210 };
10211
10212 /* codec SSID table for Intel Mac */
10213 static const struct snd_pci_quirk alc882_ssid_cfg_tbl[] = {
10214 SND_PCI_QUIRK(0x106b, 0x00a0, "MacBookPro 3,1", ALC885_MBP3),
10215 SND_PCI_QUIRK(0x106b, 0x00a1, "Macbook", ALC885_MBP3),
10216 SND_PCI_QUIRK(0x106b, 0x00a4, "MacbookPro 4,1", ALC885_MBP3),
10217 SND_PCI_QUIRK(0x106b, 0x0c00, "Mac Pro", ALC885_MACPRO),
10218 SND_PCI_QUIRK(0x106b, 0x1000, "iMac 24", ALC885_IMAC24),
10219 SND_PCI_QUIRK(0x106b, 0x2800, "AppleTV", ALC885_IMAC24),
10220 SND_PCI_QUIRK(0x106b, 0x2c00, "MacbookPro rev3", ALC885_MBP3),
10221 SND_PCI_QUIRK(0x106b, 0x3000, "iMac", ALC889A_MB31),
10222 SND_PCI_QUIRK(0x106b, 0x3200, "iMac 7,1 Aluminum", ALC882_ASUS_A7M),
10223 SND_PCI_QUIRK(0x106b, 0x3400, "MacBookAir 1,1", ALC885_MBP3),
10224 SND_PCI_QUIRK(0x106b, 0x3500, "MacBookAir 2,1", ALC885_MBA21),
10225 SND_PCI_QUIRK(0x106b, 0x3600, "Macbook 3,1", ALC889A_MB31),
10226 SND_PCI_QUIRK(0x106b, 0x3800, "MacbookPro 4,1", ALC885_MBP3),
10227 SND_PCI_QUIRK(0x106b, 0x3e00, "iMac 24 Aluminum", ALC885_IMAC24),
10228 SND_PCI_QUIRK(0x106b, 0x4900, "iMac 9,1 Aluminum", ALC885_IMAC91),
10229 SND_PCI_QUIRK(0x106b, 0x3f00, "Macbook 5,1", ALC885_MB5),
10230 SND_PCI_QUIRK(0x106b, 0x4a00, "Macbook 5,2", ALC885_MB5),
10231 /* FIXME: HP jack sense seems not working for MBP 5,1 or 5,2,
10232 * so apparently no perfect solution yet
10233 */
10234 SND_PCI_QUIRK(0x106b, 0x4000, "MacbookPro 5,1", ALC885_MB5),
10235 SND_PCI_QUIRK(0x106b, 0x4600, "MacbookPro 5,2", ALC885_MB5),
10236 SND_PCI_QUIRK(0x106b, 0x4100, "Macmini 3,1", ALC885_MACMINI3),
10237 {} /* terminator */
10238 };
10239
10240 static const struct alc_config_preset alc882_presets[] = {
10241 [ALC882_3ST_DIG] = {
10242 .mixers = { alc882_base_mixer },
10243 .init_verbs = { alc882_base_init_verbs,
10244 alc882_adc1_init_verbs },
10245 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
10246 .dac_nids = alc882_dac_nids,
10247 .dig_out_nid = ALC882_DIGOUT_NID,
10248 .dig_in_nid = ALC882_DIGIN_NID,
10249 .num_channel_mode = ARRAY_SIZE(alc882_ch_modes),
10250 .channel_mode = alc882_ch_modes,
10251 .need_dac_fix = 1,
10252 .input_mux = &alc882_capture_source,
10253 },
10254 [ALC882_6ST_DIG] = {
10255 .mixers = { alc882_base_mixer, alc882_chmode_mixer },
10256 .init_verbs = { alc882_base_init_verbs,
10257 alc882_adc1_init_verbs },
10258 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
10259 .dac_nids = alc882_dac_nids,
10260 .dig_out_nid = ALC882_DIGOUT_NID,
10261 .dig_in_nid = ALC882_DIGIN_NID,
10262 .num_channel_mode = ARRAY_SIZE(alc882_sixstack_modes),
10263 .channel_mode = alc882_sixstack_modes,
10264 .input_mux = &alc882_capture_source,
10265 },
10266 [ALC882_ARIMA] = {
10267 .mixers = { alc882_base_mixer, alc882_chmode_mixer },
10268 .init_verbs = { alc882_base_init_verbs, alc882_adc1_init_verbs,
10269 alc882_eapd_verbs },
10270 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
10271 .dac_nids = alc882_dac_nids,
10272 .num_channel_mode = ARRAY_SIZE(alc882_sixstack_modes),
10273 .channel_mode = alc882_sixstack_modes,
10274 .input_mux = &alc882_capture_source,
10275 },
10276 [ALC882_W2JC] = {
10277 .mixers = { alc882_w2jc_mixer, alc882_chmode_mixer },
10278 .init_verbs = { alc882_base_init_verbs, alc882_adc1_init_verbs,
10279 alc882_eapd_verbs, alc880_gpio1_init_verbs },
10280 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
10281 .dac_nids = alc882_dac_nids,
10282 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
10283 .channel_mode = alc880_threestack_modes,
10284 .need_dac_fix = 1,
10285 .input_mux = &alc882_capture_source,
10286 .dig_out_nid = ALC882_DIGOUT_NID,
10287 },
10288 [ALC885_MBA21] = {
10289 .mixers = { alc885_mba21_mixer },
10290 .init_verbs = { alc885_mba21_init_verbs, alc880_gpio1_init_verbs },
10291 .num_dacs = 2,
10292 .dac_nids = alc882_dac_nids,
10293 .channel_mode = alc885_mba21_ch_modes,
10294 .num_channel_mode = ARRAY_SIZE(alc885_mba21_ch_modes),
10295 .input_mux = &alc882_capture_source,
10296 .unsol_event = alc_sku_unsol_event,
10297 .setup = alc885_mba21_setup,
10298 .init_hook = alc_hp_automute,
10299 },
10300 [ALC885_MBP3] = {
10301 .mixers = { alc885_mbp3_mixer, alc882_chmode_mixer },
10302 .init_verbs = { alc885_mbp3_init_verbs,
10303 alc880_gpio1_init_verbs },
10304 .num_dacs = 2,
10305 .dac_nids = alc882_dac_nids,
10306 .hp_nid = 0x04,
10307 .channel_mode = alc885_mbp_4ch_modes,
10308 .num_channel_mode = ARRAY_SIZE(alc885_mbp_4ch_modes),
10309 .input_mux = &alc882_capture_source,
10310 .dig_out_nid = ALC882_DIGOUT_NID,
10311 .dig_in_nid = ALC882_DIGIN_NID,
10312 .unsol_event = alc_sku_unsol_event,
10313 .setup = alc885_mbp3_setup,
10314 .init_hook = alc_hp_automute,
10315 },
10316 [ALC885_MB5] = {
10317 .mixers = { alc885_mb5_mixer, alc882_chmode_mixer },
10318 .init_verbs = { alc885_mb5_init_verbs,
10319 alc880_gpio1_init_verbs },
10320 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
10321 .dac_nids = alc882_dac_nids,
10322 .channel_mode = alc885_mb5_6ch_modes,
10323 .num_channel_mode = ARRAY_SIZE(alc885_mb5_6ch_modes),
10324 .input_mux = &mb5_capture_source,
10325 .dig_out_nid = ALC882_DIGOUT_NID,
10326 .dig_in_nid = ALC882_DIGIN_NID,
10327 .unsol_event = alc_sku_unsol_event,
10328 .setup = alc885_mb5_setup,
10329 .init_hook = alc_hp_automute,
10330 },
10331 [ALC885_MACMINI3] = {
10332 .mixers = { alc885_macmini3_mixer, alc882_chmode_mixer },
10333 .init_verbs = { alc885_macmini3_init_verbs,
10334 alc880_gpio1_init_verbs },
10335 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
10336 .dac_nids = alc882_dac_nids,
10337 .channel_mode = alc885_macmini3_6ch_modes,
10338 .num_channel_mode = ARRAY_SIZE(alc885_macmini3_6ch_modes),
10339 .input_mux = &macmini3_capture_source,
10340 .dig_out_nid = ALC882_DIGOUT_NID,
10341 .dig_in_nid = ALC882_DIGIN_NID,
10342 .unsol_event = alc_sku_unsol_event,
10343 .setup = alc885_macmini3_setup,
10344 .init_hook = alc_hp_automute,
10345 },
10346 [ALC885_MACPRO] = {
10347 .mixers = { alc882_macpro_mixer },
10348 .init_verbs = { alc882_macpro_init_verbs },
10349 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
10350 .dac_nids = alc882_dac_nids,
10351 .dig_out_nid = ALC882_DIGOUT_NID,
10352 .dig_in_nid = ALC882_DIGIN_NID,
10353 .num_channel_mode = ARRAY_SIZE(alc882_ch_modes),
10354 .channel_mode = alc882_ch_modes,
10355 .input_mux = &alc882_capture_source,
10356 .init_hook = alc885_macpro_init_hook,
10357 },
10358 [ALC885_IMAC24] = {
10359 .mixers = { alc885_imac24_mixer },
10360 .init_verbs = { alc885_imac24_init_verbs },
10361 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
10362 .dac_nids = alc882_dac_nids,
10363 .dig_out_nid = ALC882_DIGOUT_NID,
10364 .dig_in_nid = ALC882_DIGIN_NID,
10365 .num_channel_mode = ARRAY_SIZE(alc882_ch_modes),
10366 .channel_mode = alc882_ch_modes,
10367 .input_mux = &alc882_capture_source,
10368 .unsol_event = alc_sku_unsol_event,
10369 .setup = alc885_imac24_setup,
10370 .init_hook = alc885_imac24_init_hook,
10371 },
10372 [ALC885_IMAC91] = {
10373 .mixers = {alc885_imac91_mixer},
10374 .init_verbs = { alc885_imac91_init_verbs,
10375 alc880_gpio1_init_verbs },
10376 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
10377 .dac_nids = alc882_dac_nids,
10378 .channel_mode = alc885_mba21_ch_modes,
10379 .num_channel_mode = ARRAY_SIZE(alc885_mba21_ch_modes),
10380 .input_mux = &alc889A_imac91_capture_source,
10381 .dig_out_nid = ALC882_DIGOUT_NID,
10382 .dig_in_nid = ALC882_DIGIN_NID,
10383 .unsol_event = alc_sku_unsol_event,
10384 .setup = alc885_imac91_setup,
10385 .init_hook = alc_hp_automute,
10386 },
10387 [ALC882_TARGA] = {
10388 .mixers = { alc882_targa_mixer, alc882_chmode_mixer },
10389 .init_verbs = { alc882_base_init_verbs, alc882_adc1_init_verbs,
10390 alc880_gpio3_init_verbs, alc882_targa_verbs},
10391 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
10392 .dac_nids = alc882_dac_nids,
10393 .dig_out_nid = ALC882_DIGOUT_NID,
10394 .num_adc_nids = ARRAY_SIZE(alc882_adc_nids),
10395 .adc_nids = alc882_adc_nids,
10396 .capsrc_nids = alc882_capsrc_nids,
10397 .num_channel_mode = ARRAY_SIZE(alc882_3ST_6ch_modes),
10398 .channel_mode = alc882_3ST_6ch_modes,
10399 .need_dac_fix = 1,
10400 .input_mux = &alc882_capture_source,
10401 .unsol_event = alc_sku_unsol_event,
10402 .setup = alc882_targa_setup,
10403 .init_hook = alc882_targa_automute,
10404 },
10405 [ALC882_ASUS_A7J] = {
10406 .mixers = { alc882_asus_a7j_mixer, alc882_chmode_mixer },
10407 .init_verbs = { alc882_base_init_verbs, alc882_adc1_init_verbs,
10408 alc882_asus_a7j_verbs},
10409 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
10410 .dac_nids = alc882_dac_nids,
10411 .dig_out_nid = ALC882_DIGOUT_NID,
10412 .num_adc_nids = ARRAY_SIZE(alc882_adc_nids),
10413 .adc_nids = alc882_adc_nids,
10414 .capsrc_nids = alc882_capsrc_nids,
10415 .num_channel_mode = ARRAY_SIZE(alc882_3ST_6ch_modes),
10416 .channel_mode = alc882_3ST_6ch_modes,
10417 .need_dac_fix = 1,
10418 .input_mux = &alc882_capture_source,
10419 },
10420 [ALC882_ASUS_A7M] = {
10421 .mixers = { alc882_asus_a7m_mixer, alc882_chmode_mixer },
10422 .init_verbs = { alc882_base_init_verbs, alc882_adc1_init_verbs,
10423 alc882_eapd_verbs, alc880_gpio1_init_verbs,
10424 alc882_asus_a7m_verbs },
10425 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
10426 .dac_nids = alc882_dac_nids,
10427 .dig_out_nid = ALC882_DIGOUT_NID,
10428 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
10429 .channel_mode = alc880_threestack_modes,
10430 .need_dac_fix = 1,
10431 .input_mux = &alc882_capture_source,
10432 },
10433 [ALC883_3ST_2ch_DIG] = {
10434 .mixers = { alc883_3ST_2ch_mixer },
10435 .init_verbs = { alc883_init_verbs },
10436 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10437 .dac_nids = alc883_dac_nids,
10438 .dig_out_nid = ALC883_DIGOUT_NID,
10439 .dig_in_nid = ALC883_DIGIN_NID,
10440 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10441 .channel_mode = alc883_3ST_2ch_modes,
10442 .input_mux = &alc883_capture_source,
10443 },
10444 [ALC883_3ST_6ch_DIG] = {
10445 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
10446 .init_verbs = { alc883_init_verbs },
10447 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10448 .dac_nids = alc883_dac_nids,
10449 .dig_out_nid = ALC883_DIGOUT_NID,
10450 .dig_in_nid = ALC883_DIGIN_NID,
10451 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
10452 .channel_mode = alc883_3ST_6ch_modes,
10453 .need_dac_fix = 1,
10454 .input_mux = &alc883_capture_source,
10455 },
10456 [ALC883_3ST_6ch] = {
10457 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
10458 .init_verbs = { alc883_init_verbs },
10459 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10460 .dac_nids = alc883_dac_nids,
10461 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
10462 .channel_mode = alc883_3ST_6ch_modes,
10463 .need_dac_fix = 1,
10464 .input_mux = &alc883_capture_source,
10465 },
10466 [ALC883_3ST_6ch_INTEL] = {
10467 .mixers = { alc883_3ST_6ch_intel_mixer, alc883_chmode_mixer },
10468 .init_verbs = { alc883_init_verbs },
10469 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10470 .dac_nids = alc883_dac_nids,
10471 .dig_out_nid = ALC883_DIGOUT_NID,
10472 .dig_in_nid = ALC883_DIGIN_NID,
10473 .slave_dig_outs = alc883_slave_dig_outs,
10474 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_intel_modes),
10475 .channel_mode = alc883_3ST_6ch_intel_modes,
10476 .need_dac_fix = 1,
10477 .input_mux = &alc883_3stack_6ch_intel,
10478 },
10479 [ALC889A_INTEL] = {
10480 .mixers = { alc885_8ch_intel_mixer, alc883_chmode_mixer },
10481 .init_verbs = { alc885_init_verbs, alc885_init_input_verbs,
10482 alc_hp15_unsol_verbs },
10483 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10484 .dac_nids = alc883_dac_nids,
10485 .num_adc_nids = ARRAY_SIZE(alc889_adc_nids),
10486 .adc_nids = alc889_adc_nids,
10487 .dig_out_nid = ALC883_DIGOUT_NID,
10488 .dig_in_nid = ALC883_DIGIN_NID,
10489 .slave_dig_outs = alc883_slave_dig_outs,
10490 .num_channel_mode = ARRAY_SIZE(alc889_8ch_intel_modes),
10491 .channel_mode = alc889_8ch_intel_modes,
10492 .capsrc_nids = alc889_capsrc_nids,
10493 .input_mux = &alc889_capture_source,
10494 .setup = alc889_automute_setup,
10495 .init_hook = alc_hp_automute,
10496 .unsol_event = alc_sku_unsol_event,
10497 .need_dac_fix = 1,
10498 },
10499 [ALC889_INTEL] = {
10500 .mixers = { alc885_8ch_intel_mixer, alc883_chmode_mixer },
10501 .init_verbs = { alc885_init_verbs, alc889_init_input_verbs,
10502 alc889_eapd_verbs, alc_hp15_unsol_verbs},
10503 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10504 .dac_nids = alc883_dac_nids,
10505 .num_adc_nids = ARRAY_SIZE(alc889_adc_nids),
10506 .adc_nids = alc889_adc_nids,
10507 .dig_out_nid = ALC883_DIGOUT_NID,
10508 .dig_in_nid = ALC883_DIGIN_NID,
10509 .slave_dig_outs = alc883_slave_dig_outs,
10510 .num_channel_mode = ARRAY_SIZE(alc889_8ch_intel_modes),
10511 .channel_mode = alc889_8ch_intel_modes,
10512 .capsrc_nids = alc889_capsrc_nids,
10513 .input_mux = &alc889_capture_source,
10514 .setup = alc889_automute_setup,
10515 .init_hook = alc889_intel_init_hook,
10516 .unsol_event = alc_sku_unsol_event,
10517 .need_dac_fix = 1,
10518 },
10519 [ALC883_6ST_DIG] = {
10520 .mixers = { alc883_base_mixer, alc883_chmode_mixer },
10521 .init_verbs = { alc883_init_verbs },
10522 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10523 .dac_nids = alc883_dac_nids,
10524 .dig_out_nid = ALC883_DIGOUT_NID,
10525 .dig_in_nid = ALC883_DIGIN_NID,
10526 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
10527 .channel_mode = alc883_sixstack_modes,
10528 .input_mux = &alc883_capture_source,
10529 },
10530 [ALC883_TARGA_DIG] = {
10531 .mixers = { alc883_targa_mixer, alc883_chmode_mixer },
10532 .init_verbs = { alc883_init_verbs, alc880_gpio3_init_verbs,
10533 alc883_targa_verbs},
10534 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10535 .dac_nids = alc883_dac_nids,
10536 .dig_out_nid = ALC883_DIGOUT_NID,
10537 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
10538 .channel_mode = alc883_3ST_6ch_modes,
10539 .need_dac_fix = 1,
10540 .input_mux = &alc883_capture_source,
10541 .unsol_event = alc883_targa_unsol_event,
10542 .setup = alc882_targa_setup,
10543 .init_hook = alc882_targa_automute,
10544 },
10545 [ALC883_TARGA_2ch_DIG] = {
10546 .mixers = { alc883_targa_2ch_mixer},
10547 .init_verbs = { alc883_init_verbs, alc880_gpio3_init_verbs,
10548 alc883_targa_verbs},
10549 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10550 .dac_nids = alc883_dac_nids,
10551 .adc_nids = alc883_adc_nids_alt,
10552 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_alt),
10553 .capsrc_nids = alc883_capsrc_nids,
10554 .dig_out_nid = ALC883_DIGOUT_NID,
10555 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10556 .channel_mode = alc883_3ST_2ch_modes,
10557 .input_mux = &alc883_capture_source,
10558 .unsol_event = alc883_targa_unsol_event,
10559 .setup = alc882_targa_setup,
10560 .init_hook = alc882_targa_automute,
10561 },
10562 [ALC883_TARGA_8ch_DIG] = {
10563 .mixers = { alc883_targa_mixer, alc883_targa_8ch_mixer,
10564 alc883_chmode_mixer },
10565 .init_verbs = { alc883_init_verbs, alc880_gpio3_init_verbs,
10566 alc883_targa_verbs },
10567 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10568 .dac_nids = alc883_dac_nids,
10569 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_rev),
10570 .adc_nids = alc883_adc_nids_rev,
10571 .capsrc_nids = alc883_capsrc_nids_rev,
10572 .dig_out_nid = ALC883_DIGOUT_NID,
10573 .dig_in_nid = ALC883_DIGIN_NID,
10574 .num_channel_mode = ARRAY_SIZE(alc883_4ST_8ch_modes),
10575 .channel_mode = alc883_4ST_8ch_modes,
10576 .need_dac_fix = 1,
10577 .input_mux = &alc883_capture_source,
10578 .unsol_event = alc883_targa_unsol_event,
10579 .setup = alc882_targa_setup,
10580 .init_hook = alc882_targa_automute,
10581 },
10582 [ALC883_ACER] = {
10583 .mixers = { alc883_base_mixer },
10584 /* On TravelMate laptops, GPIO 0 enables the internal speaker
10585 * and the headphone jack. Turn this on and rely on the
10586 * standard mute methods whenever the user wants to turn
10587 * these outputs off.
10588 */
10589 .init_verbs = { alc883_init_verbs, alc880_gpio1_init_verbs },
10590 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10591 .dac_nids = alc883_dac_nids,
10592 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10593 .channel_mode = alc883_3ST_2ch_modes,
10594 .input_mux = &alc883_capture_source,
10595 },
10596 [ALC883_ACER_ASPIRE] = {
10597 .mixers = { alc883_acer_aspire_mixer },
10598 .init_verbs = { alc883_init_verbs, alc883_acer_eapd_verbs },
10599 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10600 .dac_nids = alc883_dac_nids,
10601 .dig_out_nid = ALC883_DIGOUT_NID,
10602 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10603 .channel_mode = alc883_3ST_2ch_modes,
10604 .input_mux = &alc883_capture_source,
10605 .unsol_event = alc_sku_unsol_event,
10606 .setup = alc883_acer_aspire_setup,
10607 .init_hook = alc_hp_automute,
10608 },
10609 [ALC888_ACER_ASPIRE_4930G] = {
10610 .mixers = { alc888_acer_aspire_4930g_mixer,
10611 alc883_chmode_mixer },
10612 .init_verbs = { alc883_init_verbs, alc880_gpio1_init_verbs,
10613 alc888_acer_aspire_4930g_verbs },
10614 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10615 .dac_nids = alc883_dac_nids,
10616 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_rev),
10617 .adc_nids = alc883_adc_nids_rev,
10618 .capsrc_nids = alc883_capsrc_nids_rev,
10619 .dig_out_nid = ALC883_DIGOUT_NID,
10620 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
10621 .channel_mode = alc883_3ST_6ch_modes,
10622 .need_dac_fix = 1,
10623 .const_channel_count = 6,
10624 .num_mux_defs =
10625 ARRAY_SIZE(alc888_2_capture_sources),
10626 .input_mux = alc888_2_capture_sources,
10627 .unsol_event = alc_sku_unsol_event,
10628 .setup = alc888_acer_aspire_4930g_setup,
10629 .init_hook = alc_hp_automute,
10630 },
10631 [ALC888_ACER_ASPIRE_6530G] = {
10632 .mixers = { alc888_acer_aspire_6530_mixer },
10633 .init_verbs = { alc883_init_verbs, alc880_gpio1_init_verbs,
10634 alc888_acer_aspire_6530g_verbs },
10635 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10636 .dac_nids = alc883_dac_nids,
10637 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_rev),
10638 .adc_nids = alc883_adc_nids_rev,
10639 .capsrc_nids = alc883_capsrc_nids_rev,
10640 .dig_out_nid = ALC883_DIGOUT_NID,
10641 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10642 .channel_mode = alc883_3ST_2ch_modes,
10643 .num_mux_defs =
10644 ARRAY_SIZE(alc888_2_capture_sources),
10645 .input_mux = alc888_acer_aspire_6530_sources,
10646 .unsol_event = alc_sku_unsol_event,
10647 .setup = alc888_acer_aspire_6530g_setup,
10648 .init_hook = alc_hp_automute,
10649 },
10650 [ALC888_ACER_ASPIRE_8930G] = {
10651 .mixers = { alc889_acer_aspire_8930g_mixer,
10652 alc883_chmode_mixer },
10653 .init_verbs = { alc883_init_verbs, alc880_gpio1_init_verbs,
10654 alc889_acer_aspire_8930g_verbs,
10655 alc889_eapd_verbs},
10656 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10657 .dac_nids = alc883_dac_nids,
10658 .num_adc_nids = ARRAY_SIZE(alc889_adc_nids),
10659 .adc_nids = alc889_adc_nids,
10660 .capsrc_nids = alc889_capsrc_nids,
10661 .dig_out_nid = ALC883_DIGOUT_NID,
10662 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
10663 .channel_mode = alc883_3ST_6ch_modes,
10664 .need_dac_fix = 1,
10665 .const_channel_count = 6,
10666 .num_mux_defs =
10667 ARRAY_SIZE(alc889_capture_sources),
10668 .input_mux = alc889_capture_sources,
10669 .unsol_event = alc_sku_unsol_event,
10670 .setup = alc889_acer_aspire_8930g_setup,
10671 .init_hook = alc_hp_automute,
10672 #ifdef CONFIG_SND_HDA_POWER_SAVE
10673 .power_hook = alc_power_eapd,
10674 #endif
10675 },
10676 [ALC888_ACER_ASPIRE_7730G] = {
10677 .mixers = { alc883_3ST_6ch_mixer,
10678 alc883_chmode_mixer },
10679 .init_verbs = { alc883_init_verbs, alc880_gpio1_init_verbs,
10680 alc888_acer_aspire_7730G_verbs },
10681 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10682 .dac_nids = alc883_dac_nids,
10683 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_rev),
10684 .adc_nids = alc883_adc_nids_rev,
10685 .capsrc_nids = alc883_capsrc_nids_rev,
10686 .dig_out_nid = ALC883_DIGOUT_NID,
10687 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
10688 .channel_mode = alc883_3ST_6ch_modes,
10689 .need_dac_fix = 1,
10690 .const_channel_count = 6,
10691 .input_mux = &alc883_capture_source,
10692 .unsol_event = alc_sku_unsol_event,
10693 .setup = alc888_acer_aspire_7730g_setup,
10694 .init_hook = alc_hp_automute,
10695 },
10696 [ALC883_MEDION] = {
10697 .mixers = { alc883_fivestack_mixer,
10698 alc883_chmode_mixer },
10699 .init_verbs = { alc883_init_verbs,
10700 alc883_medion_eapd_verbs },
10701 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10702 .dac_nids = alc883_dac_nids,
10703 .adc_nids = alc883_adc_nids_alt,
10704 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_alt),
10705 .capsrc_nids = alc883_capsrc_nids,
10706 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
10707 .channel_mode = alc883_sixstack_modes,
10708 .input_mux = &alc883_capture_source,
10709 },
10710 [ALC883_MEDION_WIM2160] = {
10711 .mixers = { alc883_medion_wim2160_mixer },
10712 .init_verbs = { alc883_init_verbs, alc883_medion_wim2160_verbs },
10713 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10714 .dac_nids = alc883_dac_nids,
10715 .dig_out_nid = ALC883_DIGOUT_NID,
10716 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids),
10717 .adc_nids = alc883_adc_nids,
10718 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10719 .channel_mode = alc883_3ST_2ch_modes,
10720 .input_mux = &alc883_capture_source,
10721 .unsol_event = alc_sku_unsol_event,
10722 .setup = alc883_medion_wim2160_setup,
10723 .init_hook = alc_hp_automute,
10724 },
10725 [ALC883_LAPTOP_EAPD] = {
10726 .mixers = { alc883_base_mixer },
10727 .init_verbs = { alc883_init_verbs, alc882_eapd_verbs },
10728 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10729 .dac_nids = alc883_dac_nids,
10730 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10731 .channel_mode = alc883_3ST_2ch_modes,
10732 .input_mux = &alc883_capture_source,
10733 },
10734 [ALC883_CLEVO_M540R] = {
10735 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
10736 .init_verbs = { alc883_init_verbs, alc883_clevo_m540r_verbs },
10737 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10738 .dac_nids = alc883_dac_nids,
10739 .dig_out_nid = ALC883_DIGOUT_NID,
10740 .dig_in_nid = ALC883_DIGIN_NID,
10741 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_clevo_modes),
10742 .channel_mode = alc883_3ST_6ch_clevo_modes,
10743 .need_dac_fix = 1,
10744 .input_mux = &alc883_capture_source,
10745 /* This machine has the hardware HP auto-muting, thus
10746 * we need no software mute via unsol event
10747 */
10748 },
10749 [ALC883_CLEVO_M720] = {
10750 .mixers = { alc883_clevo_m720_mixer },
10751 .init_verbs = { alc883_init_verbs, alc883_clevo_m720_verbs },
10752 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10753 .dac_nids = alc883_dac_nids,
10754 .dig_out_nid = ALC883_DIGOUT_NID,
10755 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10756 .channel_mode = alc883_3ST_2ch_modes,
10757 .input_mux = &alc883_capture_source,
10758 .unsol_event = alc883_clevo_m720_unsol_event,
10759 .setup = alc883_clevo_m720_setup,
10760 .init_hook = alc883_clevo_m720_init_hook,
10761 },
10762 [ALC883_LENOVO_101E_2ch] = {
10763 .mixers = { alc883_lenovo_101e_2ch_mixer},
10764 .init_verbs = { alc883_init_verbs, alc883_lenovo_101e_verbs},
10765 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10766 .dac_nids = alc883_dac_nids,
10767 .adc_nids = alc883_adc_nids_alt,
10768 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_alt),
10769 .capsrc_nids = alc883_capsrc_nids,
10770 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10771 .channel_mode = alc883_3ST_2ch_modes,
10772 .input_mux = &alc883_lenovo_101e_capture_source,
10773 .setup = alc883_lenovo_101e_setup,
10774 .unsol_event = alc_sku_unsol_event,
10775 .init_hook = alc_inithook,
10776 },
10777 [ALC883_LENOVO_NB0763] = {
10778 .mixers = { alc883_lenovo_nb0763_mixer },
10779 .init_verbs = { alc883_init_verbs, alc883_lenovo_nb0763_verbs},
10780 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10781 .dac_nids = alc883_dac_nids,
10782 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10783 .channel_mode = alc883_3ST_2ch_modes,
10784 .need_dac_fix = 1,
10785 .input_mux = &alc883_lenovo_nb0763_capture_source,
10786 .unsol_event = alc_sku_unsol_event,
10787 .setup = alc883_lenovo_nb0763_setup,
10788 .init_hook = alc_hp_automute,
10789 },
10790 [ALC888_LENOVO_MS7195_DIG] = {
10791 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
10792 .init_verbs = { alc883_init_verbs, alc888_lenovo_ms7195_verbs},
10793 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10794 .dac_nids = alc883_dac_nids,
10795 .dig_out_nid = ALC883_DIGOUT_NID,
10796 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
10797 .channel_mode = alc883_3ST_6ch_modes,
10798 .need_dac_fix = 1,
10799 .input_mux = &alc883_capture_source,
10800 .unsol_event = alc_sku_unsol_event,
10801 .setup = alc888_lenovo_ms7195_setup,
10802 .init_hook = alc_inithook,
10803 },
10804 [ALC883_HAIER_W66] = {
10805 .mixers = { alc883_targa_2ch_mixer},
10806 .init_verbs = { alc883_init_verbs, alc883_haier_w66_verbs},
10807 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10808 .dac_nids = alc883_dac_nids,
10809 .dig_out_nid = ALC883_DIGOUT_NID,
10810 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10811 .channel_mode = alc883_3ST_2ch_modes,
10812 .input_mux = &alc883_capture_source,
10813 .unsol_event = alc_sku_unsol_event,
10814 .setup = alc883_haier_w66_setup,
10815 .init_hook = alc_hp_automute,
10816 },
10817 [ALC888_3ST_HP] = {
10818 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
10819 .init_verbs = { alc883_init_verbs, alc888_3st_hp_verbs },
10820 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10821 .dac_nids = alc883_dac_nids,
10822 .num_channel_mode = ARRAY_SIZE(alc888_3st_hp_modes),
10823 .channel_mode = alc888_3st_hp_modes,
10824 .need_dac_fix = 1,
10825 .input_mux = &alc883_capture_source,
10826 .unsol_event = alc_sku_unsol_event,
10827 .setup = alc888_3st_hp_setup,
10828 .init_hook = alc_hp_automute,
10829 },
10830 [ALC888_6ST_DELL] = {
10831 .mixers = { alc883_base_mixer, alc883_chmode_mixer },
10832 .init_verbs = { alc883_init_verbs, alc888_6st_dell_verbs },
10833 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10834 .dac_nids = alc883_dac_nids,
10835 .dig_out_nid = ALC883_DIGOUT_NID,
10836 .dig_in_nid = ALC883_DIGIN_NID,
10837 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
10838 .channel_mode = alc883_sixstack_modes,
10839 .input_mux = &alc883_capture_source,
10840 .unsol_event = alc_sku_unsol_event,
10841 .setup = alc888_6st_dell_setup,
10842 .init_hook = alc_hp_automute,
10843 },
10844 [ALC883_MITAC] = {
10845 .mixers = { alc883_mitac_mixer },
10846 .init_verbs = { alc883_init_verbs, alc883_mitac_verbs },
10847 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10848 .dac_nids = alc883_dac_nids,
10849 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10850 .channel_mode = alc883_3ST_2ch_modes,
10851 .input_mux = &alc883_capture_source,
10852 .unsol_event = alc_sku_unsol_event,
10853 .setup = alc883_mitac_setup,
10854 .init_hook = alc_hp_automute,
10855 },
10856 [ALC883_FUJITSU_PI2515] = {
10857 .mixers = { alc883_2ch_fujitsu_pi2515_mixer },
10858 .init_verbs = { alc883_init_verbs,
10859 alc883_2ch_fujitsu_pi2515_verbs},
10860 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10861 .dac_nids = alc883_dac_nids,
10862 .dig_out_nid = ALC883_DIGOUT_NID,
10863 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10864 .channel_mode = alc883_3ST_2ch_modes,
10865 .input_mux = &alc883_fujitsu_pi2515_capture_source,
10866 .unsol_event = alc_sku_unsol_event,
10867 .setup = alc883_2ch_fujitsu_pi2515_setup,
10868 .init_hook = alc_hp_automute,
10869 },
10870 [ALC888_FUJITSU_XA3530] = {
10871 .mixers = { alc888_base_mixer, alc883_chmode_mixer },
10872 .init_verbs = { alc883_init_verbs,
10873 alc888_fujitsu_xa3530_verbs },
10874 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10875 .dac_nids = alc883_dac_nids,
10876 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_rev),
10877 .adc_nids = alc883_adc_nids_rev,
10878 .capsrc_nids = alc883_capsrc_nids_rev,
10879 .dig_out_nid = ALC883_DIGOUT_NID,
10880 .num_channel_mode = ARRAY_SIZE(alc888_4ST_8ch_intel_modes),
10881 .channel_mode = alc888_4ST_8ch_intel_modes,
10882 .num_mux_defs =
10883 ARRAY_SIZE(alc888_2_capture_sources),
10884 .input_mux = alc888_2_capture_sources,
10885 .unsol_event = alc_sku_unsol_event,
10886 .setup = alc888_fujitsu_xa3530_setup,
10887 .init_hook = alc_hp_automute,
10888 },
10889 [ALC888_LENOVO_SKY] = {
10890 .mixers = { alc888_lenovo_sky_mixer, alc883_chmode_mixer },
10891 .init_verbs = { alc883_init_verbs, alc888_lenovo_sky_verbs},
10892 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10893 .dac_nids = alc883_dac_nids,
10894 .dig_out_nid = ALC883_DIGOUT_NID,
10895 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
10896 .channel_mode = alc883_sixstack_modes,
10897 .need_dac_fix = 1,
10898 .input_mux = &alc883_lenovo_sky_capture_source,
10899 .unsol_event = alc_sku_unsol_event,
10900 .setup = alc888_lenovo_sky_setup,
10901 .init_hook = alc_hp_automute,
10902 },
10903 [ALC888_ASUS_M90V] = {
10904 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
10905 .init_verbs = { alc883_init_verbs, alc888_asus_m90v_verbs },
10906 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10907 .dac_nids = alc883_dac_nids,
10908 .dig_out_nid = ALC883_DIGOUT_NID,
10909 .dig_in_nid = ALC883_DIGIN_NID,
10910 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
10911 .channel_mode = alc883_3ST_6ch_modes,
10912 .need_dac_fix = 1,
10913 .input_mux = &alc883_fujitsu_pi2515_capture_source,
10914 .unsol_event = alc_sku_unsol_event,
10915 .setup = alc883_mode2_setup,
10916 .init_hook = alc_inithook,
10917 },
10918 [ALC888_ASUS_EEE1601] = {
10919 .mixers = { alc883_asus_eee1601_mixer },
10920 .cap_mixer = alc883_asus_eee1601_cap_mixer,
10921 .init_verbs = { alc883_init_verbs, alc888_asus_eee1601_verbs },
10922 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10923 .dac_nids = alc883_dac_nids,
10924 .dig_out_nid = ALC883_DIGOUT_NID,
10925 .dig_in_nid = ALC883_DIGIN_NID,
10926 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10927 .channel_mode = alc883_3ST_2ch_modes,
10928 .need_dac_fix = 1,
10929 .input_mux = &alc883_asus_eee1601_capture_source,
10930 .unsol_event = alc_sku_unsol_event,
10931 .init_hook = alc883_eee1601_inithook,
10932 },
10933 [ALC1200_ASUS_P5Q] = {
10934 .mixers = { alc883_base_mixer, alc883_chmode_mixer },
10935 .init_verbs = { alc883_init_verbs },
10936 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10937 .dac_nids = alc883_dac_nids,
10938 .dig_out_nid = ALC1200_DIGOUT_NID,
10939 .dig_in_nid = ALC883_DIGIN_NID,
10940 .slave_dig_outs = alc1200_slave_dig_outs,
10941 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
10942 .channel_mode = alc883_sixstack_modes,
10943 .input_mux = &alc883_capture_source,
10944 },
10945 [ALC889A_MB31] = {
10946 .mixers = { alc889A_mb31_mixer, alc883_chmode_mixer},
10947 .init_verbs = { alc883_init_verbs, alc889A_mb31_verbs,
10948 alc880_gpio1_init_verbs },
10949 .adc_nids = alc883_adc_nids,
10950 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids),
10951 .capsrc_nids = alc883_capsrc_nids,
10952 .dac_nids = alc883_dac_nids,
10953 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10954 .channel_mode = alc889A_mb31_6ch_modes,
10955 .num_channel_mode = ARRAY_SIZE(alc889A_mb31_6ch_modes),
10956 .input_mux = &alc889A_mb31_capture_source,
10957 .dig_out_nid = ALC883_DIGOUT_NID,
10958 .unsol_event = alc889A_mb31_unsol_event,
10959 .init_hook = alc889A_mb31_automute,
10960 },
10961 [ALC883_SONY_VAIO_TT] = {
10962 .mixers = { alc883_vaiott_mixer },
10963 .init_verbs = { alc883_init_verbs, alc883_vaiott_verbs },
10964 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10965 .dac_nids = alc883_dac_nids,
10966 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10967 .channel_mode = alc883_3ST_2ch_modes,
10968 .input_mux = &alc883_capture_source,
10969 .unsol_event = alc_sku_unsol_event,
10970 .setup = alc883_vaiott_setup,
10971 .init_hook = alc_hp_automute,
10972 },
10973 };
10974
10975
10976 /*
10977 * Pin config fixes
10978 */
10979 enum {
10980 PINFIX_ABIT_AW9D_MAX,
10981 PINFIX_LENOVO_Y530,
10982 PINFIX_PB_M5210,
10983 PINFIX_ACER_ASPIRE_7736,
10984 };
10985
10986 static const struct alc_fixup alc882_fixups[] = {
10987 [PINFIX_ABIT_AW9D_MAX] = {
10988 .type = ALC_FIXUP_PINS,
10989 .v.pins = (const struct alc_pincfg[]) {
10990 { 0x15, 0x01080104 }, /* side */
10991 { 0x16, 0x01011012 }, /* rear */
10992 { 0x17, 0x01016011 }, /* clfe */
10993 { }
10994 }
10995 },
10996 [PINFIX_LENOVO_Y530] = {
10997 .type = ALC_FIXUP_PINS,
10998 .v.pins = (const struct alc_pincfg[]) {
10999 { 0x15, 0x99130112 }, /* rear int speakers */
11000 { 0x16, 0x99130111 }, /* subwoofer */
11001 { }
11002 }
11003 },
11004 [PINFIX_PB_M5210] = {
11005 .type = ALC_FIXUP_VERBS,
11006 .v.verbs = (const struct hda_verb[]) {
11007 { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50 },
11008 {}
11009 }
11010 },
11011 [PINFIX_ACER_ASPIRE_7736] = {
11012 .type = ALC_FIXUP_SKU,
11013 .v.sku = ALC_FIXUP_SKU_IGNORE,
11014 },
11015 };
11016
11017 static const struct snd_pci_quirk alc882_fixup_tbl[] = {
11018 SND_PCI_QUIRK(0x1025, 0x0155, "Packard-Bell M5120", PINFIX_PB_M5210),
11019 SND_PCI_QUIRK(0x17aa, 0x3a0d, "Lenovo Y530", PINFIX_LENOVO_Y530),
11020 SND_PCI_QUIRK(0x147b, 0x107a, "Abit AW9D-MAX", PINFIX_ABIT_AW9D_MAX),
11021 SND_PCI_QUIRK(0x1025, 0x0296, "Acer Aspire 7736z", PINFIX_ACER_ASPIRE_7736),
11022 {}
11023 };
11024
11025 /*
11026 * BIOS auto configuration
11027 */
11028 static int alc882_auto_create_input_ctls(struct hda_codec *codec,
11029 const struct auto_pin_cfg *cfg)
11030 {
11031 return alc_auto_create_input_ctls(codec, cfg, 0x0b, 0x23, 0x22);
11032 }
11033
11034 static void alc882_auto_set_output_and_unmute(struct hda_codec *codec,
11035 hda_nid_t nid, int pin_type,
11036 hda_nid_t dac)
11037 {
11038 int idx;
11039
11040 /* set as output */
11041 alc_set_pin_output(codec, nid, pin_type);
11042
11043 if (dac == 0x25)
11044 idx = 4;
11045 else if (dac >= 0x02 && dac <= 0x05)
11046 idx = dac - 2;
11047 else
11048 return;
11049 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CONNECT_SEL, idx);
11050 }
11051
11052 static void alc882_auto_init_multi_out(struct hda_codec *codec)
11053 {
11054 struct alc_spec *spec = codec->spec;
11055 int i;
11056
11057 for (i = 0; i <= HDA_SIDE; i++) {
11058 hda_nid_t nid = spec->autocfg.line_out_pins[i];
11059 int pin_type = get_pin_type(spec->autocfg.line_out_type);
11060 if (nid)
11061 alc882_auto_set_output_and_unmute(codec, nid, pin_type,
11062 spec->multiout.dac_nids[i]);
11063 }
11064 }
11065
11066 static void alc882_auto_init_hp_out(struct hda_codec *codec)
11067 {
11068 struct alc_spec *spec = codec->spec;
11069 hda_nid_t pin, dac;
11070 int i;
11071
11072 if (spec->autocfg.line_out_type != AUTO_PIN_HP_OUT) {
11073 for (i = 0; i < ARRAY_SIZE(spec->autocfg.hp_pins); i++) {
11074 pin = spec->autocfg.hp_pins[i];
11075 if (!pin)
11076 break;
11077 dac = spec->multiout.hp_nid;
11078 if (!dac)
11079 dac = spec->multiout.dac_nids[0]; /* to front */
11080 alc882_auto_set_output_and_unmute(codec, pin, PIN_HP, dac);
11081 }
11082 }
11083
11084 if (spec->autocfg.line_out_type != AUTO_PIN_SPEAKER_OUT) {
11085 for (i = 0; i < ARRAY_SIZE(spec->autocfg.speaker_pins); i++) {
11086 pin = spec->autocfg.speaker_pins[i];
11087 if (!pin)
11088 break;
11089 dac = spec->multiout.extra_out_nid[0];
11090 if (!dac)
11091 dac = spec->multiout.dac_nids[0]; /* to front */
11092 alc882_auto_set_output_and_unmute(codec, pin, PIN_OUT, dac);
11093 }
11094 }
11095 }
11096
11097 static void alc882_auto_init_analog_input(struct hda_codec *codec)
11098 {
11099 struct alc_spec *spec = codec->spec;
11100 struct auto_pin_cfg *cfg = &spec->autocfg;
11101 int i;
11102
11103 for (i = 0; i < cfg->num_inputs; i++) {
11104 hda_nid_t nid = cfg->inputs[i].pin;
11105 alc_set_input_pin(codec, nid, cfg->inputs[i].type);
11106 if (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP)
11107 snd_hda_codec_write(codec, nid, 0,
11108 AC_VERB_SET_AMP_GAIN_MUTE,
11109 AMP_OUT_MUTE);
11110 }
11111 }
11112
11113 static void alc882_auto_init_input_src(struct hda_codec *codec)
11114 {
11115 struct alc_spec *spec = codec->spec;
11116 int c;
11117
11118 for (c = 0; c < spec->num_adc_nids; c++) {
11119 hda_nid_t conn_list[HDA_MAX_NUM_INPUTS];
11120 hda_nid_t nid = spec->capsrc_nids[c];
11121 unsigned int mux_idx;
11122 const struct hda_input_mux *imux;
11123 int conns, mute, idx, item;
11124
11125 /* mute ADC */
11126 snd_hda_codec_write(codec, spec->adc_nids[c], 0,
11127 AC_VERB_SET_AMP_GAIN_MUTE,
11128 AMP_IN_MUTE(0));
11129
11130 conns = snd_hda_get_connections(codec, nid, conn_list,
11131 ARRAY_SIZE(conn_list));
11132 if (conns < 0)
11133 continue;
11134 mux_idx = c >= spec->num_mux_defs ? 0 : c;
11135 imux = &spec->input_mux[mux_idx];
11136 if (!imux->num_items && mux_idx > 0)
11137 imux = &spec->input_mux[0];
11138 for (idx = 0; idx < conns; idx++) {
11139 /* if the current connection is the selected one,
11140 * unmute it as default - otherwise mute it
11141 */
11142 mute = AMP_IN_MUTE(idx);
11143 for (item = 0; item < imux->num_items; item++) {
11144 if (imux->items[item].index == idx) {
11145 if (spec->cur_mux[c] == item)
11146 mute = AMP_IN_UNMUTE(idx);
11147 break;
11148 }
11149 }
11150 /* check if we have a selector or mixer
11151 * we could check for the widget type instead, but
11152 * just check for Amp-In presence (in case of mixer
11153 * without amp-in there is something wrong, this
11154 * function shouldn't be used or capsrc nid is wrong)
11155 */
11156 if (get_wcaps(codec, nid) & AC_WCAP_IN_AMP)
11157 snd_hda_codec_write(codec, nid, 0,
11158 AC_VERB_SET_AMP_GAIN_MUTE,
11159 mute);
11160 else if (mute != AMP_IN_MUTE(idx))
11161 snd_hda_codec_write(codec, nid, 0,
11162 AC_VERB_SET_CONNECT_SEL,
11163 idx);
11164 }
11165 }
11166 }
11167
11168 /* add mic boosts if needed */
11169 static int alc_auto_add_mic_boost(struct hda_codec *codec)
11170 {
11171 struct alc_spec *spec = codec->spec;
11172 struct auto_pin_cfg *cfg = &spec->autocfg;
11173 int i, err;
11174 int type_idx = 0;
11175 hda_nid_t nid;
11176 const char *prev_label = NULL;
11177
11178 for (i = 0; i < cfg->num_inputs; i++) {
11179 if (cfg->inputs[i].type > AUTO_PIN_MIC)
11180 break;
11181 nid = cfg->inputs[i].pin;
11182 if (get_wcaps(codec, nid) & AC_WCAP_IN_AMP) {
11183 const char *label;
11184 char boost_label[32];
11185
11186 label = hda_get_autocfg_input_label(codec, cfg, i);
11187 if (prev_label && !strcmp(label, prev_label))
11188 type_idx++;
11189 else
11190 type_idx = 0;
11191 prev_label = label;
11192
11193 snprintf(boost_label, sizeof(boost_label),
11194 "%s Boost Volume", label);
11195 err = add_control(spec, ALC_CTL_WIDGET_VOL,
11196 boost_label, type_idx,
11197 HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT));
11198 if (err < 0)
11199 return err;
11200 }
11201 }
11202 return 0;
11203 }
11204
11205 /* almost identical with ALC880 parser... */
11206 static int alc882_parse_auto_config(struct hda_codec *codec)
11207 {
11208 struct alc_spec *spec = codec->spec;
11209 static const hda_nid_t alc882_ignore[] = { 0x1d, 0 };
11210 int err;
11211
11212 err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
11213 alc882_ignore);
11214 if (err < 0)
11215 return err;
11216 if (!spec->autocfg.line_outs)
11217 return 0; /* can't find valid BIOS pin config */
11218
11219 err = alc880_auto_fill_dac_nids(spec, &spec->autocfg);
11220 if (err < 0)
11221 return err;
11222 err = alc_auto_add_multi_channel_mode(codec);
11223 if (err < 0)
11224 return err;
11225 err = alc880_auto_create_multi_out_ctls(spec, &spec->autocfg);
11226 if (err < 0)
11227 return err;
11228 err = alc880_auto_create_extra_out(spec, spec->autocfg.hp_pins[0],
11229 "Headphone");
11230 if (err < 0)
11231 return err;
11232 err = alc880_auto_create_extra_out(spec,
11233 spec->autocfg.speaker_pins[0],
11234 "Speaker");
11235 if (err < 0)
11236 return err;
11237 err = alc882_auto_create_input_ctls(codec, &spec->autocfg);
11238 if (err < 0)
11239 return err;
11240
11241 spec->multiout.max_channels = spec->multiout.num_dacs * 2;
11242
11243 alc_auto_parse_digital(codec);
11244
11245 if (spec->kctls.list)
11246 add_mixer(spec, spec->kctls.list);
11247
11248 add_verb(spec, alc883_auto_init_verbs);
11249 /* if ADC 0x07 is available, initialize it, too */
11250 if (get_wcaps_type(get_wcaps(codec, 0x07)) == AC_WID_AUD_IN)
11251 add_verb(spec, alc882_adc1_init_verbs);
11252
11253 spec->num_mux_defs = 1;
11254 spec->input_mux = &spec->private_imux[0];
11255
11256 alc_ssid_check(codec, 0x15, 0x1b, 0x14, 0);
11257
11258 err = alc_auto_add_mic_boost(codec);
11259 if (err < 0)
11260 return err;
11261
11262 return 1; /* config found */
11263 }
11264
11265 /* additional initialization for auto-configuration model */
11266 static void alc882_auto_init(struct hda_codec *codec)
11267 {
11268 struct alc_spec *spec = codec->spec;
11269 alc882_auto_init_multi_out(codec);
11270 alc882_auto_init_hp_out(codec);
11271 alc882_auto_init_analog_input(codec);
11272 alc882_auto_init_input_src(codec);
11273 alc_auto_init_digital(codec);
11274 if (spec->unsol_event)
11275 alc_inithook(codec);
11276 }
11277
11278 static int patch_alc882(struct hda_codec *codec)
11279 {
11280 struct alc_spec *spec;
11281 int err, board_config;
11282
11283 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
11284 if (spec == NULL)
11285 return -ENOMEM;
11286
11287 codec->spec = spec;
11288
11289 switch (codec->vendor_id) {
11290 case 0x10ec0882:
11291 case 0x10ec0885:
11292 break;
11293 default:
11294 /* ALC883 and variants */
11295 alc_fix_pll_init(codec, 0x20, 0x0a, 10);
11296 break;
11297 }
11298
11299 board_config = snd_hda_check_board_config(codec, ALC882_MODEL_LAST,
11300 alc882_models,
11301 alc882_cfg_tbl);
11302
11303 if (board_config < 0 || board_config >= ALC882_MODEL_LAST)
11304 board_config = snd_hda_check_board_codec_sid_config(codec,
11305 ALC882_MODEL_LAST, alc882_models, alc882_ssid_cfg_tbl);
11306
11307 if (board_config < 0 || board_config >= ALC882_MODEL_LAST) {
11308 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
11309 codec->chip_name);
11310 board_config = ALC882_AUTO;
11311 }
11312
11313 if (board_config == ALC882_AUTO) {
11314 alc_pick_fixup(codec, NULL, alc882_fixup_tbl, alc882_fixups);
11315 alc_apply_fixup(codec, ALC_FIXUP_ACT_PRE_PROBE);
11316 }
11317
11318 alc_auto_parse_customize_define(codec);
11319
11320 if (board_config == ALC882_AUTO) {
11321 /* automatic parse from the BIOS config */
11322 err = alc882_parse_auto_config(codec);
11323 if (err < 0) {
11324 alc_free(codec);
11325 return err;
11326 } else if (!err) {
11327 printk(KERN_INFO
11328 "hda_codec: Cannot set up configuration "
11329 "from BIOS. Using base mode...\n");
11330 board_config = ALC882_3ST_DIG;
11331 }
11332 }
11333
11334 if (has_cdefine_beep(codec)) {
11335 err = snd_hda_attach_beep_device(codec, 0x1);
11336 if (err < 0) {
11337 alc_free(codec);
11338 return err;
11339 }
11340 }
11341
11342 if (board_config != ALC882_AUTO)
11343 setup_preset(codec, &alc882_presets[board_config]);
11344
11345 spec->stream_analog_playback = &alc882_pcm_analog_playback;
11346 spec->stream_analog_capture = &alc882_pcm_analog_capture;
11347 /* FIXME: setup DAC5 */
11348 /*spec->stream_analog_alt_playback = &alc880_pcm_analog_alt_playback;*/
11349 spec->stream_analog_alt_capture = &alc880_pcm_analog_alt_capture;
11350
11351 spec->stream_digital_playback = &alc882_pcm_digital_playback;
11352 spec->stream_digital_capture = &alc882_pcm_digital_capture;
11353
11354 if (!spec->adc_nids && spec->input_mux) {
11355 int i, j;
11356 spec->num_adc_nids = 0;
11357 for (i = 0; i < ARRAY_SIZE(alc882_adc_nids); i++) {
11358 const struct hda_input_mux *imux = spec->input_mux;
11359 hda_nid_t cap;
11360 hda_nid_t items[16];
11361 hda_nid_t nid = alc882_adc_nids[i];
11362 unsigned int wcap = get_wcaps(codec, nid);
11363 /* get type */
11364 wcap = get_wcaps_type(wcap);
11365 if (wcap != AC_WID_AUD_IN)
11366 continue;
11367 spec->private_adc_nids[spec->num_adc_nids] = nid;
11368 err = snd_hda_get_connections(codec, nid, &cap, 1);
11369 if (err < 0)
11370 continue;
11371 err = snd_hda_get_connections(codec, cap, items,
11372 ARRAY_SIZE(items));
11373 if (err < 0)
11374 continue;
11375 for (j = 0; j < imux->num_items; j++)
11376 if (imux->items[j].index >= err)
11377 break;
11378 if (j < imux->num_items)
11379 continue;
11380 spec->private_capsrc_nids[spec->num_adc_nids] = cap;
11381 spec->num_adc_nids++;
11382 }
11383 spec->adc_nids = spec->private_adc_nids;
11384 spec->capsrc_nids = spec->private_capsrc_nids;
11385 }
11386
11387 set_capture_mixer(codec);
11388
11389 if (has_cdefine_beep(codec))
11390 set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
11391
11392 alc_apply_fixup(codec, ALC_FIXUP_ACT_PROBE);
11393
11394 spec->vmaster_nid = 0x0c;
11395
11396 codec->patch_ops = alc_patch_ops;
11397 if (board_config == ALC882_AUTO)
11398 spec->init_hook = alc882_auto_init;
11399
11400 alc_init_jacks(codec);
11401 #ifdef CONFIG_SND_HDA_POWER_SAVE
11402 if (!spec->loopback.amplist)
11403 spec->loopback.amplist = alc882_loopbacks;
11404 #endif
11405
11406 return 0;
11407 }
11408
11409
11410 /*
11411 * ALC262 support
11412 */
11413
11414 #define ALC262_DIGOUT_NID ALC880_DIGOUT_NID
11415 #define ALC262_DIGIN_NID ALC880_DIGIN_NID
11416
11417 #define alc262_dac_nids alc260_dac_nids
11418 #define alc262_adc_nids alc882_adc_nids
11419 #define alc262_adc_nids_alt alc882_adc_nids_alt
11420 #define alc262_capsrc_nids alc882_capsrc_nids
11421 #define alc262_capsrc_nids_alt alc882_capsrc_nids_alt
11422
11423 #define alc262_modes alc260_modes
11424 #define alc262_capture_source alc882_capture_source
11425
11426 static const hda_nid_t alc262_dmic_adc_nids[1] = {
11427 /* ADC0 */
11428 0x09
11429 };
11430
11431 static const hda_nid_t alc262_dmic_capsrc_nids[1] = { 0x22 };
11432
11433 static const struct snd_kcontrol_new alc262_base_mixer[] = {
11434 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
11435 HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
11436 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
11437 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
11438 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
11439 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
11440 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11441 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11442 HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
11443 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
11444 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
11445 HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x19, 0, HDA_INPUT),
11446 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0D, 0x0, HDA_OUTPUT),
11447 HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
11448 HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
11449 HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x16, 2, 0x0, HDA_OUTPUT),
11450 { } /* end */
11451 };
11452
11453 /* update HP, line and mono-out pins according to the master switch */
11454 #define alc262_hp_master_update alc260_hp_master_update
11455
11456 static void alc262_hp_bpc_setup(struct hda_codec *codec)
11457 {
11458 struct alc_spec *spec = codec->spec;
11459
11460 spec->autocfg.hp_pins[0] = 0x1b;
11461 spec->autocfg.speaker_pins[0] = 0x16;
11462 spec->automute = 1;
11463 spec->automute_mode = ALC_AUTOMUTE_PIN;
11464 }
11465
11466 static void alc262_hp_wildwest_setup(struct hda_codec *codec)
11467 {
11468 struct alc_spec *spec = codec->spec;
11469
11470 spec->autocfg.hp_pins[0] = 0x15;
11471 spec->autocfg.speaker_pins[0] = 0x16;
11472 spec->automute = 1;
11473 spec->automute_mode = ALC_AUTOMUTE_PIN;
11474 }
11475
11476 #define alc262_hp_master_sw_get alc260_hp_master_sw_get
11477 #define alc262_hp_master_sw_put alc260_hp_master_sw_put
11478
11479 #define ALC262_HP_MASTER_SWITCH \
11480 { \
11481 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
11482 .name = "Master Playback Switch", \
11483 .info = snd_ctl_boolean_mono_info, \
11484 .get = alc262_hp_master_sw_get, \
11485 .put = alc262_hp_master_sw_put, \
11486 }, \
11487 { \
11488 .iface = NID_MAPPING, \
11489 .name = "Master Playback Switch", \
11490 .private_value = 0x15 | (0x16 << 8) | (0x1b << 16), \
11491 }
11492
11493
11494 static const struct snd_kcontrol_new alc262_HP_BPC_mixer[] = {
11495 ALC262_HP_MASTER_SWITCH,
11496 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
11497 HDA_CODEC_MUTE("Front Playback Switch", 0x15, 0x0, HDA_OUTPUT),
11498 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
11499 HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0e, 2, 0x0,
11500 HDA_OUTPUT),
11501 HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x16, 2, 0x0,
11502 HDA_OUTPUT),
11503 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11504 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11505 HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
11506 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
11507 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
11508 HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x19, 0, HDA_INPUT),
11509 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
11510 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
11511 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
11512 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
11513 HDA_CODEC_VOLUME("AUX IN Playback Volume", 0x0b, 0x06, HDA_INPUT),
11514 HDA_CODEC_MUTE("AUX IN Playback Switch", 0x0b, 0x06, HDA_INPUT),
11515 { } /* end */
11516 };
11517
11518 static const struct snd_kcontrol_new alc262_HP_BPC_WildWest_mixer[] = {
11519 ALC262_HP_MASTER_SWITCH,
11520 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
11521 HDA_CODEC_MUTE("Front Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
11522 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
11523 HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
11524 HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0e, 2, 0x0,
11525 HDA_OUTPUT),
11526 HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x16, 2, 0x0,
11527 HDA_OUTPUT),
11528 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x02, HDA_INPUT),
11529 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x02, HDA_INPUT),
11530 HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x1a, 0, HDA_INPUT),
11531 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x01, HDA_INPUT),
11532 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x01, HDA_INPUT),
11533 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
11534 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
11535 { } /* end */
11536 };
11537
11538 static const struct snd_kcontrol_new alc262_HP_BPC_WildWest_option_mixer[] = {
11539 HDA_CODEC_VOLUME("Rear Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11540 HDA_CODEC_MUTE("Rear Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11541 HDA_CODEC_VOLUME("Rear Mic Boost Volume", 0x18, 0, HDA_INPUT),
11542 { } /* end */
11543 };
11544
11545 /* mute/unmute internal speaker according to the hp jack and mute state */
11546 static void alc262_hp_t5735_setup(struct hda_codec *codec)
11547 {
11548 struct alc_spec *spec = codec->spec;
11549
11550 spec->autocfg.hp_pins[0] = 0x15;
11551 spec->autocfg.speaker_pins[0] = 0x14;
11552 spec->automute = 1;
11553 spec->automute_mode = ALC_AUTOMUTE_PIN;
11554 }
11555
11556 static const struct snd_kcontrol_new alc262_hp_t5735_mixer[] = {
11557 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
11558 HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
11559 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
11560 HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
11561 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11562 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11563 HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
11564 { } /* end */
11565 };
11566
11567 static const struct hda_verb alc262_hp_t5735_verbs[] = {
11568 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
11569 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11570
11571 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
11572 { }
11573 };
11574
11575 static const struct snd_kcontrol_new alc262_hp_rp5700_mixer[] = {
11576 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
11577 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
11578 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0e, 0x0, HDA_OUTPUT),
11579 HDA_CODEC_MUTE("Speaker Playback Switch", 0x16, 0x0, HDA_OUTPUT),
11580 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x01, HDA_INPUT),
11581 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x01, HDA_INPUT),
11582 { } /* end */
11583 };
11584
11585 static const struct hda_verb alc262_hp_rp5700_verbs[] = {
11586 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
11587 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
11588 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
11589 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
11590 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
11591 {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
11592 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
11593 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
11594 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x00 << 8))},
11595 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x00 << 8))},
11596 {}
11597 };
11598
11599 static const struct hda_input_mux alc262_hp_rp5700_capture_source = {
11600 .num_items = 1,
11601 .items = {
11602 { "Line", 0x1 },
11603 },
11604 };
11605
11606 /* bind hp and internal speaker mute (with plug check) as master switch */
11607 #define alc262_hippo_master_update alc262_hp_master_update
11608 #define alc262_hippo_master_sw_get alc262_hp_master_sw_get
11609 #define alc262_hippo_master_sw_put alc262_hp_master_sw_put
11610
11611 #define ALC262_HIPPO_MASTER_SWITCH \
11612 { \
11613 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
11614 .name = "Master Playback Switch", \
11615 .info = snd_ctl_boolean_mono_info, \
11616 .get = alc262_hippo_master_sw_get, \
11617 .put = alc262_hippo_master_sw_put, \
11618 }, \
11619 { \
11620 .iface = NID_MAPPING, \
11621 .name = "Master Playback Switch", \
11622 .subdevice = SUBDEV_HP(0) | (SUBDEV_LINE(0) << 8) | \
11623 (SUBDEV_SPEAKER(0) << 16), \
11624 }
11625
11626 static const struct snd_kcontrol_new alc262_hippo_mixer[] = {
11627 ALC262_HIPPO_MASTER_SWITCH,
11628 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
11629 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
11630 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
11631 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
11632 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
11633 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11634 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11635 HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
11636 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
11637 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
11638 HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x19, 0, HDA_INPUT),
11639 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
11640 { } /* end */
11641 };
11642
11643 static const struct snd_kcontrol_new alc262_hippo1_mixer[] = {
11644 HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
11645 ALC262_HIPPO_MASTER_SWITCH,
11646 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
11647 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
11648 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
11649 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
11650 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11651 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11652 HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
11653 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
11654 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
11655 HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x19, 0, HDA_INPUT),
11656 { } /* end */
11657 };
11658
11659 /* mute/unmute internal speaker according to the hp jack and mute state */
11660 static void alc262_hippo_setup(struct hda_codec *codec)
11661 {
11662 struct alc_spec *spec = codec->spec;
11663
11664 spec->autocfg.hp_pins[0] = 0x15;
11665 spec->autocfg.speaker_pins[0] = 0x14;
11666 spec->automute = 1;
11667 spec->automute_mode = ALC_AUTOMUTE_AMP;
11668 }
11669
11670 static void alc262_hippo1_setup(struct hda_codec *codec)
11671 {
11672 struct alc_spec *spec = codec->spec;
11673
11674 spec->autocfg.hp_pins[0] = 0x1b;
11675 spec->autocfg.speaker_pins[0] = 0x14;
11676 spec->automute = 1;
11677 spec->automute_mode = ALC_AUTOMUTE_AMP;
11678 }
11679
11680
11681 static const struct snd_kcontrol_new alc262_sony_mixer[] = {
11682 HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
11683 ALC262_HIPPO_MASTER_SWITCH,
11684 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11685 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11686 HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
11687 HDA_CODEC_MUTE("ATAPI Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
11688 { } /* end */
11689 };
11690
11691 static const struct snd_kcontrol_new alc262_benq_t31_mixer[] = {
11692 HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
11693 ALC262_HIPPO_MASTER_SWITCH,
11694 HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
11695 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11696 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11697 HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
11698 HDA_CODEC_MUTE("ATAPI Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
11699 { } /* end */
11700 };
11701
11702 static const struct snd_kcontrol_new alc262_tyan_mixer[] = {
11703 HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
11704 HDA_BIND_MUTE("Master Playback Switch", 0x0c, 2, HDA_INPUT),
11705 HDA_CODEC_VOLUME("Aux Playback Volume", 0x0b, 0x06, HDA_INPUT),
11706 HDA_CODEC_MUTE("Aux Playback Switch", 0x0b, 0x06, HDA_INPUT),
11707 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
11708 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
11709 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11710 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11711 HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
11712 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
11713 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
11714 HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x19, 0, HDA_INPUT),
11715 { } /* end */
11716 };
11717
11718 static const struct hda_verb alc262_tyan_verbs[] = {
11719 /* Headphone automute */
11720 {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
11721 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11722 {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
11723
11724 /* P11 AUX_IN, white 4-pin connector */
11725 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
11726 {0x14, AC_VERB_SET_CONFIG_DEFAULT_BYTES_1, 0xe1},
11727 {0x14, AC_VERB_SET_CONFIG_DEFAULT_BYTES_2, 0x93},
11728 {0x14, AC_VERB_SET_CONFIG_DEFAULT_BYTES_3, 0x19},
11729
11730 {}
11731 };
11732
11733 /* unsolicited event for HP jack sensing */
11734 static void alc262_tyan_setup(struct hda_codec *codec)
11735 {
11736 struct alc_spec *spec = codec->spec;
11737
11738 spec->autocfg.hp_pins[0] = 0x1b;
11739 spec->autocfg.speaker_pins[0] = 0x15;
11740 spec->automute = 1;
11741 spec->automute_mode = ALC_AUTOMUTE_AMP;
11742 }
11743
11744
11745 #define alc262_capture_mixer alc882_capture_mixer
11746 #define alc262_capture_alt_mixer alc882_capture_alt_mixer
11747
11748 /*
11749 * generic initialization of ADC, input mixers and output mixers
11750 */
11751 static const struct hda_verb alc262_init_verbs[] = {
11752 /*
11753 * Unmute ADC0-2 and set the default input to mic-in
11754 */
11755 {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
11756 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11757 {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
11758 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11759 {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
11760 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11761
11762 /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
11763 * mixer widget
11764 * Note: PASD motherboards uses the Line In 2 as the input for
11765 * front panel mic (mic 2)
11766 */
11767 /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
11768 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
11769 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
11770 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
11771 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
11772 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
11773
11774 /*
11775 * Set up output mixers (0x0c - 0x0e)
11776 */
11777 /* set vol=0 to output mixers */
11778 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11779 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11780 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11781 /* set up input amps for analog loopback */
11782 /* Amp Indices: DAC = 0, mixer = 1 */
11783 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11784 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11785 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11786 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11787 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11788 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11789
11790 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
11791 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
11792 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
11793 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
11794 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
11795 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
11796
11797 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
11798 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
11799 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
11800 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
11801 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
11802
11803 {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
11804 {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
11805
11806 /* FIXME: use matrix-type input source selection */
11807 /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
11808 /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
11809 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
11810 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
11811 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
11812 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
11813 /* Input mixer2 */
11814 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
11815 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
11816 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
11817 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
11818 /* Input mixer3 */
11819 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
11820 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
11821 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
11822 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
11823
11824 { }
11825 };
11826
11827 static const struct hda_verb alc262_eapd_verbs[] = {
11828 {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
11829 {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
11830 { }
11831 };
11832
11833 static const struct hda_verb alc262_hippo1_unsol_verbs[] = {
11834 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
11835 {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
11836 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
11837
11838 {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
11839 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11840 {}
11841 };
11842
11843 static const struct hda_verb alc262_sony_unsol_verbs[] = {
11844 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
11845 {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
11846 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24}, // Front Mic
11847
11848 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
11849 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11850 {}
11851 };
11852
11853 static const struct snd_kcontrol_new alc262_toshiba_s06_mixer[] = {
11854 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
11855 HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
11856 HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
11857 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11858 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11859 { } /* end */
11860 };
11861
11862 static const struct hda_verb alc262_toshiba_s06_verbs[] = {
11863 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
11864 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
11865 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11866 {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
11867 {0x22, AC_VERB_SET_CONNECT_SEL, 0x09},
11868 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
11869 {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
11870 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
11871 {}
11872 };
11873
11874 static void alc262_toshiba_s06_setup(struct hda_codec *codec)
11875 {
11876 struct alc_spec *spec = codec->spec;
11877
11878 spec->autocfg.hp_pins[0] = 0x15;
11879 spec->autocfg.speaker_pins[0] = 0x14;
11880 spec->ext_mic.pin = 0x18;
11881 spec->ext_mic.mux_idx = 0;
11882 spec->int_mic.pin = 0x12;
11883 spec->int_mic.mux_idx = 9;
11884 spec->auto_mic = 1;
11885 spec->automute = 1;
11886 spec->automute_mode = ALC_AUTOMUTE_PIN;
11887 }
11888
11889 /*
11890 * nec model
11891 * 0x15 = headphone
11892 * 0x16 = internal speaker
11893 * 0x18 = external mic
11894 */
11895
11896 static const struct snd_kcontrol_new alc262_nec_mixer[] = {
11897 HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
11898 HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x16, 0, 0x0, HDA_OUTPUT),
11899
11900 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11901 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11902 HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
11903
11904 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
11905 HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
11906 { } /* end */
11907 };
11908
11909 static const struct hda_verb alc262_nec_verbs[] = {
11910 /* Unmute Speaker */
11911 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
11912
11913 /* Headphone */
11914 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
11915 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
11916
11917 /* External mic to headphone */
11918 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11919 /* External mic to speaker */
11920 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11921 {}
11922 };
11923
11924 /*
11925 * fujitsu model
11926 * 0x14 = headphone/spdif-out, 0x15 = internal speaker,
11927 * 0x1b = port replicator headphone out
11928 */
11929
11930 #define ALC_HP_EVENT ALC880_HP_EVENT
11931
11932 static const struct hda_verb alc262_fujitsu_unsol_verbs[] = {
11933 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_HP_EVENT},
11934 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11935 {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_HP_EVENT},
11936 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11937 {}
11938 };
11939
11940 static const struct hda_verb alc262_lenovo_3000_unsol_verbs[] = {
11941 {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_HP_EVENT},
11942 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11943 {}
11944 };
11945
11946 static const struct hda_verb alc262_lenovo_3000_init_verbs[] = {
11947 /* Front Mic pin: input vref at 50% */
11948 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
11949 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11950 {}
11951 };
11952
11953 static const struct hda_input_mux alc262_fujitsu_capture_source = {
11954 .num_items = 3,
11955 .items = {
11956 { "Mic", 0x0 },
11957 { "Internal Mic", 0x1 },
11958 { "CD", 0x4 },
11959 },
11960 };
11961
11962 static const struct hda_input_mux alc262_HP_capture_source = {
11963 .num_items = 5,
11964 .items = {
11965 { "Mic", 0x0 },
11966 { "Front Mic", 0x1 },
11967 { "Line", 0x2 },
11968 { "CD", 0x4 },
11969 { "AUX IN", 0x6 },
11970 },
11971 };
11972
11973 static const struct hda_input_mux alc262_HP_D7000_capture_source = {
11974 .num_items = 4,
11975 .items = {
11976 { "Mic", 0x0 },
11977 { "Front Mic", 0x2 },
11978 { "Line", 0x1 },
11979 { "CD", 0x4 },
11980 },
11981 };
11982
11983 static void alc262_fujitsu_setup(struct hda_codec *codec)
11984 {
11985 struct alc_spec *spec = codec->spec;
11986
11987 spec->autocfg.hp_pins[0] = 0x14;
11988 spec->autocfg.hp_pins[1] = 0x1b;
11989 spec->autocfg.speaker_pins[0] = 0x15;
11990 spec->automute = 1;
11991 spec->automute_mode = ALC_AUTOMUTE_AMP;
11992 }
11993
11994 /* bind volumes of both NID 0x0c and 0x0d */
11995 static const struct hda_bind_ctls alc262_fujitsu_bind_master_vol = {
11996 .ops = &snd_hda_bind_vol,
11997 .values = {
11998 HDA_COMPOSE_AMP_VAL(0x0c, 3, 0, HDA_OUTPUT),
11999 HDA_COMPOSE_AMP_VAL(0x0d, 3, 0, HDA_OUTPUT),
12000 0
12001 },
12002 };
12003
12004 static const struct snd_kcontrol_new alc262_fujitsu_mixer[] = {
12005 HDA_BIND_VOL("Master Playback Volume", &alc262_fujitsu_bind_master_vol),
12006 {
12007 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
12008 .name = "Master Playback Switch",
12009 .subdevice = HDA_SUBDEV_NID_FLAG | 0x14,
12010 .info = snd_ctl_boolean_mono_info,
12011 .get = alc262_hp_master_sw_get,
12012 .put = alc262_hp_master_sw_put,
12013 },
12014 {
12015 .iface = NID_MAPPING,
12016 .name = "Master Playback Switch",
12017 .private_value = 0x1b,
12018 },
12019 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
12020 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
12021 HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
12022 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
12023 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
12024 HDA_CODEC_VOLUME("Internal Mic Boost Volume", 0x19, 0, HDA_INPUT),
12025 HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
12026 HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
12027 { } /* end */
12028 };
12029
12030 static void alc262_lenovo_3000_setup(struct hda_codec *codec)
12031 {
12032 struct alc_spec *spec = codec->spec;
12033
12034 spec->autocfg.hp_pins[0] = 0x1b;
12035 spec->autocfg.speaker_pins[0] = 0x14;
12036 spec->autocfg.speaker_pins[1] = 0x16;
12037 spec->automute = 1;
12038 spec->automute_mode = ALC_AUTOMUTE_AMP;
12039 }
12040
12041 static const struct snd_kcontrol_new alc262_lenovo_3000_mixer[] = {
12042 HDA_BIND_VOL("Master Playback Volume", &alc262_fujitsu_bind_master_vol),
12043 {
12044 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
12045 .name = "Master Playback Switch",
12046 .subdevice = HDA_SUBDEV_NID_FLAG | 0x1b,
12047 .info = snd_ctl_boolean_mono_info,
12048 .get = alc262_hp_master_sw_get,
12049 .put = alc262_hp_master_sw_put,
12050 },
12051 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
12052 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
12053 HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
12054 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
12055 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
12056 HDA_CODEC_VOLUME("Internal Mic Boost Volume", 0x19, 0, HDA_INPUT),
12057 HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
12058 HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
12059 { } /* end */
12060 };
12061
12062 static const struct snd_kcontrol_new alc262_toshiba_rx1_mixer[] = {
12063 HDA_BIND_VOL("Master Playback Volume", &alc262_fujitsu_bind_master_vol),
12064 ALC262_HIPPO_MASTER_SWITCH,
12065 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
12066 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
12067 HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
12068 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
12069 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
12070 HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x19, 0, HDA_INPUT),
12071 { } /* end */
12072 };
12073
12074 /* additional init verbs for Benq laptops */
12075 static const struct hda_verb alc262_EAPD_verbs[] = {
12076 {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
12077 {0x20, AC_VERB_SET_PROC_COEF, 0x3070},
12078 {}
12079 };
12080
12081 static const struct hda_verb alc262_benq_t31_EAPD_verbs[] = {
12082 {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
12083 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
12084
12085 {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
12086 {0x20, AC_VERB_SET_PROC_COEF, 0x3050},
12087 {}
12088 };
12089
12090 /* Samsung Q1 Ultra Vista model setup */
12091 static const struct snd_kcontrol_new alc262_ultra_mixer[] = {
12092 HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
12093 HDA_BIND_MUTE("Master Playback Switch", 0x0c, 2, HDA_INPUT),
12094 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
12095 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
12096 HDA_CODEC_VOLUME("Mic Boost Volume", 0x19, 0, HDA_INPUT),
12097 HDA_CODEC_VOLUME("Headphone Mic Boost Volume", 0x15, 0, HDA_INPUT),
12098 { } /* end */
12099 };
12100
12101 static const struct hda_verb alc262_ultra_verbs[] = {
12102 /* output mixer */
12103 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
12104 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
12105 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12106 /* speaker */
12107 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
12108 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12109 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12110 {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
12111 /* HP */
12112 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
12113 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12114 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12115 {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
12116 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
12117 /* internal mic */
12118 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
12119 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
12120 /* ADC, choose mic */
12121 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
12122 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
12123 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12124 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
12125 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
12126 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
12127 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
12128 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
12129 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
12130 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(8)},
12131 {}
12132 };
12133
12134 /* mute/unmute internal speaker according to the hp jack and mute state */
12135 static void alc262_ultra_automute(struct hda_codec *codec)
12136 {
12137 struct alc_spec *spec = codec->spec;
12138 unsigned int mute;
12139
12140 mute = 0;
12141 /* auto-mute only when HP is used as HP */
12142 if (!spec->cur_mux[0]) {
12143 spec->jack_present = snd_hda_jack_detect(codec, 0x15);
12144 if (spec->jack_present)
12145 mute = HDA_AMP_MUTE;
12146 }
12147 /* mute/unmute internal speaker */
12148 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
12149 HDA_AMP_MUTE, mute);
12150 /* mute/unmute HP */
12151 snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
12152 HDA_AMP_MUTE, mute ? 0 : HDA_AMP_MUTE);
12153 }
12154
12155 /* unsolicited event for HP jack sensing */
12156 static void alc262_ultra_unsol_event(struct hda_codec *codec,
12157 unsigned int res)
12158 {
12159 if ((res >> 26) != ALC880_HP_EVENT)
12160 return;
12161 alc262_ultra_automute(codec);
12162 }
12163
12164 static const struct hda_input_mux alc262_ultra_capture_source = {
12165 .num_items = 2,
12166 .items = {
12167 { "Mic", 0x1 },
12168 { "Headphone", 0x7 },
12169 },
12170 };
12171
12172 static int alc262_ultra_mux_enum_put(struct snd_kcontrol *kcontrol,
12173 struct snd_ctl_elem_value *ucontrol)
12174 {
12175 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
12176 struct alc_spec *spec = codec->spec;
12177 int ret;
12178
12179 ret = alc_mux_enum_put(kcontrol, ucontrol);
12180 if (!ret)
12181 return 0;
12182 /* reprogram the HP pin as mic or HP according to the input source */
12183 snd_hda_codec_write_cache(codec, 0x15, 0,
12184 AC_VERB_SET_PIN_WIDGET_CONTROL,
12185 spec->cur_mux[0] ? PIN_VREF80 : PIN_HP);
12186 alc262_ultra_automute(codec); /* mute/unmute HP */
12187 return ret;
12188 }
12189
12190 static const struct snd_kcontrol_new alc262_ultra_capture_mixer[] = {
12191 HDA_CODEC_VOLUME("Capture Volume", 0x07, 0x0, HDA_INPUT),
12192 HDA_CODEC_MUTE("Capture Switch", 0x07, 0x0, HDA_INPUT),
12193 {
12194 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
12195 .name = "Capture Source",
12196 .info = alc_mux_enum_info,
12197 .get = alc_mux_enum_get,
12198 .put = alc262_ultra_mux_enum_put,
12199 },
12200 {
12201 .iface = NID_MAPPING,
12202 .name = "Capture Source",
12203 .private_value = 0x15,
12204 },
12205 { } /* end */
12206 };
12207
12208 /* We use two mixers depending on the output pin; 0x16 is a mono output
12209 * and thus it's bound with a different mixer.
12210 * This function returns which mixer amp should be used.
12211 */
12212 static int alc262_check_volbit(hda_nid_t nid)
12213 {
12214 if (!nid)
12215 return 0;
12216 else if (nid == 0x16)
12217 return 2;
12218 else
12219 return 1;
12220 }
12221
12222 static int alc262_add_out_vol_ctl(struct alc_spec *spec, hda_nid_t nid,
12223 const char *pfx, int *vbits, int idx)
12224 {
12225 unsigned long val;
12226 int vbit;
12227
12228 vbit = alc262_check_volbit(nid);
12229 if (!vbit)
12230 return 0;
12231 if (*vbits & vbit) /* a volume control for this mixer already there */
12232 return 0;
12233 *vbits |= vbit;
12234 if (vbit == 2)
12235 val = HDA_COMPOSE_AMP_VAL(0x0e, 2, 0, HDA_OUTPUT);
12236 else
12237 val = HDA_COMPOSE_AMP_VAL(0x0c, 3, 0, HDA_OUTPUT);
12238 return __add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, pfx, idx, val);
12239 }
12240
12241 static int alc262_add_out_sw_ctl(struct alc_spec *spec, hda_nid_t nid,
12242 const char *pfx, int idx)
12243 {
12244 unsigned long val;
12245
12246 if (!nid)
12247 return 0;
12248 if (nid == 0x16)
12249 val = HDA_COMPOSE_AMP_VAL(nid, 2, 0, HDA_OUTPUT);
12250 else
12251 val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
12252 return __add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, pfx, idx, val);
12253 }
12254
12255 /* add playback controls from the parsed DAC table */
12256 static int alc262_auto_create_multi_out_ctls(struct alc_spec *spec,
12257 const struct auto_pin_cfg *cfg)
12258 {
12259 const char *pfx;
12260 int vbits;
12261 int i, err;
12262
12263 spec->multiout.num_dacs = 1; /* only use one dac */
12264 spec->multiout.dac_nids = spec->private_dac_nids;
12265 spec->private_dac_nids[0] = 2;
12266
12267 pfx = alc_get_line_out_pfx(spec, true);
12268 if (!pfx)
12269 pfx = "Front";
12270 for (i = 0; i < 2; i++) {
12271 err = alc262_add_out_sw_ctl(spec, cfg->line_out_pins[i], pfx, i);
12272 if (err < 0)
12273 return err;
12274 if (cfg->line_out_type != AUTO_PIN_SPEAKER_OUT) {
12275 err = alc262_add_out_sw_ctl(spec, cfg->speaker_pins[i],
12276 "Speaker", i);
12277 if (err < 0)
12278 return err;
12279 }
12280 if (cfg->line_out_type != AUTO_PIN_HP_OUT) {
12281 err = alc262_add_out_sw_ctl(spec, cfg->hp_pins[i],
12282 "Headphone", i);
12283 if (err < 0)
12284 return err;
12285 }
12286 }
12287
12288 vbits = alc262_check_volbit(cfg->line_out_pins[0]) |
12289 alc262_check_volbit(cfg->speaker_pins[0]) |
12290 alc262_check_volbit(cfg->hp_pins[0]);
12291 if (vbits == 1 || vbits == 2)
12292 pfx = "Master"; /* only one mixer is used */
12293 vbits = 0;
12294 for (i = 0; i < 2; i++) {
12295 err = alc262_add_out_vol_ctl(spec, cfg->line_out_pins[i], pfx,
12296 &vbits, i);
12297 if (err < 0)
12298 return err;
12299 if (cfg->line_out_type != AUTO_PIN_SPEAKER_OUT) {
12300 err = alc262_add_out_vol_ctl(spec, cfg->speaker_pins[i],
12301 "Speaker", &vbits, i);
12302 if (err < 0)
12303 return err;
12304 }
12305 if (cfg->line_out_type != AUTO_PIN_HP_OUT) {
12306 err = alc262_add_out_vol_ctl(spec, cfg->hp_pins[i],
12307 "Headphone", &vbits, i);
12308 if (err < 0)
12309 return err;
12310 }
12311 }
12312 return 0;
12313 }
12314
12315 #define alc262_auto_create_input_ctls \
12316 alc882_auto_create_input_ctls
12317
12318 /*
12319 * generic initialization of ADC, input mixers and output mixers
12320 */
12321 static const struct hda_verb alc262_volume_init_verbs[] = {
12322 /*
12323 * Unmute ADC0-2 and set the default input to mic-in
12324 */
12325 {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
12326 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12327 {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
12328 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12329 {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
12330 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12331
12332 /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
12333 * mixer widget
12334 * Note: PASD motherboards uses the Line In 2 as the input for
12335 * front panel mic (mic 2)
12336 */
12337 /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
12338 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
12339 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
12340 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
12341 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
12342 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
12343
12344 /*
12345 * Set up output mixers (0x0c - 0x0f)
12346 */
12347 /* set vol=0 to output mixers */
12348 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12349 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12350 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12351
12352 /* set up input amps for analog loopback */
12353 /* Amp Indices: DAC = 0, mixer = 1 */
12354 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12355 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12356 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12357 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12358 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12359 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12360
12361 /* FIXME: use matrix-type input source selection */
12362 /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
12363 /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
12364 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
12365 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
12366 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
12367 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
12368 /* Input mixer2 */
12369 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
12370 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
12371 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
12372 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
12373 /* Input mixer3 */
12374 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
12375 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
12376 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
12377 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
12378
12379 { }
12380 };
12381
12382 static const struct hda_verb alc262_HP_BPC_init_verbs[] = {
12383 /*
12384 * Unmute ADC0-2 and set the default input to mic-in
12385 */
12386 {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
12387 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12388 {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
12389 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12390 {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
12391 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12392
12393 /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
12394 * mixer widget
12395 * Note: PASD motherboards uses the Line In 2 as the input for
12396 * front panel mic (mic 2)
12397 */
12398 /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
12399 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
12400 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
12401 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
12402 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
12403 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
12404 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
12405 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
12406
12407 /*
12408 * Set up output mixers (0x0c - 0x0e)
12409 */
12410 /* set vol=0 to output mixers */
12411 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12412 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12413 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12414
12415 /* set up input amps for analog loopback */
12416 /* Amp Indices: DAC = 0, mixer = 1 */
12417 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12418 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12419 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12420 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12421 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12422 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12423
12424 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
12425 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
12426 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
12427
12428 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
12429 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
12430
12431 {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
12432 {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
12433
12434 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
12435 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
12436 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
12437 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
12438 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
12439
12440 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
12441 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
12442 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
12443 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
12444 {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
12445 {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
12446
12447
12448 /* FIXME: use matrix-type input source selection */
12449 /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 0b, 12 */
12450 /* Input mixer1: only unmute Mic */
12451 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
12452 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8))},
12453 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
12454 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
12455 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
12456 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x05 << 8))},
12457 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x06 << 8))},
12458 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x07 << 8))},
12459 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x08 << 8))},
12460 /* Input mixer2 */
12461 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
12462 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8))},
12463 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
12464 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
12465 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
12466 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x05 << 8))},
12467 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x06 << 8))},
12468 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x07 << 8))},
12469 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x08 << 8))},
12470 /* Input mixer3 */
12471 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
12472 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8))},
12473 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
12474 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
12475 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
12476 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x05 << 8))},
12477 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x06 << 8))},
12478 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x07 << 8))},
12479 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x08 << 8))},
12480
12481 {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
12482
12483 { }
12484 };
12485
12486 static const struct hda_verb alc262_HP_BPC_WildWest_init_verbs[] = {
12487 /*
12488 * Unmute ADC0-2 and set the default input to mic-in
12489 */
12490 {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
12491 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12492 {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
12493 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12494 {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
12495 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12496
12497 /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
12498 * mixer widget
12499 * Note: PASD motherboards uses the Line In 2 as the input for front
12500 * panel mic (mic 2)
12501 */
12502 /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
12503 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
12504 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
12505 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
12506 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
12507 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
12508 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
12509 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
12510 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
12511 /*
12512 * Set up output mixers (0x0c - 0x0e)
12513 */
12514 /* set vol=0 to output mixers */
12515 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12516 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12517 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12518
12519 /* set up input amps for analog loopback */
12520 /* Amp Indices: DAC = 0, mixer = 1 */
12521 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12522 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12523 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12524 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12525 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12526 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12527
12528
12529 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP }, /* HP */
12530 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, /* Mono */
12531 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, /* rear MIC */
12532 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN }, /* Line in */
12533 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, /* Front MIC */
12534 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, /* Line out */
12535 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN }, /* CD in */
12536
12537 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
12538 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
12539
12540 {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
12541 {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
12542
12543 /* {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0x7023 }, */
12544 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
12545 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
12546 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0x7023 },
12547 {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
12548 {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
12549
12550 /* FIXME: use matrix-type input source selection */
12551 /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
12552 /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
12553 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, /*rear MIC*/
12554 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))}, /*Line in*/
12555 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))}, /*F MIC*/
12556 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))}, /*Front*/
12557 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))}, /*CD*/
12558 /* {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x06 << 8))}, */
12559 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x07 << 8))}, /*HP*/
12560 /* Input mixer2 */
12561 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
12562 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
12563 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))},
12564 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))},
12565 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))},
12566 /* {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x06 << 8))}, */
12567 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x07 << 8))},
12568 /* Input mixer3 */
12569 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
12570 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
12571 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))},
12572 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))},
12573 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))},
12574 /* {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x06 << 8))}, */
12575 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x07 << 8))},
12576
12577 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
12578
12579 { }
12580 };
12581
12582 static const struct hda_verb alc262_toshiba_rx1_unsol_verbs[] = {
12583
12584 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, /* Front Speaker */
12585 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
12586 {0x14, AC_VERB_SET_CONNECT_SEL, 0x01},
12587
12588 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, /* MIC jack */
12589 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, /* Front MIC */
12590 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0) },
12591 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0) },
12592
12593 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP }, /* HP jack */
12594 {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
12595 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
12596 {}
12597 };
12598
12599 /*
12600 * Pin config fixes
12601 */
12602 enum {
12603 PINFIX_FSC_H270,
12604 };
12605
12606 static const struct alc_fixup alc262_fixups[] = {
12607 [PINFIX_FSC_H270] = {
12608 .type = ALC_FIXUP_PINS,
12609 .v.pins = (const struct alc_pincfg[]) {
12610 { 0x14, 0x99130110 }, /* speaker */
12611 { 0x15, 0x0221142f }, /* front HP */
12612 { 0x1b, 0x0121141f }, /* rear HP */
12613 { }
12614 }
12615 },
12616 };
12617
12618 static const struct snd_pci_quirk alc262_fixup_tbl[] = {
12619 SND_PCI_QUIRK(0x1734, 0x1147, "FSC Celsius H270", PINFIX_FSC_H270),
12620 {}
12621 };
12622
12623
12624 #ifdef CONFIG_SND_HDA_POWER_SAVE
12625 #define alc262_loopbacks alc880_loopbacks
12626 #endif
12627
12628 /* pcm configuration: identical with ALC880 */
12629 #define alc262_pcm_analog_playback alc880_pcm_analog_playback
12630 #define alc262_pcm_analog_capture alc880_pcm_analog_capture
12631 #define alc262_pcm_digital_playback alc880_pcm_digital_playback
12632 #define alc262_pcm_digital_capture alc880_pcm_digital_capture
12633
12634 /*
12635 * BIOS auto configuration
12636 */
12637 static int alc262_parse_auto_config(struct hda_codec *codec)
12638 {
12639 struct alc_spec *spec = codec->spec;
12640 int err;
12641 static const hda_nid_t alc262_ignore[] = { 0x1d, 0 };
12642
12643 err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
12644 alc262_ignore);
12645 if (err < 0)
12646 return err;
12647 if (!spec->autocfg.line_outs) {
12648 if (spec->autocfg.dig_outs || spec->autocfg.dig_in_pin) {
12649 spec->multiout.max_channels = 2;
12650 spec->no_analog = 1;
12651 goto dig_only;
12652 }
12653 return 0; /* can't find valid BIOS pin config */
12654 }
12655 err = alc262_auto_create_multi_out_ctls(spec, &spec->autocfg);
12656 if (err < 0)
12657 return err;
12658 err = alc262_auto_create_input_ctls(codec, &spec->autocfg);
12659 if (err < 0)
12660 return err;
12661
12662 spec->multiout.max_channels = spec->multiout.num_dacs * 2;
12663
12664 dig_only:
12665 alc_auto_parse_digital(codec);
12666
12667 if (spec->kctls.list)
12668 add_mixer(spec, spec->kctls.list);
12669
12670 add_verb(spec, alc262_volume_init_verbs);
12671 spec->num_mux_defs = 1;
12672 spec->input_mux = &spec->private_imux[0];
12673
12674 err = alc_auto_add_mic_boost(codec);
12675 if (err < 0)
12676 return err;
12677
12678 alc_ssid_check(codec, 0x15, 0x1b, 0x14, 0);
12679
12680 return 1;
12681 }
12682
12683 #define alc262_auto_init_multi_out alc882_auto_init_multi_out
12684 #define alc262_auto_init_hp_out alc882_auto_init_hp_out
12685 #define alc262_auto_init_analog_input alc882_auto_init_analog_input
12686 #define alc262_auto_init_input_src alc882_auto_init_input_src
12687
12688
12689 /* init callback for auto-configuration model -- overriding the default init */
12690 static void alc262_auto_init(struct hda_codec *codec)
12691 {
12692 struct alc_spec *spec = codec->spec;
12693 alc262_auto_init_multi_out(codec);
12694 alc262_auto_init_hp_out(codec);
12695 alc262_auto_init_analog_input(codec);
12696 alc262_auto_init_input_src(codec);
12697 alc_auto_init_digital(codec);
12698 if (spec->unsol_event)
12699 alc_inithook(codec);
12700 }
12701
12702 /*
12703 * configuration and preset
12704 */
12705 static const char * const alc262_models[ALC262_MODEL_LAST] = {
12706 [ALC262_BASIC] = "basic",
12707 [ALC262_HIPPO] = "hippo",
12708 [ALC262_HIPPO_1] = "hippo_1",
12709 [ALC262_FUJITSU] = "fujitsu",
12710 [ALC262_HP_BPC] = "hp-bpc",
12711 [ALC262_HP_BPC_D7000_WL]= "hp-bpc-d7000",
12712 [ALC262_HP_TC_T5735] = "hp-tc-t5735",
12713 [ALC262_HP_RP5700] = "hp-rp5700",
12714 [ALC262_BENQ_ED8] = "benq",
12715 [ALC262_BENQ_T31] = "benq-t31",
12716 [ALC262_SONY_ASSAMD] = "sony-assamd",
12717 [ALC262_TOSHIBA_S06] = "toshiba-s06",
12718 [ALC262_TOSHIBA_RX1] = "toshiba-rx1",
12719 [ALC262_ULTRA] = "ultra",
12720 [ALC262_LENOVO_3000] = "lenovo-3000",
12721 [ALC262_NEC] = "nec",
12722 [ALC262_TYAN] = "tyan",
12723 [ALC262_AUTO] = "auto",
12724 };
12725
12726 static const struct snd_pci_quirk alc262_cfg_tbl[] = {
12727 SND_PCI_QUIRK(0x1002, 0x437b, "Hippo", ALC262_HIPPO),
12728 SND_PCI_QUIRK(0x1033, 0x8895, "NEC Versa S9100", ALC262_NEC),
12729 SND_PCI_QUIRK_MASK(0x103c, 0xff00, 0x1200, "HP xw series",
12730 ALC262_HP_BPC),
12731 SND_PCI_QUIRK_MASK(0x103c, 0xff00, 0x1300, "HP xw series",
12732 ALC262_HP_BPC),
12733 SND_PCI_QUIRK_MASK(0x103c, 0xff00, 0x1500, "HP z series",
12734 ALC262_HP_BPC),
12735 SND_PCI_QUIRK_MASK(0x103c, 0xff00, 0x1700, "HP xw series",
12736 ALC262_HP_BPC),
12737 SND_PCI_QUIRK(0x103c, 0x2800, "HP D7000", ALC262_HP_BPC_D7000_WL),
12738 SND_PCI_QUIRK(0x103c, 0x2801, "HP D7000", ALC262_HP_BPC_D7000_WF),
12739 SND_PCI_QUIRK(0x103c, 0x2802, "HP D7000", ALC262_HP_BPC_D7000_WL),
12740 SND_PCI_QUIRK(0x103c, 0x2803, "HP D7000", ALC262_HP_BPC_D7000_WF),
12741 SND_PCI_QUIRK(0x103c, 0x2804, "HP D7000", ALC262_HP_BPC_D7000_WL),
12742 SND_PCI_QUIRK(0x103c, 0x2805, "HP D7000", ALC262_HP_BPC_D7000_WF),
12743 SND_PCI_QUIRK(0x103c, 0x2806, "HP D7000", ALC262_HP_BPC_D7000_WL),
12744 SND_PCI_QUIRK(0x103c, 0x2807, "HP D7000", ALC262_HP_BPC_D7000_WF),
12745 SND_PCI_QUIRK(0x103c, 0x280c, "HP xw4400", ALC262_HP_BPC),
12746 SND_PCI_QUIRK(0x103c, 0x3014, "HP xw6400", ALC262_HP_BPC),
12747 SND_PCI_QUIRK(0x103c, 0x3015, "HP xw8400", ALC262_HP_BPC),
12748 SND_PCI_QUIRK(0x103c, 0x302f, "HP Thin Client T5735",
12749 ALC262_HP_TC_T5735),
12750 SND_PCI_QUIRK(0x103c, 0x2817, "HP RP5700", ALC262_HP_RP5700),
12751 SND_PCI_QUIRK(0x104d, 0x1f00, "Sony ASSAMD", ALC262_SONY_ASSAMD),
12752 SND_PCI_QUIRK(0x104d, 0x8203, "Sony UX-90", ALC262_HIPPO),
12753 SND_PCI_QUIRK(0x104d, 0x820f, "Sony ASSAMD", ALC262_SONY_ASSAMD),
12754 SND_PCI_QUIRK(0x104d, 0x9016, "Sony VAIO", ALC262_AUTO), /* dig-only */
12755 SND_PCI_QUIRK(0x104d, 0x9025, "Sony VAIO Z21MN", ALC262_TOSHIBA_S06),
12756 SND_PCI_QUIRK(0x104d, 0x9035, "Sony VAIO VGN-FW170J", ALC262_AUTO),
12757 SND_PCI_QUIRK(0x104d, 0x9047, "Sony VAIO Type G", ALC262_AUTO),
12758 #if 0 /* disable the quirk since model=auto works better in recent versions */
12759 SND_PCI_QUIRK_MASK(0x104d, 0xff00, 0x9000, "Sony VAIO",
12760 ALC262_SONY_ASSAMD),
12761 #endif
12762 SND_PCI_QUIRK(0x1179, 0x0001, "Toshiba dynabook SS RX1",
12763 ALC262_TOSHIBA_RX1),
12764 SND_PCI_QUIRK(0x1179, 0xff7b, "Toshiba S06", ALC262_TOSHIBA_S06),
12765 SND_PCI_QUIRK(0x10cf, 0x1397, "Fujitsu", ALC262_FUJITSU),
12766 SND_PCI_QUIRK(0x10cf, 0x142d, "Fujitsu Lifebook E8410", ALC262_FUJITSU),
12767 SND_PCI_QUIRK(0x10f1, 0x2915, "Tyan Thunder n6650W", ALC262_TYAN),
12768 SND_PCI_QUIRK_MASK(0x144d, 0xff00, 0xc032, "Samsung Q1",
12769 ALC262_ULTRA),
12770 SND_PCI_QUIRK(0x144d, 0xc510, "Samsung Q45", ALC262_HIPPO),
12771 SND_PCI_QUIRK(0x17aa, 0x384e, "Lenovo 3000 y410", ALC262_LENOVO_3000),
12772 SND_PCI_QUIRK(0x17ff, 0x0560, "Benq ED8", ALC262_BENQ_ED8),
12773 SND_PCI_QUIRK(0x17ff, 0x058d, "Benq T31-16", ALC262_BENQ_T31),
12774 SND_PCI_QUIRK(0x17ff, 0x058f, "Benq Hippo", ALC262_HIPPO_1),
12775 {}
12776 };
12777
12778 static const struct alc_config_preset alc262_presets[] = {
12779 [ALC262_BASIC] = {
12780 .mixers = { alc262_base_mixer },
12781 .init_verbs = { alc262_init_verbs },
12782 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12783 .dac_nids = alc262_dac_nids,
12784 .hp_nid = 0x03,
12785 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12786 .channel_mode = alc262_modes,
12787 .input_mux = &alc262_capture_source,
12788 },
12789 [ALC262_HIPPO] = {
12790 .mixers = { alc262_hippo_mixer },
12791 .init_verbs = { alc262_init_verbs, alc_hp15_unsol_verbs},
12792 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12793 .dac_nids = alc262_dac_nids,
12794 .hp_nid = 0x03,
12795 .dig_out_nid = ALC262_DIGOUT_NID,
12796 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12797 .channel_mode = alc262_modes,
12798 .input_mux = &alc262_capture_source,
12799 .unsol_event = alc_sku_unsol_event,
12800 .setup = alc262_hippo_setup,
12801 .init_hook = alc_inithook,
12802 },
12803 [ALC262_HIPPO_1] = {
12804 .mixers = { alc262_hippo1_mixer },
12805 .init_verbs = { alc262_init_verbs, alc262_hippo1_unsol_verbs},
12806 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12807 .dac_nids = alc262_dac_nids,
12808 .hp_nid = 0x02,
12809 .dig_out_nid = ALC262_DIGOUT_NID,
12810 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12811 .channel_mode = alc262_modes,
12812 .input_mux = &alc262_capture_source,
12813 .unsol_event = alc_sku_unsol_event,
12814 .setup = alc262_hippo1_setup,
12815 .init_hook = alc_inithook,
12816 },
12817 [ALC262_FUJITSU] = {
12818 .mixers = { alc262_fujitsu_mixer },
12819 .init_verbs = { alc262_init_verbs, alc262_EAPD_verbs,
12820 alc262_fujitsu_unsol_verbs },
12821 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12822 .dac_nids = alc262_dac_nids,
12823 .hp_nid = 0x03,
12824 .dig_out_nid = ALC262_DIGOUT_NID,
12825 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12826 .channel_mode = alc262_modes,
12827 .input_mux = &alc262_fujitsu_capture_source,
12828 .unsol_event = alc_sku_unsol_event,
12829 .setup = alc262_fujitsu_setup,
12830 .init_hook = alc_inithook,
12831 },
12832 [ALC262_HP_BPC] = {
12833 .mixers = { alc262_HP_BPC_mixer },
12834 .init_verbs = { alc262_HP_BPC_init_verbs },
12835 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12836 .dac_nids = alc262_dac_nids,
12837 .hp_nid = 0x03,
12838 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12839 .channel_mode = alc262_modes,
12840 .input_mux = &alc262_HP_capture_source,
12841 .unsol_event = alc_sku_unsol_event,
12842 .setup = alc262_hp_bpc_setup,
12843 .init_hook = alc_inithook,
12844 },
12845 [ALC262_HP_BPC_D7000_WF] = {
12846 .mixers = { alc262_HP_BPC_WildWest_mixer },
12847 .init_verbs = { alc262_HP_BPC_WildWest_init_verbs },
12848 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12849 .dac_nids = alc262_dac_nids,
12850 .hp_nid = 0x03,
12851 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12852 .channel_mode = alc262_modes,
12853 .input_mux = &alc262_HP_D7000_capture_source,
12854 .unsol_event = alc_sku_unsol_event,
12855 .setup = alc262_hp_wildwest_setup,
12856 .init_hook = alc_inithook,
12857 },
12858 [ALC262_HP_BPC_D7000_WL] = {
12859 .mixers = { alc262_HP_BPC_WildWest_mixer,
12860 alc262_HP_BPC_WildWest_option_mixer },
12861 .init_verbs = { alc262_HP_BPC_WildWest_init_verbs },
12862 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12863 .dac_nids = alc262_dac_nids,
12864 .hp_nid = 0x03,
12865 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12866 .channel_mode = alc262_modes,
12867 .input_mux = &alc262_HP_D7000_capture_source,
12868 .unsol_event = alc_sku_unsol_event,
12869 .setup = alc262_hp_wildwest_setup,
12870 .init_hook = alc_inithook,
12871 },
12872 [ALC262_HP_TC_T5735] = {
12873 .mixers = { alc262_hp_t5735_mixer },
12874 .init_verbs = { alc262_init_verbs, alc262_hp_t5735_verbs },
12875 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12876 .dac_nids = alc262_dac_nids,
12877 .hp_nid = 0x03,
12878 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12879 .channel_mode = alc262_modes,
12880 .input_mux = &alc262_capture_source,
12881 .unsol_event = alc_sku_unsol_event,
12882 .setup = alc262_hp_t5735_setup,
12883 .init_hook = alc_inithook,
12884 },
12885 [ALC262_HP_RP5700] = {
12886 .mixers = { alc262_hp_rp5700_mixer },
12887 .init_verbs = { alc262_init_verbs, alc262_hp_rp5700_verbs },
12888 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12889 .dac_nids = alc262_dac_nids,
12890 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12891 .channel_mode = alc262_modes,
12892 .input_mux = &alc262_hp_rp5700_capture_source,
12893 },
12894 [ALC262_BENQ_ED8] = {
12895 .mixers = { alc262_base_mixer },
12896 .init_verbs = { alc262_init_verbs, alc262_EAPD_verbs },
12897 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12898 .dac_nids = alc262_dac_nids,
12899 .hp_nid = 0x03,
12900 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12901 .channel_mode = alc262_modes,
12902 .input_mux = &alc262_capture_source,
12903 },
12904 [ALC262_SONY_ASSAMD] = {
12905 .mixers = { alc262_sony_mixer },
12906 .init_verbs = { alc262_init_verbs, alc262_sony_unsol_verbs},
12907 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12908 .dac_nids = alc262_dac_nids,
12909 .hp_nid = 0x02,
12910 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12911 .channel_mode = alc262_modes,
12912 .input_mux = &alc262_capture_source,
12913 .unsol_event = alc_sku_unsol_event,
12914 .setup = alc262_hippo_setup,
12915 .init_hook = alc_inithook,
12916 },
12917 [ALC262_BENQ_T31] = {
12918 .mixers = { alc262_benq_t31_mixer },
12919 .init_verbs = { alc262_init_verbs, alc262_benq_t31_EAPD_verbs,
12920 alc_hp15_unsol_verbs },
12921 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12922 .dac_nids = alc262_dac_nids,
12923 .hp_nid = 0x03,
12924 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12925 .channel_mode = alc262_modes,
12926 .input_mux = &alc262_capture_source,
12927 .unsol_event = alc_sku_unsol_event,
12928 .setup = alc262_hippo_setup,
12929 .init_hook = alc_inithook,
12930 },
12931 [ALC262_ULTRA] = {
12932 .mixers = { alc262_ultra_mixer },
12933 .cap_mixer = alc262_ultra_capture_mixer,
12934 .init_verbs = { alc262_ultra_verbs },
12935 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12936 .dac_nids = alc262_dac_nids,
12937 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12938 .channel_mode = alc262_modes,
12939 .input_mux = &alc262_ultra_capture_source,
12940 .adc_nids = alc262_adc_nids, /* ADC0 */
12941 .capsrc_nids = alc262_capsrc_nids,
12942 .num_adc_nids = 1, /* single ADC */
12943 .unsol_event = alc262_ultra_unsol_event,
12944 .init_hook = alc262_ultra_automute,
12945 },
12946 [ALC262_LENOVO_3000] = {
12947 .mixers = { alc262_lenovo_3000_mixer },
12948 .init_verbs = { alc262_init_verbs, alc262_EAPD_verbs,
12949 alc262_lenovo_3000_unsol_verbs,
12950 alc262_lenovo_3000_init_verbs },
12951 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12952 .dac_nids = alc262_dac_nids,
12953 .hp_nid = 0x03,
12954 .dig_out_nid = ALC262_DIGOUT_NID,
12955 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12956 .channel_mode = alc262_modes,
12957 .input_mux = &alc262_fujitsu_capture_source,
12958 .unsol_event = alc_sku_unsol_event,
12959 .setup = alc262_lenovo_3000_setup,
12960 .init_hook = alc_inithook,
12961 },
12962 [ALC262_NEC] = {
12963 .mixers = { alc262_nec_mixer },
12964 .init_verbs = { alc262_nec_verbs },
12965 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12966 .dac_nids = alc262_dac_nids,
12967 .hp_nid = 0x03,
12968 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12969 .channel_mode = alc262_modes,
12970 .input_mux = &alc262_capture_source,
12971 },
12972 [ALC262_TOSHIBA_S06] = {
12973 .mixers = { alc262_toshiba_s06_mixer },
12974 .init_verbs = { alc262_init_verbs, alc262_toshiba_s06_verbs,
12975 alc262_eapd_verbs },
12976 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12977 .capsrc_nids = alc262_dmic_capsrc_nids,
12978 .dac_nids = alc262_dac_nids,
12979 .adc_nids = alc262_dmic_adc_nids, /* ADC0 */
12980 .num_adc_nids = 1, /* single ADC */
12981 .dig_out_nid = ALC262_DIGOUT_NID,
12982 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12983 .channel_mode = alc262_modes,
12984 .unsol_event = alc_sku_unsol_event,
12985 .setup = alc262_toshiba_s06_setup,
12986 .init_hook = alc_inithook,
12987 },
12988 [ALC262_TOSHIBA_RX1] = {
12989 .mixers = { alc262_toshiba_rx1_mixer },
12990 .init_verbs = { alc262_init_verbs, alc262_toshiba_rx1_unsol_verbs },
12991 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12992 .dac_nids = alc262_dac_nids,
12993 .hp_nid = 0x03,
12994 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12995 .channel_mode = alc262_modes,
12996 .input_mux = &alc262_capture_source,
12997 .unsol_event = alc_sku_unsol_event,
12998 .setup = alc262_hippo_setup,
12999 .init_hook = alc_inithook,
13000 },
13001 [ALC262_TYAN] = {
13002 .mixers = { alc262_tyan_mixer },
13003 .init_verbs = { alc262_init_verbs, alc262_tyan_verbs},
13004 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
13005 .dac_nids = alc262_dac_nids,
13006 .hp_nid = 0x02,
13007 .dig_out_nid = ALC262_DIGOUT_NID,
13008 .num_channel_mode = ARRAY_SIZE(alc262_modes),
13009 .channel_mode = alc262_modes,
13010 .input_mux = &alc262_capture_source,
13011 .unsol_event = alc_sku_unsol_event,
13012 .setup = alc262_tyan_setup,
13013 .init_hook = alc_hp_automute,
13014 },
13015 };
13016
13017 static int patch_alc262(struct hda_codec *codec)
13018 {
13019 struct alc_spec *spec;
13020 int board_config;
13021 int err;
13022
13023 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
13024 if (spec == NULL)
13025 return -ENOMEM;
13026
13027 codec->spec = spec;
13028 #if 0
13029 /* pshou 07/11/05 set a zero PCM sample to DAC when FIFO is
13030 * under-run
13031 */
13032 {
13033 int tmp;
13034 snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_COEF_INDEX, 7);
13035 tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0);
13036 snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_COEF_INDEX, 7);
13037 snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_PROC_COEF, tmp | 0x80);
13038 }
13039 #endif
13040 alc_auto_parse_customize_define(codec);
13041
13042 alc_fix_pll_init(codec, 0x20, 0x0a, 10);
13043
13044 board_config = snd_hda_check_board_config(codec, ALC262_MODEL_LAST,
13045 alc262_models,
13046 alc262_cfg_tbl);
13047
13048 if (board_config < 0) {
13049 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
13050 codec->chip_name);
13051 board_config = ALC262_AUTO;
13052 }
13053
13054 if (board_config == ALC262_AUTO) {
13055 alc_pick_fixup(codec, NULL, alc262_fixup_tbl, alc262_fixups);
13056 alc_apply_fixup(codec, ALC_FIXUP_ACT_PRE_PROBE);
13057 }
13058
13059 if (board_config == ALC262_AUTO) {
13060 /* automatic parse from the BIOS config */
13061 err = alc262_parse_auto_config(codec);
13062 if (err < 0) {
13063 alc_free(codec);
13064 return err;
13065 } else if (!err) {
13066 printk(KERN_INFO
13067 "hda_codec: Cannot set up configuration "
13068 "from BIOS. Using base mode...\n");
13069 board_config = ALC262_BASIC;
13070 }
13071 }
13072
13073 if (!spec->no_analog && has_cdefine_beep(codec)) {
13074 err = snd_hda_attach_beep_device(codec, 0x1);
13075 if (err < 0) {
13076 alc_free(codec);
13077 return err;
13078 }
13079 }
13080
13081 if (board_config != ALC262_AUTO)
13082 setup_preset(codec, &alc262_presets[board_config]);
13083
13084 spec->stream_analog_playback = &alc262_pcm_analog_playback;
13085 spec->stream_analog_capture = &alc262_pcm_analog_capture;
13086
13087 spec->stream_digital_playback = &alc262_pcm_digital_playback;
13088 spec->stream_digital_capture = &alc262_pcm_digital_capture;
13089
13090 if (!spec->adc_nids && spec->input_mux) {
13091 int i;
13092 /* check whether the digital-mic has to be supported */
13093 for (i = 0; i < spec->input_mux->num_items; i++) {
13094 if (spec->input_mux->items[i].index >= 9)
13095 break;
13096 }
13097 if (i < spec->input_mux->num_items) {
13098 /* use only ADC0 */
13099 spec->adc_nids = alc262_dmic_adc_nids;
13100 spec->num_adc_nids = 1;
13101 spec->capsrc_nids = alc262_dmic_capsrc_nids;
13102 } else {
13103 /* all analog inputs */
13104 /* check whether NID 0x07 is valid */
13105 unsigned int wcap = get_wcaps(codec, 0x07);
13106
13107 /* get type */
13108 wcap = get_wcaps_type(wcap);
13109 if (wcap != AC_WID_AUD_IN) {
13110 spec->adc_nids = alc262_adc_nids_alt;
13111 spec->num_adc_nids =
13112 ARRAY_SIZE(alc262_adc_nids_alt);
13113 spec->capsrc_nids = alc262_capsrc_nids_alt;
13114 } else {
13115 spec->adc_nids = alc262_adc_nids;
13116 spec->num_adc_nids =
13117 ARRAY_SIZE(alc262_adc_nids);
13118 spec->capsrc_nids = alc262_capsrc_nids;
13119 }
13120 }
13121 }
13122 if (!spec->cap_mixer && !spec->no_analog)
13123 set_capture_mixer(codec);
13124 if (!spec->no_analog && has_cdefine_beep(codec))
13125 set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
13126
13127 alc_apply_fixup(codec, ALC_FIXUP_ACT_PROBE);
13128
13129 spec->vmaster_nid = 0x0c;
13130
13131 codec->patch_ops = alc_patch_ops;
13132 if (board_config == ALC262_AUTO)
13133 spec->init_hook = alc262_auto_init;
13134 spec->shutup = alc_eapd_shutup;
13135
13136 alc_init_jacks(codec);
13137 #ifdef CONFIG_SND_HDA_POWER_SAVE
13138 if (!spec->loopback.amplist)
13139 spec->loopback.amplist = alc262_loopbacks;
13140 #endif
13141
13142 return 0;
13143 }
13144
13145 /*
13146 * ALC268 channel source setting (2 channel)
13147 */
13148 #define ALC268_DIGOUT_NID ALC880_DIGOUT_NID
13149 #define alc268_modes alc260_modes
13150
13151 static const hda_nid_t alc268_dac_nids[2] = {
13152 /* front, hp */
13153 0x02, 0x03
13154 };
13155
13156 static const hda_nid_t alc268_adc_nids[2] = {
13157 /* ADC0-1 */
13158 0x08, 0x07
13159 };
13160
13161 static const hda_nid_t alc268_adc_nids_alt[1] = {
13162 /* ADC0 */
13163 0x08
13164 };
13165
13166 static const hda_nid_t alc268_capsrc_nids[2] = { 0x23, 0x24 };
13167
13168 static const struct snd_kcontrol_new alc268_base_mixer[] = {
13169 /* output mixer control */
13170 HDA_CODEC_VOLUME("Front Playback Volume", 0x2, 0x0, HDA_OUTPUT),
13171 HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
13172 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x3, 0x0, HDA_OUTPUT),
13173 HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
13174 HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
13175 HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x19, 0, HDA_INPUT),
13176 HDA_CODEC_VOLUME("Line In Boost Volume", 0x1a, 0, HDA_INPUT),
13177 { }
13178 };
13179
13180 static const struct snd_kcontrol_new alc268_toshiba_mixer[] = {
13181 /* output mixer control */
13182 HDA_CODEC_VOLUME("Front Playback Volume", 0x2, 0x0, HDA_OUTPUT),
13183 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x3, 0x0, HDA_OUTPUT),
13184 ALC262_HIPPO_MASTER_SWITCH,
13185 HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
13186 HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x19, 0, HDA_INPUT),
13187 HDA_CODEC_VOLUME("Line In Boost Volume", 0x1a, 0, HDA_INPUT),
13188 { }
13189 };
13190
13191 /* bind Beep switches of both NID 0x0f and 0x10 */
13192 static const struct hda_bind_ctls alc268_bind_beep_sw = {
13193 .ops = &snd_hda_bind_sw,
13194 .values = {
13195 HDA_COMPOSE_AMP_VAL(0x0f, 3, 1, HDA_INPUT),
13196 HDA_COMPOSE_AMP_VAL(0x10, 3, 1, HDA_INPUT),
13197 0
13198 },
13199 };
13200
13201 static const struct snd_kcontrol_new alc268_beep_mixer[] = {
13202 HDA_CODEC_VOLUME("Beep Playback Volume", 0x1d, 0x0, HDA_INPUT),
13203 HDA_BIND_SW("Beep Playback Switch", &alc268_bind_beep_sw),
13204 { }
13205 };
13206
13207 static const struct hda_verb alc268_eapd_verbs[] = {
13208 {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
13209 {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
13210 { }
13211 };
13212
13213 /* Toshiba specific */
13214 static const struct hda_verb alc268_toshiba_verbs[] = {
13215 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
13216 { } /* end */
13217 };
13218
13219 /* Acer specific */
13220 /* bind volumes of both NID 0x02 and 0x03 */
13221 static const struct hda_bind_ctls alc268_acer_bind_master_vol = {
13222 .ops = &snd_hda_bind_vol,
13223 .values = {
13224 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT),
13225 HDA_COMPOSE_AMP_VAL(0x03, 3, 0, HDA_OUTPUT),
13226 0
13227 },
13228 };
13229
13230 static void alc268_acer_setup(struct hda_codec *codec)
13231 {
13232 struct alc_spec *spec = codec->spec;
13233
13234 spec->autocfg.hp_pins[0] = 0x14;
13235 spec->autocfg.speaker_pins[0] = 0x15;
13236 spec->automute = 1;
13237 spec->automute_mode = ALC_AUTOMUTE_AMP;
13238 }
13239
13240 #define alc268_acer_master_sw_get alc262_hp_master_sw_get
13241 #define alc268_acer_master_sw_put alc262_hp_master_sw_put
13242
13243 static const struct snd_kcontrol_new alc268_acer_aspire_one_mixer[] = {
13244 /* output mixer control */
13245 HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
13246 {
13247 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
13248 .name = "Master Playback Switch",
13249 .subdevice = HDA_SUBDEV_NID_FLAG | 0x15,
13250 .info = snd_ctl_boolean_mono_info,
13251 .get = alc268_acer_master_sw_get,
13252 .put = alc268_acer_master_sw_put,
13253 },
13254 HDA_CODEC_VOLUME("Mic Boost Capture Volume", 0x18, 0, HDA_INPUT),
13255 { }
13256 };
13257
13258 static const struct snd_kcontrol_new alc268_acer_mixer[] = {
13259 /* output mixer control */
13260 HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
13261 {
13262 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
13263 .name = "Master Playback Switch",
13264 .subdevice = HDA_SUBDEV_NID_FLAG | 0x14,
13265 .info = snd_ctl_boolean_mono_info,
13266 .get = alc268_acer_master_sw_get,
13267 .put = alc268_acer_master_sw_put,
13268 },
13269 HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
13270 HDA_CODEC_VOLUME("Internal Mic Boost Volume", 0x19, 0, HDA_INPUT),
13271 HDA_CODEC_VOLUME("Line In Boost Volume", 0x1a, 0, HDA_INPUT),
13272 { }
13273 };
13274
13275 static const struct snd_kcontrol_new alc268_acer_dmic_mixer[] = {
13276 /* output mixer control */
13277 HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
13278 {
13279 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
13280 .name = "Master Playback Switch",
13281 .subdevice = HDA_SUBDEV_NID_FLAG | 0x14,
13282 .info = snd_ctl_boolean_mono_info,
13283 .get = alc268_acer_master_sw_get,
13284 .put = alc268_acer_master_sw_put,
13285 },
13286 HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
13287 HDA_CODEC_VOLUME("Line In Boost Volume", 0x1a, 0, HDA_INPUT),
13288 { }
13289 };
13290
13291 static const struct hda_verb alc268_acer_aspire_one_verbs[] = {
13292 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
13293 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
13294 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
13295 {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
13296 {0x23, AC_VERB_SET_CONNECT_SEL, 0x06},
13297 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, 0xa017},
13298 { }
13299 };
13300
13301 static const struct hda_verb alc268_acer_verbs[] = {
13302 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, /* internal dmic? */
13303 {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
13304 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
13305 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
13306 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
13307 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
13308 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
13309 { }
13310 };
13311
13312 /* unsolicited event for HP jack sensing */
13313 #define alc268_toshiba_setup alc262_hippo_setup
13314
13315 static void alc268_acer_lc_setup(struct hda_codec *codec)
13316 {
13317 struct alc_spec *spec = codec->spec;
13318 spec->autocfg.hp_pins[0] = 0x15;
13319 spec->autocfg.speaker_pins[0] = 0x14;
13320 spec->automute = 1;
13321 spec->automute_mode = ALC_AUTOMUTE_AMP;
13322 spec->ext_mic.pin = 0x18;
13323 spec->ext_mic.mux_idx = 0;
13324 spec->int_mic.pin = 0x12;
13325 spec->int_mic.mux_idx = 6;
13326 spec->auto_mic = 1;
13327 }
13328
13329 static const struct snd_kcontrol_new alc268_dell_mixer[] = {
13330 /* output mixer control */
13331 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
13332 HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
13333 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
13334 HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
13335 HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
13336 HDA_CODEC_VOLUME("Internal Mic Boost Volume", 0x19, 0, HDA_INPUT),
13337 { }
13338 };
13339
13340 static const struct hda_verb alc268_dell_verbs[] = {
13341 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
13342 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
13343 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
13344 {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN},
13345 { }
13346 };
13347
13348 /* mute/unmute internal speaker according to the hp jack and mute state */
13349 static void alc268_dell_setup(struct hda_codec *codec)
13350 {
13351 struct alc_spec *spec = codec->spec;
13352
13353 spec->autocfg.hp_pins[0] = 0x15;
13354 spec->autocfg.speaker_pins[0] = 0x14;
13355 spec->ext_mic.pin = 0x18;
13356 spec->ext_mic.mux_idx = 0;
13357 spec->int_mic.pin = 0x19;
13358 spec->int_mic.mux_idx = 1;
13359 spec->auto_mic = 1;
13360 spec->automute = 1;
13361 spec->automute_mode = ALC_AUTOMUTE_PIN;
13362 }
13363
13364 static const struct snd_kcontrol_new alc267_quanta_il1_mixer[] = {
13365 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x2, 0x0, HDA_OUTPUT),
13366 HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
13367 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x3, 0x0, HDA_OUTPUT),
13368 HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
13369 HDA_CODEC_VOLUME("Mic Capture Volume", 0x23, 0x0, HDA_OUTPUT),
13370 HDA_BIND_MUTE("Mic Capture Switch", 0x23, 2, HDA_OUTPUT),
13371 HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
13372 HDA_CODEC_VOLUME("Internal Mic Boost Volume", 0x19, 0, HDA_INPUT),
13373 { }
13374 };
13375
13376 static const struct hda_verb alc267_quanta_il1_verbs[] = {
13377 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
13378 {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN},
13379 { }
13380 };
13381
13382 static void alc267_quanta_il1_setup(struct hda_codec *codec)
13383 {
13384 struct alc_spec *spec = codec->spec;
13385 spec->autocfg.hp_pins[0] = 0x15;
13386 spec->autocfg.speaker_pins[0] = 0x14;
13387 spec->ext_mic.pin = 0x18;
13388 spec->ext_mic.mux_idx = 0;
13389 spec->int_mic.pin = 0x19;
13390 spec->int_mic.mux_idx = 1;
13391 spec->auto_mic = 1;
13392 spec->automute = 1;
13393 spec->automute_mode = ALC_AUTOMUTE_PIN;
13394 }
13395
13396 /*
13397 * generic initialization of ADC, input mixers and output mixers
13398 */
13399 static const struct hda_verb alc268_base_init_verbs[] = {
13400 /* Unmute DAC0-1 and set vol = 0 */
13401 {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
13402 {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
13403
13404 /*
13405 * Set up output mixers (0x0c - 0x0e)
13406 */
13407 /* set vol=0 to output mixers */
13408 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13409 {0x0e, AC_VERB_SET_CONNECT_SEL, 0x00},
13410
13411 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13412 {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13413
13414 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
13415 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
13416 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
13417 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
13418 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
13419 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
13420 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
13421 {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
13422
13423 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13424 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13425 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13426 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13427 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13428
13429 /* set PCBEEP vol = 0, mute connections */
13430 {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13431 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
13432 {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
13433
13434 /* Unmute Selector 23h,24h and set the default input to mic-in */
13435
13436 {0x23, AC_VERB_SET_CONNECT_SEL, 0x00},
13437 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13438 {0x24, AC_VERB_SET_CONNECT_SEL, 0x00},
13439 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13440
13441 { }
13442 };
13443
13444 /*
13445 * generic initialization of ADC, input mixers and output mixers
13446 */
13447 static const struct hda_verb alc268_volume_init_verbs[] = {
13448 /* set output DAC */
13449 {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
13450 {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
13451
13452 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
13453 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
13454 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
13455 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
13456 {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
13457
13458 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13459 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13460 {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13461
13462 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13463 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13464
13465 /* set PCBEEP vol = 0, mute connections */
13466 {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13467 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
13468 {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
13469
13470 { }
13471 };
13472
13473 static const struct snd_kcontrol_new alc268_capture_nosrc_mixer[] = {
13474 HDA_CODEC_VOLUME("Capture Volume", 0x23, 0x0, HDA_OUTPUT),
13475 HDA_CODEC_MUTE("Capture Switch", 0x23, 0x0, HDA_OUTPUT),
13476 { } /* end */
13477 };
13478
13479 static const struct snd_kcontrol_new alc268_capture_alt_mixer[] = {
13480 HDA_CODEC_VOLUME("Capture Volume", 0x23, 0x0, HDA_OUTPUT),
13481 HDA_CODEC_MUTE("Capture Switch", 0x23, 0x0, HDA_OUTPUT),
13482 _DEFINE_CAPSRC(1),
13483 { } /* end */
13484 };
13485
13486 static const struct snd_kcontrol_new alc268_capture_mixer[] = {
13487 HDA_CODEC_VOLUME("Capture Volume", 0x23, 0x0, HDA_OUTPUT),
13488 HDA_CODEC_MUTE("Capture Switch", 0x23, 0x0, HDA_OUTPUT),
13489 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x24, 0x0, HDA_OUTPUT),
13490 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x24, 0x0, HDA_OUTPUT),
13491 _DEFINE_CAPSRC(2),
13492 { } /* end */
13493 };
13494
13495 static const struct hda_input_mux alc268_capture_source = {
13496 .num_items = 4,
13497 .items = {
13498 { "Mic", 0x0 },
13499 { "Front Mic", 0x1 },
13500 { "Line", 0x2 },
13501 { "CD", 0x3 },
13502 },
13503 };
13504
13505 static const struct hda_input_mux alc268_acer_capture_source = {
13506 .num_items = 3,
13507 .items = {
13508 { "Mic", 0x0 },
13509 { "Internal Mic", 0x1 },
13510 { "Line", 0x2 },
13511 },
13512 };
13513
13514 static const struct hda_input_mux alc268_acer_dmic_capture_source = {
13515 .num_items = 3,
13516 .items = {
13517 { "Mic", 0x0 },
13518 { "Internal Mic", 0x6 },
13519 { "Line", 0x2 },
13520 },
13521 };
13522
13523 #ifdef CONFIG_SND_DEBUG
13524 static const struct snd_kcontrol_new alc268_test_mixer[] = {
13525 /* Volume widgets */
13526 HDA_CODEC_VOLUME("LOUT1 Playback Volume", 0x02, 0x0, HDA_OUTPUT),
13527 HDA_CODEC_VOLUME("LOUT2 Playback Volume", 0x03, 0x0, HDA_OUTPUT),
13528 HDA_BIND_MUTE_MONO("Mono sum Playback Switch", 0x0e, 1, 2, HDA_INPUT),
13529 HDA_BIND_MUTE("LINE-OUT sum Playback Switch", 0x0f, 2, HDA_INPUT),
13530 HDA_BIND_MUTE("HP-OUT sum Playback Switch", 0x10, 2, HDA_INPUT),
13531 HDA_BIND_MUTE("LINE-OUT Playback Switch", 0x14, 2, HDA_OUTPUT),
13532 HDA_BIND_MUTE("HP-OUT Playback Switch", 0x15, 2, HDA_OUTPUT),
13533 HDA_BIND_MUTE("Mono Playback Switch", 0x16, 2, HDA_OUTPUT),
13534 HDA_CODEC_VOLUME("MIC1 Capture Volume", 0x18, 0x0, HDA_INPUT),
13535 HDA_BIND_MUTE("MIC1 Capture Switch", 0x18, 2, HDA_OUTPUT),
13536 HDA_CODEC_VOLUME("MIC2 Capture Volume", 0x19, 0x0, HDA_INPUT),
13537 HDA_CODEC_VOLUME("LINE1 Capture Volume", 0x1a, 0x0, HDA_INPUT),
13538 HDA_BIND_MUTE("LINE1 Capture Switch", 0x1a, 2, HDA_OUTPUT),
13539 /* The below appears problematic on some hardwares */
13540 /*HDA_CODEC_VOLUME("PCBEEP Playback Volume", 0x1d, 0x0, HDA_INPUT),*/
13541 HDA_CODEC_VOLUME("PCM-IN1 Capture Volume", 0x23, 0x0, HDA_OUTPUT),
13542 HDA_BIND_MUTE("PCM-IN1 Capture Switch", 0x23, 2, HDA_OUTPUT),
13543 HDA_CODEC_VOLUME("PCM-IN2 Capture Volume", 0x24, 0x0, HDA_OUTPUT),
13544 HDA_BIND_MUTE("PCM-IN2 Capture Switch", 0x24, 2, HDA_OUTPUT),
13545
13546 /* Modes for retasking pin widgets */
13547 ALC_PIN_MODE("LINE-OUT pin mode", 0x14, ALC_PIN_DIR_INOUT),
13548 ALC_PIN_MODE("HP-OUT pin mode", 0x15, ALC_PIN_DIR_INOUT),
13549 ALC_PIN_MODE("MIC1 pin mode", 0x18, ALC_PIN_DIR_INOUT),
13550 ALC_PIN_MODE("LINE1 pin mode", 0x1a, ALC_PIN_DIR_INOUT),
13551
13552 /* Controls for GPIO pins, assuming they are configured as outputs */
13553 ALC_GPIO_DATA_SWITCH("GPIO pin 0", 0x01, 0x01),
13554 ALC_GPIO_DATA_SWITCH("GPIO pin 1", 0x01, 0x02),
13555 ALC_GPIO_DATA_SWITCH("GPIO pin 2", 0x01, 0x04),
13556 ALC_GPIO_DATA_SWITCH("GPIO pin 3", 0x01, 0x08),
13557
13558 /* Switches to allow the digital SPDIF output pin to be enabled.
13559 * The ALC268 does not have an SPDIF input.
13560 */
13561 ALC_SPDIF_CTRL_SWITCH("SPDIF Playback Switch", 0x06, 0x01),
13562
13563 /* A switch allowing EAPD to be enabled. Some laptops seem to use
13564 * this output to turn on an external amplifier.
13565 */
13566 ALC_EAPD_CTRL_SWITCH("LINE-OUT EAPD Enable Switch", 0x0f, 0x02),
13567 ALC_EAPD_CTRL_SWITCH("HP-OUT EAPD Enable Switch", 0x10, 0x02),
13568
13569 { } /* end */
13570 };
13571 #endif
13572
13573 /* create input playback/capture controls for the given pin */
13574 static int alc268_new_analog_output(struct alc_spec *spec, hda_nid_t nid,
13575 const char *ctlname, int idx)
13576 {
13577 hda_nid_t dac;
13578 int err;
13579
13580 switch (nid) {
13581 case 0x14:
13582 case 0x16:
13583 dac = 0x02;
13584 break;
13585 case 0x15:
13586 case 0x1a: /* ALC259/269 only */
13587 case 0x1b: /* ALC259/269 only */
13588 case 0x21: /* ALC269vb has this pin, too */
13589 dac = 0x03;
13590 break;
13591 default:
13592 snd_printd(KERN_WARNING "hda_codec: "
13593 "ignoring pin 0x%x as unknown\n", nid);
13594 return 0;
13595 }
13596 if (spec->multiout.dac_nids[0] != dac &&
13597 spec->multiout.dac_nids[1] != dac) {
13598 err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, ctlname,
13599 HDA_COMPOSE_AMP_VAL(dac, 3, idx,
13600 HDA_OUTPUT));
13601 if (err < 0)
13602 return err;
13603 spec->private_dac_nids[spec->multiout.num_dacs++] = dac;
13604 }
13605
13606 if (nid != 0x16)
13607 err = add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, ctlname,
13608 HDA_COMPOSE_AMP_VAL(nid, 3, idx, HDA_OUTPUT));
13609 else /* mono */
13610 err = add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, ctlname,
13611 HDA_COMPOSE_AMP_VAL(nid, 2, idx, HDA_OUTPUT));
13612 if (err < 0)
13613 return err;
13614 return 0;
13615 }
13616
13617 /* add playback controls from the parsed DAC table */
13618 static int alc268_auto_create_multi_out_ctls(struct alc_spec *spec,
13619 const struct auto_pin_cfg *cfg)
13620 {
13621 hda_nid_t nid;
13622 int err;
13623
13624 spec->multiout.dac_nids = spec->private_dac_nids;
13625
13626 nid = cfg->line_out_pins[0];
13627 if (nid) {
13628 const char *name;
13629 if (cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
13630 name = "Speaker";
13631 else
13632 name = "Front";
13633 err = alc268_new_analog_output(spec, nid, name, 0);
13634 if (err < 0)
13635 return err;
13636 }
13637
13638 nid = cfg->speaker_pins[0];
13639 if (nid == 0x1d) {
13640 err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, "Speaker",
13641 HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT));
13642 if (err < 0)
13643 return err;
13644 } else if (nid) {
13645 err = alc268_new_analog_output(spec, nid, "Speaker", 0);
13646 if (err < 0)
13647 return err;
13648 }
13649 nid = cfg->hp_pins[0];
13650 if (nid) {
13651 err = alc268_new_analog_output(spec, nid, "Headphone", 0);
13652 if (err < 0)
13653 return err;
13654 }
13655
13656 nid = cfg->line_out_pins[1] | cfg->line_out_pins[2];
13657 if (nid == 0x16) {
13658 err = add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, "Mono",
13659 HDA_COMPOSE_AMP_VAL(nid, 2, 0, HDA_OUTPUT));
13660 if (err < 0)
13661 return err;
13662 }
13663 return 0;
13664 }
13665
13666 /* create playback/capture controls for input pins */
13667 static int alc268_auto_create_input_ctls(struct hda_codec *codec,
13668 const struct auto_pin_cfg *cfg)
13669 {
13670 return alc_auto_create_input_ctls(codec, cfg, 0, 0x23, 0x24);
13671 }
13672
13673 static void alc268_auto_set_output_and_unmute(struct hda_codec *codec,
13674 hda_nid_t nid, int pin_type)
13675 {
13676 int idx;
13677
13678 alc_set_pin_output(codec, nid, pin_type);
13679 if (nid == 0x14 || nid == 0x16)
13680 idx = 0;
13681 else
13682 idx = 1;
13683 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CONNECT_SEL, idx);
13684 }
13685
13686 static void alc268_auto_init_multi_out(struct hda_codec *codec)
13687 {
13688 struct alc_spec *spec = codec->spec;
13689 int i;
13690
13691 for (i = 0; i < spec->autocfg.line_outs; i++) {
13692 hda_nid_t nid = spec->autocfg.line_out_pins[i];
13693 int pin_type = get_pin_type(spec->autocfg.line_out_type);
13694 alc268_auto_set_output_and_unmute(codec, nid, pin_type);
13695 }
13696 }
13697
13698 static void alc268_auto_init_hp_out(struct hda_codec *codec)
13699 {
13700 struct alc_spec *spec = codec->spec;
13701 hda_nid_t pin;
13702 int i;
13703
13704 for (i = 0; i < spec->autocfg.hp_outs; i++) {
13705 pin = spec->autocfg.hp_pins[i];
13706 alc268_auto_set_output_and_unmute(codec, pin, PIN_HP);
13707 }
13708 for (i = 0; i < spec->autocfg.speaker_outs; i++) {
13709 pin = spec->autocfg.speaker_pins[i];
13710 alc268_auto_set_output_and_unmute(codec, pin, PIN_OUT);
13711 }
13712 if (spec->autocfg.mono_out_pin)
13713 snd_hda_codec_write(codec, spec->autocfg.mono_out_pin, 0,
13714 AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
13715 }
13716
13717 static void alc268_auto_init_mono_speaker_out(struct hda_codec *codec)
13718 {
13719 struct alc_spec *spec = codec->spec;
13720 hda_nid_t speaker_nid = spec->autocfg.speaker_pins[0];
13721 hda_nid_t hp_nid = spec->autocfg.hp_pins[0];
13722 hda_nid_t line_nid = spec->autocfg.line_out_pins[0];
13723 unsigned int dac_vol1, dac_vol2;
13724
13725 if (line_nid == 0x1d || speaker_nid == 0x1d) {
13726 snd_hda_codec_write(codec, speaker_nid, 0,
13727 AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
13728 /* mute mixer inputs from 0x1d */
13729 snd_hda_codec_write(codec, 0x0f, 0,
13730 AC_VERB_SET_AMP_GAIN_MUTE,
13731 AMP_IN_UNMUTE(1));
13732 snd_hda_codec_write(codec, 0x10, 0,
13733 AC_VERB_SET_AMP_GAIN_MUTE,
13734 AMP_IN_UNMUTE(1));
13735 } else {
13736 /* unmute mixer inputs from 0x1d */
13737 snd_hda_codec_write(codec, 0x0f, 0,
13738 AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1));
13739 snd_hda_codec_write(codec, 0x10, 0,
13740 AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1));
13741 }
13742
13743 dac_vol1 = dac_vol2 = 0xb000 | 0x40; /* set max volume */
13744 if (line_nid == 0x14)
13745 dac_vol2 = AMP_OUT_ZERO;
13746 else if (line_nid == 0x15)
13747 dac_vol1 = AMP_OUT_ZERO;
13748 if (hp_nid == 0x14)
13749 dac_vol2 = AMP_OUT_ZERO;
13750 else if (hp_nid == 0x15)
13751 dac_vol1 = AMP_OUT_ZERO;
13752 if (line_nid != 0x16 || hp_nid != 0x16 ||
13753 spec->autocfg.line_out_pins[1] != 0x16 ||
13754 spec->autocfg.line_out_pins[2] != 0x16)
13755 dac_vol1 = dac_vol2 = AMP_OUT_ZERO;
13756
13757 snd_hda_codec_write(codec, 0x02, 0,
13758 AC_VERB_SET_AMP_GAIN_MUTE, dac_vol1);
13759 snd_hda_codec_write(codec, 0x03, 0,
13760 AC_VERB_SET_AMP_GAIN_MUTE, dac_vol2);
13761 }
13762
13763 /* pcm configuration: identical with ALC880 */
13764 #define alc268_pcm_analog_playback alc880_pcm_analog_playback
13765 #define alc268_pcm_analog_capture alc880_pcm_analog_capture
13766 #define alc268_pcm_analog_alt_capture alc880_pcm_analog_alt_capture
13767 #define alc268_pcm_digital_playback alc880_pcm_digital_playback
13768
13769 /*
13770 * BIOS auto configuration
13771 */
13772 static int alc268_parse_auto_config(struct hda_codec *codec)
13773 {
13774 struct alc_spec *spec = codec->spec;
13775 int err;
13776 static const hda_nid_t alc268_ignore[] = { 0 };
13777
13778 err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
13779 alc268_ignore);
13780 if (err < 0)
13781 return err;
13782 if (!spec->autocfg.line_outs) {
13783 if (spec->autocfg.dig_outs || spec->autocfg.dig_in_pin) {
13784 spec->multiout.max_channels = 2;
13785 spec->no_analog = 1;
13786 goto dig_only;
13787 }
13788 return 0; /* can't find valid BIOS pin config */
13789 }
13790 err = alc268_auto_create_multi_out_ctls(spec, &spec->autocfg);
13791 if (err < 0)
13792 return err;
13793 err = alc268_auto_create_input_ctls(codec, &spec->autocfg);
13794 if (err < 0)
13795 return err;
13796
13797 spec->multiout.max_channels = 2;
13798
13799 dig_only:
13800 /* digital only support output */
13801 alc_auto_parse_digital(codec);
13802 if (spec->kctls.list)
13803 add_mixer(spec, spec->kctls.list);
13804
13805 if (!spec->no_analog && spec->autocfg.speaker_pins[0] != 0x1d)
13806 add_mixer(spec, alc268_beep_mixer);
13807
13808 add_verb(spec, alc268_volume_init_verbs);
13809 spec->num_mux_defs = 2;
13810 spec->input_mux = &spec->private_imux[0];
13811
13812 err = alc_auto_add_mic_boost(codec);
13813 if (err < 0)
13814 return err;
13815
13816 alc_ssid_check(codec, 0x15, 0x1b, 0x14, 0);
13817
13818 return 1;
13819 }
13820
13821 #define alc268_auto_init_analog_input alc882_auto_init_analog_input
13822 #define alc268_auto_init_input_src alc882_auto_init_input_src
13823
13824 /* init callback for auto-configuration model -- overriding the default init */
13825 static void alc268_auto_init(struct hda_codec *codec)
13826 {
13827 struct alc_spec *spec = codec->spec;
13828 alc268_auto_init_multi_out(codec);
13829 alc268_auto_init_hp_out(codec);
13830 alc268_auto_init_mono_speaker_out(codec);
13831 alc268_auto_init_analog_input(codec);
13832 alc268_auto_init_input_src(codec);
13833 alc_auto_init_digital(codec);
13834 if (spec->unsol_event)
13835 alc_inithook(codec);
13836 }
13837
13838 /*
13839 * configuration and preset
13840 */
13841 static const char * const alc268_models[ALC268_MODEL_LAST] = {
13842 [ALC267_QUANTA_IL1] = "quanta-il1",
13843 [ALC268_3ST] = "3stack",
13844 [ALC268_TOSHIBA] = "toshiba",
13845 [ALC268_ACER] = "acer",
13846 [ALC268_ACER_DMIC] = "acer-dmic",
13847 [ALC268_ACER_ASPIRE_ONE] = "acer-aspire",
13848 [ALC268_DELL] = "dell",
13849 [ALC268_ZEPTO] = "zepto",
13850 #ifdef CONFIG_SND_DEBUG
13851 [ALC268_TEST] = "test",
13852 #endif
13853 [ALC268_AUTO] = "auto",
13854 };
13855
13856 static const struct snd_pci_quirk alc268_cfg_tbl[] = {
13857 SND_PCI_QUIRK(0x1025, 0x011e, "Acer Aspire 5720z", ALC268_ACER),
13858 SND_PCI_QUIRK(0x1025, 0x0126, "Acer", ALC268_ACER),
13859 SND_PCI_QUIRK(0x1025, 0x012e, "Acer Aspire 5310", ALC268_ACER),
13860 SND_PCI_QUIRK(0x1025, 0x0130, "Acer Extensa 5210", ALC268_ACER),
13861 SND_PCI_QUIRK(0x1025, 0x0136, "Acer Aspire 5315", ALC268_ACER),
13862 SND_PCI_QUIRK(0x1025, 0x015b, "Acer Aspire One",
13863 ALC268_ACER_ASPIRE_ONE),
13864 SND_PCI_QUIRK(0x1028, 0x0253, "Dell OEM", ALC268_DELL),
13865 SND_PCI_QUIRK(0x1028, 0x02b0, "Dell Inspiron 910", ALC268_AUTO),
13866 SND_PCI_QUIRK_MASK(0x1028, 0xfff0, 0x02b0,
13867 "Dell Inspiron Mini9/Vostro A90", ALC268_DELL),
13868 /* almost compatible with toshiba but with optional digital outs;
13869 * auto-probing seems working fine
13870 */
13871 SND_PCI_QUIRK_MASK(0x103c, 0xff00, 0x3000, "HP TX25xx series",
13872 ALC268_AUTO),
13873 SND_PCI_QUIRK(0x1043, 0x1205, "ASUS W7J", ALC268_3ST),
13874 SND_PCI_QUIRK(0x1170, 0x0040, "ZEPTO", ALC268_ZEPTO),
13875 SND_PCI_QUIRK(0x14c0, 0x0025, "COMPAL IFL90/JFL-92", ALC268_TOSHIBA),
13876 SND_PCI_QUIRK(0x152d, 0x0763, "Diverse (CPR2000)", ALC268_ACER),
13877 SND_PCI_QUIRK(0x152d, 0x0771, "Quanta IL1", ALC267_QUANTA_IL1),
13878 {}
13879 };
13880
13881 /* Toshiba laptops have no unique PCI SSID but only codec SSID */
13882 static const struct snd_pci_quirk alc268_ssid_cfg_tbl[] = {
13883 SND_PCI_QUIRK(0x1179, 0xff0a, "TOSHIBA X-200", ALC268_AUTO),
13884 SND_PCI_QUIRK(0x1179, 0xff0e, "TOSHIBA X-200 HDMI", ALC268_AUTO),
13885 SND_PCI_QUIRK_MASK(0x1179, 0xff00, 0xff00, "TOSHIBA A/Lx05",
13886 ALC268_TOSHIBA),
13887 {}
13888 };
13889
13890 static const struct alc_config_preset alc268_presets[] = {
13891 [ALC267_QUANTA_IL1] = {
13892 .mixers = { alc267_quanta_il1_mixer, alc268_beep_mixer,
13893 alc268_capture_nosrc_mixer },
13894 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
13895 alc267_quanta_il1_verbs },
13896 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
13897 .dac_nids = alc268_dac_nids,
13898 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
13899 .adc_nids = alc268_adc_nids_alt,
13900 .hp_nid = 0x03,
13901 .num_channel_mode = ARRAY_SIZE(alc268_modes),
13902 .channel_mode = alc268_modes,
13903 .unsol_event = alc_sku_unsol_event,
13904 .setup = alc267_quanta_il1_setup,
13905 .init_hook = alc_inithook,
13906 },
13907 [ALC268_3ST] = {
13908 .mixers = { alc268_base_mixer, alc268_capture_alt_mixer,
13909 alc268_beep_mixer },
13910 .init_verbs = { alc268_base_init_verbs },
13911 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
13912 .dac_nids = alc268_dac_nids,
13913 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
13914 .adc_nids = alc268_adc_nids_alt,
13915 .capsrc_nids = alc268_capsrc_nids,
13916 .hp_nid = 0x03,
13917 .dig_out_nid = ALC268_DIGOUT_NID,
13918 .num_channel_mode = ARRAY_SIZE(alc268_modes),
13919 .channel_mode = alc268_modes,
13920 .input_mux = &alc268_capture_source,
13921 },
13922 [ALC268_TOSHIBA] = {
13923 .mixers = { alc268_toshiba_mixer, alc268_capture_alt_mixer,
13924 alc268_beep_mixer },
13925 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
13926 alc268_toshiba_verbs },
13927 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
13928 .dac_nids = alc268_dac_nids,
13929 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
13930 .adc_nids = alc268_adc_nids_alt,
13931 .capsrc_nids = alc268_capsrc_nids,
13932 .hp_nid = 0x03,
13933 .num_channel_mode = ARRAY_SIZE(alc268_modes),
13934 .channel_mode = alc268_modes,
13935 .input_mux = &alc268_capture_source,
13936 .unsol_event = alc_sku_unsol_event,
13937 .setup = alc268_toshiba_setup,
13938 .init_hook = alc_inithook,
13939 },
13940 [ALC268_ACER] = {
13941 .mixers = { alc268_acer_mixer, alc268_capture_alt_mixer,
13942 alc268_beep_mixer },
13943 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
13944 alc268_acer_verbs },
13945 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
13946 .dac_nids = alc268_dac_nids,
13947 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
13948 .adc_nids = alc268_adc_nids_alt,
13949 .capsrc_nids = alc268_capsrc_nids,
13950 .hp_nid = 0x02,
13951 .num_channel_mode = ARRAY_SIZE(alc268_modes),
13952 .channel_mode = alc268_modes,
13953 .input_mux = &alc268_acer_capture_source,
13954 .unsol_event = alc_sku_unsol_event,
13955 .setup = alc268_acer_setup,
13956 .init_hook = alc_inithook,
13957 },
13958 [ALC268_ACER_DMIC] = {
13959 .mixers = { alc268_acer_dmic_mixer, alc268_capture_alt_mixer,
13960 alc268_beep_mixer },
13961 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
13962 alc268_acer_verbs },
13963 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
13964 .dac_nids = alc268_dac_nids,
13965 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
13966 .adc_nids = alc268_adc_nids_alt,
13967 .capsrc_nids = alc268_capsrc_nids,
13968 .hp_nid = 0x02,
13969 .num_channel_mode = ARRAY_SIZE(alc268_modes),
13970 .channel_mode = alc268_modes,
13971 .input_mux = &alc268_acer_dmic_capture_source,
13972 .unsol_event = alc_sku_unsol_event,
13973 .setup = alc268_acer_setup,
13974 .init_hook = alc_inithook,
13975 },
13976 [ALC268_ACER_ASPIRE_ONE] = {
13977 .mixers = { alc268_acer_aspire_one_mixer,
13978 alc268_beep_mixer,
13979 alc268_capture_nosrc_mixer },
13980 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
13981 alc268_acer_aspire_one_verbs },
13982 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
13983 .dac_nids = alc268_dac_nids,
13984 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
13985 .adc_nids = alc268_adc_nids_alt,
13986 .capsrc_nids = alc268_capsrc_nids,
13987 .hp_nid = 0x03,
13988 .num_channel_mode = ARRAY_SIZE(alc268_modes),
13989 .channel_mode = alc268_modes,
13990 .unsol_event = alc_sku_unsol_event,
13991 .setup = alc268_acer_lc_setup,
13992 .init_hook = alc_inithook,
13993 },
13994 [ALC268_DELL] = {
13995 .mixers = { alc268_dell_mixer, alc268_beep_mixer,
13996 alc268_capture_nosrc_mixer },
13997 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
13998 alc268_dell_verbs },
13999 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
14000 .dac_nids = alc268_dac_nids,
14001 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
14002 .adc_nids = alc268_adc_nids_alt,
14003 .capsrc_nids = alc268_capsrc_nids,
14004 .hp_nid = 0x02,
14005 .num_channel_mode = ARRAY_SIZE(alc268_modes),
14006 .channel_mode = alc268_modes,
14007 .unsol_event = alc_sku_unsol_event,
14008 .setup = alc268_dell_setup,
14009 .init_hook = alc_inithook,
14010 },
14011 [ALC268_ZEPTO] = {
14012 .mixers = { alc268_base_mixer, alc268_capture_alt_mixer,
14013 alc268_beep_mixer },
14014 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
14015 alc268_toshiba_verbs },
14016 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
14017 .dac_nids = alc268_dac_nids,
14018 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
14019 .adc_nids = alc268_adc_nids_alt,
14020 .capsrc_nids = alc268_capsrc_nids,
14021 .hp_nid = 0x03,
14022 .dig_out_nid = ALC268_DIGOUT_NID,
14023 .num_channel_mode = ARRAY_SIZE(alc268_modes),
14024 .channel_mode = alc268_modes,
14025 .input_mux = &alc268_capture_source,
14026 .unsol_event = alc_sku_unsol_event,
14027 .setup = alc268_toshiba_setup,
14028 .init_hook = alc_inithook,
14029 },
14030 #ifdef CONFIG_SND_DEBUG
14031 [ALC268_TEST] = {
14032 .mixers = { alc268_test_mixer, alc268_capture_mixer },
14033 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
14034 alc268_volume_init_verbs },
14035 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
14036 .dac_nids = alc268_dac_nids,
14037 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
14038 .adc_nids = alc268_adc_nids_alt,
14039 .capsrc_nids = alc268_capsrc_nids,
14040 .hp_nid = 0x03,
14041 .dig_out_nid = ALC268_DIGOUT_NID,
14042 .num_channel_mode = ARRAY_SIZE(alc268_modes),
14043 .channel_mode = alc268_modes,
14044 .input_mux = &alc268_capture_source,
14045 },
14046 #endif
14047 };
14048
14049 static int patch_alc268(struct hda_codec *codec)
14050 {
14051 struct alc_spec *spec;
14052 int board_config;
14053 int i, has_beep, err;
14054
14055 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
14056 if (spec == NULL)
14057 return -ENOMEM;
14058
14059 codec->spec = spec;
14060
14061 board_config = snd_hda_check_board_config(codec, ALC268_MODEL_LAST,
14062 alc268_models,
14063 alc268_cfg_tbl);
14064
14065 if (board_config < 0 || board_config >= ALC268_MODEL_LAST)
14066 board_config = snd_hda_check_board_codec_sid_config(codec,
14067 ALC268_MODEL_LAST, alc268_models, alc268_ssid_cfg_tbl);
14068
14069 if (board_config < 0 || board_config >= ALC268_MODEL_LAST) {
14070 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
14071 codec->chip_name);
14072 board_config = ALC268_AUTO;
14073 }
14074
14075 if (board_config == ALC268_AUTO) {
14076 /* automatic parse from the BIOS config */
14077 err = alc268_parse_auto_config(codec);
14078 if (err < 0) {
14079 alc_free(codec);
14080 return err;
14081 } else if (!err) {
14082 printk(KERN_INFO
14083 "hda_codec: Cannot set up configuration "
14084 "from BIOS. Using base mode...\n");
14085 board_config = ALC268_3ST;
14086 }
14087 }
14088
14089 if (board_config != ALC268_AUTO)
14090 setup_preset(codec, &alc268_presets[board_config]);
14091
14092 spec->stream_analog_playback = &alc268_pcm_analog_playback;
14093 spec->stream_analog_capture = &alc268_pcm_analog_capture;
14094 spec->stream_analog_alt_capture = &alc268_pcm_analog_alt_capture;
14095
14096 spec->stream_digital_playback = &alc268_pcm_digital_playback;
14097
14098 has_beep = 0;
14099 for (i = 0; i < spec->num_mixers; i++) {
14100 if (spec->mixers[i] == alc268_beep_mixer) {
14101 has_beep = 1;
14102 break;
14103 }
14104 }
14105
14106 if (has_beep) {
14107 err = snd_hda_attach_beep_device(codec, 0x1);
14108 if (err < 0) {
14109 alc_free(codec);
14110 return err;
14111 }
14112 if (!query_amp_caps(codec, 0x1d, HDA_INPUT))
14113 /* override the amp caps for beep generator */
14114 snd_hda_override_amp_caps(codec, 0x1d, HDA_INPUT,
14115 (0x0c << AC_AMPCAP_OFFSET_SHIFT) |
14116 (0x0c << AC_AMPCAP_NUM_STEPS_SHIFT) |
14117 (0x07 << AC_AMPCAP_STEP_SIZE_SHIFT) |
14118 (0 << AC_AMPCAP_MUTE_SHIFT));
14119 }
14120
14121 if (!spec->no_analog && !spec->adc_nids && spec->input_mux) {
14122 /* check whether NID 0x07 is valid */
14123 unsigned int wcap = get_wcaps(codec, 0x07);
14124
14125 spec->capsrc_nids = alc268_capsrc_nids;
14126 /* get type */
14127 wcap = get_wcaps_type(wcap);
14128 if (spec->auto_mic ||
14129 wcap != AC_WID_AUD_IN || spec->input_mux->num_items == 1) {
14130 spec->adc_nids = alc268_adc_nids_alt;
14131 spec->num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt);
14132 if (spec->auto_mic)
14133 fixup_automic_adc(codec);
14134 if (spec->auto_mic || spec->input_mux->num_items == 1)
14135 add_mixer(spec, alc268_capture_nosrc_mixer);
14136 else
14137 add_mixer(spec, alc268_capture_alt_mixer);
14138 } else {
14139 spec->adc_nids = alc268_adc_nids;
14140 spec->num_adc_nids = ARRAY_SIZE(alc268_adc_nids);
14141 add_mixer(spec, alc268_capture_mixer);
14142 }
14143 }
14144
14145 spec->vmaster_nid = 0x02;
14146
14147 codec->patch_ops = alc_patch_ops;
14148 if (board_config == ALC268_AUTO)
14149 spec->init_hook = alc268_auto_init;
14150 spec->shutup = alc_eapd_shutup;
14151
14152 alc_init_jacks(codec);
14153
14154 return 0;
14155 }
14156
14157 /*
14158 * ALC269 channel source setting (2 channel)
14159 */
14160 #define ALC269_DIGOUT_NID ALC880_DIGOUT_NID
14161
14162 #define alc269_dac_nids alc260_dac_nids
14163
14164 static const hda_nid_t alc269_adc_nids[1] = {
14165 /* ADC1 */
14166 0x08,
14167 };
14168
14169 static const hda_nid_t alc269_capsrc_nids[1] = {
14170 0x23,
14171 };
14172
14173 static const hda_nid_t alc269vb_adc_nids[1] = {
14174 /* ADC1 */
14175 0x09,
14176 };
14177
14178 static const hda_nid_t alc269vb_capsrc_nids[1] = {
14179 0x22,
14180 };
14181
14182 static const hda_nid_t alc269_adc_candidates[] = {
14183 0x08, 0x09, 0x07, 0x11,
14184 };
14185
14186 #define alc269_modes alc260_modes
14187 #define alc269_capture_source alc880_lg_lw_capture_source
14188
14189 static const struct snd_kcontrol_new alc269_base_mixer[] = {
14190 HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
14191 HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
14192 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
14193 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
14194 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
14195 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
14196 HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
14197 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
14198 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
14199 HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x19, 0, HDA_INPUT),
14200 HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
14201 HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x16, 2, 0x0, HDA_OUTPUT),
14202 { } /* end */
14203 };
14204
14205 static const struct snd_kcontrol_new alc269_quanta_fl1_mixer[] = {
14206 /* output mixer control */
14207 HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
14208 {
14209 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
14210 .name = "Master Playback Switch",
14211 .subdevice = HDA_SUBDEV_AMP_FLAG,
14212 .info = snd_hda_mixer_amp_switch_info,
14213 .get = snd_hda_mixer_amp_switch_get,
14214 .put = alc268_acer_master_sw_put,
14215 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
14216 },
14217 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
14218 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
14219 HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
14220 HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
14221 HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
14222 HDA_CODEC_VOLUME("Internal Mic Boost Volume", 0x19, 0, HDA_INPUT),
14223 { }
14224 };
14225
14226 static const struct snd_kcontrol_new alc269_lifebook_mixer[] = {
14227 /* output mixer control */
14228 HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
14229 {
14230 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
14231 .name = "Master Playback Switch",
14232 .subdevice = HDA_SUBDEV_AMP_FLAG,
14233 .info = snd_hda_mixer_amp_switch_info,
14234 .get = snd_hda_mixer_amp_switch_get,
14235 .put = alc268_acer_master_sw_put,
14236 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
14237 },
14238 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
14239 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
14240 HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
14241 HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
14242 HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
14243 HDA_CODEC_VOLUME("Internal Mic Boost Volume", 0x19, 0, HDA_INPUT),
14244 HDA_CODEC_VOLUME("Dock Mic Playback Volume", 0x0b, 0x03, HDA_INPUT),
14245 HDA_CODEC_MUTE("Dock Mic Playback Switch", 0x0b, 0x03, HDA_INPUT),
14246 HDA_CODEC_VOLUME("Dock Mic Boost Volume", 0x1b, 0, HDA_INPUT),
14247 { }
14248 };
14249
14250 static const struct snd_kcontrol_new alc269_laptop_mixer[] = {
14251 HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
14252 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
14253 HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
14254 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
14255 { } /* end */
14256 };
14257
14258 static const struct snd_kcontrol_new alc269vb_laptop_mixer[] = {
14259 HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
14260 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
14261 HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT),
14262 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
14263 { } /* end */
14264 };
14265
14266 static const struct snd_kcontrol_new alc269_asus_mixer[] = {
14267 HDA_CODEC_VOLUME("Master Playback Volume", 0x02, 0x0, HDA_OUTPUT),
14268 HDA_CODEC_MUTE("Master Playback Switch", 0x0c, 0x0, HDA_INPUT),
14269 { } /* end */
14270 };
14271
14272 /* capture mixer elements */
14273 static const struct snd_kcontrol_new alc269_laptop_analog_capture_mixer[] = {
14274 HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
14275 HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
14276 HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
14277 HDA_CODEC_VOLUME("Internal Mic Boost Volume", 0x19, 0, HDA_INPUT),
14278 { } /* end */
14279 };
14280
14281 static const struct snd_kcontrol_new alc269_laptop_digital_capture_mixer[] = {
14282 HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
14283 HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
14284 HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
14285 { } /* end */
14286 };
14287
14288 static const struct snd_kcontrol_new alc269vb_laptop_analog_capture_mixer[] = {
14289 HDA_CODEC_VOLUME("Capture Volume", 0x09, 0x0, HDA_INPUT),
14290 HDA_CODEC_MUTE("Capture Switch", 0x09, 0x0, HDA_INPUT),
14291 HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
14292 HDA_CODEC_VOLUME("Internal Mic Boost Volume", 0x19, 0, HDA_INPUT),
14293 { } /* end */
14294 };
14295
14296 static const struct snd_kcontrol_new alc269vb_laptop_digital_capture_mixer[] = {
14297 HDA_CODEC_VOLUME("Capture Volume", 0x09, 0x0, HDA_INPUT),
14298 HDA_CODEC_MUTE("Capture Switch", 0x09, 0x0, HDA_INPUT),
14299 HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
14300 { } /* end */
14301 };
14302
14303 /* FSC amilo */
14304 #define alc269_fujitsu_mixer alc269_laptop_mixer
14305
14306 static const struct hda_verb alc269_quanta_fl1_verbs[] = {
14307 {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
14308 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14309 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
14310 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
14311 {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
14312 {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14313 { }
14314 };
14315
14316 static const struct hda_verb alc269_lifebook_verbs[] = {
14317 {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
14318 {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01},
14319 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14320 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
14321 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
14322 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14323 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
14324 {0x1a, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
14325 {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
14326 {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14327 { }
14328 };
14329
14330 /* toggle speaker-output according to the hp-jack state */
14331 static void alc269_quanta_fl1_speaker_automute(struct hda_codec *codec)
14332 {
14333 alc_hp_automute(codec);
14334
14335 snd_hda_codec_write(codec, 0x20, 0,
14336 AC_VERB_SET_COEF_INDEX, 0x0c);
14337 snd_hda_codec_write(codec, 0x20, 0,
14338 AC_VERB_SET_PROC_COEF, 0x680);
14339
14340 snd_hda_codec_write(codec, 0x20, 0,
14341 AC_VERB_SET_COEF_INDEX, 0x0c);
14342 snd_hda_codec_write(codec, 0x20, 0,
14343 AC_VERB_SET_PROC_COEF, 0x480);
14344 }
14345
14346 #define alc269_lifebook_speaker_automute \
14347 alc269_quanta_fl1_speaker_automute
14348
14349 static void alc269_lifebook_mic_autoswitch(struct hda_codec *codec)
14350 {
14351 unsigned int present_laptop;
14352 unsigned int present_dock;
14353
14354 present_laptop = snd_hda_jack_detect(codec, 0x18);
14355 present_dock = snd_hda_jack_detect(codec, 0x1b);
14356
14357 /* Laptop mic port overrides dock mic port, design decision */
14358 if (present_dock)
14359 snd_hda_codec_write(codec, 0x23, 0,
14360 AC_VERB_SET_CONNECT_SEL, 0x3);
14361 if (present_laptop)
14362 snd_hda_codec_write(codec, 0x23, 0,
14363 AC_VERB_SET_CONNECT_SEL, 0x0);
14364 if (!present_dock && !present_laptop)
14365 snd_hda_codec_write(codec, 0x23, 0,
14366 AC_VERB_SET_CONNECT_SEL, 0x1);
14367 }
14368
14369 static void alc269_quanta_fl1_unsol_event(struct hda_codec *codec,
14370 unsigned int res)
14371 {
14372 switch (res >> 26) {
14373 case ALC880_HP_EVENT:
14374 alc269_quanta_fl1_speaker_automute(codec);
14375 break;
14376 case ALC880_MIC_EVENT:
14377 alc_mic_automute(codec);
14378 break;
14379 }
14380 }
14381
14382 static void alc269_lifebook_unsol_event(struct hda_codec *codec,
14383 unsigned int res)
14384 {
14385 if ((res >> 26) == ALC880_HP_EVENT)
14386 alc269_lifebook_speaker_automute(codec);
14387 if ((res >> 26) == ALC880_MIC_EVENT)
14388 alc269_lifebook_mic_autoswitch(codec);
14389 }
14390
14391 static void alc269_quanta_fl1_setup(struct hda_codec *codec)
14392 {
14393 struct alc_spec *spec = codec->spec;
14394 spec->autocfg.hp_pins[0] = 0x15;
14395 spec->autocfg.speaker_pins[0] = 0x14;
14396 spec->automute_mixer_nid[0] = 0x0c;
14397 spec->automute = 1;
14398 spec->automute_mode = ALC_AUTOMUTE_MIXER;
14399 spec->ext_mic.pin = 0x18;
14400 spec->ext_mic.mux_idx = 0;
14401 spec->int_mic.pin = 0x19;
14402 spec->int_mic.mux_idx = 1;
14403 spec->auto_mic = 1;
14404 }
14405
14406 static void alc269_quanta_fl1_init_hook(struct hda_codec *codec)
14407 {
14408 alc269_quanta_fl1_speaker_automute(codec);
14409 alc_mic_automute(codec);
14410 }
14411
14412 static void alc269_lifebook_setup(struct hda_codec *codec)
14413 {
14414 struct alc_spec *spec = codec->spec;
14415 spec->autocfg.hp_pins[0] = 0x15;
14416 spec->autocfg.hp_pins[1] = 0x1a;
14417 spec->autocfg.speaker_pins[0] = 0x14;
14418 spec->automute_mixer_nid[0] = 0x0c;
14419 spec->automute = 1;
14420 spec->automute_mode = ALC_AUTOMUTE_MIXER;
14421 }
14422
14423 static void alc269_lifebook_init_hook(struct hda_codec *codec)
14424 {
14425 alc269_lifebook_speaker_automute(codec);
14426 alc269_lifebook_mic_autoswitch(codec);
14427 }
14428
14429 static const struct hda_verb alc269_laptop_dmic_init_verbs[] = {
14430 {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
14431 {0x23, AC_VERB_SET_CONNECT_SEL, 0x05},
14432 {0x02, AC_VERB_SET_AMP_GAIN_MUTE, 0xb026 },
14433 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7019 | (0x00 << 8))},
14434 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14435 {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
14436 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
14437 {}
14438 };
14439
14440 static const struct hda_verb alc269_laptop_amic_init_verbs[] = {
14441 {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
14442 {0x23, AC_VERB_SET_CONNECT_SEL, 0x01},
14443 {0x02, AC_VERB_SET_AMP_GAIN_MUTE, 0xb026 },
14444 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x701b | (0x00 << 8))},
14445 {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
14446 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
14447 {}
14448 };
14449
14450 static const struct hda_verb alc269vb_laptop_dmic_init_verbs[] = {
14451 {0x21, AC_VERB_SET_CONNECT_SEL, 0x01},
14452 {0x22, AC_VERB_SET_CONNECT_SEL, 0x06},
14453 {0x02, AC_VERB_SET_AMP_GAIN_MUTE, 0xb026 },
14454 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7019 | (0x00 << 8))},
14455 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14456 {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
14457 {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
14458 {}
14459 };
14460
14461 static const struct hda_verb alc269vb_laptop_amic_init_verbs[] = {
14462 {0x21, AC_VERB_SET_CONNECT_SEL, 0x01},
14463 {0x22, AC_VERB_SET_CONNECT_SEL, 0x01},
14464 {0x02, AC_VERB_SET_AMP_GAIN_MUTE, 0xb026 },
14465 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7019 | (0x00 << 8))},
14466 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14467 {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
14468 {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
14469 {}
14470 };
14471
14472 static const struct hda_verb alc271_acer_dmic_verbs[] = {
14473 {0x20, AC_VERB_SET_COEF_INDEX, 0x0d},
14474 {0x20, AC_VERB_SET_PROC_COEF, 0x4000},
14475 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14476 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14477 {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
14478 {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14479 {0x21, AC_VERB_SET_CONNECT_SEL, 0x00},
14480 {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
14481 {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
14482 {0x22, AC_VERB_SET_CONNECT_SEL, 6},
14483 { }
14484 };
14485
14486 static void alc269_laptop_amic_setup(struct hda_codec *codec)
14487 {
14488 struct alc_spec *spec = codec->spec;
14489 spec->autocfg.hp_pins[0] = 0x15;
14490 spec->autocfg.speaker_pins[0] = 0x14;
14491 spec->automute_mixer_nid[0] = 0x0c;
14492 spec->automute = 1;
14493 spec->automute_mode = ALC_AUTOMUTE_MIXER;
14494 spec->ext_mic.pin = 0x18;
14495 spec->ext_mic.mux_idx = 0;
14496 spec->int_mic.pin = 0x19;
14497 spec->int_mic.mux_idx = 1;
14498 spec->auto_mic = 1;
14499 }
14500
14501 static void alc269_laptop_dmic_setup(struct hda_codec *codec)
14502 {
14503 struct alc_spec *spec = codec->spec;
14504 spec->autocfg.hp_pins[0] = 0x15;
14505 spec->autocfg.speaker_pins[0] = 0x14;
14506 spec->automute_mixer_nid[0] = 0x0c;
14507 spec->automute = 1;
14508 spec->automute_mode = ALC_AUTOMUTE_MIXER;
14509 spec->ext_mic.pin = 0x18;
14510 spec->ext_mic.mux_idx = 0;
14511 spec->int_mic.pin = 0x12;
14512 spec->int_mic.mux_idx = 5;
14513 spec->auto_mic = 1;
14514 }
14515
14516 static void alc269vb_laptop_amic_setup(struct hda_codec *codec)
14517 {
14518 struct alc_spec *spec = codec->spec;
14519 spec->autocfg.hp_pins[0] = 0x21;
14520 spec->autocfg.speaker_pins[0] = 0x14;
14521 spec->automute_mixer_nid[0] = 0x0c;
14522 spec->automute = 1;
14523 spec->automute_mode = ALC_AUTOMUTE_MIXER;
14524 spec->ext_mic.pin = 0x18;
14525 spec->ext_mic.mux_idx = 0;
14526 spec->int_mic.pin = 0x19;
14527 spec->int_mic.mux_idx = 1;
14528 spec->auto_mic = 1;
14529 }
14530
14531 static void alc269vb_laptop_dmic_setup(struct hda_codec *codec)
14532 {
14533 struct alc_spec *spec = codec->spec;
14534 spec->autocfg.hp_pins[0] = 0x21;
14535 spec->autocfg.speaker_pins[0] = 0x14;
14536 spec->automute_mixer_nid[0] = 0x0c;
14537 spec->automute = 1;
14538 spec->automute_mode = ALC_AUTOMUTE_MIXER;
14539 spec->ext_mic.pin = 0x18;
14540 spec->ext_mic.mux_idx = 0;
14541 spec->int_mic.pin = 0x12;
14542 spec->int_mic.mux_idx = 6;
14543 spec->auto_mic = 1;
14544 }
14545
14546 /*
14547 * generic initialization of ADC, input mixers and output mixers
14548 */
14549 static const struct hda_verb alc269_init_verbs[] = {
14550 /*
14551 * Unmute ADC0 and set the default input to mic-in
14552 */
14553 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14554
14555 /*
14556 * Set up output mixers (0x02 - 0x03)
14557 */
14558 /* set vol=0 to output mixers */
14559 {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
14560 {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
14561
14562 /* set up input amps for analog loopback */
14563 /* Amp Indices: DAC = 0, mixer = 1 */
14564 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14565 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14566 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14567 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14568 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14569 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14570
14571 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14572 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
14573 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14574 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
14575 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
14576 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14577 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14578
14579 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14580 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14581
14582 /* FIXME: use Mux-type input source selection */
14583 /* Mixer elements: 0x18, 19, 1a, 1b, 1d, 0b */
14584 /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
14585 {0x23, AC_VERB_SET_CONNECT_SEL, 0x00},
14586
14587 /* set EAPD */
14588 {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
14589 { }
14590 };
14591
14592 static const struct hda_verb alc269vb_init_verbs[] = {
14593 /*
14594 * Unmute ADC0 and set the default input to mic-in
14595 */
14596 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14597
14598 /*
14599 * Set up output mixers (0x02 - 0x03)
14600 */
14601 /* set vol=0 to output mixers */
14602 {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
14603 {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
14604
14605 /* set up input amps for analog loopback */
14606 /* Amp Indices: DAC = 0, mixer = 1 */
14607 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14608 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14609 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14610 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14611 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14612 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14613
14614 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14615 {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
14616 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14617 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
14618 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
14619 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14620 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14621
14622 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14623 {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14624
14625 /* FIXME: use Mux-type input source selection */
14626 /* Mixer elements: 0x18, 19, 1a, 1b, 1d, 0b */
14627 /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
14628 {0x22, AC_VERB_SET_CONNECT_SEL, 0x00},
14629
14630 /* set EAPD */
14631 {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
14632 { }
14633 };
14634
14635 #define alc269_auto_create_multi_out_ctls \
14636 alc268_auto_create_multi_out_ctls
14637 #define alc269_auto_create_input_ctls \
14638 alc268_auto_create_input_ctls
14639
14640 #ifdef CONFIG_SND_HDA_POWER_SAVE
14641 #define alc269_loopbacks alc880_loopbacks
14642 #endif
14643
14644 /* pcm configuration: identical with ALC880 */
14645 #define alc269_pcm_analog_playback alc880_pcm_analog_playback
14646 #define alc269_pcm_analog_capture alc880_pcm_analog_capture
14647 #define alc269_pcm_digital_playback alc880_pcm_digital_playback
14648 #define alc269_pcm_digital_capture alc880_pcm_digital_capture
14649
14650 static const struct hda_pcm_stream alc269_44k_pcm_analog_playback = {
14651 .substreams = 1,
14652 .channels_min = 2,
14653 .channels_max = 8,
14654 .rates = SNDRV_PCM_RATE_44100, /* fixed rate */
14655 /* NID is set in alc_build_pcms */
14656 .ops = {
14657 .open = alc880_playback_pcm_open,
14658 .prepare = alc880_playback_pcm_prepare,
14659 .cleanup = alc880_playback_pcm_cleanup
14660 },
14661 };
14662
14663 static const struct hda_pcm_stream alc269_44k_pcm_analog_capture = {
14664 .substreams = 1,
14665 .channels_min = 2,
14666 .channels_max = 2,
14667 .rates = SNDRV_PCM_RATE_44100, /* fixed rate */
14668 /* NID is set in alc_build_pcms */
14669 };
14670
14671 #ifdef CONFIG_SND_HDA_POWER_SAVE
14672 static int alc269_mic2_for_mute_led(struct hda_codec *codec)
14673 {
14674 switch (codec->subsystem_id) {
14675 case 0x103c1586:
14676 return 1;
14677 }
14678 return 0;
14679 }
14680
14681 static int alc269_mic2_mute_check_ps(struct hda_codec *codec, hda_nid_t nid)
14682 {
14683 /* update mute-LED according to the speaker mute state */
14684 if (nid == 0x01 || nid == 0x14) {
14685 int pinval;
14686 if (snd_hda_codec_amp_read(codec, 0x14, 0, HDA_OUTPUT, 0) &
14687 HDA_AMP_MUTE)
14688 pinval = 0x24;
14689 else
14690 pinval = 0x20;
14691 /* mic2 vref pin is used for mute LED control */
14692 snd_hda_codec_update_cache(codec, 0x19, 0,
14693 AC_VERB_SET_PIN_WIDGET_CONTROL,
14694 pinval);
14695 }
14696 return alc_check_power_status(codec, nid);
14697 }
14698 #endif /* CONFIG_SND_HDA_POWER_SAVE */
14699
14700 static int alc275_setup_dual_adc(struct hda_codec *codec)
14701 {
14702 struct alc_spec *spec = codec->spec;
14703
14704 if (codec->vendor_id != 0x10ec0275 || !spec->auto_mic)
14705 return 0;
14706 if ((spec->ext_mic.pin >= 0x18 && spec->int_mic.pin <= 0x13) ||
14707 (spec->ext_mic.pin <= 0x12 && spec->int_mic.pin >= 0x18)) {
14708 if (spec->ext_mic.pin <= 0x12) {
14709 spec->private_adc_nids[0] = 0x08;
14710 spec->private_adc_nids[1] = 0x11;
14711 spec->private_capsrc_nids[0] = 0x23;
14712 spec->private_capsrc_nids[1] = 0x22;
14713 } else {
14714 spec->private_adc_nids[0] = 0x11;
14715 spec->private_adc_nids[1] = 0x08;
14716 spec->private_capsrc_nids[0] = 0x22;
14717 spec->private_capsrc_nids[1] = 0x23;
14718 }
14719 spec->adc_nids = spec->private_adc_nids;
14720 spec->capsrc_nids = spec->private_capsrc_nids;
14721 spec->num_adc_nids = 2;
14722 spec->dual_adc_switch = 1;
14723 snd_printdd("realtek: enabling dual ADC switchg (%02x:%02x)\n",
14724 spec->adc_nids[0], spec->adc_nids[1]);
14725 return 1;
14726 }
14727 return 0;
14728 }
14729
14730 /* different alc269-variants */
14731 enum {
14732 ALC269_TYPE_NORMAL,
14733 ALC269_TYPE_ALC258,
14734 ALC269_TYPE_ALC259,
14735 ALC269_TYPE_ALC269VB,
14736 ALC269_TYPE_ALC270,
14737 ALC269_TYPE_ALC271X,
14738 };
14739
14740 /*
14741 * BIOS auto configuration
14742 */
14743 static int alc269_parse_auto_config(struct hda_codec *codec)
14744 {
14745 struct alc_spec *spec = codec->spec;
14746 int err;
14747 static const hda_nid_t alc269_ignore[] = { 0x1d, 0 };
14748
14749 err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
14750 alc269_ignore);
14751 if (err < 0)
14752 return err;
14753
14754 err = alc269_auto_create_multi_out_ctls(spec, &spec->autocfg);
14755 if (err < 0)
14756 return err;
14757 if (spec->codec_variant == ALC269_TYPE_NORMAL)
14758 err = alc269_auto_create_input_ctls(codec, &spec->autocfg);
14759 else
14760 err = alc_auto_create_input_ctls(codec, &spec->autocfg, 0,
14761 0x22, 0);
14762 if (err < 0)
14763 return err;
14764
14765 spec->multiout.max_channels = spec->multiout.num_dacs * 2;
14766
14767 alc_auto_parse_digital(codec);
14768
14769 if (spec->kctls.list)
14770 add_mixer(spec, spec->kctls.list);
14771
14772 if (spec->codec_variant != ALC269_TYPE_NORMAL) {
14773 add_verb(spec, alc269vb_init_verbs);
14774 alc_ssid_check(codec, 0, 0x1b, 0x14, 0x21);
14775 } else {
14776 add_verb(spec, alc269_init_verbs);
14777 alc_ssid_check(codec, 0x15, 0x1b, 0x14, 0);
14778 }
14779
14780 spec->num_mux_defs = 1;
14781 spec->input_mux = &spec->private_imux[0];
14782
14783 if (!alc275_setup_dual_adc(codec))
14784 fillup_priv_adc_nids(codec, alc269_adc_candidates,
14785 sizeof(alc269_adc_candidates));
14786
14787 err = alc_auto_add_mic_boost(codec);
14788 if (err < 0)
14789 return err;
14790
14791 if (!spec->cap_mixer && !spec->no_analog)
14792 set_capture_mixer(codec);
14793
14794 return 1;
14795 }
14796
14797 #define alc269_auto_init_multi_out alc268_auto_init_multi_out
14798 #define alc269_auto_init_hp_out alc268_auto_init_hp_out
14799 #define alc269_auto_init_analog_input alc882_auto_init_analog_input
14800 #define alc269_auto_init_input_src alc882_auto_init_input_src
14801
14802
14803 /* init callback for auto-configuration model -- overriding the default init */
14804 static void alc269_auto_init(struct hda_codec *codec)
14805 {
14806 struct alc_spec *spec = codec->spec;
14807 alc269_auto_init_multi_out(codec);
14808 alc269_auto_init_hp_out(codec);
14809 alc269_auto_init_analog_input(codec);
14810 if (!spec->dual_adc_switch)
14811 alc269_auto_init_input_src(codec);
14812 alc_auto_init_digital(codec);
14813 if (spec->unsol_event)
14814 alc_inithook(codec);
14815 }
14816
14817 static void alc269_toggle_power_output(struct hda_codec *codec, int power_up)
14818 {
14819 int val = alc_read_coef_idx(codec, 0x04);
14820 if (power_up)
14821 val |= 1 << 11;
14822 else
14823 val &= ~(1 << 11);
14824 alc_write_coef_idx(codec, 0x04, val);
14825 }
14826
14827 static void alc269_shutup(struct hda_codec *codec)
14828 {
14829 if ((alc_read_coef_idx(codec, 0) & 0x00ff) == 0x017)
14830 alc269_toggle_power_output(codec, 0);
14831 if ((alc_read_coef_idx(codec, 0) & 0x00ff) == 0x018) {
14832 alc269_toggle_power_output(codec, 0);
14833 msleep(150);
14834 }
14835 }
14836
14837 #ifdef SND_HDA_NEEDS_RESUME
14838 static int alc269_resume(struct hda_codec *codec)
14839 {
14840 if ((alc_read_coef_idx(codec, 0) & 0x00ff) == 0x018) {
14841 alc269_toggle_power_output(codec, 0);
14842 msleep(150);
14843 }
14844
14845 codec->patch_ops.init(codec);
14846
14847 if ((alc_read_coef_idx(codec, 0) & 0x00ff) == 0x017) {
14848 alc269_toggle_power_output(codec, 1);
14849 msleep(200);
14850 }
14851
14852 if ((alc_read_coef_idx(codec, 0) & 0x00ff) == 0x018)
14853 alc269_toggle_power_output(codec, 1);
14854
14855 snd_hda_codec_resume_amp(codec);
14856 snd_hda_codec_resume_cache(codec);
14857 hda_call_check_power_status(codec, 0x01);
14858 return 0;
14859 }
14860 #endif /* SND_HDA_NEEDS_RESUME */
14861
14862 static void alc269_fixup_hweq(struct hda_codec *codec,
14863 const struct alc_fixup *fix, int action)
14864 {
14865 int coef;
14866
14867 if (action != ALC_FIXUP_ACT_INIT)
14868 return;
14869 coef = alc_read_coef_idx(codec, 0x1e);
14870 alc_write_coef_idx(codec, 0x1e, coef | 0x80);
14871 }
14872
14873 static void alc271_fixup_dmic(struct hda_codec *codec,
14874 const struct alc_fixup *fix, int action)
14875 {
14876 static const struct hda_verb verbs[] = {
14877 {0x20, AC_VERB_SET_COEF_INDEX, 0x0d},
14878 {0x20, AC_VERB_SET_PROC_COEF, 0x4000},
14879 {}
14880 };
14881 unsigned int cfg;
14882
14883 if (strcmp(codec->chip_name, "ALC271X"))
14884 return;
14885 cfg = snd_hda_codec_get_pincfg(codec, 0x12);
14886 if (get_defcfg_connect(cfg) == AC_JACK_PORT_FIXED)
14887 snd_hda_sequence_write(codec, verbs);
14888 }
14889
14890 enum {
14891 ALC269_FIXUP_SONY_VAIO,
14892 ALC275_FIXUP_SONY_VAIO_GPIO2,
14893 ALC269_FIXUP_DELL_M101Z,
14894 ALC269_FIXUP_SKU_IGNORE,
14895 ALC269_FIXUP_ASUS_G73JW,
14896 ALC269_FIXUP_LENOVO_EAPD,
14897 ALC275_FIXUP_SONY_HWEQ,
14898 ALC271_FIXUP_DMIC,
14899 };
14900
14901 static const struct alc_fixup alc269_fixups[] = {
14902 [ALC269_FIXUP_SONY_VAIO] = {
14903 .type = ALC_FIXUP_VERBS,
14904 .v.verbs = (const struct hda_verb[]) {
14905 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREFGRD},
14906 {}
14907 }
14908 },
14909 [ALC275_FIXUP_SONY_VAIO_GPIO2] = {
14910 .type = ALC_FIXUP_VERBS,
14911 .v.verbs = (const struct hda_verb[]) {
14912 {0x01, AC_VERB_SET_GPIO_MASK, 0x04},
14913 {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x04},
14914 {0x01, AC_VERB_SET_GPIO_DATA, 0x00},
14915 { }
14916 },
14917 .chained = true,
14918 .chain_id = ALC269_FIXUP_SONY_VAIO
14919 },
14920 [ALC269_FIXUP_DELL_M101Z] = {
14921 .type = ALC_FIXUP_VERBS,
14922 .v.verbs = (const struct hda_verb[]) {
14923 /* Enables internal speaker */
14924 {0x20, AC_VERB_SET_COEF_INDEX, 13},
14925 {0x20, AC_VERB_SET_PROC_COEF, 0x4040},
14926 {}
14927 }
14928 },
14929 [ALC269_FIXUP_SKU_IGNORE] = {
14930 .type = ALC_FIXUP_SKU,
14931 .v.sku = ALC_FIXUP_SKU_IGNORE,
14932 },
14933 [ALC269_FIXUP_ASUS_G73JW] = {
14934 .type = ALC_FIXUP_PINS,
14935 .v.pins = (const struct alc_pincfg[]) {
14936 { 0x17, 0x99130111 }, /* subwoofer */
14937 { }
14938 }
14939 },
14940 [ALC269_FIXUP_LENOVO_EAPD] = {
14941 .type = ALC_FIXUP_VERBS,
14942 .v.verbs = (const struct hda_verb[]) {
14943 {0x14, AC_VERB_SET_EAPD_BTLENABLE, 0},
14944 {}
14945 }
14946 },
14947 [ALC275_FIXUP_SONY_HWEQ] = {
14948 .type = ALC_FIXUP_FUNC,
14949 .v.func = alc269_fixup_hweq,
14950 .chained = true,
14951 .chain_id = ALC275_FIXUP_SONY_VAIO_GPIO2
14952 },
14953 [ALC271_FIXUP_DMIC] = {
14954 .type = ALC_FIXUP_FUNC,
14955 .v.func = alc271_fixup_dmic,
14956 },
14957 };
14958
14959 static const struct snd_pci_quirk alc269_fixup_tbl[] = {
14960 SND_PCI_QUIRK(0x104d, 0x9073, "Sony VAIO", ALC275_FIXUP_SONY_VAIO_GPIO2),
14961 SND_PCI_QUIRK(0x104d, 0x907b, "Sony VAIO", ALC275_FIXUP_SONY_HWEQ),
14962 SND_PCI_QUIRK(0x104d, 0x9084, "Sony VAIO", ALC275_FIXUP_SONY_HWEQ),
14963 SND_PCI_QUIRK_VENDOR(0x104d, "Sony VAIO", ALC269_FIXUP_SONY_VAIO),
14964 SND_PCI_QUIRK(0x1028, 0x0470, "Dell M101z", ALC269_FIXUP_DELL_M101Z),
14965 SND_PCI_QUIRK_VENDOR(0x1025, "Acer Aspire", ALC271_FIXUP_DMIC),
14966 SND_PCI_QUIRK(0x17aa, 0x20f2, "Thinkpad SL410/510", ALC269_FIXUP_SKU_IGNORE),
14967 SND_PCI_QUIRK(0x17aa, 0x215e, "Thinkpad L512", ALC269_FIXUP_SKU_IGNORE),
14968 SND_PCI_QUIRK(0x17aa, 0x21b8, "Thinkpad Edge 14", ALC269_FIXUP_SKU_IGNORE),
14969 SND_PCI_QUIRK(0x17aa, 0x21ca, "Thinkpad L412", ALC269_FIXUP_SKU_IGNORE),
14970 SND_PCI_QUIRK(0x17aa, 0x21e9, "Thinkpad Edge 15", ALC269_FIXUP_SKU_IGNORE),
14971 SND_PCI_QUIRK(0x1043, 0x1a13, "Asus G73Jw", ALC269_FIXUP_ASUS_G73JW),
14972 SND_PCI_QUIRK(0x17aa, 0x9e54, "LENOVO NB", ALC269_FIXUP_LENOVO_EAPD),
14973 {}
14974 };
14975
14976
14977 /*
14978 * configuration and preset
14979 */
14980 static const char * const alc269_models[ALC269_MODEL_LAST] = {
14981 [ALC269_BASIC] = "basic",
14982 [ALC269_QUANTA_FL1] = "quanta",
14983 [ALC269_AMIC] = "laptop-amic",
14984 [ALC269_DMIC] = "laptop-dmic",
14985 [ALC269_FUJITSU] = "fujitsu",
14986 [ALC269_LIFEBOOK] = "lifebook",
14987 [ALC269_AUTO] = "auto",
14988 };
14989
14990 static const struct snd_pci_quirk alc269_cfg_tbl[] = {
14991 SND_PCI_QUIRK(0x17aa, 0x3bf8, "Quanta FL1", ALC269_QUANTA_FL1),
14992 SND_PCI_QUIRK(0x1025, 0x047c, "ACER ZGA", ALC271_ACER),
14993 SND_PCI_QUIRK(0x1043, 0x8330, "ASUS Eeepc P703 P900A",
14994 ALC269_AMIC),
14995 SND_PCI_QUIRK(0x1043, 0x1013, "ASUS N61Da", ALC269VB_AMIC),
14996 SND_PCI_QUIRK(0x1043, 0x1113, "ASUS N63Jn", ALC269VB_AMIC),
14997 SND_PCI_QUIRK(0x1043, 0x1143, "ASUS B53f", ALC269VB_AMIC),
14998 SND_PCI_QUIRK(0x1043, 0x1133, "ASUS UJ20ft", ALC269_AMIC),
14999 SND_PCI_QUIRK(0x1043, 0x1183, "ASUS K72DR", ALC269VB_AMIC),
15000 SND_PCI_QUIRK(0x1043, 0x11b3, "ASUS K52DR", ALC269VB_AMIC),
15001 SND_PCI_QUIRK(0x1043, 0x11e3, "ASUS U33Jc", ALC269VB_AMIC),
15002 SND_PCI_QUIRK(0x1043, 0x1273, "ASUS UL80Jt", ALC269VB_AMIC),
15003 SND_PCI_QUIRK(0x1043, 0x1283, "ASUS U53Jc", ALC269_AMIC),
15004 SND_PCI_QUIRK(0x1043, 0x12b3, "ASUS N82JV", ALC269VB_AMIC),
15005 SND_PCI_QUIRK(0x1043, 0x12d3, "ASUS N61Jv", ALC269_AMIC),
15006 SND_PCI_QUIRK(0x1043, 0x13a3, "ASUS UL30Vt", ALC269_AMIC),
15007 SND_PCI_QUIRK(0x1043, 0x1373, "ASUS G73JX", ALC269_AMIC),
15008 SND_PCI_QUIRK(0x1043, 0x1383, "ASUS UJ30Jc", ALC269_AMIC),
15009 SND_PCI_QUIRK(0x1043, 0x13d3, "ASUS N61JA", ALC269_AMIC),
15010 SND_PCI_QUIRK(0x1043, 0x1413, "ASUS UL50", ALC269_AMIC),
15011 SND_PCI_QUIRK(0x1043, 0x1443, "ASUS UL30", ALC269_AMIC),
15012 SND_PCI_QUIRK(0x1043, 0x1453, "ASUS M60Jv", ALC269_AMIC),
15013 SND_PCI_QUIRK(0x1043, 0x1483, "ASUS UL80", ALC269_AMIC),
15014 SND_PCI_QUIRK(0x1043, 0x14f3, "ASUS F83Vf", ALC269_AMIC),
15015 SND_PCI_QUIRK(0x1043, 0x14e3, "ASUS UL20", ALC269_AMIC),
15016 SND_PCI_QUIRK(0x1043, 0x1513, "ASUS UX30", ALC269_AMIC),
15017 SND_PCI_QUIRK(0x1043, 0x1593, "ASUS N51Vn", ALC269_AMIC),
15018 SND_PCI_QUIRK(0x1043, 0x15a3, "ASUS N60Jv", ALC269_AMIC),
15019 SND_PCI_QUIRK(0x1043, 0x15b3, "ASUS N60Dp", ALC269_AMIC),
15020 SND_PCI_QUIRK(0x1043, 0x15c3, "ASUS N70De", ALC269_AMIC),
15021 SND_PCI_QUIRK(0x1043, 0x15e3, "ASUS F83T", ALC269_AMIC),
15022 SND_PCI_QUIRK(0x1043, 0x1643, "ASUS M60J", ALC269_AMIC),
15023 SND_PCI_QUIRK(0x1043, 0x1653, "ASUS U50", ALC269_AMIC),
15024 SND_PCI_QUIRK(0x1043, 0x1693, "ASUS F50N", ALC269_AMIC),
15025 SND_PCI_QUIRK(0x1043, 0x16a3, "ASUS F5Q", ALC269_AMIC),
15026 SND_PCI_QUIRK(0x1043, 0x16e3, "ASUS UX50", ALC269_DMIC),
15027 SND_PCI_QUIRK(0x1043, 0x1723, "ASUS P80", ALC269_AMIC),
15028 SND_PCI_QUIRK(0x1043, 0x1743, "ASUS U80", ALC269_AMIC),
15029 SND_PCI_QUIRK(0x1043, 0x1773, "ASUS U20A", ALC269_AMIC),
15030 SND_PCI_QUIRK(0x1043, 0x1883, "ASUS F81Se", ALC269_AMIC),
15031 SND_PCI_QUIRK(0x1043, 0x831a, "ASUS Eeepc P901",
15032 ALC269_DMIC),
15033 SND_PCI_QUIRK(0x1043, 0x834a, "ASUS Eeepc S101",
15034 ALC269_DMIC),
15035 SND_PCI_QUIRK(0x1043, 0x8398, "ASUS P1005HA", ALC269_DMIC),
15036 SND_PCI_QUIRK(0x1043, 0x83ce, "ASUS P1005HA", ALC269_DMIC),
15037 SND_PCI_QUIRK(0x104d, 0x9071, "Sony VAIO", ALC269_AUTO),
15038 SND_PCI_QUIRK(0x10cf, 0x1475, "Lifebook ICH9M-based", ALC269_LIFEBOOK),
15039 SND_PCI_QUIRK(0x152d, 0x1778, "Quanta ON1", ALC269_DMIC),
15040 SND_PCI_QUIRK(0x1734, 0x115d, "FSC Amilo", ALC269_FUJITSU),
15041 SND_PCI_QUIRK(0x17aa, 0x3be9, "Quanta Wistron", ALC269_AMIC),
15042 SND_PCI_QUIRK(0x17aa, 0x3bf8, "Quanta FL1", ALC269_AMIC),
15043 SND_PCI_QUIRK(0x17ff, 0x059a, "Quanta EL3", ALC269_DMIC),
15044 SND_PCI_QUIRK(0x17ff, 0x059b, "Quanta JR1", ALC269_DMIC),
15045 {}
15046 };
15047
15048 static const struct alc_config_preset alc269_presets[] = {
15049 [ALC269_BASIC] = {
15050 .mixers = { alc269_base_mixer },
15051 .init_verbs = { alc269_init_verbs },
15052 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
15053 .dac_nids = alc269_dac_nids,
15054 .hp_nid = 0x03,
15055 .num_channel_mode = ARRAY_SIZE(alc269_modes),
15056 .channel_mode = alc269_modes,
15057 .input_mux = &alc269_capture_source,
15058 },
15059 [ALC269_QUANTA_FL1] = {
15060 .mixers = { alc269_quanta_fl1_mixer },
15061 .init_verbs = { alc269_init_verbs, alc269_quanta_fl1_verbs },
15062 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
15063 .dac_nids = alc269_dac_nids,
15064 .hp_nid = 0x03,
15065 .num_channel_mode = ARRAY_SIZE(alc269_modes),
15066 .channel_mode = alc269_modes,
15067 .input_mux = &alc269_capture_source,
15068 .unsol_event = alc269_quanta_fl1_unsol_event,
15069 .setup = alc269_quanta_fl1_setup,
15070 .init_hook = alc269_quanta_fl1_init_hook,
15071 },
15072 [ALC269_AMIC] = {
15073 .mixers = { alc269_laptop_mixer },
15074 .cap_mixer = alc269_laptop_analog_capture_mixer,
15075 .init_verbs = { alc269_init_verbs,
15076 alc269_laptop_amic_init_verbs },
15077 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
15078 .dac_nids = alc269_dac_nids,
15079 .hp_nid = 0x03,
15080 .num_channel_mode = ARRAY_SIZE(alc269_modes),
15081 .channel_mode = alc269_modes,
15082 .unsol_event = alc_sku_unsol_event,
15083 .setup = alc269_laptop_amic_setup,
15084 .init_hook = alc_inithook,
15085 },
15086 [ALC269_DMIC] = {
15087 .mixers = { alc269_laptop_mixer },
15088 .cap_mixer = alc269_laptop_digital_capture_mixer,
15089 .init_verbs = { alc269_init_verbs,
15090 alc269_laptop_dmic_init_verbs },
15091 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
15092 .dac_nids = alc269_dac_nids,
15093 .hp_nid = 0x03,
15094 .num_channel_mode = ARRAY_SIZE(alc269_modes),
15095 .channel_mode = alc269_modes,
15096 .unsol_event = alc_sku_unsol_event,
15097 .setup = alc269_laptop_dmic_setup,
15098 .init_hook = alc_inithook,
15099 },
15100 [ALC269VB_AMIC] = {
15101 .mixers = { alc269vb_laptop_mixer },
15102 .cap_mixer = alc269vb_laptop_analog_capture_mixer,
15103 .init_verbs = { alc269vb_init_verbs,
15104 alc269vb_laptop_amic_init_verbs },
15105 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
15106 .dac_nids = alc269_dac_nids,
15107 .hp_nid = 0x03,
15108 .num_channel_mode = ARRAY_SIZE(alc269_modes),
15109 .channel_mode = alc269_modes,
15110 .unsol_event = alc_sku_unsol_event,
15111 .setup = alc269vb_laptop_amic_setup,
15112 .init_hook = alc_inithook,
15113 },
15114 [ALC269VB_DMIC] = {
15115 .mixers = { alc269vb_laptop_mixer },
15116 .cap_mixer = alc269vb_laptop_digital_capture_mixer,
15117 .init_verbs = { alc269vb_init_verbs,
15118 alc269vb_laptop_dmic_init_verbs },
15119 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
15120 .dac_nids = alc269_dac_nids,
15121 .hp_nid = 0x03,
15122 .num_channel_mode = ARRAY_SIZE(alc269_modes),
15123 .channel_mode = alc269_modes,
15124 .unsol_event = alc_sku_unsol_event,
15125 .setup = alc269vb_laptop_dmic_setup,
15126 .init_hook = alc_inithook,
15127 },
15128 [ALC269_FUJITSU] = {
15129 .mixers = { alc269_fujitsu_mixer },
15130 .cap_mixer = alc269_laptop_digital_capture_mixer,
15131 .init_verbs = { alc269_init_verbs,
15132 alc269_laptop_dmic_init_verbs },
15133 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
15134 .dac_nids = alc269_dac_nids,
15135 .hp_nid = 0x03,
15136 .num_channel_mode = ARRAY_SIZE(alc269_modes),
15137 .channel_mode = alc269_modes,
15138 .unsol_event = alc_sku_unsol_event,
15139 .setup = alc269_laptop_dmic_setup,
15140 .init_hook = alc_inithook,
15141 },
15142 [ALC269_LIFEBOOK] = {
15143 .mixers = { alc269_lifebook_mixer },
15144 .init_verbs = { alc269_init_verbs, alc269_lifebook_verbs },
15145 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
15146 .dac_nids = alc269_dac_nids,
15147 .hp_nid = 0x03,
15148 .num_channel_mode = ARRAY_SIZE(alc269_modes),
15149 .channel_mode = alc269_modes,
15150 .input_mux = &alc269_capture_source,
15151 .unsol_event = alc269_lifebook_unsol_event,
15152 .setup = alc269_lifebook_setup,
15153 .init_hook = alc269_lifebook_init_hook,
15154 },
15155 [ALC271_ACER] = {
15156 .mixers = { alc269_asus_mixer },
15157 .cap_mixer = alc269vb_laptop_digital_capture_mixer,
15158 .init_verbs = { alc269_init_verbs, alc271_acer_dmic_verbs },
15159 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
15160 .dac_nids = alc269_dac_nids,
15161 .adc_nids = alc262_dmic_adc_nids,
15162 .num_adc_nids = ARRAY_SIZE(alc262_dmic_adc_nids),
15163 .capsrc_nids = alc262_dmic_capsrc_nids,
15164 .num_channel_mode = ARRAY_SIZE(alc269_modes),
15165 .channel_mode = alc269_modes,
15166 .input_mux = &alc269_capture_source,
15167 .dig_out_nid = ALC880_DIGOUT_NID,
15168 .unsol_event = alc_sku_unsol_event,
15169 .setup = alc269vb_laptop_dmic_setup,
15170 .init_hook = alc_inithook,
15171 },
15172 };
15173
15174 static int alc269_fill_coef(struct hda_codec *codec)
15175 {
15176 int val;
15177
15178 if ((alc_read_coef_idx(codec, 0) & 0x00ff) < 0x015) {
15179 alc_write_coef_idx(codec, 0xf, 0x960b);
15180 alc_write_coef_idx(codec, 0xe, 0x8817);
15181 }
15182
15183 if ((alc_read_coef_idx(codec, 0) & 0x00ff) == 0x016) {
15184 alc_write_coef_idx(codec, 0xf, 0x960b);
15185 alc_write_coef_idx(codec, 0xe, 0x8814);
15186 }
15187
15188 if ((alc_read_coef_idx(codec, 0) & 0x00ff) == 0x017) {
15189 val = alc_read_coef_idx(codec, 0x04);
15190 /* Power up output pin */
15191 alc_write_coef_idx(codec, 0x04, val | (1<<11));
15192 }
15193
15194 if ((alc_read_coef_idx(codec, 0) & 0x00ff) == 0x018) {
15195 val = alc_read_coef_idx(codec, 0xd);
15196 if ((val & 0x0c00) >> 10 != 0x1) {
15197 /* Capless ramp up clock control */
15198 alc_write_coef_idx(codec, 0xd, val | (1<<10));
15199 }
15200 val = alc_read_coef_idx(codec, 0x17);
15201 if ((val & 0x01c0) >> 6 != 0x4) {
15202 /* Class D power on reset */
15203 alc_write_coef_idx(codec, 0x17, val | (1<<7));
15204 }
15205 }
15206
15207 val = alc_read_coef_idx(codec, 0xd); /* Class D */
15208 alc_write_coef_idx(codec, 0xd, val | (1<<14));
15209
15210 val = alc_read_coef_idx(codec, 0x4); /* HP */
15211 alc_write_coef_idx(codec, 0x4, val | (1<<11));
15212
15213 return 0;
15214 }
15215
15216 static int patch_alc269(struct hda_codec *codec)
15217 {
15218 struct alc_spec *spec;
15219 int board_config, coef;
15220 int err;
15221
15222 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
15223 if (spec == NULL)
15224 return -ENOMEM;
15225
15226 codec->spec = spec;
15227
15228 alc_auto_parse_customize_define(codec);
15229
15230 if (codec->vendor_id == 0x10ec0269) {
15231 coef = alc_read_coef_idx(codec, 0);
15232 if ((coef & 0x00f0) == 0x0010) {
15233 if (codec->bus->pci->subsystem_vendor == 0x1025 &&
15234 spec->cdefine.platform_type == 1) {
15235 alc_codec_rename(codec, "ALC271X");
15236 spec->codec_variant = ALC269_TYPE_ALC271X;
15237 } else if ((coef & 0xf000) == 0x1000) {
15238 spec->codec_variant = ALC269_TYPE_ALC270;
15239 } else if ((coef & 0xf000) == 0x2000) {
15240 alc_codec_rename(codec, "ALC259");
15241 spec->codec_variant = ALC269_TYPE_ALC259;
15242 } else if ((coef & 0xf000) == 0x3000) {
15243 alc_codec_rename(codec, "ALC258");
15244 spec->codec_variant = ALC269_TYPE_ALC258;
15245 } else {
15246 alc_codec_rename(codec, "ALC269VB");
15247 spec->codec_variant = ALC269_TYPE_ALC269VB;
15248 }
15249 } else
15250 alc_fix_pll_init(codec, 0x20, 0x04, 15);
15251 alc269_fill_coef(codec);
15252 }
15253
15254 board_config = snd_hda_check_board_config(codec, ALC269_MODEL_LAST,
15255 alc269_models,
15256 alc269_cfg_tbl);
15257
15258 if (board_config < 0) {
15259 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
15260 codec->chip_name);
15261 board_config = ALC269_AUTO;
15262 }
15263
15264 if (board_config == ALC269_AUTO) {
15265 alc_pick_fixup(codec, NULL, alc269_fixup_tbl, alc269_fixups);
15266 alc_apply_fixup(codec, ALC_FIXUP_ACT_PRE_PROBE);
15267 }
15268
15269 if (board_config == ALC269_AUTO) {
15270 /* automatic parse from the BIOS config */
15271 err = alc269_parse_auto_config(codec);
15272 if (err < 0) {
15273 alc_free(codec);
15274 return err;
15275 } else if (!err) {
15276 printk(KERN_INFO
15277 "hda_codec: Cannot set up configuration "
15278 "from BIOS. Using base mode...\n");
15279 board_config = ALC269_BASIC;
15280 }
15281 }
15282
15283 if (has_cdefine_beep(codec)) {
15284 err = snd_hda_attach_beep_device(codec, 0x1);
15285 if (err < 0) {
15286 alc_free(codec);
15287 return err;
15288 }
15289 }
15290
15291 if (board_config != ALC269_AUTO)
15292 setup_preset(codec, &alc269_presets[board_config]);
15293
15294 if (board_config == ALC269_QUANTA_FL1) {
15295 /* Due to a hardware problem on Lenovo Ideadpad, we need to
15296 * fix the sample rate of analog I/O to 44.1kHz
15297 */
15298 spec->stream_analog_playback = &alc269_44k_pcm_analog_playback;
15299 spec->stream_analog_capture = &alc269_44k_pcm_analog_capture;
15300 } else if (spec->dual_adc_switch) {
15301 spec->stream_analog_playback = &alc269_pcm_analog_playback;
15302 /* switch ADC dynamically */
15303 spec->stream_analog_capture = &dualmic_pcm_analog_capture;
15304 } else {
15305 spec->stream_analog_playback = &alc269_pcm_analog_playback;
15306 spec->stream_analog_capture = &alc269_pcm_analog_capture;
15307 }
15308 spec->stream_digital_playback = &alc269_pcm_digital_playback;
15309 spec->stream_digital_capture = &alc269_pcm_digital_capture;
15310
15311 if (!spec->adc_nids) { /* wasn't filled automatically? use default */
15312 if (spec->codec_variant == ALC269_TYPE_NORMAL) {
15313 spec->adc_nids = alc269_adc_nids;
15314 spec->num_adc_nids = ARRAY_SIZE(alc269_adc_nids);
15315 spec->capsrc_nids = alc269_capsrc_nids;
15316 } else {
15317 spec->adc_nids = alc269vb_adc_nids;
15318 spec->num_adc_nids = ARRAY_SIZE(alc269vb_adc_nids);
15319 spec->capsrc_nids = alc269vb_capsrc_nids;
15320 }
15321 }
15322
15323 if (!spec->cap_mixer)
15324 set_capture_mixer(codec);
15325 if (has_cdefine_beep(codec))
15326 set_beep_amp(spec, 0x0b, 0x04, HDA_INPUT);
15327
15328 alc_apply_fixup(codec, ALC_FIXUP_ACT_PROBE);
15329
15330 spec->vmaster_nid = 0x02;
15331
15332 codec->patch_ops = alc_patch_ops;
15333 #ifdef SND_HDA_NEEDS_RESUME
15334 codec->patch_ops.resume = alc269_resume;
15335 #endif
15336 if (board_config == ALC269_AUTO)
15337 spec->init_hook = alc269_auto_init;
15338 spec->shutup = alc269_shutup;
15339
15340 alc_init_jacks(codec);
15341 #ifdef CONFIG_SND_HDA_POWER_SAVE
15342 if (!spec->loopback.amplist)
15343 spec->loopback.amplist = alc269_loopbacks;
15344 if (alc269_mic2_for_mute_led(codec))
15345 codec->patch_ops.check_power_status = alc269_mic2_mute_check_ps;
15346 #endif
15347
15348 return 0;
15349 }
15350
15351 /*
15352 * ALC861 channel source setting (2/6 channel selection for 3-stack)
15353 */
15354
15355 /*
15356 * set the path ways for 2 channel output
15357 * need to set the codec line out and mic 1 pin widgets to inputs
15358 */
15359 static const struct hda_verb alc861_threestack_ch2_init[] = {
15360 /* set pin widget 1Ah (line in) for input */
15361 { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
15362 /* set pin widget 18h (mic1/2) for input, for mic also enable
15363 * the vref
15364 */
15365 { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
15366
15367 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c },
15368 #if 0
15369 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8)) }, /*mic*/
15370 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8)) }, /*line-in*/
15371 #endif
15372 { } /* end */
15373 };
15374 /*
15375 * 6ch mode
15376 * need to set the codec line out and mic 1 pin widgets to outputs
15377 */
15378 static const struct hda_verb alc861_threestack_ch6_init[] = {
15379 /* set pin widget 1Ah (line in) for output (Back Surround)*/
15380 { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
15381 /* set pin widget 18h (mic1) for output (CLFE)*/
15382 { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
15383
15384 { 0x0c, AC_VERB_SET_CONNECT_SEL, 0x00 },
15385 { 0x0d, AC_VERB_SET_CONNECT_SEL, 0x00 },
15386
15387 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080 },
15388 #if 0
15389 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8)) }, /*mic*/
15390 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8)) }, /*line in*/
15391 #endif
15392 { } /* end */
15393 };
15394
15395 static const struct hda_channel_mode alc861_threestack_modes[2] = {
15396 { 2, alc861_threestack_ch2_init },
15397 { 6, alc861_threestack_ch6_init },
15398 };
15399 /* Set mic1 as input and unmute the mixer */
15400 static const struct hda_verb alc861_uniwill_m31_ch2_init[] = {
15401 { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
15402 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8)) }, /*mic*/
15403 { } /* end */
15404 };
15405 /* Set mic1 as output and mute mixer */
15406 static const struct hda_verb alc861_uniwill_m31_ch4_init[] = {
15407 { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
15408 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8)) }, /*mic*/
15409 { } /* end */
15410 };
15411
15412 static const struct hda_channel_mode alc861_uniwill_m31_modes[2] = {
15413 { 2, alc861_uniwill_m31_ch2_init },
15414 { 4, alc861_uniwill_m31_ch4_init },
15415 };
15416
15417 /* Set mic1 and line-in as input and unmute the mixer */
15418 static const struct hda_verb alc861_asus_ch2_init[] = {
15419 /* set pin widget 1Ah (line in) for input */
15420 { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
15421 /* set pin widget 18h (mic1/2) for input, for mic also enable
15422 * the vref
15423 */
15424 { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
15425
15426 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c },
15427 #if 0
15428 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8)) }, /*mic*/
15429 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8)) }, /*line-in*/
15430 #endif
15431 { } /* end */
15432 };
15433 /* Set mic1 nad line-in as output and mute mixer */
15434 static const struct hda_verb alc861_asus_ch6_init[] = {
15435 /* set pin widget 1Ah (line in) for output (Back Surround)*/
15436 { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
15437 /* { 0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, */
15438 /* set pin widget 18h (mic1) for output (CLFE)*/
15439 { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
15440 /* { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, */
15441 { 0x0c, AC_VERB_SET_CONNECT_SEL, 0x00 },
15442 { 0x0d, AC_VERB_SET_CONNECT_SEL, 0x00 },
15443
15444 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080 },
15445 #if 0
15446 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8)) }, /*mic*/
15447 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8)) }, /*line in*/
15448 #endif
15449 { } /* end */
15450 };
15451
15452 static const struct hda_channel_mode alc861_asus_modes[2] = {
15453 { 2, alc861_asus_ch2_init },
15454 { 6, alc861_asus_ch6_init },
15455 };
15456
15457 /* patch-ALC861 */
15458
15459 static const struct snd_kcontrol_new alc861_base_mixer[] = {
15460 /* output mixer control */
15461 HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
15462 HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
15463 HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
15464 HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
15465 HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT),
15466
15467 /*Input mixer control */
15468 /* HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
15469 HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT), */
15470 HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
15471 HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
15472 HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
15473 HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
15474 HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
15475 HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
15476 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
15477 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_INPUT),
15478
15479 { } /* end */
15480 };
15481
15482 static const struct snd_kcontrol_new alc861_3ST_mixer[] = {
15483 /* output mixer control */
15484 HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
15485 HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
15486 HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
15487 HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
15488 /*HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT), */
15489
15490 /* Input mixer control */
15491 /* HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
15492 HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT), */
15493 HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
15494 HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
15495 HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
15496 HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
15497 HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
15498 HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
15499 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
15500 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_INPUT),
15501
15502 {
15503 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
15504 .name = "Channel Mode",
15505 .info = alc_ch_mode_info,
15506 .get = alc_ch_mode_get,
15507 .put = alc_ch_mode_put,
15508 .private_value = ARRAY_SIZE(alc861_threestack_modes),
15509 },
15510 { } /* end */
15511 };
15512
15513 static const struct snd_kcontrol_new alc861_toshiba_mixer[] = {
15514 /* output mixer control */
15515 HDA_CODEC_MUTE("Master Playback Switch", 0x03, 0x0, HDA_OUTPUT),
15516 HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
15517 HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
15518
15519 { } /* end */
15520 };
15521
15522 static const struct snd_kcontrol_new alc861_uniwill_m31_mixer[] = {
15523 /* output mixer control */
15524 HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
15525 HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
15526 HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
15527 HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
15528 /*HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT), */
15529
15530 /* Input mixer control */
15531 /* HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
15532 HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT), */
15533 HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
15534 HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
15535 HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
15536 HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
15537 HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
15538 HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
15539 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
15540 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_INPUT),
15541
15542 {
15543 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
15544 .name = "Channel Mode",
15545 .info = alc_ch_mode_info,
15546 .get = alc_ch_mode_get,
15547 .put = alc_ch_mode_put,
15548 .private_value = ARRAY_SIZE(alc861_uniwill_m31_modes),
15549 },
15550 { } /* end */
15551 };
15552
15553 static const struct snd_kcontrol_new alc861_asus_mixer[] = {
15554 /* output mixer control */
15555 HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
15556 HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
15557 HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
15558 HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
15559 HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT),
15560
15561 /* Input mixer control */
15562 HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
15563 HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT),
15564 HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
15565 HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
15566 HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
15567 HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
15568 HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
15569 HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
15570 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
15571 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_OUTPUT),
15572
15573 {
15574 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
15575 .name = "Channel Mode",
15576 .info = alc_ch_mode_info,
15577 .get = alc_ch_mode_get,
15578 .put = alc_ch_mode_put,
15579 .private_value = ARRAY_SIZE(alc861_asus_modes),
15580 },
15581 { }
15582 };
15583
15584 /* additional mixer */
15585 static const struct snd_kcontrol_new alc861_asus_laptop_mixer[] = {
15586 HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
15587 HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
15588 { }
15589 };
15590
15591 /*
15592 * generic initialization of ADC, input mixers and output mixers
15593 */
15594 static const struct hda_verb alc861_base_init_verbs[] = {
15595 /*
15596 * Unmute ADC0 and set the default input to mic-in
15597 */
15598 /* port-A for surround (rear panel) */
15599 { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
15600 { 0x0e, AC_VERB_SET_CONNECT_SEL, 0x00 },
15601 /* port-B for mic-in (rear panel) with vref */
15602 { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
15603 /* port-C for line-in (rear panel) */
15604 { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
15605 /* port-D for Front */
15606 { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
15607 { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
15608 /* port-E for HP out (front panel) */
15609 { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 },
15610 /* route front PCM to HP */
15611 { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
15612 /* port-F for mic-in (front panel) with vref */
15613 { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
15614 /* port-G for CLFE (rear panel) */
15615 { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
15616 { 0x1f, AC_VERB_SET_CONNECT_SEL, 0x00 },
15617 /* port-H for side (rear panel) */
15618 { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
15619 { 0x20, AC_VERB_SET_CONNECT_SEL, 0x00 },
15620 /* CD-in */
15621 { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
15622 /* route front mic to ADC1*/
15623 {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
15624 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15625
15626 /* Unmute DAC0~3 & spdif out*/
15627 {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15628 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15629 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15630 {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15631 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15632
15633 /* Unmute Mixer 14 (mic) 1c (Line in)*/
15634 {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15635 {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15636 {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15637 {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15638
15639 /* Unmute Stereo Mixer 15 */
15640 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15641 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15642 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
15643 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */
15644
15645 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15646 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15647 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15648 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15649 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15650 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15651 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15652 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15653 /* hp used DAC 3 (Front) */
15654 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
15655 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
15656
15657 { }
15658 };
15659
15660 static const struct hda_verb alc861_threestack_init_verbs[] = {
15661 /*
15662 * Unmute ADC0 and set the default input to mic-in
15663 */
15664 /* port-A for surround (rear panel) */
15665 { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
15666 /* port-B for mic-in (rear panel) with vref */
15667 { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
15668 /* port-C for line-in (rear panel) */
15669 { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
15670 /* port-D for Front */
15671 { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
15672 { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
15673 /* port-E for HP out (front panel) */
15674 { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 },
15675 /* route front PCM to HP */
15676 { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
15677 /* port-F for mic-in (front panel) with vref */
15678 { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
15679 /* port-G for CLFE (rear panel) */
15680 { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
15681 /* port-H for side (rear panel) */
15682 { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
15683 /* CD-in */
15684 { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
15685 /* route front mic to ADC1*/
15686 {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
15687 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15688 /* Unmute DAC0~3 & spdif out*/
15689 {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15690 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15691 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15692 {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15693 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15694
15695 /* Unmute Mixer 14 (mic) 1c (Line in)*/
15696 {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15697 {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15698 {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15699 {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15700
15701 /* Unmute Stereo Mixer 15 */
15702 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15703 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15704 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
15705 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */
15706
15707 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15708 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15709 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15710 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15711 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15712 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15713 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15714 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15715 /* hp used DAC 3 (Front) */
15716 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
15717 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
15718 { }
15719 };
15720
15721 static const struct hda_verb alc861_uniwill_m31_init_verbs[] = {
15722 /*
15723 * Unmute ADC0 and set the default input to mic-in
15724 */
15725 /* port-A for surround (rear panel) */
15726 { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
15727 /* port-B for mic-in (rear panel) with vref */
15728 { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
15729 /* port-C for line-in (rear panel) */
15730 { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
15731 /* port-D for Front */
15732 { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
15733 { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
15734 /* port-E for HP out (front panel) */
15735 /* this has to be set to VREF80 */
15736 { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
15737 /* route front PCM to HP */
15738 { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
15739 /* port-F for mic-in (front panel) with vref */
15740 { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
15741 /* port-G for CLFE (rear panel) */
15742 { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
15743 /* port-H for side (rear panel) */
15744 { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
15745 /* CD-in */
15746 { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
15747 /* route front mic to ADC1*/
15748 {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
15749 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15750 /* Unmute DAC0~3 & spdif out*/
15751 {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15752 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15753 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15754 {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15755 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15756
15757 /* Unmute Mixer 14 (mic) 1c (Line in)*/
15758 {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15759 {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15760 {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15761 {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15762
15763 /* Unmute Stereo Mixer 15 */
15764 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15765 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15766 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
15767 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */
15768
15769 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15770 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15771 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15772 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15773 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15774 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15775 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15776 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15777 /* hp used DAC 3 (Front) */
15778 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
15779 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
15780 { }
15781 };
15782
15783 static const struct hda_verb alc861_asus_init_verbs[] = {
15784 /*
15785 * Unmute ADC0 and set the default input to mic-in
15786 */
15787 /* port-A for surround (rear panel)
15788 * according to codec#0 this is the HP jack
15789 */
15790 { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 }, /* was 0x00 */
15791 /* route front PCM to HP */
15792 { 0x0e, AC_VERB_SET_CONNECT_SEL, 0x01 },
15793 /* port-B for mic-in (rear panel) with vref */
15794 { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
15795 /* port-C for line-in (rear panel) */
15796 { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
15797 /* port-D for Front */
15798 { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
15799 { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
15800 /* port-E for HP out (front panel) */
15801 /* this has to be set to VREF80 */
15802 { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
15803 /* route front PCM to HP */
15804 { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
15805 /* port-F for mic-in (front panel) with vref */
15806 { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
15807 /* port-G for CLFE (rear panel) */
15808 { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
15809 /* port-H for side (rear panel) */
15810 { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
15811 /* CD-in */
15812 { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
15813 /* route front mic to ADC1*/
15814 {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
15815 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15816 /* Unmute DAC0~3 & spdif out*/
15817 {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15818 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15819 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15820 {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15821 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15822 /* Unmute Mixer 14 (mic) 1c (Line in)*/
15823 {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15824 {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15825 {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15826 {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15827
15828 /* Unmute Stereo Mixer 15 */
15829 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15830 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15831 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
15832 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */
15833
15834 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15835 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15836 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15837 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15838 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15839 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15840 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15841 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15842 /* hp used DAC 3 (Front) */
15843 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
15844 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
15845 { }
15846 };
15847
15848 /* additional init verbs for ASUS laptops */
15849 static const struct hda_verb alc861_asus_laptop_init_verbs[] = {
15850 { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x45 }, /* HP-out */
15851 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2) }, /* mute line-in */
15852 { }
15853 };
15854
15855 /*
15856 * generic initialization of ADC, input mixers and output mixers
15857 */
15858 static const struct hda_verb alc861_auto_init_verbs[] = {
15859 /*
15860 * Unmute ADC0 and set the default input to mic-in
15861 */
15862 /* {0x08, AC_VERB_SET_CONNECT_SEL, 0x00}, */
15863 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15864
15865 /* Unmute DAC0~3 & spdif out*/
15866 {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
15867 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
15868 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
15869 {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
15870 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15871
15872 /* Unmute Mixer 14 (mic) 1c (Line in)*/
15873 {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15874 {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15875 {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15876 {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15877
15878 /* Unmute Stereo Mixer 15 */
15879 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15880 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15881 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
15882 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c},
15883
15884 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15885 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
15886 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15887 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
15888 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15889 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
15890 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15891 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
15892
15893 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15894 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
15895 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
15896 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
15897 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15898 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
15899 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
15900 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
15901
15902 {0x08, AC_VERB_SET_CONNECT_SEL, 0x00}, /* set Mic 1 */
15903
15904 { }
15905 };
15906
15907 static const struct hda_verb alc861_toshiba_init_verbs[] = {
15908 {0x0f, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15909
15910 { }
15911 };
15912
15913 /* toggle speaker-output according to the hp-jack state */
15914 static void alc861_toshiba_automute(struct hda_codec *codec)
15915 {
15916 unsigned int present = snd_hda_jack_detect(codec, 0x0f);
15917
15918 snd_hda_codec_amp_stereo(codec, 0x16, HDA_INPUT, 0,
15919 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
15920 snd_hda_codec_amp_stereo(codec, 0x1a, HDA_INPUT, 3,
15921 HDA_AMP_MUTE, present ? 0 : HDA_AMP_MUTE);
15922 }
15923
15924 static void alc861_toshiba_unsol_event(struct hda_codec *codec,
15925 unsigned int res)
15926 {
15927 if ((res >> 26) == ALC880_HP_EVENT)
15928 alc861_toshiba_automute(codec);
15929 }
15930
15931 /* pcm configuration: identical with ALC880 */
15932 #define alc861_pcm_analog_playback alc880_pcm_analog_playback
15933 #define alc861_pcm_analog_capture alc880_pcm_analog_capture
15934 #define alc861_pcm_digital_playback alc880_pcm_digital_playback
15935 #define alc861_pcm_digital_capture alc880_pcm_digital_capture
15936
15937
15938 #define ALC861_DIGOUT_NID 0x07
15939
15940 static const struct hda_channel_mode alc861_8ch_modes[1] = {
15941 { 8, NULL }
15942 };
15943
15944 static const hda_nid_t alc861_dac_nids[4] = {
15945 /* front, surround, clfe, side */
15946 0x03, 0x06, 0x05, 0x04
15947 };
15948
15949 static const hda_nid_t alc660_dac_nids[3] = {
15950 /* front, clfe, surround */
15951 0x03, 0x05, 0x06
15952 };
15953
15954 static const hda_nid_t alc861_adc_nids[1] = {
15955 /* ADC0-2 */
15956 0x08,
15957 };
15958
15959 static const struct hda_input_mux alc861_capture_source = {
15960 .num_items = 5,
15961 .items = {
15962 { "Mic", 0x0 },
15963 { "Front Mic", 0x3 },
15964 { "Line", 0x1 },
15965 { "CD", 0x4 },
15966 { "Mixer", 0x5 },
15967 },
15968 };
15969
15970 static hda_nid_t alc861_look_for_dac(struct hda_codec *codec, hda_nid_t pin)
15971 {
15972 struct alc_spec *spec = codec->spec;
15973 hda_nid_t mix, srcs[5];
15974 int i, j, num;
15975
15976 if (snd_hda_get_connections(codec, pin, &mix, 1) != 1)
15977 return 0;
15978 num = snd_hda_get_connections(codec, mix, srcs, ARRAY_SIZE(srcs));
15979 if (num < 0)
15980 return 0;
15981 for (i = 0; i < num; i++) {
15982 unsigned int type;
15983 type = get_wcaps_type(get_wcaps(codec, srcs[i]));
15984 if (type != AC_WID_AUD_OUT)
15985 continue;
15986 for (j = 0; j < spec->multiout.num_dacs; j++)
15987 if (spec->multiout.dac_nids[j] == srcs[i])
15988 break;
15989 if (j >= spec->multiout.num_dacs)
15990 return srcs[i];
15991 }
15992 return 0;
15993 }
15994
15995 /* fill in the dac_nids table from the parsed pin configuration */
15996 static int alc861_auto_fill_dac_nids(struct hda_codec *codec,
15997 const struct auto_pin_cfg *cfg)
15998 {
15999 struct alc_spec *spec = codec->spec;
16000 int i;
16001 hda_nid_t nid, dac;
16002
16003 spec->multiout.dac_nids = spec->private_dac_nids;
16004 for (i = 0; i < cfg->line_outs; i++) {
16005 nid = cfg->line_out_pins[i];
16006 dac = alc861_look_for_dac(codec, nid);
16007 if (!dac)
16008 continue;
16009 spec->private_dac_nids[spec->multiout.num_dacs++] = dac;
16010 }
16011 return 0;
16012 }
16013
16014 static int __alc861_create_out_sw(struct hda_codec *codec, const char *pfx,
16015 hda_nid_t nid, int idx, unsigned int chs)
16016 {
16017 return __add_pb_sw_ctrl(codec->spec, ALC_CTL_WIDGET_MUTE, pfx, idx,
16018 HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_OUTPUT));
16019 }
16020
16021 #define alc861_create_out_sw(codec, pfx, nid, chs) \
16022 __alc861_create_out_sw(codec, pfx, nid, 0, chs)
16023
16024 /* add playback controls from the parsed DAC table */
16025 static int alc861_auto_create_multi_out_ctls(struct hda_codec *codec,
16026 const struct auto_pin_cfg *cfg)
16027 {
16028 struct alc_spec *spec = codec->spec;
16029 static const char * const chname[4] = {
16030 "Front", "Surround", NULL /*CLFE*/, "Side"
16031 };
16032 const char *pfx = alc_get_line_out_pfx(spec, true);
16033 hda_nid_t nid;
16034 int i, err, noutputs;
16035
16036 noutputs = cfg->line_outs;
16037 if (spec->multi_ios > 0)
16038 noutputs += spec->multi_ios;
16039
16040 for (i = 0; i < noutputs; i++) {
16041 nid = spec->multiout.dac_nids[i];
16042 if (!nid)
16043 continue;
16044 if (!pfx && i == 2) {
16045 /* Center/LFE */
16046 err = alc861_create_out_sw(codec, "Center", nid, 1);
16047 if (err < 0)
16048 return err;
16049 err = alc861_create_out_sw(codec, "LFE", nid, 2);
16050 if (err < 0)
16051 return err;
16052 } else {
16053 const char *name = pfx;
16054 int index = i;
16055 if (!name) {
16056 name = chname[i];
16057 index = 0;
16058 }
16059 err = __alc861_create_out_sw(codec, name, nid, index, 3);
16060 if (err < 0)
16061 return err;
16062 }
16063 }
16064 return 0;
16065 }
16066
16067 static int alc861_auto_create_hp_ctls(struct hda_codec *codec, hda_nid_t pin)
16068 {
16069 struct alc_spec *spec = codec->spec;
16070 int err;
16071 hda_nid_t nid;
16072
16073 if (!pin)
16074 return 0;
16075
16076 if ((pin >= 0x0b && pin <= 0x10) || pin == 0x1f || pin == 0x20) {
16077 nid = alc861_look_for_dac(codec, pin);
16078 if (nid) {
16079 err = alc861_create_out_sw(codec, "Headphone", nid, 3);
16080 if (err < 0)
16081 return err;
16082 spec->multiout.hp_nid = nid;
16083 }
16084 }
16085 return 0;
16086 }
16087
16088 /* create playback/capture controls for input pins */
16089 static int alc861_auto_create_input_ctls(struct hda_codec *codec,
16090 const struct auto_pin_cfg *cfg)
16091 {
16092 return alc_auto_create_input_ctls(codec, cfg, 0x15, 0x08, 0);
16093 }
16094
16095 static void alc861_auto_set_output_and_unmute(struct hda_codec *codec,
16096 hda_nid_t nid,
16097 int pin_type, hda_nid_t dac)
16098 {
16099 hda_nid_t mix, srcs[5];
16100 int i, num;
16101
16102 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
16103 pin_type);
16104 snd_hda_codec_write(codec, dac, 0, AC_VERB_SET_AMP_GAIN_MUTE,
16105 AMP_OUT_UNMUTE);
16106 if (snd_hda_get_connections(codec, nid, &mix, 1) != 1)
16107 return;
16108 num = snd_hda_get_connections(codec, mix, srcs, ARRAY_SIZE(srcs));
16109 if (num < 0)
16110 return;
16111 for (i = 0; i < num; i++) {
16112 unsigned int mute;
16113 if (srcs[i] == dac || srcs[i] == 0x15)
16114 mute = AMP_IN_UNMUTE(i);
16115 else
16116 mute = AMP_IN_MUTE(i);
16117 snd_hda_codec_write(codec, mix, 0, AC_VERB_SET_AMP_GAIN_MUTE,
16118 mute);
16119 }
16120 }
16121
16122 static void alc861_auto_init_multi_out(struct hda_codec *codec)
16123 {
16124 struct alc_spec *spec = codec->spec;
16125 int i;
16126
16127 for (i = 0; i < spec->autocfg.line_outs; i++) {
16128 hda_nid_t nid = spec->autocfg.line_out_pins[i];
16129 int pin_type = get_pin_type(spec->autocfg.line_out_type);
16130 if (nid)
16131 alc861_auto_set_output_and_unmute(codec, nid, pin_type,
16132 spec->multiout.dac_nids[i]);
16133 }
16134 }
16135
16136 static void alc861_auto_init_hp_out(struct hda_codec *codec)
16137 {
16138 struct alc_spec *spec = codec->spec;
16139
16140 if (spec->autocfg.hp_outs)
16141 alc861_auto_set_output_and_unmute(codec,
16142 spec->autocfg.hp_pins[0],
16143 PIN_HP,
16144 spec->multiout.hp_nid);
16145 if (spec->autocfg.speaker_outs)
16146 alc861_auto_set_output_and_unmute(codec,
16147 spec->autocfg.speaker_pins[0],
16148 PIN_OUT,
16149 spec->multiout.dac_nids[0]);
16150 }
16151
16152 static void alc861_auto_init_analog_input(struct hda_codec *codec)
16153 {
16154 struct alc_spec *spec = codec->spec;
16155 struct auto_pin_cfg *cfg = &spec->autocfg;
16156 int i;
16157
16158 for (i = 0; i < cfg->num_inputs; i++) {
16159 hda_nid_t nid = cfg->inputs[i].pin;
16160 if (nid >= 0x0c && nid <= 0x11)
16161 alc_set_input_pin(codec, nid, cfg->inputs[i].type);
16162 }
16163 }
16164
16165 /* parse the BIOS configuration and set up the alc_spec */
16166 /* return 1 if successful, 0 if the proper config is not found,
16167 * or a negative error code
16168 */
16169 static int alc861_parse_auto_config(struct hda_codec *codec)
16170 {
16171 struct alc_spec *spec = codec->spec;
16172 int err;
16173 static const hda_nid_t alc861_ignore[] = { 0x1d, 0 };
16174
16175 err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
16176 alc861_ignore);
16177 if (err < 0)
16178 return err;
16179 if (!spec->autocfg.line_outs)
16180 return 0; /* can't find valid BIOS pin config */
16181
16182 err = alc861_auto_fill_dac_nids(codec, &spec->autocfg);
16183 if (err < 0)
16184 return err;
16185 err = alc_auto_add_multi_channel_mode(codec);
16186 if (err < 0)
16187 return err;
16188 err = alc861_auto_create_multi_out_ctls(codec, &spec->autocfg);
16189 if (err < 0)
16190 return err;
16191 err = alc861_auto_create_hp_ctls(codec, spec->autocfg.hp_pins[0]);
16192 if (err < 0)
16193 return err;
16194 err = alc861_auto_create_input_ctls(codec, &spec->autocfg);
16195 if (err < 0)
16196 return err;
16197
16198 spec->multiout.max_channels = spec->multiout.num_dacs * 2;
16199
16200 alc_auto_parse_digital(codec);
16201
16202 if (spec->kctls.list)
16203 add_mixer(spec, spec->kctls.list);
16204
16205 add_verb(spec, alc861_auto_init_verbs);
16206
16207 spec->num_mux_defs = 1;
16208 spec->input_mux = &spec->private_imux[0];
16209
16210 spec->adc_nids = alc861_adc_nids;
16211 spec->num_adc_nids = ARRAY_SIZE(alc861_adc_nids);
16212 set_capture_mixer(codec);
16213
16214 alc_ssid_check(codec, 0x0e, 0x0f, 0x0b, 0);
16215
16216 return 1;
16217 }
16218
16219 /* additional initialization for auto-configuration model */
16220 static void alc861_auto_init(struct hda_codec *codec)
16221 {
16222 struct alc_spec *spec = codec->spec;
16223 alc861_auto_init_multi_out(codec);
16224 alc861_auto_init_hp_out(codec);
16225 alc861_auto_init_analog_input(codec);
16226 alc_auto_init_digital(codec);
16227 if (spec->unsol_event)
16228 alc_inithook(codec);
16229 }
16230
16231 #ifdef CONFIG_SND_HDA_POWER_SAVE
16232 static const struct hda_amp_list alc861_loopbacks[] = {
16233 { 0x15, HDA_INPUT, 0 },
16234 { 0x15, HDA_INPUT, 1 },
16235 { 0x15, HDA_INPUT, 2 },
16236 { 0x15, HDA_INPUT, 3 },
16237 { } /* end */
16238 };
16239 #endif
16240
16241
16242 /*
16243 * configuration and preset
16244 */
16245 static const char * const alc861_models[ALC861_MODEL_LAST] = {
16246 [ALC861_3ST] = "3stack",
16247 [ALC660_3ST] = "3stack-660",
16248 [ALC861_3ST_DIG] = "3stack-dig",
16249 [ALC861_6ST_DIG] = "6stack-dig",
16250 [ALC861_UNIWILL_M31] = "uniwill-m31",
16251 [ALC861_TOSHIBA] = "toshiba",
16252 [ALC861_ASUS] = "asus",
16253 [ALC861_ASUS_LAPTOP] = "asus-laptop",
16254 [ALC861_AUTO] = "auto",
16255 };
16256
16257 static const struct snd_pci_quirk alc861_cfg_tbl[] = {
16258 SND_PCI_QUIRK(0x1043, 0x1205, "ASUS W7J", ALC861_3ST),
16259 SND_PCI_QUIRK(0x1043, 0x1335, "ASUS F2/3", ALC861_ASUS_LAPTOP),
16260 SND_PCI_QUIRK(0x1043, 0x1338, "ASUS F2/3", ALC861_ASUS_LAPTOP),
16261 SND_PCI_QUIRK(0x1043, 0x1393, "ASUS", ALC861_ASUS),
16262 SND_PCI_QUIRK(0x1043, 0x13d7, "ASUS A9rp", ALC861_ASUS_LAPTOP),
16263 SND_PCI_QUIRK(0x1043, 0x81cb, "ASUS P1-AH2", ALC861_3ST_DIG),
16264 SND_PCI_QUIRK(0x1179, 0xff00, "Toshiba", ALC861_TOSHIBA),
16265 /* FIXME: the entry below breaks Toshiba A100 (model=auto works!)
16266 * Any other models that need this preset?
16267 */
16268 /* SND_PCI_QUIRK(0x1179, 0xff10, "Toshiba", ALC861_TOSHIBA), */
16269 SND_PCI_QUIRK(0x1462, 0x7254, "HP dx2200 (MSI MS-7254)", ALC861_3ST),
16270 SND_PCI_QUIRK(0x1462, 0x7297, "HP dx2250 (MSI MS-7297)", ALC861_3ST),
16271 SND_PCI_QUIRK(0x1584, 0x2b01, "Uniwill X40AIx", ALC861_UNIWILL_M31),
16272 SND_PCI_QUIRK(0x1584, 0x9072, "Uniwill m31", ALC861_UNIWILL_M31),
16273 SND_PCI_QUIRK(0x1584, 0x9075, "Airis Praxis N1212", ALC861_ASUS_LAPTOP),
16274 /* FIXME: the below seems conflict */
16275 /* SND_PCI_QUIRK(0x1584, 0x9075, "Uniwill", ALC861_UNIWILL_M31), */
16276 SND_PCI_QUIRK(0x1849, 0x0660, "Asrock 939SLI32", ALC660_3ST),
16277 SND_PCI_QUIRK(0x8086, 0xd600, "Intel", ALC861_3ST),
16278 {}
16279 };
16280
16281 static const struct alc_config_preset alc861_presets[] = {
16282 [ALC861_3ST] = {
16283 .mixers = { alc861_3ST_mixer },
16284 .init_verbs = { alc861_threestack_init_verbs },
16285 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
16286 .dac_nids = alc861_dac_nids,
16287 .num_channel_mode = ARRAY_SIZE(alc861_threestack_modes),
16288 .channel_mode = alc861_threestack_modes,
16289 .need_dac_fix = 1,
16290 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
16291 .adc_nids = alc861_adc_nids,
16292 .input_mux = &alc861_capture_source,
16293 },
16294 [ALC861_3ST_DIG] = {
16295 .mixers = { alc861_base_mixer },
16296 .init_verbs = { alc861_threestack_init_verbs },
16297 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
16298 .dac_nids = alc861_dac_nids,
16299 .dig_out_nid = ALC861_DIGOUT_NID,
16300 .num_channel_mode = ARRAY_SIZE(alc861_threestack_modes),
16301 .channel_mode = alc861_threestack_modes,
16302 .need_dac_fix = 1,
16303 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
16304 .adc_nids = alc861_adc_nids,
16305 .input_mux = &alc861_capture_source,
16306 },
16307 [ALC861_6ST_DIG] = {
16308 .mixers = { alc861_base_mixer },
16309 .init_verbs = { alc861_base_init_verbs },
16310 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
16311 .dac_nids = alc861_dac_nids,
16312 .dig_out_nid = ALC861_DIGOUT_NID,
16313 .num_channel_mode = ARRAY_SIZE(alc861_8ch_modes),
16314 .channel_mode = alc861_8ch_modes,
16315 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
16316 .adc_nids = alc861_adc_nids,
16317 .input_mux = &alc861_capture_source,
16318 },
16319 [ALC660_3ST] = {
16320 .mixers = { alc861_3ST_mixer },
16321 .init_verbs = { alc861_threestack_init_verbs },
16322 .num_dacs = ARRAY_SIZE(alc660_dac_nids),
16323 .dac_nids = alc660_dac_nids,
16324 .num_channel_mode = ARRAY_SIZE(alc861_threestack_modes),
16325 .channel_mode = alc861_threestack_modes,
16326 .need_dac_fix = 1,
16327 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
16328 .adc_nids = alc861_adc_nids,
16329 .input_mux = &alc861_capture_source,
16330 },
16331 [ALC861_UNIWILL_M31] = {
16332 .mixers = { alc861_uniwill_m31_mixer },
16333 .init_verbs = { alc861_uniwill_m31_init_verbs },
16334 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
16335 .dac_nids = alc861_dac_nids,
16336 .dig_out_nid = ALC861_DIGOUT_NID,
16337 .num_channel_mode = ARRAY_SIZE(alc861_uniwill_m31_modes),
16338 .channel_mode = alc861_uniwill_m31_modes,
16339 .need_dac_fix = 1,
16340 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
16341 .adc_nids = alc861_adc_nids,
16342 .input_mux = &alc861_capture_source,
16343 },
16344 [ALC861_TOSHIBA] = {
16345 .mixers = { alc861_toshiba_mixer },
16346 .init_verbs = { alc861_base_init_verbs,
16347 alc861_toshiba_init_verbs },
16348 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
16349 .dac_nids = alc861_dac_nids,
16350 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
16351 .channel_mode = alc883_3ST_2ch_modes,
16352 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
16353 .adc_nids = alc861_adc_nids,
16354 .input_mux = &alc861_capture_source,
16355 .unsol_event = alc861_toshiba_unsol_event,
16356 .init_hook = alc861_toshiba_automute,
16357 },
16358 [ALC861_ASUS] = {
16359 .mixers = { alc861_asus_mixer },
16360 .init_verbs = { alc861_asus_init_verbs },
16361 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
16362 .dac_nids = alc861_dac_nids,
16363 .dig_out_nid = ALC861_DIGOUT_NID,
16364 .num_channel_mode = ARRAY_SIZE(alc861_asus_modes),
16365 .channel_mode = alc861_asus_modes,
16366 .need_dac_fix = 1,
16367 .hp_nid = 0x06,
16368 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
16369 .adc_nids = alc861_adc_nids,
16370 .input_mux = &alc861_capture_source,
16371 },
16372 [ALC861_ASUS_LAPTOP] = {
16373 .mixers = { alc861_toshiba_mixer, alc861_asus_laptop_mixer },
16374 .init_verbs = { alc861_asus_init_verbs,
16375 alc861_asus_laptop_init_verbs },
16376 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
16377 .dac_nids = alc861_dac_nids,
16378 .dig_out_nid = ALC861_DIGOUT_NID,
16379 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
16380 .channel_mode = alc883_3ST_2ch_modes,
16381 .need_dac_fix = 1,
16382 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
16383 .adc_nids = alc861_adc_nids,
16384 .input_mux = &alc861_capture_source,
16385 },
16386 };
16387
16388 /* Pin config fixes */
16389 enum {
16390 PINFIX_FSC_AMILO_PI1505,
16391 };
16392
16393 static const struct alc_fixup alc861_fixups[] = {
16394 [PINFIX_FSC_AMILO_PI1505] = {
16395 .type = ALC_FIXUP_PINS,
16396 .v.pins = (const struct alc_pincfg[]) {
16397 { 0x0b, 0x0221101f }, /* HP */
16398 { 0x0f, 0x90170310 }, /* speaker */
16399 { }
16400 }
16401 },
16402 };
16403
16404 static const struct snd_pci_quirk alc861_fixup_tbl[] = {
16405 SND_PCI_QUIRK(0x1734, 0x10c7, "FSC Amilo Pi1505", PINFIX_FSC_AMILO_PI1505),
16406 {}
16407 };
16408
16409 static int patch_alc861(struct hda_codec *codec)
16410 {
16411 struct alc_spec *spec;
16412 int board_config;
16413 int err;
16414
16415 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
16416 if (spec == NULL)
16417 return -ENOMEM;
16418
16419 codec->spec = spec;
16420
16421 board_config = snd_hda_check_board_config(codec, ALC861_MODEL_LAST,
16422 alc861_models,
16423 alc861_cfg_tbl);
16424
16425 if (board_config < 0) {
16426 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
16427 codec->chip_name);
16428 board_config = ALC861_AUTO;
16429 }
16430
16431 if (board_config == ALC861_AUTO) {
16432 alc_pick_fixup(codec, NULL, alc861_fixup_tbl, alc861_fixups);
16433 alc_apply_fixup(codec, ALC_FIXUP_ACT_PRE_PROBE);
16434 }
16435
16436 if (board_config == ALC861_AUTO) {
16437 /* automatic parse from the BIOS config */
16438 err = alc861_parse_auto_config(codec);
16439 if (err < 0) {
16440 alc_free(codec);
16441 return err;
16442 } else if (!err) {
16443 printk(KERN_INFO
16444 "hda_codec: Cannot set up configuration "
16445 "from BIOS. Using base mode...\n");
16446 board_config = ALC861_3ST_DIG;
16447 }
16448 }
16449
16450 err = snd_hda_attach_beep_device(codec, 0x23);
16451 if (err < 0) {
16452 alc_free(codec);
16453 return err;
16454 }
16455
16456 if (board_config != ALC861_AUTO)
16457 setup_preset(codec, &alc861_presets[board_config]);
16458
16459 spec->stream_analog_playback = &alc861_pcm_analog_playback;
16460 spec->stream_analog_capture = &alc861_pcm_analog_capture;
16461
16462 spec->stream_digital_playback = &alc861_pcm_digital_playback;
16463 spec->stream_digital_capture = &alc861_pcm_digital_capture;
16464
16465 if (!spec->cap_mixer)
16466 set_capture_mixer(codec);
16467 set_beep_amp(spec, 0x23, 0, HDA_OUTPUT);
16468
16469 spec->vmaster_nid = 0x03;
16470
16471 alc_apply_fixup(codec, ALC_FIXUP_ACT_PROBE);
16472
16473 codec->patch_ops = alc_patch_ops;
16474 if (board_config == ALC861_AUTO) {
16475 spec->init_hook = alc861_auto_init;
16476 #ifdef CONFIG_SND_HDA_POWER_SAVE
16477 spec->power_hook = alc_power_eapd;
16478 #endif
16479 }
16480 #ifdef CONFIG_SND_HDA_POWER_SAVE
16481 if (!spec->loopback.amplist)
16482 spec->loopback.amplist = alc861_loopbacks;
16483 #endif
16484
16485 return 0;
16486 }
16487
16488 /*
16489 * ALC861-VD support
16490 *
16491 * Based on ALC882
16492 *
16493 * In addition, an independent DAC
16494 */
16495 #define ALC861VD_DIGOUT_NID 0x06
16496
16497 static const hda_nid_t alc861vd_dac_nids[4] = {
16498 /* front, surr, clfe, side surr */
16499 0x02, 0x03, 0x04, 0x05
16500 };
16501
16502 /* dac_nids for ALC660vd are in a different order - according to
16503 * Realtek's driver.
16504 * This should probably result in a different mixer for 6stack models
16505 * of ALC660vd codecs, but for now there is only 3stack mixer
16506 * - and it is the same as in 861vd.
16507 * adc_nids in ALC660vd are (is) the same as in 861vd
16508 */
16509 static const hda_nid_t alc660vd_dac_nids[3] = {
16510 /* front, rear, clfe, rear_surr */
16511 0x02, 0x04, 0x03
16512 };
16513
16514 static const hda_nid_t alc861vd_adc_nids[1] = {
16515 /* ADC0 */
16516 0x09,
16517 };
16518
16519 static const hda_nid_t alc861vd_capsrc_nids[1] = { 0x22 };
16520
16521 /* input MUX */
16522 /* FIXME: should be a matrix-type input source selection */
16523 static const struct hda_input_mux alc861vd_capture_source = {
16524 .num_items = 4,
16525 .items = {
16526 { "Mic", 0x0 },
16527 { "Front Mic", 0x1 },
16528 { "Line", 0x2 },
16529 { "CD", 0x4 },
16530 },
16531 };
16532
16533 static const struct hda_input_mux alc861vd_dallas_capture_source = {
16534 .num_items = 2,
16535 .items = {
16536 { "Mic", 0x0 },
16537 { "Internal Mic", 0x1 },
16538 },
16539 };
16540
16541 static const struct hda_input_mux alc861vd_hp_capture_source = {
16542 .num_items = 2,
16543 .items = {
16544 { "Front Mic", 0x0 },
16545 { "ATAPI Mic", 0x1 },
16546 },
16547 };
16548
16549 /*
16550 * 2ch mode
16551 */
16552 static const struct hda_channel_mode alc861vd_3stack_2ch_modes[1] = {
16553 { 2, NULL }
16554 };
16555
16556 /*
16557 * 6ch mode
16558 */
16559 static const struct hda_verb alc861vd_6stack_ch6_init[] = {
16560 { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
16561 { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
16562 { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
16563 { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
16564 { } /* end */
16565 };
16566
16567 /*
16568 * 8ch mode
16569 */
16570 static const struct hda_verb alc861vd_6stack_ch8_init[] = {
16571 { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
16572 { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
16573 { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
16574 { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
16575 { } /* end */
16576 };
16577
16578 static const struct hda_channel_mode alc861vd_6stack_modes[2] = {
16579 { 6, alc861vd_6stack_ch6_init },
16580 { 8, alc861vd_6stack_ch8_init },
16581 };
16582
16583 static const struct snd_kcontrol_new alc861vd_chmode_mixer[] = {
16584 {
16585 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
16586 .name = "Channel Mode",
16587 .info = alc_ch_mode_info,
16588 .get = alc_ch_mode_get,
16589 .put = alc_ch_mode_put,
16590 },
16591 { } /* end */
16592 };
16593
16594 /* Pin assignment: Front=0x14, Rear=0x15, CLFE=0x16, Side=0x17
16595 * Mic=0x18, Front Mic=0x19, Line-In=0x1a, HP=0x1b
16596 */
16597 static const struct snd_kcontrol_new alc861vd_6st_mixer[] = {
16598 HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
16599 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
16600
16601 HDA_CODEC_VOLUME("Surround Playback Volume", 0x03, 0x0, HDA_OUTPUT),
16602 HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
16603
16604 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0,
16605 HDA_OUTPUT),
16606 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0,
16607 HDA_OUTPUT),
16608 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
16609 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
16610
16611 HDA_CODEC_VOLUME("Side Playback Volume", 0x05, 0x0, HDA_OUTPUT),
16612 HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
16613
16614 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
16615
16616 HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
16617 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16618 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16619
16620 HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x19, 0, HDA_INPUT),
16621 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
16622 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
16623
16624 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
16625 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
16626
16627 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
16628 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
16629
16630 { } /* end */
16631 };
16632
16633 static const struct snd_kcontrol_new alc861vd_3st_mixer[] = {
16634 HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
16635 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
16636
16637 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
16638
16639 HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
16640 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16641 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16642
16643 HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x19, 0, HDA_INPUT),
16644 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
16645 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
16646
16647 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
16648 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
16649
16650 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
16651 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
16652
16653 { } /* end */
16654 };
16655
16656 static const struct snd_kcontrol_new alc861vd_lenovo_mixer[] = {
16657 HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
16658 /*HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),*/
16659 HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
16660
16661 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
16662
16663 HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
16664 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16665 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16666
16667 HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x19, 0, HDA_INPUT),
16668 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
16669 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
16670
16671 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
16672 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
16673
16674 { } /* end */
16675 };
16676
16677 /* Pin assignment: Speaker=0x14, HP = 0x15,
16678 * Mic=0x18, Internal Mic = 0x19, CD = 0x1c, PC Beep = 0x1d
16679 */
16680 static const struct snd_kcontrol_new alc861vd_dallas_mixer[] = {
16681 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
16682 HDA_BIND_MUTE("Speaker Playback Switch", 0x0c, 2, HDA_INPUT),
16683 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
16684 HDA_BIND_MUTE("Headphone Playback Switch", 0x0d, 2, HDA_INPUT),
16685 HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
16686 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16687 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16688 HDA_CODEC_VOLUME("Internal Mic Boost Volume", 0x19, 0, HDA_INPUT),
16689 HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
16690 HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
16691 { } /* end */
16692 };
16693
16694 /* Pin assignment: Speaker=0x14, Line-out = 0x15,
16695 * Front Mic=0x18, ATAPI Mic = 0x19,
16696 */
16697 static const struct snd_kcontrol_new alc861vd_hp_mixer[] = {
16698 HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
16699 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
16700 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
16701 HDA_BIND_MUTE("Headphone Playback Switch", 0x0d, 2, HDA_INPUT),
16702 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16703 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16704 HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
16705 HDA_CODEC_MUTE("ATAPI Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
16706
16707 { } /* end */
16708 };
16709
16710 /*
16711 * generic initialization of ADC, input mixers and output mixers
16712 */
16713 static const struct hda_verb alc861vd_volume_init_verbs[] = {
16714 /*
16715 * Unmute ADC0 and set the default input to mic-in
16716 */
16717 {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
16718 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
16719
16720 /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of
16721 * the analog-loopback mixer widget
16722 */
16723 /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
16724 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16725 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
16726 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
16727 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
16728 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
16729
16730 /* Capture mixer: unmute Mic, F-Mic, Line, CD inputs */
16731 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
16732 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
16733 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
16734 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
16735
16736 /*
16737 * Set up output mixers (0x02 - 0x05)
16738 */
16739 /* set vol=0 to output mixers */
16740 {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
16741 {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
16742 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
16743 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
16744
16745 /* set up input amps for analog loopback */
16746 /* Amp Indices: DAC = 0, mixer = 1 */
16747 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16748 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
16749 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16750 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
16751 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16752 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
16753 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16754 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
16755
16756 { }
16757 };
16758
16759 /*
16760 * 3-stack pin configuration:
16761 * front = 0x14, mic/clfe = 0x18, HP = 0x19, line/surr = 0x1a, f-mic = 0x1b
16762 */
16763 static const struct hda_verb alc861vd_3stack_init_verbs[] = {
16764 /*
16765 * Set pin mode and muting
16766 */
16767 /* set front pin widgets 0x14 for output */
16768 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16769 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16770 {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
16771
16772 /* Mic (rear) pin: input vref at 80% */
16773 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
16774 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
16775 /* Front Mic pin: input vref at 80% */
16776 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
16777 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
16778 /* Line In pin: input */
16779 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16780 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
16781 /* Line-2 In: Headphone output (output 0 - 0x0c) */
16782 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16783 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16784 {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
16785 /* CD pin widget for input */
16786 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16787
16788 { }
16789 };
16790
16791 /*
16792 * 6-stack pin configuration:
16793 */
16794 static const struct hda_verb alc861vd_6stack_init_verbs[] = {
16795 /*
16796 * Set pin mode and muting
16797 */
16798 /* set front pin widgets 0x14 for output */
16799 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16800 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16801 {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
16802
16803 /* Rear Pin: output 1 (0x0d) */
16804 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16805 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16806 {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
16807 /* CLFE Pin: output 2 (0x0e) */
16808 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16809 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16810 {0x16, AC_VERB_SET_CONNECT_SEL, 0x02},
16811 /* Side Pin: output 3 (0x0f) */
16812 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16813 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16814 {0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
16815
16816 /* Mic (rear) pin: input vref at 80% */
16817 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
16818 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
16819 /* Front Mic pin: input vref at 80% */
16820 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
16821 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
16822 /* Line In pin: input */
16823 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16824 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
16825 /* Line-2 In: Headphone output (output 0 - 0x0c) */
16826 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16827 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16828 {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
16829 /* CD pin widget for input */
16830 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16831
16832 { }
16833 };
16834
16835 static const struct hda_verb alc861vd_eapd_verbs[] = {
16836 {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
16837 { }
16838 };
16839
16840 static const struct hda_verb alc660vd_eapd_verbs[] = {
16841 {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
16842 {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
16843 { }
16844 };
16845
16846 static const struct hda_verb alc861vd_lenovo_unsol_verbs[] = {
16847 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
16848 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
16849 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
16850 {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
16851 {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
16852 {}
16853 };
16854
16855 static void alc861vd_lenovo_setup(struct hda_codec *codec)
16856 {
16857 struct alc_spec *spec = codec->spec;
16858 spec->autocfg.hp_pins[0] = 0x1b;
16859 spec->autocfg.speaker_pins[0] = 0x14;
16860 spec->automute = 1;
16861 spec->automute_mode = ALC_AUTOMUTE_AMP;
16862 }
16863
16864 static void alc861vd_lenovo_init_hook(struct hda_codec *codec)
16865 {
16866 alc_hp_automute(codec);
16867 alc88x_simple_mic_automute(codec);
16868 }
16869
16870 static void alc861vd_lenovo_unsol_event(struct hda_codec *codec,
16871 unsigned int res)
16872 {
16873 switch (res >> 26) {
16874 case ALC880_MIC_EVENT:
16875 alc88x_simple_mic_automute(codec);
16876 break;
16877 default:
16878 alc_sku_unsol_event(codec, res);
16879 break;
16880 }
16881 }
16882
16883 static const struct hda_verb alc861vd_dallas_verbs[] = {
16884 {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
16885 {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
16886 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
16887 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
16888
16889 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
16890 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
16891 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16892 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
16893 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16894 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
16895 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16896 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
16897
16898 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16899 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16900 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16901 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16902 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16903 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16904 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16905 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16906
16907 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
16908 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
16909 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
16910 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
16911 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16912 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16913 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16914 {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16915
16916 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
16917 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
16918 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
16919 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
16920
16921 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16922 {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
16923 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
16924
16925 { } /* end */
16926 };
16927
16928 /* toggle speaker-output according to the hp-jack state */
16929 static void alc861vd_dallas_setup(struct hda_codec *codec)
16930 {
16931 struct alc_spec *spec = codec->spec;
16932
16933 spec->autocfg.hp_pins[0] = 0x15;
16934 spec->autocfg.speaker_pins[0] = 0x14;
16935 spec->automute = 1;
16936 spec->automute_mode = ALC_AUTOMUTE_AMP;
16937 }
16938
16939 #ifdef CONFIG_SND_HDA_POWER_SAVE
16940 #define alc861vd_loopbacks alc880_loopbacks
16941 #endif
16942
16943 /* pcm configuration: identical with ALC880 */
16944 #define alc861vd_pcm_analog_playback alc880_pcm_analog_playback
16945 #define alc861vd_pcm_analog_capture alc880_pcm_analog_capture
16946 #define alc861vd_pcm_digital_playback alc880_pcm_digital_playback
16947 #define alc861vd_pcm_digital_capture alc880_pcm_digital_capture
16948
16949 /*
16950 * configuration and preset
16951 */
16952 static const char * const alc861vd_models[ALC861VD_MODEL_LAST] = {
16953 [ALC660VD_3ST] = "3stack-660",
16954 [ALC660VD_3ST_DIG] = "3stack-660-digout",
16955 [ALC660VD_ASUS_V1S] = "asus-v1s",
16956 [ALC861VD_3ST] = "3stack",
16957 [ALC861VD_3ST_DIG] = "3stack-digout",
16958 [ALC861VD_6ST_DIG] = "6stack-digout",
16959 [ALC861VD_LENOVO] = "lenovo",
16960 [ALC861VD_DALLAS] = "dallas",
16961 [ALC861VD_HP] = "hp",
16962 [ALC861VD_AUTO] = "auto",
16963 };
16964
16965 static const struct snd_pci_quirk alc861vd_cfg_tbl[] = {
16966 SND_PCI_QUIRK(0x1019, 0xa88d, "Realtek ALC660 demo", ALC660VD_3ST),
16967 SND_PCI_QUIRK(0x103c, 0x30bf, "HP TX1000", ALC861VD_HP),
16968 SND_PCI_QUIRK(0x1043, 0x12e2, "Asus z35m", ALC660VD_3ST),
16969 /*SND_PCI_QUIRK(0x1043, 0x1339, "Asus G1", ALC660VD_3ST),*/ /* auto */
16970 SND_PCI_QUIRK(0x1043, 0x1633, "Asus V1Sn", ALC660VD_ASUS_V1S),
16971 SND_PCI_QUIRK(0x1043, 0x81e7, "ASUS", ALC660VD_3ST_DIG),
16972 SND_PCI_QUIRK(0x10de, 0x03f0, "Realtek ALC660 demo", ALC660VD_3ST),
16973 SND_PCI_QUIRK(0x1179, 0xff00, "Toshiba A135", ALC861VD_LENOVO),
16974 /*SND_PCI_QUIRK(0x1179, 0xff00, "DALLAS", ALC861VD_DALLAS),*/ /*lenovo*/
16975 SND_PCI_QUIRK(0x1179, 0xff01, "Toshiba A135", ALC861VD_LENOVO),
16976 SND_PCI_QUIRK(0x1179, 0xff03, "Toshiba P205", ALC861VD_LENOVO),
16977 SND_PCI_QUIRK(0x1179, 0xff31, "Toshiba L30-149", ALC861VD_DALLAS),
16978 SND_PCI_QUIRK(0x1565, 0x820d, "Biostar NF61S SE", ALC861VD_6ST_DIG),
16979 SND_PCI_QUIRK_VENDOR(0x17aa, "Lenovo", ALC861VD_LENOVO),
16980 SND_PCI_QUIRK(0x1849, 0x0862, "ASRock K8NF6G-VSTA", ALC861VD_6ST_DIG),
16981 {}
16982 };
16983
16984 static const struct alc_config_preset alc861vd_presets[] = {
16985 [ALC660VD_3ST] = {
16986 .mixers = { alc861vd_3st_mixer },
16987 .init_verbs = { alc861vd_volume_init_verbs,
16988 alc861vd_3stack_init_verbs },
16989 .num_dacs = ARRAY_SIZE(alc660vd_dac_nids),
16990 .dac_nids = alc660vd_dac_nids,
16991 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
16992 .channel_mode = alc861vd_3stack_2ch_modes,
16993 .input_mux = &alc861vd_capture_source,
16994 },
16995 [ALC660VD_3ST_DIG] = {
16996 .mixers = { alc861vd_3st_mixer },
16997 .init_verbs = { alc861vd_volume_init_verbs,
16998 alc861vd_3stack_init_verbs },
16999 .num_dacs = ARRAY_SIZE(alc660vd_dac_nids),
17000 .dac_nids = alc660vd_dac_nids,
17001 .dig_out_nid = ALC861VD_DIGOUT_NID,
17002 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
17003 .channel_mode = alc861vd_3stack_2ch_modes,
17004 .input_mux = &alc861vd_capture_source,
17005 },
17006 [ALC861VD_3ST] = {
17007 .mixers = { alc861vd_3st_mixer },
17008 .init_verbs = { alc861vd_volume_init_verbs,
17009 alc861vd_3stack_init_verbs },
17010 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
17011 .dac_nids = alc861vd_dac_nids,
17012 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
17013 .channel_mode = alc861vd_3stack_2ch_modes,
17014 .input_mux = &alc861vd_capture_source,
17015 },
17016 [ALC861VD_3ST_DIG] = {
17017 .mixers = { alc861vd_3st_mixer },
17018 .init_verbs = { alc861vd_volume_init_verbs,
17019 alc861vd_3stack_init_verbs },
17020 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
17021 .dac_nids = alc861vd_dac_nids,
17022 .dig_out_nid = ALC861VD_DIGOUT_NID,
17023 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
17024 .channel_mode = alc861vd_3stack_2ch_modes,
17025 .input_mux = &alc861vd_capture_source,
17026 },
17027 [ALC861VD_6ST_DIG] = {
17028 .mixers = { alc861vd_6st_mixer, alc861vd_chmode_mixer },
17029 .init_verbs = { alc861vd_volume_init_verbs,
17030 alc861vd_6stack_init_verbs },
17031 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
17032 .dac_nids = alc861vd_dac_nids,
17033 .dig_out_nid = ALC861VD_DIGOUT_NID,
17034 .num_channel_mode = ARRAY_SIZE(alc861vd_6stack_modes),
17035 .channel_mode = alc861vd_6stack_modes,
17036 .input_mux = &alc861vd_capture_source,
17037 },
17038 [ALC861VD_LENOVO] = {
17039 .mixers = { alc861vd_lenovo_mixer },
17040 .init_verbs = { alc861vd_volume_init_verbs,
17041 alc861vd_3stack_init_verbs,
17042 alc861vd_eapd_verbs,
17043 alc861vd_lenovo_unsol_verbs },
17044 .num_dacs = ARRAY_SIZE(alc660vd_dac_nids),
17045 .dac_nids = alc660vd_dac_nids,
17046 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
17047 .channel_mode = alc861vd_3stack_2ch_modes,
17048 .input_mux = &alc861vd_capture_source,
17049 .unsol_event = alc861vd_lenovo_unsol_event,
17050 .setup = alc861vd_lenovo_setup,
17051 .init_hook = alc861vd_lenovo_init_hook,
17052 },
17053 [ALC861VD_DALLAS] = {
17054 .mixers = { alc861vd_dallas_mixer },
17055 .init_verbs = { alc861vd_dallas_verbs },
17056 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
17057 .dac_nids = alc861vd_dac_nids,
17058 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
17059 .channel_mode = alc861vd_3stack_2ch_modes,
17060 .input_mux = &alc861vd_dallas_capture_source,
17061 .unsol_event = alc_sku_unsol_event,
17062 .setup = alc861vd_dallas_setup,
17063 .init_hook = alc_hp_automute,
17064 },
17065 [ALC861VD_HP] = {
17066 .mixers = { alc861vd_hp_mixer },
17067 .init_verbs = { alc861vd_dallas_verbs, alc861vd_eapd_verbs },
17068 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
17069 .dac_nids = alc861vd_dac_nids,
17070 .dig_out_nid = ALC861VD_DIGOUT_NID,
17071 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
17072 .channel_mode = alc861vd_3stack_2ch_modes,
17073 .input_mux = &alc861vd_hp_capture_source,
17074 .unsol_event = alc_sku_unsol_event,
17075 .setup = alc861vd_dallas_setup,
17076 .init_hook = alc_hp_automute,
17077 },
17078 [ALC660VD_ASUS_V1S] = {
17079 .mixers = { alc861vd_lenovo_mixer },
17080 .init_verbs = { alc861vd_volume_init_verbs,
17081 alc861vd_3stack_init_verbs,
17082 alc861vd_eapd_verbs,
17083 alc861vd_lenovo_unsol_verbs },
17084 .num_dacs = ARRAY_SIZE(alc660vd_dac_nids),
17085 .dac_nids = alc660vd_dac_nids,
17086 .dig_out_nid = ALC861VD_DIGOUT_NID,
17087 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
17088 .channel_mode = alc861vd_3stack_2ch_modes,
17089 .input_mux = &alc861vd_capture_source,
17090 .unsol_event = alc861vd_lenovo_unsol_event,
17091 .setup = alc861vd_lenovo_setup,
17092 .init_hook = alc861vd_lenovo_init_hook,
17093 },
17094 };
17095
17096 /*
17097 * BIOS auto configuration
17098 */
17099 static int alc861vd_auto_create_input_ctls(struct hda_codec *codec,
17100 const struct auto_pin_cfg *cfg)
17101 {
17102 return alc_auto_create_input_ctls(codec, cfg, 0x0b, 0x22, 0);
17103 }
17104
17105
17106 static void alc861vd_auto_set_output_and_unmute(struct hda_codec *codec,
17107 hda_nid_t nid, int pin_type, int dac_idx)
17108 {
17109 alc_set_pin_output(codec, nid, pin_type);
17110 }
17111
17112 static void alc861vd_auto_init_multi_out(struct hda_codec *codec)
17113 {
17114 struct alc_spec *spec = codec->spec;
17115 int i;
17116
17117 for (i = 0; i <= HDA_SIDE; i++) {
17118 hda_nid_t nid = spec->autocfg.line_out_pins[i];
17119 int pin_type = get_pin_type(spec->autocfg.line_out_type);
17120 if (nid)
17121 alc861vd_auto_set_output_and_unmute(codec, nid,
17122 pin_type, i);
17123 }
17124 }
17125
17126
17127 static void alc861vd_auto_init_hp_out(struct hda_codec *codec)
17128 {
17129 struct alc_spec *spec = codec->spec;
17130 hda_nid_t pin;
17131
17132 pin = spec->autocfg.hp_pins[0];
17133 if (pin) /* connect to front and use dac 0 */
17134 alc861vd_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
17135 pin = spec->autocfg.speaker_pins[0];
17136 if (pin)
17137 alc861vd_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
17138 }
17139
17140 #define ALC861VD_PIN_CD_NID ALC880_PIN_CD_NID
17141
17142 static void alc861vd_auto_init_analog_input(struct hda_codec *codec)
17143 {
17144 struct alc_spec *spec = codec->spec;
17145 struct auto_pin_cfg *cfg = &spec->autocfg;
17146 int i;
17147
17148 for (i = 0; i < cfg->num_inputs; i++) {
17149 hda_nid_t nid = cfg->inputs[i].pin;
17150 if (alc_is_input_pin(codec, nid)) {
17151 alc_set_input_pin(codec, nid, cfg->inputs[i].type);
17152 if (nid != ALC861VD_PIN_CD_NID &&
17153 (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP))
17154 snd_hda_codec_write(codec, nid, 0,
17155 AC_VERB_SET_AMP_GAIN_MUTE,
17156 AMP_OUT_MUTE);
17157 }
17158 }
17159 }
17160
17161 #define alc861vd_auto_init_input_src alc882_auto_init_input_src
17162
17163 #define alc861vd_idx_to_mixer_vol(nid) ((nid) + 0x02)
17164 #define alc861vd_idx_to_mixer_switch(nid) ((nid) + 0x0c)
17165
17166 /* add playback controls from the parsed DAC table */
17167 /* Based on ALC880 version. But ALC861VD has separate,
17168 * different NIDs for mute/unmute switch and volume control */
17169 static int alc861vd_auto_create_multi_out_ctls(struct alc_spec *spec,
17170 const struct auto_pin_cfg *cfg)
17171 {
17172 static const char * const chname[4] = {
17173 "Front", "Surround", "CLFE", "Side"
17174 };
17175 const char *pfx = alc_get_line_out_pfx(spec, true);
17176 hda_nid_t nid_v, nid_s;
17177 int i, err, noutputs;
17178
17179 noutputs = cfg->line_outs;
17180 if (spec->multi_ios > 0)
17181 noutputs += spec->multi_ios;
17182
17183 for (i = 0; i < noutputs; i++) {
17184 if (!spec->multiout.dac_nids[i])
17185 continue;
17186 nid_v = alc861vd_idx_to_mixer_vol(
17187 alc880_dac_to_idx(
17188 spec->multiout.dac_nids[i]));
17189 nid_s = alc861vd_idx_to_mixer_switch(
17190 alc880_dac_to_idx(
17191 spec->multiout.dac_nids[i]));
17192
17193 if (!pfx && i == 2) {
17194 /* Center/LFE */
17195 err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL,
17196 "Center",
17197 HDA_COMPOSE_AMP_VAL(nid_v, 1, 0,
17198 HDA_OUTPUT));
17199 if (err < 0)
17200 return err;
17201 err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL,
17202 "LFE",
17203 HDA_COMPOSE_AMP_VAL(nid_v, 2, 0,
17204 HDA_OUTPUT));
17205 if (err < 0)
17206 return err;
17207 err = add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE,
17208 "Center",
17209 HDA_COMPOSE_AMP_VAL(nid_s, 1, 2,
17210 HDA_INPUT));
17211 if (err < 0)
17212 return err;
17213 err = add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE,
17214 "LFE",
17215 HDA_COMPOSE_AMP_VAL(nid_s, 2, 2,
17216 HDA_INPUT));
17217 if (err < 0)
17218 return err;
17219 } else {
17220 const char *name = pfx;
17221 int index = i;
17222 if (!name) {
17223 name = chname[i];
17224 index = 0;
17225 }
17226 err = __add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL,
17227 name, index,
17228 HDA_COMPOSE_AMP_VAL(nid_v, 3, 0,
17229 HDA_OUTPUT));
17230 if (err < 0)
17231 return err;
17232 err = __add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE,
17233 name, index,
17234 HDA_COMPOSE_AMP_VAL(nid_s, 3, 2,
17235 HDA_INPUT));
17236 if (err < 0)
17237 return err;
17238 }
17239 }
17240 return 0;
17241 }
17242
17243 /* add playback controls for speaker and HP outputs */
17244 /* Based on ALC880 version. But ALC861VD has separate,
17245 * different NIDs for mute/unmute switch and volume control */
17246 static int alc861vd_auto_create_extra_out(struct alc_spec *spec,
17247 hda_nid_t pin, const char *pfx)
17248 {
17249 hda_nid_t nid_v, nid_s;
17250 int err;
17251
17252 if (!pin)
17253 return 0;
17254
17255 if (alc880_is_fixed_pin(pin)) {
17256 nid_v = alc880_idx_to_dac(alc880_fixed_pin_idx(pin));
17257 /* specify the DAC as the extra output */
17258 if (!spec->multiout.hp_nid)
17259 spec->multiout.hp_nid = nid_v;
17260 else
17261 spec->multiout.extra_out_nid[0] = nid_v;
17262 /* control HP volume/switch on the output mixer amp */
17263 nid_v = alc861vd_idx_to_mixer_vol(
17264 alc880_fixed_pin_idx(pin));
17265 nid_s = alc861vd_idx_to_mixer_switch(
17266 alc880_fixed_pin_idx(pin));
17267
17268 err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, pfx,
17269 HDA_COMPOSE_AMP_VAL(nid_v, 3, 0, HDA_OUTPUT));
17270 if (err < 0)
17271 return err;
17272 err = add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE, pfx,
17273 HDA_COMPOSE_AMP_VAL(nid_s, 3, 2, HDA_INPUT));
17274 if (err < 0)
17275 return err;
17276 } else if (alc880_is_multi_pin(pin)) {
17277 /* set manual connection */
17278 /* we have only a switch on HP-out PIN */
17279 err = add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, pfx,
17280 HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
17281 if (err < 0)
17282 return err;
17283 }
17284 return 0;
17285 }
17286
17287 /* parse the BIOS configuration and set up the alc_spec
17288 * return 1 if successful, 0 if the proper config is not found,
17289 * or a negative error code
17290 * Based on ALC880 version - had to change it to override
17291 * alc880_auto_create_extra_out and alc880_auto_create_multi_out_ctls */
17292 static int alc861vd_parse_auto_config(struct hda_codec *codec)
17293 {
17294 struct alc_spec *spec = codec->spec;
17295 int err;
17296 static const hda_nid_t alc861vd_ignore[] = { 0x1d, 0 };
17297
17298 err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
17299 alc861vd_ignore);
17300 if (err < 0)
17301 return err;
17302 if (!spec->autocfg.line_outs)
17303 return 0; /* can't find valid BIOS pin config */
17304
17305 err = alc880_auto_fill_dac_nids(spec, &spec->autocfg);
17306 if (err < 0)
17307 return err;
17308 err = alc_auto_add_multi_channel_mode(codec);
17309 if (err < 0)
17310 return err;
17311 err = alc861vd_auto_create_multi_out_ctls(spec, &spec->autocfg);
17312 if (err < 0)
17313 return err;
17314 err = alc861vd_auto_create_extra_out(spec,
17315 spec->autocfg.speaker_pins[0],
17316 "Speaker");
17317 if (err < 0)
17318 return err;
17319 err = alc861vd_auto_create_extra_out(spec,
17320 spec->autocfg.hp_pins[0],
17321 "Headphone");
17322 if (err < 0)
17323 return err;
17324 err = alc861vd_auto_create_input_ctls(codec, &spec->autocfg);
17325 if (err < 0)
17326 return err;
17327
17328 spec->multiout.max_channels = spec->multiout.num_dacs * 2;
17329
17330 alc_auto_parse_digital(codec);
17331
17332 if (spec->kctls.list)
17333 add_mixer(spec, spec->kctls.list);
17334
17335 add_verb(spec, alc861vd_volume_init_verbs);
17336
17337 spec->num_mux_defs = 1;
17338 spec->input_mux = &spec->private_imux[0];
17339
17340 err = alc_auto_add_mic_boost(codec);
17341 if (err < 0)
17342 return err;
17343
17344 alc_ssid_check(codec, 0x15, 0x1b, 0x14, 0);
17345
17346 return 1;
17347 }
17348
17349 /* additional initialization for auto-configuration model */
17350 static void alc861vd_auto_init(struct hda_codec *codec)
17351 {
17352 struct alc_spec *spec = codec->spec;
17353 alc861vd_auto_init_multi_out(codec);
17354 alc861vd_auto_init_hp_out(codec);
17355 alc861vd_auto_init_analog_input(codec);
17356 alc861vd_auto_init_input_src(codec);
17357 alc_auto_init_digital(codec);
17358 if (spec->unsol_event)
17359 alc_inithook(codec);
17360 }
17361
17362 enum {
17363 ALC660VD_FIX_ASUS_GPIO1
17364 };
17365
17366 /* reset GPIO1 */
17367 static const struct alc_fixup alc861vd_fixups[] = {
17368 [ALC660VD_FIX_ASUS_GPIO1] = {
17369 .type = ALC_FIXUP_VERBS,
17370 .v.verbs = (const struct hda_verb[]) {
17371 {0x01, AC_VERB_SET_GPIO_MASK, 0x03},
17372 {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
17373 {0x01, AC_VERB_SET_GPIO_DATA, 0x01},
17374 { }
17375 }
17376 },
17377 };
17378
17379 static const struct snd_pci_quirk alc861vd_fixup_tbl[] = {
17380 SND_PCI_QUIRK(0x1043, 0x1339, "ASUS A7-K", ALC660VD_FIX_ASUS_GPIO1),
17381 {}
17382 };
17383
17384 static int patch_alc861vd(struct hda_codec *codec)
17385 {
17386 struct alc_spec *spec;
17387 int err, board_config;
17388
17389 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
17390 if (spec == NULL)
17391 return -ENOMEM;
17392
17393 codec->spec = spec;
17394
17395 board_config = snd_hda_check_board_config(codec, ALC861VD_MODEL_LAST,
17396 alc861vd_models,
17397 alc861vd_cfg_tbl);
17398
17399 if (board_config < 0 || board_config >= ALC861VD_MODEL_LAST) {
17400 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
17401 codec->chip_name);
17402 board_config = ALC861VD_AUTO;
17403 }
17404
17405 if (board_config == ALC861VD_AUTO) {
17406 alc_pick_fixup(codec, NULL, alc861vd_fixup_tbl, alc861vd_fixups);
17407 alc_apply_fixup(codec, ALC_FIXUP_ACT_PRE_PROBE);
17408 }
17409
17410 if (board_config == ALC861VD_AUTO) {
17411 /* automatic parse from the BIOS config */
17412 err = alc861vd_parse_auto_config(codec);
17413 if (err < 0) {
17414 alc_free(codec);
17415 return err;
17416 } else if (!err) {
17417 printk(KERN_INFO
17418 "hda_codec: Cannot set up configuration "
17419 "from BIOS. Using base mode...\n");
17420 board_config = ALC861VD_3ST;
17421 }
17422 }
17423
17424 err = snd_hda_attach_beep_device(codec, 0x23);
17425 if (err < 0) {
17426 alc_free(codec);
17427 return err;
17428 }
17429
17430 if (board_config != ALC861VD_AUTO)
17431 setup_preset(codec, &alc861vd_presets[board_config]);
17432
17433 if (codec->vendor_id == 0x10ec0660) {
17434 /* always turn on EAPD */
17435 add_verb(spec, alc660vd_eapd_verbs);
17436 }
17437
17438 spec->stream_analog_playback = &alc861vd_pcm_analog_playback;
17439 spec->stream_analog_capture = &alc861vd_pcm_analog_capture;
17440
17441 spec->stream_digital_playback = &alc861vd_pcm_digital_playback;
17442 spec->stream_digital_capture = &alc861vd_pcm_digital_capture;
17443
17444 if (!spec->adc_nids) {
17445 spec->adc_nids = alc861vd_adc_nids;
17446 spec->num_adc_nids = ARRAY_SIZE(alc861vd_adc_nids);
17447 }
17448 if (!spec->capsrc_nids)
17449 spec->capsrc_nids = alc861vd_capsrc_nids;
17450
17451 set_capture_mixer(codec);
17452 set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
17453
17454 spec->vmaster_nid = 0x02;
17455
17456 alc_apply_fixup(codec, ALC_FIXUP_ACT_PROBE);
17457
17458 codec->patch_ops = alc_patch_ops;
17459
17460 if (board_config == ALC861VD_AUTO)
17461 spec->init_hook = alc861vd_auto_init;
17462 spec->shutup = alc_eapd_shutup;
17463 #ifdef CONFIG_SND_HDA_POWER_SAVE
17464 if (!spec->loopback.amplist)
17465 spec->loopback.amplist = alc861vd_loopbacks;
17466 #endif
17467
17468 return 0;
17469 }
17470
17471 /*
17472 * ALC662 support
17473 *
17474 * ALC662 is almost identical with ALC880 but has cleaner and more flexible
17475 * configuration. Each pin widget can choose any input DACs and a mixer.
17476 * Each ADC is connected from a mixer of all inputs. This makes possible
17477 * 6-channel independent captures.
17478 *
17479 * In addition, an independent DAC for the multi-playback (not used in this
17480 * driver yet).
17481 */
17482 #define ALC662_DIGOUT_NID 0x06
17483 #define ALC662_DIGIN_NID 0x0a
17484
17485 static const hda_nid_t alc662_dac_nids[3] = {
17486 /* front, rear, clfe */
17487 0x02, 0x03, 0x04
17488 };
17489
17490 static const hda_nid_t alc272_dac_nids[2] = {
17491 0x02, 0x03
17492 };
17493
17494 static const hda_nid_t alc662_adc_nids[2] = {
17495 /* ADC1-2 */
17496 0x09, 0x08
17497 };
17498
17499 static const hda_nid_t alc272_adc_nids[1] = {
17500 /* ADC1-2 */
17501 0x08,
17502 };
17503
17504 static const hda_nid_t alc662_capsrc_nids[2] = { 0x22, 0x23 };
17505 static const hda_nid_t alc272_capsrc_nids[1] = { 0x23 };
17506
17507
17508 /* input MUX */
17509 /* FIXME: should be a matrix-type input source selection */
17510 static const struct hda_input_mux alc662_capture_source = {
17511 .num_items = 4,
17512 .items = {
17513 { "Mic", 0x0 },
17514 { "Front Mic", 0x1 },
17515 { "Line", 0x2 },
17516 { "CD", 0x4 },
17517 },
17518 };
17519
17520 static const struct hda_input_mux alc662_lenovo_101e_capture_source = {
17521 .num_items = 2,
17522 .items = {
17523 { "Mic", 0x1 },
17524 { "Line", 0x2 },
17525 },
17526 };
17527
17528 static const struct hda_input_mux alc663_capture_source = {
17529 .num_items = 3,
17530 .items = {
17531 { "Mic", 0x0 },
17532 { "Front Mic", 0x1 },
17533 { "Line", 0x2 },
17534 },
17535 };
17536
17537 #if 0 /* set to 1 for testing other input sources below */
17538 static const struct hda_input_mux alc272_nc10_capture_source = {
17539 .num_items = 16,
17540 .items = {
17541 { "Autoselect Mic", 0x0 },
17542 { "Internal Mic", 0x1 },
17543 { "In-0x02", 0x2 },
17544 { "In-0x03", 0x3 },
17545 { "In-0x04", 0x4 },
17546 { "In-0x05", 0x5 },
17547 { "In-0x06", 0x6 },
17548 { "In-0x07", 0x7 },
17549 { "In-0x08", 0x8 },
17550 { "In-0x09", 0x9 },
17551 { "In-0x0a", 0x0a },
17552 { "In-0x0b", 0x0b },
17553 { "In-0x0c", 0x0c },
17554 { "In-0x0d", 0x0d },
17555 { "In-0x0e", 0x0e },
17556 { "In-0x0f", 0x0f },
17557 },
17558 };
17559 #endif
17560
17561 /*
17562 * 2ch mode
17563 */
17564 static const struct hda_channel_mode alc662_3ST_2ch_modes[1] = {
17565 { 2, NULL }
17566 };
17567
17568 /*
17569 * 2ch mode
17570 */
17571 static const struct hda_verb alc662_3ST_ch2_init[] = {
17572 { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
17573 { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
17574 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
17575 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
17576 { } /* end */
17577 };
17578
17579 /*
17580 * 6ch mode
17581 */
17582 static const struct hda_verb alc662_3ST_ch6_init[] = {
17583 { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
17584 { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
17585 { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
17586 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
17587 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
17588 { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
17589 { } /* end */
17590 };
17591
17592 static const struct hda_channel_mode alc662_3ST_6ch_modes[2] = {
17593 { 2, alc662_3ST_ch2_init },
17594 { 6, alc662_3ST_ch6_init },
17595 };
17596
17597 /*
17598 * 2ch mode
17599 */
17600 static const struct hda_verb alc662_sixstack_ch6_init[] = {
17601 { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
17602 { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
17603 { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
17604 { } /* end */
17605 };
17606
17607 /*
17608 * 6ch mode
17609 */
17610 static const struct hda_verb alc662_sixstack_ch8_init[] = {
17611 { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
17612 { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
17613 { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
17614 { } /* end */
17615 };
17616
17617 static const struct hda_channel_mode alc662_5stack_modes[2] = {
17618 { 2, alc662_sixstack_ch6_init },
17619 { 6, alc662_sixstack_ch8_init },
17620 };
17621
17622 /* Pin assignment: Front=0x14, Rear=0x15, CLFE=0x16, Side=0x17
17623 * Mic=0x18, Front Mic=0x19, Line-In=0x1a, HP=0x1b
17624 */
17625
17626 static const struct snd_kcontrol_new alc662_base_mixer[] = {
17627 /* output mixer control */
17628 HDA_CODEC_VOLUME("Front Playback Volume", 0x2, 0x0, HDA_OUTPUT),
17629 HDA_CODEC_MUTE("Front Playback Switch", 0x0c, 0x0, HDA_INPUT),
17630 HDA_CODEC_VOLUME("Surround Playback Volume", 0x3, 0x0, HDA_OUTPUT),
17631 HDA_CODEC_MUTE("Surround Playback Switch", 0x0d, 0x0, HDA_INPUT),
17632 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0, HDA_OUTPUT),
17633 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0, HDA_OUTPUT),
17634 HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x0e, 1, 0x0, HDA_INPUT),
17635 HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 0x0, HDA_INPUT),
17636 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
17637
17638 /*Input mixer control */
17639 HDA_CODEC_VOLUME("CD Playback Volume", 0xb, 0x4, HDA_INPUT),
17640 HDA_CODEC_MUTE("CD Playback Switch", 0xb, 0x4, HDA_INPUT),
17641 HDA_CODEC_VOLUME("Line Playback Volume", 0xb, 0x02, HDA_INPUT),
17642 HDA_CODEC_MUTE("Line Playback Switch", 0xb, 0x02, HDA_INPUT),
17643 HDA_CODEC_VOLUME("Mic Playback Volume", 0xb, 0x0, HDA_INPUT),
17644 HDA_CODEC_MUTE("Mic Playback Switch", 0xb, 0x0, HDA_INPUT),
17645 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0xb, 0x01, HDA_INPUT),
17646 HDA_CODEC_MUTE("Front Mic Playback Switch", 0xb, 0x01, HDA_INPUT),
17647 { } /* end */
17648 };
17649
17650 static const struct snd_kcontrol_new alc662_3ST_2ch_mixer[] = {
17651 HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
17652 HDA_CODEC_MUTE("Front Playback Switch", 0x0c, 0x0, HDA_INPUT),
17653 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
17654 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
17655 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
17656 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
17657 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
17658 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17659 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17660 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
17661 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
17662 { } /* end */
17663 };
17664
17665 static const struct snd_kcontrol_new alc662_3ST_6ch_mixer[] = {
17666 HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
17667 HDA_CODEC_MUTE("Front Playback Switch", 0x0c, 0x0, HDA_INPUT),
17668 HDA_CODEC_VOLUME("Surround Playback Volume", 0x03, 0x0, HDA_OUTPUT),
17669 HDA_CODEC_MUTE("Surround Playback Switch", 0x0d, 0x0, HDA_INPUT),
17670 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0, HDA_OUTPUT),
17671 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0, HDA_OUTPUT),
17672 HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x0e, 1, 0x0, HDA_INPUT),
17673 HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 0x0, HDA_INPUT),
17674 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
17675 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
17676 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
17677 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
17678 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
17679 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17680 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17681 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
17682 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
17683 { } /* end */
17684 };
17685
17686 static const struct snd_kcontrol_new alc662_lenovo_101e_mixer[] = {
17687 HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
17688 HDA_BIND_MUTE("Front Playback Switch", 0x02, 2, HDA_INPUT),
17689 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x03, 0x0, HDA_OUTPUT),
17690 HDA_BIND_MUTE("Speaker Playback Switch", 0x03, 2, HDA_INPUT),
17691 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
17692 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
17693 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
17694 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
17695 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
17696 { } /* end */
17697 };
17698
17699 static const struct snd_kcontrol_new alc662_eeepc_p701_mixer[] = {
17700 HDA_CODEC_VOLUME("Master Playback Volume", 0x02, 0x0, HDA_OUTPUT),
17701 ALC262_HIPPO_MASTER_SWITCH,
17702
17703 HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
17704 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17705 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17706
17707 HDA_CODEC_VOLUME("Internal Mic Boost Volume", 0x19, 0, HDA_INPUT),
17708 HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
17709 HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
17710 { } /* end */
17711 };
17712
17713 static const struct snd_kcontrol_new alc662_eeepc_ep20_mixer[] = {
17714 ALC262_HIPPO_MASTER_SWITCH,
17715 HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
17716 HDA_CODEC_VOLUME("Surround Playback Volume", 0x03, 0x0, HDA_OUTPUT),
17717 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0, HDA_OUTPUT),
17718 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0, HDA_OUTPUT),
17719 HDA_BIND_MUTE("MuteCtrl Playback Switch", 0x0c, 2, HDA_INPUT),
17720 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
17721 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
17722 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17723 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17724 { } /* end */
17725 };
17726
17727 static const struct hda_bind_ctls alc663_asus_bind_master_vol = {
17728 .ops = &snd_hda_bind_vol,
17729 .values = {
17730 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT),
17731 HDA_COMPOSE_AMP_VAL(0x03, 3, 0, HDA_OUTPUT),
17732 0
17733 },
17734 };
17735
17736 static const struct hda_bind_ctls alc663_asus_one_bind_switch = {
17737 .ops = &snd_hda_bind_sw,
17738 .values = {
17739 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
17740 HDA_COMPOSE_AMP_VAL(0x21, 3, 0, HDA_OUTPUT),
17741 0
17742 },
17743 };
17744
17745 static const struct snd_kcontrol_new alc663_m51va_mixer[] = {
17746 HDA_BIND_VOL("Master Playback Volume", &alc663_asus_bind_master_vol),
17747 HDA_BIND_SW("Master Playback Switch", &alc663_asus_one_bind_switch),
17748 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17749 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17750 { } /* end */
17751 };
17752
17753 static const struct hda_bind_ctls alc663_asus_tree_bind_switch = {
17754 .ops = &snd_hda_bind_sw,
17755 .values = {
17756 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
17757 HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT),
17758 HDA_COMPOSE_AMP_VAL(0x21, 3, 0, HDA_OUTPUT),
17759 0
17760 },
17761 };
17762
17763 static const struct snd_kcontrol_new alc663_two_hp_m1_mixer[] = {
17764 HDA_BIND_VOL("Master Playback Volume", &alc663_asus_bind_master_vol),
17765 HDA_BIND_SW("Master Playback Switch", &alc663_asus_tree_bind_switch),
17766 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17767 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17768 HDA_CODEC_VOLUME("F-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
17769 HDA_CODEC_MUTE("F-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
17770
17771 { } /* end */
17772 };
17773
17774 static const struct hda_bind_ctls alc663_asus_four_bind_switch = {
17775 .ops = &snd_hda_bind_sw,
17776 .values = {
17777 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
17778 HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT),
17779 HDA_COMPOSE_AMP_VAL(0x1b, 3, 0, HDA_OUTPUT),
17780 0
17781 },
17782 };
17783
17784 static const struct snd_kcontrol_new alc663_two_hp_m2_mixer[] = {
17785 HDA_BIND_VOL("Master Playback Volume", &alc663_asus_bind_master_vol),
17786 HDA_BIND_SW("Master Playback Switch", &alc663_asus_four_bind_switch),
17787 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17788 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17789 HDA_CODEC_VOLUME("F-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
17790 HDA_CODEC_MUTE("F-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
17791 { } /* end */
17792 };
17793
17794 static const struct snd_kcontrol_new alc662_1bjd_mixer[] = {
17795 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
17796 HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
17797 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
17798 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17799 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17800 HDA_CODEC_VOLUME("F-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
17801 HDA_CODEC_MUTE("F-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
17802 { } /* end */
17803 };
17804
17805 static const struct hda_bind_ctls alc663_asus_two_bind_master_vol = {
17806 .ops = &snd_hda_bind_vol,
17807 .values = {
17808 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT),
17809 HDA_COMPOSE_AMP_VAL(0x04, 3, 0, HDA_OUTPUT),
17810 0
17811 },
17812 };
17813
17814 static const struct hda_bind_ctls alc663_asus_two_bind_switch = {
17815 .ops = &snd_hda_bind_sw,
17816 .values = {
17817 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
17818 HDA_COMPOSE_AMP_VAL(0x16, 3, 0, HDA_OUTPUT),
17819 0
17820 },
17821 };
17822
17823 static const struct snd_kcontrol_new alc663_asus_21jd_clfe_mixer[] = {
17824 HDA_BIND_VOL("Master Playback Volume",
17825 &alc663_asus_two_bind_master_vol),
17826 HDA_BIND_SW("Master Playback Switch", &alc663_asus_two_bind_switch),
17827 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
17828 HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT),
17829 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17830 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17831 { } /* end */
17832 };
17833
17834 static const struct snd_kcontrol_new alc663_asus_15jd_clfe_mixer[] = {
17835 HDA_BIND_VOL("Master Playback Volume", &alc663_asus_bind_master_vol),
17836 HDA_BIND_SW("Master Playback Switch", &alc663_asus_two_bind_switch),
17837 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
17838 HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
17839 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17840 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17841 { } /* end */
17842 };
17843
17844 static const struct snd_kcontrol_new alc663_g71v_mixer[] = {
17845 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
17846 HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
17847 HDA_CODEC_VOLUME("Front Playback Volume", 0x03, 0x0, HDA_OUTPUT),
17848 HDA_CODEC_MUTE("Front Playback Switch", 0x15, 0x0, HDA_OUTPUT),
17849 HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT),
17850
17851 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17852 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17853 HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
17854 HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
17855 { } /* end */
17856 };
17857
17858 static const struct snd_kcontrol_new alc663_g50v_mixer[] = {
17859 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
17860 HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
17861 HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT),
17862
17863 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17864 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17865 HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
17866 HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
17867 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
17868 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
17869 { } /* end */
17870 };
17871
17872 static const struct hda_bind_ctls alc663_asus_mode7_8_all_bind_switch = {
17873 .ops = &snd_hda_bind_sw,
17874 .values = {
17875 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
17876 HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT),
17877 HDA_COMPOSE_AMP_VAL(0x17, 3, 0, HDA_OUTPUT),
17878 HDA_COMPOSE_AMP_VAL(0x1b, 3, 0, HDA_OUTPUT),
17879 HDA_COMPOSE_AMP_VAL(0x21, 3, 0, HDA_OUTPUT),
17880 0
17881 },
17882 };
17883
17884 static const struct hda_bind_ctls alc663_asus_mode7_8_sp_bind_switch = {
17885 .ops = &snd_hda_bind_sw,
17886 .values = {
17887 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
17888 HDA_COMPOSE_AMP_VAL(0x17, 3, 0, HDA_OUTPUT),
17889 0
17890 },
17891 };
17892
17893 static const struct snd_kcontrol_new alc663_mode7_mixer[] = {
17894 HDA_BIND_SW("Master Playback Switch", &alc663_asus_mode7_8_all_bind_switch),
17895 HDA_BIND_VOL("Speaker Playback Volume", &alc663_asus_bind_master_vol),
17896 HDA_BIND_SW("Speaker Playback Switch", &alc663_asus_mode7_8_sp_bind_switch),
17897 HDA_CODEC_MUTE("Headphone1 Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
17898 HDA_CODEC_MUTE("Headphone2 Playback Switch", 0x21, 0x0, HDA_OUTPUT),
17899 HDA_CODEC_VOLUME("IntMic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17900 HDA_CODEC_MUTE("IntMic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17901 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
17902 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
17903 { } /* end */
17904 };
17905
17906 static const struct snd_kcontrol_new alc663_mode8_mixer[] = {
17907 HDA_BIND_SW("Master Playback Switch", &alc663_asus_mode7_8_all_bind_switch),
17908 HDA_BIND_VOL("Speaker Playback Volume", &alc663_asus_bind_master_vol),
17909 HDA_BIND_SW("Speaker Playback Switch", &alc663_asus_mode7_8_sp_bind_switch),
17910 HDA_CODEC_MUTE("Headphone1 Playback Switch", 0x15, 0x0, HDA_OUTPUT),
17911 HDA_CODEC_MUTE("Headphone2 Playback Switch", 0x21, 0x0, HDA_OUTPUT),
17912 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17913 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17914 { } /* end */
17915 };
17916
17917
17918 static const struct snd_kcontrol_new alc662_chmode_mixer[] = {
17919 {
17920 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
17921 .name = "Channel Mode",
17922 .info = alc_ch_mode_info,
17923 .get = alc_ch_mode_get,
17924 .put = alc_ch_mode_put,
17925 },
17926 { } /* end */
17927 };
17928
17929 static const struct hda_verb alc662_init_verbs[] = {
17930 /* ADC: mute amp left and right */
17931 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
17932 {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
17933
17934 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
17935 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
17936 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
17937 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
17938 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
17939 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
17940
17941 /* Front Pin: output 0 (0x0c) */
17942 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
17943 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17944
17945 /* Rear Pin: output 1 (0x0d) */
17946 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
17947 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17948
17949 /* CLFE Pin: output 2 (0x0e) */
17950 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
17951 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17952
17953 /* Mic (rear) pin: input vref at 80% */
17954 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
17955 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
17956 /* Front Mic pin: input vref at 80% */
17957 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
17958 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
17959 /* Line In pin: input */
17960 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17961 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
17962 /* Line-2 In: Headphone output (output 0 - 0x0c) */
17963 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
17964 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17965 {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
17966 /* CD pin widget for input */
17967 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17968
17969 /* FIXME: use matrix-type input source selection */
17970 /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
17971 /* Input mixer */
17972 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
17973 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
17974
17975 { }
17976 };
17977
17978 static const struct hda_verb alc662_eapd_init_verbs[] = {
17979 /* always trun on EAPD */
17980 {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
17981 {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
17982 { }
17983 };
17984
17985 static const struct hda_verb alc662_sue_init_verbs[] = {
17986 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_FRONT_EVENT},
17987 {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_HP_EVENT},
17988 {}
17989 };
17990
17991 static const struct hda_verb alc662_eeepc_sue_init_verbs[] = {
17992 {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
17993 {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
17994 {}
17995 };
17996
17997 /* Set Unsolicited Event*/
17998 static const struct hda_verb alc662_eeepc_ep20_sue_init_verbs[] = {
17999 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
18000 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
18001 {}
18002 };
18003
18004 static const struct hda_verb alc663_m51va_init_verbs[] = {
18005 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
18006 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
18007 {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
18008 {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
18009 {0x21, AC_VERB_SET_CONNECT_SEL, 0x01}, /* Headphone */
18010 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
18011 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(9)},
18012 {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
18013 {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
18014 {}
18015 };
18016
18017 static const struct hda_verb alc663_21jd_amic_init_verbs[] = {
18018 {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
18019 {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
18020 {0x21, AC_VERB_SET_CONNECT_SEL, 0x01}, /* Headphone */
18021 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
18022 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
18023 {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
18024 {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
18025 {}
18026 };
18027
18028 static const struct hda_verb alc662_1bjd_amic_init_verbs[] = {
18029 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
18030 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
18031 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
18032 {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Headphone */
18033 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
18034 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
18035 {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
18036 {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
18037 {}
18038 };
18039
18040 static const struct hda_verb alc663_15jd_amic_init_verbs[] = {
18041 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
18042 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
18043 {0x15, AC_VERB_SET_CONNECT_SEL, 0x01}, /* Headphone */
18044 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
18045 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
18046 {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
18047 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
18048 {}
18049 };
18050
18051 static const struct hda_verb alc663_two_hp_amic_m1_init_verbs[] = {
18052 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
18053 {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
18054 {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
18055 {0x21, AC_VERB_SET_CONNECT_SEL, 0x0}, /* Headphone */
18056 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
18057 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
18058 {0x15, AC_VERB_SET_CONNECT_SEL, 0x0}, /* Headphone */
18059 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
18060 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
18061 {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
18062 {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
18063 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
18064 {}
18065 };
18066
18067 static const struct hda_verb alc663_two_hp_amic_m2_init_verbs[] = {
18068 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
18069 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
18070 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
18071 {0x1b, AC_VERB_SET_CONNECT_SEL, 0x01}, /* Headphone */
18072 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
18073 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
18074 {0x15, AC_VERB_SET_CONNECT_SEL, 0x01}, /* Headphone */
18075 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
18076 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
18077 {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
18078 {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
18079 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
18080 {}
18081 };
18082
18083 static const struct hda_verb alc663_g71v_init_verbs[] = {
18084 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
18085 /* {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, */
18086 /* {0x15, AC_VERB_SET_CONNECT_SEL, 0x01}, */ /* Headphone */
18087
18088 {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
18089 {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
18090 {0x21, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Headphone */
18091
18092 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_FRONT_EVENT},
18093 {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_MIC_EVENT},
18094 {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_HP_EVENT},
18095 {}
18096 };
18097
18098 static const struct hda_verb alc663_g50v_init_verbs[] = {
18099 {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
18100 {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
18101 {0x21, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Headphone */
18102
18103 {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
18104 {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
18105 {}
18106 };
18107
18108 static const struct hda_verb alc662_ecs_init_verbs[] = {
18109 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, 0x701f},
18110 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
18111 {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
18112 {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
18113 {}
18114 };
18115
18116 static const struct hda_verb alc272_dell_zm1_init_verbs[] = {
18117 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
18118 {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
18119 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
18120 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
18121 {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
18122 {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
18123 {0x21, AC_VERB_SET_CONNECT_SEL, 0x01}, /* Headphone */
18124 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
18125 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(9)},
18126 {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
18127 {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
18128 {}
18129 };
18130
18131 static const struct hda_verb alc272_dell_init_verbs[] = {
18132 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
18133 {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
18134 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
18135 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
18136 {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
18137 {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
18138 {0x21, AC_VERB_SET_CONNECT_SEL, 0x01}, /* Headphone */
18139 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
18140 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(9)},
18141 {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
18142 {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
18143 {}
18144 };
18145
18146 static const struct hda_verb alc663_mode7_init_verbs[] = {
18147 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
18148 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
18149 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
18150 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
18151 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
18152 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
18153 {0x1b, AC_VERB_SET_CONNECT_SEL, 0x01},
18154 {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
18155 {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
18156 {0x21, AC_VERB_SET_CONNECT_SEL, 0x01}, /* Headphone */
18157 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
18158 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(9)},
18159 {0x19, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
18160 {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
18161 {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
18162 {}
18163 };
18164
18165 static const struct hda_verb alc663_mode8_init_verbs[] = {
18166 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
18167 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
18168 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
18169 {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
18170 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
18171 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
18172 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
18173 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
18174 {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
18175 {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
18176 {0x21, AC_VERB_SET_CONNECT_SEL, 0x01}, /* Headphone */
18177 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
18178 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(9)},
18179 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
18180 {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
18181 {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
18182 {}
18183 };
18184
18185 static const struct snd_kcontrol_new alc662_auto_capture_mixer[] = {
18186 HDA_CODEC_VOLUME("Capture Volume", 0x09, 0x0, HDA_INPUT),
18187 HDA_CODEC_MUTE("Capture Switch", 0x09, 0x0, HDA_INPUT),
18188 { } /* end */
18189 };
18190
18191 static const struct snd_kcontrol_new alc272_auto_capture_mixer[] = {
18192 HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
18193 HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
18194 { } /* end */
18195 };
18196
18197 static void alc662_lenovo_101e_setup(struct hda_codec *codec)
18198 {
18199 struct alc_spec *spec = codec->spec;
18200
18201 spec->autocfg.hp_pins[0] = 0x1b;
18202 spec->autocfg.line_out_pins[0] = 0x14;
18203 spec->autocfg.speaker_pins[0] = 0x15;
18204 spec->automute = 1;
18205 spec->detect_line = 1;
18206 spec->automute_lines = 1;
18207 spec->automute_mode = ALC_AUTOMUTE_AMP;
18208 }
18209
18210 static void alc662_eeepc_setup(struct hda_codec *codec)
18211 {
18212 struct alc_spec *spec = codec->spec;
18213
18214 alc262_hippo1_setup(codec);
18215 spec->ext_mic.pin = 0x18;
18216 spec->ext_mic.mux_idx = 0;
18217 spec->int_mic.pin = 0x19;
18218 spec->int_mic.mux_idx = 1;
18219 spec->auto_mic = 1;
18220 }
18221
18222 static void alc662_eeepc_ep20_setup(struct hda_codec *codec)
18223 {
18224 struct alc_spec *spec = codec->spec;
18225
18226 spec->autocfg.hp_pins[0] = 0x14;
18227 spec->autocfg.speaker_pins[0] = 0x1b;
18228 spec->automute = 1;
18229 spec->automute_mode = ALC_AUTOMUTE_AMP;
18230 }
18231
18232 static void alc663_m51va_setup(struct hda_codec *codec)
18233 {
18234 struct alc_spec *spec = codec->spec;
18235 spec->autocfg.hp_pins[0] = 0x21;
18236 spec->autocfg.speaker_pins[0] = 0x14;
18237 spec->automute_mixer_nid[0] = 0x0c;
18238 spec->automute = 1;
18239 spec->automute_mode = ALC_AUTOMUTE_MIXER;
18240 spec->ext_mic.pin = 0x18;
18241 spec->ext_mic.mux_idx = 0;
18242 spec->int_mic.pin = 0x12;
18243 spec->int_mic.mux_idx = 9;
18244 spec->auto_mic = 1;
18245 }
18246
18247 /* ***************** Mode1 ******************************/
18248 static void alc663_mode1_setup(struct hda_codec *codec)
18249 {
18250 struct alc_spec *spec = codec->spec;
18251 spec->autocfg.hp_pins[0] = 0x21;
18252 spec->autocfg.speaker_pins[0] = 0x14;
18253 spec->automute_mixer_nid[0] = 0x0c;
18254 spec->automute = 1;
18255 spec->automute_mode = ALC_AUTOMUTE_MIXER;
18256 spec->ext_mic.pin = 0x18;
18257 spec->ext_mic.mux_idx = 0;
18258 spec->int_mic.pin = 0x19;
18259 spec->int_mic.mux_idx = 1;
18260 spec->auto_mic = 1;
18261 }
18262
18263 /* ***************** Mode2 ******************************/
18264 static void alc662_mode2_setup(struct hda_codec *codec)
18265 {
18266 struct alc_spec *spec = codec->spec;
18267 spec->autocfg.hp_pins[0] = 0x1b;
18268 spec->autocfg.speaker_pins[0] = 0x14;
18269 spec->automute = 1;
18270 spec->automute_mode = ALC_AUTOMUTE_PIN;
18271 spec->ext_mic.pin = 0x18;
18272 spec->ext_mic.mux_idx = 0;
18273 spec->int_mic.pin = 0x19;
18274 spec->int_mic.mux_idx = 1;
18275 spec->auto_mic = 1;
18276 }
18277
18278 /* ***************** Mode3 ******************************/
18279 static void alc663_mode3_setup(struct hda_codec *codec)
18280 {
18281 struct alc_spec *spec = codec->spec;
18282 spec->autocfg.hp_pins[0] = 0x21;
18283 spec->autocfg.hp_pins[0] = 0x15;
18284 spec->autocfg.speaker_pins[0] = 0x14;
18285 spec->automute = 1;
18286 spec->automute_mode = ALC_AUTOMUTE_PIN;
18287 spec->ext_mic.pin = 0x18;
18288 spec->ext_mic.mux_idx = 0;
18289 spec->int_mic.pin = 0x19;
18290 spec->int_mic.mux_idx = 1;
18291 spec->auto_mic = 1;
18292 }
18293
18294 /* ***************** Mode4 ******************************/
18295 static void alc663_mode4_setup(struct hda_codec *codec)
18296 {
18297 struct alc_spec *spec = codec->spec;
18298 spec->autocfg.hp_pins[0] = 0x21;
18299 spec->autocfg.speaker_pins[0] = 0x14;
18300 spec->autocfg.speaker_pins[1] = 0x16;
18301 spec->automute_mixer_nid[0] = 0x0c;
18302 spec->automute_mixer_nid[1] = 0x0e;
18303 spec->automute = 1;
18304 spec->automute_mode = ALC_AUTOMUTE_MIXER;
18305 spec->ext_mic.pin = 0x18;
18306 spec->ext_mic.mux_idx = 0;
18307 spec->int_mic.pin = 0x19;
18308 spec->int_mic.mux_idx = 1;
18309 spec->auto_mic = 1;
18310 }
18311
18312 /* ***************** Mode5 ******************************/
18313 static void alc663_mode5_setup(struct hda_codec *codec)
18314 {
18315 struct alc_spec *spec = codec->spec;
18316 spec->autocfg.hp_pins[0] = 0x15;
18317 spec->autocfg.speaker_pins[0] = 0x14;
18318 spec->autocfg.speaker_pins[1] = 0x16;
18319 spec->automute_mixer_nid[0] = 0x0c;
18320 spec->automute_mixer_nid[1] = 0x0e;
18321 spec->automute = 1;
18322 spec->automute_mode = ALC_AUTOMUTE_MIXER;
18323 spec->ext_mic.pin = 0x18;
18324 spec->ext_mic.mux_idx = 0;
18325 spec->int_mic.pin = 0x19;
18326 spec->int_mic.mux_idx = 1;
18327 spec->auto_mic = 1;
18328 }
18329
18330 /* ***************** Mode6 ******************************/
18331 static void alc663_mode6_setup(struct hda_codec *codec)
18332 {
18333 struct alc_spec *spec = codec->spec;
18334 spec->autocfg.hp_pins[0] = 0x1b;
18335 spec->autocfg.hp_pins[0] = 0x15;
18336 spec->autocfg.speaker_pins[0] = 0x14;
18337 spec->automute_mixer_nid[0] = 0x0c;
18338 spec->automute = 1;
18339 spec->automute_mode = ALC_AUTOMUTE_MIXER;
18340 spec->ext_mic.pin = 0x18;
18341 spec->ext_mic.mux_idx = 0;
18342 spec->int_mic.pin = 0x19;
18343 spec->int_mic.mux_idx = 1;
18344 spec->auto_mic = 1;
18345 }
18346
18347 /* ***************** Mode7 ******************************/
18348 static void alc663_mode7_setup(struct hda_codec *codec)
18349 {
18350 struct alc_spec *spec = codec->spec;
18351 spec->autocfg.hp_pins[0] = 0x1b;
18352 spec->autocfg.hp_pins[0] = 0x21;
18353 spec->autocfg.speaker_pins[0] = 0x14;
18354 spec->autocfg.speaker_pins[0] = 0x17;
18355 spec->automute = 1;
18356 spec->automute_mode = ALC_AUTOMUTE_PIN;
18357 spec->ext_mic.pin = 0x18;
18358 spec->ext_mic.mux_idx = 0;
18359 spec->int_mic.pin = 0x19;
18360 spec->int_mic.mux_idx = 1;
18361 spec->auto_mic = 1;
18362 }
18363
18364 /* ***************** Mode8 ******************************/
18365 static void alc663_mode8_setup(struct hda_codec *codec)
18366 {
18367 struct alc_spec *spec = codec->spec;
18368 spec->autocfg.hp_pins[0] = 0x21;
18369 spec->autocfg.hp_pins[1] = 0x15;
18370 spec->autocfg.speaker_pins[0] = 0x14;
18371 spec->autocfg.speaker_pins[0] = 0x17;
18372 spec->automute = 1;
18373 spec->automute_mode = ALC_AUTOMUTE_PIN;
18374 spec->ext_mic.pin = 0x18;
18375 spec->ext_mic.mux_idx = 0;
18376 spec->int_mic.pin = 0x12;
18377 spec->int_mic.mux_idx = 9;
18378 spec->auto_mic = 1;
18379 }
18380
18381 static void alc663_g71v_setup(struct hda_codec *codec)
18382 {
18383 struct alc_spec *spec = codec->spec;
18384 spec->autocfg.hp_pins[0] = 0x21;
18385 spec->autocfg.line_out_pins[0] = 0x15;
18386 spec->autocfg.speaker_pins[0] = 0x14;
18387 spec->automute = 1;
18388 spec->automute_mode = ALC_AUTOMUTE_AMP;
18389 spec->detect_line = 1;
18390 spec->automute_lines = 1;
18391 spec->ext_mic.pin = 0x18;
18392 spec->ext_mic.mux_idx = 0;
18393 spec->int_mic.pin = 0x12;
18394 spec->int_mic.mux_idx = 9;
18395 spec->auto_mic = 1;
18396 }
18397
18398 #define alc663_g50v_setup alc663_m51va_setup
18399
18400 static const struct snd_kcontrol_new alc662_ecs_mixer[] = {
18401 HDA_CODEC_VOLUME("Master Playback Volume", 0x02, 0x0, HDA_OUTPUT),
18402 ALC262_HIPPO_MASTER_SWITCH,
18403
18404 HDA_CODEC_VOLUME("Mic/LineIn Boost Volume", 0x18, 0, HDA_INPUT),
18405 HDA_CODEC_VOLUME("Mic/LineIn Playback Volume", 0x0b, 0x0, HDA_INPUT),
18406 HDA_CODEC_MUTE("Mic/LineIn Playback Switch", 0x0b, 0x0, HDA_INPUT),
18407
18408 HDA_CODEC_VOLUME("Internal Mic Boost Volume", 0x19, 0, HDA_INPUT),
18409 HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
18410 HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
18411 { } /* end */
18412 };
18413
18414 static const struct snd_kcontrol_new alc272_nc10_mixer[] = {
18415 /* Master Playback automatically created from Speaker and Headphone */
18416 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
18417 HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
18418 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
18419 HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT),
18420
18421 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
18422 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
18423 HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
18424
18425 HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
18426 HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
18427 HDA_CODEC_VOLUME("Internal Mic Boost Volume", 0x19, 0, HDA_INPUT),
18428 { } /* end */
18429 };
18430
18431 #ifdef CONFIG_SND_HDA_POWER_SAVE
18432 #define alc662_loopbacks alc880_loopbacks
18433 #endif
18434
18435
18436 /* pcm configuration: identical with ALC880 */
18437 #define alc662_pcm_analog_playback alc880_pcm_analog_playback
18438 #define alc662_pcm_analog_capture alc880_pcm_analog_capture
18439 #define alc662_pcm_digital_playback alc880_pcm_digital_playback
18440 #define alc662_pcm_digital_capture alc880_pcm_digital_capture
18441
18442 /*
18443 * configuration and preset
18444 */
18445 static const char * const alc662_models[ALC662_MODEL_LAST] = {
18446 [ALC662_3ST_2ch_DIG] = "3stack-dig",
18447 [ALC662_3ST_6ch_DIG] = "3stack-6ch-dig",
18448 [ALC662_3ST_6ch] = "3stack-6ch",
18449 [ALC662_5ST_DIG] = "5stack-dig",
18450 [ALC662_LENOVO_101E] = "lenovo-101e",
18451 [ALC662_ASUS_EEEPC_P701] = "eeepc-p701",
18452 [ALC662_ASUS_EEEPC_EP20] = "eeepc-ep20",
18453 [ALC662_ECS] = "ecs",
18454 [ALC663_ASUS_M51VA] = "m51va",
18455 [ALC663_ASUS_G71V] = "g71v",
18456 [ALC663_ASUS_H13] = "h13",
18457 [ALC663_ASUS_G50V] = "g50v",
18458 [ALC663_ASUS_MODE1] = "asus-mode1",
18459 [ALC662_ASUS_MODE2] = "asus-mode2",
18460 [ALC663_ASUS_MODE3] = "asus-mode3",
18461 [ALC663_ASUS_MODE4] = "asus-mode4",
18462 [ALC663_ASUS_MODE5] = "asus-mode5",
18463 [ALC663_ASUS_MODE6] = "asus-mode6",
18464 [ALC663_ASUS_MODE7] = "asus-mode7",
18465 [ALC663_ASUS_MODE8] = "asus-mode8",
18466 [ALC272_DELL] = "dell",
18467 [ALC272_DELL_ZM1] = "dell-zm1",
18468 [ALC272_SAMSUNG_NC10] = "samsung-nc10",
18469 [ALC662_AUTO] = "auto",
18470 };
18471
18472 static const struct snd_pci_quirk alc662_cfg_tbl[] = {
18473 SND_PCI_QUIRK(0x1019, 0x9087, "ECS", ALC662_ECS),
18474 SND_PCI_QUIRK(0x1028, 0x02d6, "DELL", ALC272_DELL),
18475 SND_PCI_QUIRK(0x1028, 0x02f4, "DELL ZM1", ALC272_DELL_ZM1),
18476 SND_PCI_QUIRK(0x1043, 0x1000, "ASUS N50Vm", ALC663_ASUS_MODE1),
18477 SND_PCI_QUIRK(0x1043, 0x1092, "ASUS NB", ALC663_ASUS_MODE3),
18478 SND_PCI_QUIRK(0x1043, 0x1173, "ASUS K73Jn", ALC663_ASUS_MODE1),
18479 SND_PCI_QUIRK(0x1043, 0x11c3, "ASUS M70V", ALC663_ASUS_MODE3),
18480 SND_PCI_QUIRK(0x1043, 0x11d3, "ASUS NB", ALC663_ASUS_MODE1),
18481 SND_PCI_QUIRK(0x1043, 0x11f3, "ASUS NB", ALC662_ASUS_MODE2),
18482 SND_PCI_QUIRK(0x1043, 0x1203, "ASUS NB", ALC663_ASUS_MODE1),
18483 SND_PCI_QUIRK(0x1043, 0x1303, "ASUS G60J", ALC663_ASUS_MODE1),
18484 SND_PCI_QUIRK(0x1043, 0x1333, "ASUS G60Jx", ALC663_ASUS_MODE1),
18485 SND_PCI_QUIRK(0x1043, 0x1339, "ASUS NB", ALC662_ASUS_MODE2),
18486 SND_PCI_QUIRK(0x1043, 0x13e3, "ASUS N71JA", ALC663_ASUS_MODE7),
18487 SND_PCI_QUIRK(0x1043, 0x1463, "ASUS N71", ALC663_ASUS_MODE7),
18488 SND_PCI_QUIRK(0x1043, 0x14d3, "ASUS G72", ALC663_ASUS_MODE8),
18489 SND_PCI_QUIRK(0x1043, 0x1563, "ASUS N90", ALC663_ASUS_MODE3),
18490 SND_PCI_QUIRK(0x1043, 0x15d3, "ASUS N50SF F50SF", ALC663_ASUS_MODE1),
18491 SND_PCI_QUIRK(0x1043, 0x16c3, "ASUS NB", ALC662_ASUS_MODE2),
18492 SND_PCI_QUIRK(0x1043, 0x16f3, "ASUS K40C K50C", ALC662_ASUS_MODE2),
18493 SND_PCI_QUIRK(0x1043, 0x1733, "ASUS N81De", ALC663_ASUS_MODE1),
18494 SND_PCI_QUIRK(0x1043, 0x1753, "ASUS NB", ALC662_ASUS_MODE2),
18495 SND_PCI_QUIRK(0x1043, 0x1763, "ASUS NB", ALC663_ASUS_MODE6),
18496 SND_PCI_QUIRK(0x1043, 0x1765, "ASUS NB", ALC663_ASUS_MODE6),
18497 SND_PCI_QUIRK(0x1043, 0x1783, "ASUS NB", ALC662_ASUS_MODE2),
18498 SND_PCI_QUIRK(0x1043, 0x1793, "ASUS F50GX", ALC663_ASUS_MODE1),
18499 SND_PCI_QUIRK(0x1043, 0x17b3, "ASUS F70SL", ALC663_ASUS_MODE3),
18500 SND_PCI_QUIRK(0x1043, 0x17c3, "ASUS UX20", ALC663_ASUS_M51VA),
18501 SND_PCI_QUIRK(0x1043, 0x17f3, "ASUS X58LE", ALC662_ASUS_MODE2),
18502 SND_PCI_QUIRK(0x1043, 0x1813, "ASUS NB", ALC662_ASUS_MODE2),
18503 SND_PCI_QUIRK(0x1043, 0x1823, "ASUS NB", ALC663_ASUS_MODE5),
18504 SND_PCI_QUIRK(0x1043, 0x1833, "ASUS NB", ALC663_ASUS_MODE6),
18505 SND_PCI_QUIRK(0x1043, 0x1843, "ASUS NB", ALC662_ASUS_MODE2),
18506 SND_PCI_QUIRK(0x1043, 0x1853, "ASUS F50Z", ALC663_ASUS_MODE1),
18507 SND_PCI_QUIRK(0x1043, 0x1864, "ASUS NB", ALC662_ASUS_MODE2),
18508 SND_PCI_QUIRK(0x1043, 0x1876, "ASUS NB", ALC662_ASUS_MODE2),
18509 SND_PCI_QUIRK(0x1043, 0x1878, "ASUS M51VA", ALC663_ASUS_M51VA),
18510 /*SND_PCI_QUIRK(0x1043, 0x1878, "ASUS M50Vr", ALC663_ASUS_MODE1),*/
18511 SND_PCI_QUIRK(0x1043, 0x1893, "ASUS M50Vm", ALC663_ASUS_MODE3),
18512 SND_PCI_QUIRK(0x1043, 0x1894, "ASUS X55", ALC663_ASUS_MODE3),
18513 SND_PCI_QUIRK(0x1043, 0x18b3, "ASUS N80Vc", ALC663_ASUS_MODE1),
18514 SND_PCI_QUIRK(0x1043, 0x18c3, "ASUS VX5", ALC663_ASUS_MODE1),
18515 SND_PCI_QUIRK(0x1043, 0x18d3, "ASUS N81Te", ALC663_ASUS_MODE1),
18516 SND_PCI_QUIRK(0x1043, 0x18f3, "ASUS N505Tp", ALC663_ASUS_MODE1),
18517 SND_PCI_QUIRK(0x1043, 0x1903, "ASUS F5GL", ALC663_ASUS_MODE1),
18518 SND_PCI_QUIRK(0x1043, 0x1913, "ASUS NB", ALC662_ASUS_MODE2),
18519 SND_PCI_QUIRK(0x1043, 0x1933, "ASUS F80Q", ALC662_ASUS_MODE2),
18520 SND_PCI_QUIRK(0x1043, 0x1943, "ASUS Vx3V", ALC663_ASUS_MODE1),
18521 SND_PCI_QUIRK(0x1043, 0x1953, "ASUS NB", ALC663_ASUS_MODE1),
18522 SND_PCI_QUIRK(0x1043, 0x1963, "ASUS X71C", ALC663_ASUS_MODE3),
18523 SND_PCI_QUIRK(0x1043, 0x1983, "ASUS N5051A", ALC663_ASUS_MODE1),
18524 SND_PCI_QUIRK(0x1043, 0x1993, "ASUS N20", ALC663_ASUS_MODE1),
18525 SND_PCI_QUIRK(0x1043, 0x19a3, "ASUS G50V", ALC663_ASUS_G50V),
18526 /*SND_PCI_QUIRK(0x1043, 0x19a3, "ASUS NB", ALC663_ASUS_MODE1),*/
18527 SND_PCI_QUIRK(0x1043, 0x19b3, "ASUS F7Z", ALC663_ASUS_MODE1),
18528 SND_PCI_QUIRK(0x1043, 0x19c3, "ASUS F5Z/F6x", ALC662_ASUS_MODE2),
18529 SND_PCI_QUIRK(0x1043, 0x19d3, "ASUS NB", ALC663_ASUS_M51VA),
18530 SND_PCI_QUIRK(0x1043, 0x19e3, "ASUS NB", ALC663_ASUS_MODE1),
18531 SND_PCI_QUIRK(0x1043, 0x19f3, "ASUS NB", ALC663_ASUS_MODE4),
18532 SND_PCI_QUIRK(0x1043, 0x8290, "ASUS P5GC-MX", ALC662_3ST_6ch_DIG),
18533 SND_PCI_QUIRK(0x1043, 0x82a1, "ASUS Eeepc", ALC662_ASUS_EEEPC_P701),
18534 SND_PCI_QUIRK(0x1043, 0x82d1, "ASUS Eeepc EP20", ALC662_ASUS_EEEPC_EP20),
18535 SND_PCI_QUIRK(0x105b, 0x0cd6, "Foxconn", ALC662_ECS),
18536 SND_PCI_QUIRK(0x105b, 0x0d47, "Foxconn 45CMX/45GMX/45CMX-K",
18537 ALC662_3ST_6ch_DIG),
18538 SND_PCI_QUIRK(0x1179, 0xff6e, "Toshiba NB20x", ALC662_AUTO),
18539 SND_PCI_QUIRK(0x144d, 0xca00, "Samsung NC10", ALC272_SAMSUNG_NC10),
18540 SND_PCI_QUIRK(0x1458, 0xa002, "Gigabyte 945GCM-S2L",
18541 ALC662_3ST_6ch_DIG),
18542 SND_PCI_QUIRK(0x152d, 0x2304, "Quanta WH1", ALC663_ASUS_H13),
18543 SND_PCI_QUIRK(0x1565, 0x820f, "Biostar TA780G M2+", ALC662_3ST_6ch_DIG),
18544 SND_PCI_QUIRK(0x1631, 0xc10c, "PB RS65", ALC663_ASUS_M51VA),
18545 SND_PCI_QUIRK(0x17aa, 0x101e, "Lenovo", ALC662_LENOVO_101E),
18546 SND_PCI_QUIRK(0x1849, 0x3662, "ASROCK K10N78FullHD-hSLI R3.0",
18547 ALC662_3ST_6ch_DIG),
18548 SND_PCI_QUIRK_MASK(0x1854, 0xf000, 0x2000, "ASUS H13-200x",
18549 ALC663_ASUS_H13),
18550 SND_PCI_QUIRK(0x1991, 0x5628, "Ordissimo EVE", ALC662_LENOVO_101E),
18551 {}
18552 };
18553
18554 static const struct alc_config_preset alc662_presets[] = {
18555 [ALC662_3ST_2ch_DIG] = {
18556 .mixers = { alc662_3ST_2ch_mixer },
18557 .init_verbs = { alc662_init_verbs, alc662_eapd_init_verbs },
18558 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18559 .dac_nids = alc662_dac_nids,
18560 .dig_out_nid = ALC662_DIGOUT_NID,
18561 .dig_in_nid = ALC662_DIGIN_NID,
18562 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18563 .channel_mode = alc662_3ST_2ch_modes,
18564 .input_mux = &alc662_capture_source,
18565 },
18566 [ALC662_3ST_6ch_DIG] = {
18567 .mixers = { alc662_3ST_6ch_mixer, alc662_chmode_mixer },
18568 .init_verbs = { alc662_init_verbs, alc662_eapd_init_verbs },
18569 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18570 .dac_nids = alc662_dac_nids,
18571 .dig_out_nid = ALC662_DIGOUT_NID,
18572 .dig_in_nid = ALC662_DIGIN_NID,
18573 .num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes),
18574 .channel_mode = alc662_3ST_6ch_modes,
18575 .need_dac_fix = 1,
18576 .input_mux = &alc662_capture_source,
18577 },
18578 [ALC662_3ST_6ch] = {
18579 .mixers = { alc662_3ST_6ch_mixer, alc662_chmode_mixer },
18580 .init_verbs = { alc662_init_verbs, alc662_eapd_init_verbs },
18581 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18582 .dac_nids = alc662_dac_nids,
18583 .num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes),
18584 .channel_mode = alc662_3ST_6ch_modes,
18585 .need_dac_fix = 1,
18586 .input_mux = &alc662_capture_source,
18587 },
18588 [ALC662_5ST_DIG] = {
18589 .mixers = { alc662_base_mixer, alc662_chmode_mixer },
18590 .init_verbs = { alc662_init_verbs, alc662_eapd_init_verbs },
18591 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18592 .dac_nids = alc662_dac_nids,
18593 .dig_out_nid = ALC662_DIGOUT_NID,
18594 .dig_in_nid = ALC662_DIGIN_NID,
18595 .num_channel_mode = ARRAY_SIZE(alc662_5stack_modes),
18596 .channel_mode = alc662_5stack_modes,
18597 .input_mux = &alc662_capture_source,
18598 },
18599 [ALC662_LENOVO_101E] = {
18600 .mixers = { alc662_lenovo_101e_mixer },
18601 .init_verbs = { alc662_init_verbs,
18602 alc662_eapd_init_verbs,
18603 alc662_sue_init_verbs },
18604 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18605 .dac_nids = alc662_dac_nids,
18606 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18607 .channel_mode = alc662_3ST_2ch_modes,
18608 .input_mux = &alc662_lenovo_101e_capture_source,
18609 .unsol_event = alc_sku_unsol_event,
18610 .setup = alc662_lenovo_101e_setup,
18611 .init_hook = alc_inithook,
18612 },
18613 [ALC662_ASUS_EEEPC_P701] = {
18614 .mixers = { alc662_eeepc_p701_mixer },
18615 .init_verbs = { alc662_init_verbs,
18616 alc662_eapd_init_verbs,
18617 alc662_eeepc_sue_init_verbs },
18618 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18619 .dac_nids = alc662_dac_nids,
18620 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18621 .channel_mode = alc662_3ST_2ch_modes,
18622 .unsol_event = alc_sku_unsol_event,
18623 .setup = alc662_eeepc_setup,
18624 .init_hook = alc_inithook,
18625 },
18626 [ALC662_ASUS_EEEPC_EP20] = {
18627 .mixers = { alc662_eeepc_ep20_mixer,
18628 alc662_chmode_mixer },
18629 .init_verbs = { alc662_init_verbs,
18630 alc662_eapd_init_verbs,
18631 alc662_eeepc_ep20_sue_init_verbs },
18632 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18633 .dac_nids = alc662_dac_nids,
18634 .num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes),
18635 .channel_mode = alc662_3ST_6ch_modes,
18636 .input_mux = &alc662_lenovo_101e_capture_source,
18637 .unsol_event = alc_sku_unsol_event,
18638 .setup = alc662_eeepc_ep20_setup,
18639 .init_hook = alc_inithook,
18640 },
18641 [ALC662_ECS] = {
18642 .mixers = { alc662_ecs_mixer },
18643 .init_verbs = { alc662_init_verbs,
18644 alc662_eapd_init_verbs,
18645 alc662_ecs_init_verbs },
18646 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18647 .dac_nids = alc662_dac_nids,
18648 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18649 .channel_mode = alc662_3ST_2ch_modes,
18650 .unsol_event = alc_sku_unsol_event,
18651 .setup = alc662_eeepc_setup,
18652 .init_hook = alc_inithook,
18653 },
18654 [ALC663_ASUS_M51VA] = {
18655 .mixers = { alc663_m51va_mixer },
18656 .init_verbs = { alc662_init_verbs,
18657 alc662_eapd_init_verbs,
18658 alc663_m51va_init_verbs },
18659 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18660 .dac_nids = alc662_dac_nids,
18661 .dig_out_nid = ALC662_DIGOUT_NID,
18662 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18663 .channel_mode = alc662_3ST_2ch_modes,
18664 .unsol_event = alc_sku_unsol_event,
18665 .setup = alc663_m51va_setup,
18666 .init_hook = alc_inithook,
18667 },
18668 [ALC663_ASUS_G71V] = {
18669 .mixers = { alc663_g71v_mixer },
18670 .init_verbs = { alc662_init_verbs,
18671 alc662_eapd_init_verbs,
18672 alc663_g71v_init_verbs },
18673 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18674 .dac_nids = alc662_dac_nids,
18675 .dig_out_nid = ALC662_DIGOUT_NID,
18676 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18677 .channel_mode = alc662_3ST_2ch_modes,
18678 .unsol_event = alc_sku_unsol_event,
18679 .setup = alc663_g71v_setup,
18680 .init_hook = alc_inithook,
18681 },
18682 [ALC663_ASUS_H13] = {
18683 .mixers = { alc663_m51va_mixer },
18684 .init_verbs = { alc662_init_verbs,
18685 alc662_eapd_init_verbs,
18686 alc663_m51va_init_verbs },
18687 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18688 .dac_nids = alc662_dac_nids,
18689 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18690 .channel_mode = alc662_3ST_2ch_modes,
18691 .setup = alc663_m51va_setup,
18692 .unsol_event = alc_sku_unsol_event,
18693 .init_hook = alc_inithook,
18694 },
18695 [ALC663_ASUS_G50V] = {
18696 .mixers = { alc663_g50v_mixer },
18697 .init_verbs = { alc662_init_verbs,
18698 alc662_eapd_init_verbs,
18699 alc663_g50v_init_verbs },
18700 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18701 .dac_nids = alc662_dac_nids,
18702 .dig_out_nid = ALC662_DIGOUT_NID,
18703 .num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes),
18704 .channel_mode = alc662_3ST_6ch_modes,
18705 .input_mux = &alc663_capture_source,
18706 .unsol_event = alc_sku_unsol_event,
18707 .setup = alc663_g50v_setup,
18708 .init_hook = alc_inithook,
18709 },
18710 [ALC663_ASUS_MODE1] = {
18711 .mixers = { alc663_m51va_mixer },
18712 .cap_mixer = alc662_auto_capture_mixer,
18713 .init_verbs = { alc662_init_verbs,
18714 alc662_eapd_init_verbs,
18715 alc663_21jd_amic_init_verbs },
18716 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18717 .hp_nid = 0x03,
18718 .dac_nids = alc662_dac_nids,
18719 .dig_out_nid = ALC662_DIGOUT_NID,
18720 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18721 .channel_mode = alc662_3ST_2ch_modes,
18722 .unsol_event = alc_sku_unsol_event,
18723 .setup = alc663_mode1_setup,
18724 .init_hook = alc_inithook,
18725 },
18726 [ALC662_ASUS_MODE2] = {
18727 .mixers = { alc662_1bjd_mixer },
18728 .cap_mixer = alc662_auto_capture_mixer,
18729 .init_verbs = { alc662_init_verbs,
18730 alc662_eapd_init_verbs,
18731 alc662_1bjd_amic_init_verbs },
18732 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18733 .dac_nids = alc662_dac_nids,
18734 .dig_out_nid = ALC662_DIGOUT_NID,
18735 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18736 .channel_mode = alc662_3ST_2ch_modes,
18737 .unsol_event = alc_sku_unsol_event,
18738 .setup = alc662_mode2_setup,
18739 .init_hook = alc_inithook,
18740 },
18741 [ALC663_ASUS_MODE3] = {
18742 .mixers = { alc663_two_hp_m1_mixer },
18743 .cap_mixer = alc662_auto_capture_mixer,
18744 .init_verbs = { alc662_init_verbs,
18745 alc662_eapd_init_verbs,
18746 alc663_two_hp_amic_m1_init_verbs },
18747 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18748 .hp_nid = 0x03,
18749 .dac_nids = alc662_dac_nids,
18750 .dig_out_nid = ALC662_DIGOUT_NID,
18751 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18752 .channel_mode = alc662_3ST_2ch_modes,
18753 .unsol_event = alc_sku_unsol_event,
18754 .setup = alc663_mode3_setup,
18755 .init_hook = alc_inithook,
18756 },
18757 [ALC663_ASUS_MODE4] = {
18758 .mixers = { alc663_asus_21jd_clfe_mixer },
18759 .cap_mixer = alc662_auto_capture_mixer,
18760 .init_verbs = { alc662_init_verbs,
18761 alc662_eapd_init_verbs,
18762 alc663_21jd_amic_init_verbs},
18763 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18764 .hp_nid = 0x03,
18765 .dac_nids = alc662_dac_nids,
18766 .dig_out_nid = ALC662_DIGOUT_NID,
18767 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18768 .channel_mode = alc662_3ST_2ch_modes,
18769 .unsol_event = alc_sku_unsol_event,
18770 .setup = alc663_mode4_setup,
18771 .init_hook = alc_inithook,
18772 },
18773 [ALC663_ASUS_MODE5] = {
18774 .mixers = { alc663_asus_15jd_clfe_mixer },
18775 .cap_mixer = alc662_auto_capture_mixer,
18776 .init_verbs = { alc662_init_verbs,
18777 alc662_eapd_init_verbs,
18778 alc663_15jd_amic_init_verbs },
18779 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18780 .hp_nid = 0x03,
18781 .dac_nids = alc662_dac_nids,
18782 .dig_out_nid = ALC662_DIGOUT_NID,
18783 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18784 .channel_mode = alc662_3ST_2ch_modes,
18785 .unsol_event = alc_sku_unsol_event,
18786 .setup = alc663_mode5_setup,
18787 .init_hook = alc_inithook,
18788 },
18789 [ALC663_ASUS_MODE6] = {
18790 .mixers = { alc663_two_hp_m2_mixer },
18791 .cap_mixer = alc662_auto_capture_mixer,
18792 .init_verbs = { alc662_init_verbs,
18793 alc662_eapd_init_verbs,
18794 alc663_two_hp_amic_m2_init_verbs },
18795 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18796 .hp_nid = 0x03,
18797 .dac_nids = alc662_dac_nids,
18798 .dig_out_nid = ALC662_DIGOUT_NID,
18799 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18800 .channel_mode = alc662_3ST_2ch_modes,
18801 .unsol_event = alc_sku_unsol_event,
18802 .setup = alc663_mode6_setup,
18803 .init_hook = alc_inithook,
18804 },
18805 [ALC663_ASUS_MODE7] = {
18806 .mixers = { alc663_mode7_mixer },
18807 .cap_mixer = alc662_auto_capture_mixer,
18808 .init_verbs = { alc662_init_verbs,
18809 alc662_eapd_init_verbs,
18810 alc663_mode7_init_verbs },
18811 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18812 .hp_nid = 0x03,
18813 .dac_nids = alc662_dac_nids,
18814 .dig_out_nid = ALC662_DIGOUT_NID,
18815 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18816 .channel_mode = alc662_3ST_2ch_modes,
18817 .unsol_event = alc_sku_unsol_event,
18818 .setup = alc663_mode7_setup,
18819 .init_hook = alc_inithook,
18820 },
18821 [ALC663_ASUS_MODE8] = {
18822 .mixers = { alc663_mode8_mixer },
18823 .cap_mixer = alc662_auto_capture_mixer,
18824 .init_verbs = { alc662_init_verbs,
18825 alc662_eapd_init_verbs,
18826 alc663_mode8_init_verbs },
18827 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18828 .hp_nid = 0x03,
18829 .dac_nids = alc662_dac_nids,
18830 .dig_out_nid = ALC662_DIGOUT_NID,
18831 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18832 .channel_mode = alc662_3ST_2ch_modes,
18833 .unsol_event = alc_sku_unsol_event,
18834 .setup = alc663_mode8_setup,
18835 .init_hook = alc_inithook,
18836 },
18837 [ALC272_DELL] = {
18838 .mixers = { alc663_m51va_mixer },
18839 .cap_mixer = alc272_auto_capture_mixer,
18840 .init_verbs = { alc662_init_verbs,
18841 alc662_eapd_init_verbs,
18842 alc272_dell_init_verbs },
18843 .num_dacs = ARRAY_SIZE(alc272_dac_nids),
18844 .dac_nids = alc272_dac_nids,
18845 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18846 .adc_nids = alc272_adc_nids,
18847 .num_adc_nids = ARRAY_SIZE(alc272_adc_nids),
18848 .capsrc_nids = alc272_capsrc_nids,
18849 .channel_mode = alc662_3ST_2ch_modes,
18850 .unsol_event = alc_sku_unsol_event,
18851 .setup = alc663_m51va_setup,
18852 .init_hook = alc_inithook,
18853 },
18854 [ALC272_DELL_ZM1] = {
18855 .mixers = { alc663_m51va_mixer },
18856 .cap_mixer = alc662_auto_capture_mixer,
18857 .init_verbs = { alc662_init_verbs,
18858 alc662_eapd_init_verbs,
18859 alc272_dell_zm1_init_verbs },
18860 .num_dacs = ARRAY_SIZE(alc272_dac_nids),
18861 .dac_nids = alc272_dac_nids,
18862 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18863 .adc_nids = alc662_adc_nids,
18864 .num_adc_nids = 1,
18865 .capsrc_nids = alc662_capsrc_nids,
18866 .channel_mode = alc662_3ST_2ch_modes,
18867 .unsol_event = alc_sku_unsol_event,
18868 .setup = alc663_m51va_setup,
18869 .init_hook = alc_inithook,
18870 },
18871 [ALC272_SAMSUNG_NC10] = {
18872 .mixers = { alc272_nc10_mixer },
18873 .init_verbs = { alc662_init_verbs,
18874 alc662_eapd_init_verbs,
18875 alc663_21jd_amic_init_verbs },
18876 .num_dacs = ARRAY_SIZE(alc272_dac_nids),
18877 .dac_nids = alc272_dac_nids,
18878 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18879 .channel_mode = alc662_3ST_2ch_modes,
18880 /*.input_mux = &alc272_nc10_capture_source,*/
18881 .unsol_event = alc_sku_unsol_event,
18882 .setup = alc663_mode4_setup,
18883 .init_hook = alc_inithook,
18884 },
18885 };
18886
18887
18888 /*
18889 * BIOS auto configuration
18890 */
18891
18892 /* convert from MIX nid to DAC */
18893 static hda_nid_t alc_auto_mix_to_dac(struct hda_codec *codec, hda_nid_t nid)
18894 {
18895 hda_nid_t list[5];
18896 int i, num;
18897
18898 num = snd_hda_get_connections(codec, nid, list, ARRAY_SIZE(list));
18899 for (i = 0; i < num; i++) {
18900 if (get_wcaps_type(get_wcaps(codec, list[i])) == AC_WID_AUD_OUT)
18901 return list[i];
18902 }
18903 return 0;
18904 }
18905
18906 /* go down to the selector widget before the mixer */
18907 static hda_nid_t alc_go_down_to_selector(struct hda_codec *codec, hda_nid_t pin)
18908 {
18909 hda_nid_t srcs[5];
18910 int num = snd_hda_get_connections(codec, pin, srcs,
18911 ARRAY_SIZE(srcs));
18912 if (num != 1 ||
18913 get_wcaps_type(get_wcaps(codec, srcs[0])) != AC_WID_AUD_SEL)
18914 return pin;
18915 return srcs[0];
18916 }
18917
18918 /* get MIX nid connected to the given pin targeted to DAC */
18919 static hda_nid_t alc_auto_dac_to_mix(struct hda_codec *codec, hda_nid_t pin,
18920 hda_nid_t dac)
18921 {
18922 hda_nid_t mix[5];
18923 int i, num;
18924
18925 pin = alc_go_down_to_selector(codec, pin);
18926 num = snd_hda_get_connections(codec, pin, mix, ARRAY_SIZE(mix));
18927 for (i = 0; i < num; i++) {
18928 if (alc_auto_mix_to_dac(codec, mix[i]) == dac)
18929 return mix[i];
18930 }
18931 return 0;
18932 }
18933
18934 /* select the connection from pin to DAC if needed */
18935 static int alc_auto_select_dac(struct hda_codec *codec, hda_nid_t pin,
18936 hda_nid_t dac)
18937 {
18938 hda_nid_t mix[5];
18939 int i, num;
18940
18941 pin = alc_go_down_to_selector(codec, pin);
18942 num = snd_hda_get_connections(codec, pin, mix, ARRAY_SIZE(mix));
18943 if (num < 2)
18944 return 0;
18945 for (i = 0; i < num; i++) {
18946 if (alc_auto_mix_to_dac(codec, mix[i]) == dac) {
18947 snd_hda_codec_update_cache(codec, pin, 0,
18948 AC_VERB_SET_CONNECT_SEL, i);
18949 return 0;
18950 }
18951 }
18952 return 0;
18953 }
18954
18955 /* look for an empty DAC slot */
18956 static hda_nid_t alc_auto_look_for_dac(struct hda_codec *codec, hda_nid_t pin)
18957 {
18958 struct alc_spec *spec = codec->spec;
18959 hda_nid_t srcs[5];
18960 int i, j, num;
18961
18962 pin = alc_go_down_to_selector(codec, pin);
18963 num = snd_hda_get_connections(codec, pin, srcs, ARRAY_SIZE(srcs));
18964 for (i = 0; i < num; i++) {
18965 hda_nid_t nid = alc_auto_mix_to_dac(codec, srcs[i]);
18966 if (!nid)
18967 continue;
18968 for (j = 0; j < spec->multiout.num_dacs; j++)
18969 if (spec->multiout.dac_nids[j] == nid)
18970 break;
18971 if (j >= spec->multiout.num_dacs)
18972 return nid;
18973 }
18974 return 0;
18975 }
18976
18977 /* fill in the dac_nids table from the parsed pin configuration */
18978 static int alc662_auto_fill_dac_nids(struct hda_codec *codec,
18979 const struct auto_pin_cfg *cfg)
18980 {
18981 struct alc_spec *spec = codec->spec;
18982 int i;
18983 hda_nid_t dac;
18984
18985 spec->multiout.dac_nids = spec->private_dac_nids;
18986 for (i = 0; i < cfg->line_outs; i++) {
18987 dac = alc_auto_look_for_dac(codec, cfg->line_out_pins[i]);
18988 if (!dac)
18989 continue;
18990 spec->private_dac_nids[spec->multiout.num_dacs++] = dac;
18991 }
18992 return 0;
18993 }
18994
18995 static inline int __alc662_add_vol_ctl(struct alc_spec *spec, const char *pfx,
18996 hda_nid_t nid, int idx, unsigned int chs)
18997 {
18998 return __add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, pfx, idx,
18999 HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_OUTPUT));
19000 }
19001
19002 static inline int __alc662_add_sw_ctl(struct alc_spec *spec, const char *pfx,
19003 hda_nid_t nid, int idx, unsigned int chs)
19004 {
19005 return __add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, pfx, idx,
19006 HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_INPUT));
19007 }
19008
19009 #define alc662_add_vol_ctl(spec, pfx, nid, chs) \
19010 __alc662_add_vol_ctl(spec, pfx, nid, 0, chs)
19011 #define alc662_add_sw_ctl(spec, pfx, nid, chs) \
19012 __alc662_add_sw_ctl(spec, pfx, nid, 0, chs)
19013 #define alc662_add_stereo_vol(spec, pfx, nid) \
19014 alc662_add_vol_ctl(spec, pfx, nid, 3)
19015 #define alc662_add_stereo_sw(spec, pfx, nid) \
19016 alc662_add_sw_ctl(spec, pfx, nid, 3)
19017
19018 /* add playback controls from the parsed DAC table */
19019 static int alc662_auto_create_multi_out_ctls(struct hda_codec *codec,
19020 const struct auto_pin_cfg *cfg)
19021 {
19022 struct alc_spec *spec = codec->spec;
19023 static const char * const chname[4] = {
19024 "Front", "Surround", NULL /*CLFE*/, "Side"
19025 };
19026 const char *pfx = alc_get_line_out_pfx(spec, true);
19027 hda_nid_t nid, mix, pin;
19028 int i, err, noutputs;
19029
19030 noutputs = cfg->line_outs;
19031 if (spec->multi_ios > 0)
19032 noutputs += spec->multi_ios;
19033
19034 for (i = 0; i < noutputs; i++) {
19035 nid = spec->multiout.dac_nids[i];
19036 if (!nid)
19037 continue;
19038 if (i >= cfg->line_outs)
19039 pin = spec->multi_io[i - 1].pin;
19040 else
19041 pin = cfg->line_out_pins[i];
19042 mix = alc_auto_dac_to_mix(codec, pin, nid);
19043 if (!mix)
19044 continue;
19045 if (!pfx && i == 2) {
19046 /* Center/LFE */
19047 err = alc662_add_vol_ctl(spec, "Center", nid, 1);
19048 if (err < 0)
19049 return err;
19050 err = alc662_add_vol_ctl(spec, "LFE", nid, 2);
19051 if (err < 0)
19052 return err;
19053 err = alc662_add_sw_ctl(spec, "Center", mix, 1);
19054 if (err < 0)
19055 return err;
19056 err = alc662_add_sw_ctl(spec, "LFE", mix, 2);
19057 if (err < 0)
19058 return err;
19059 } else {
19060 const char *name = pfx;
19061 int index = i;
19062 if (!name) {
19063 name = chname[i];
19064 index = 0;
19065 }
19066 err = __alc662_add_vol_ctl(spec, name, nid, index, 3);
19067 if (err < 0)
19068 return err;
19069 err = __alc662_add_sw_ctl(spec, name, mix, index, 3);
19070 if (err < 0)
19071 return err;
19072 }
19073 }
19074 return 0;
19075 }
19076
19077 /* add playback controls for speaker and HP outputs */
19078 /* return DAC nid if any new DAC is assigned */
19079 static int alc662_auto_create_extra_out(struct hda_codec *codec, hda_nid_t pin,
19080 const char *pfx)
19081 {
19082 struct alc_spec *spec = codec->spec;
19083 hda_nid_t nid, mix;
19084 int err;
19085
19086 if (!pin)
19087 return 0;
19088 nid = alc_auto_look_for_dac(codec, pin);
19089 if (!nid) {
19090 /* the corresponding DAC is already occupied */
19091 if (!(get_wcaps(codec, pin) & AC_WCAP_OUT_AMP))
19092 return 0; /* no way */
19093 /* create a switch only */
19094 return add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, pfx,
19095 HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
19096 }
19097
19098 mix = alc_auto_dac_to_mix(codec, pin, nid);
19099 if (!mix)
19100 return 0;
19101 err = alc662_add_vol_ctl(spec, pfx, nid, 3);
19102 if (err < 0)
19103 return err;
19104 err = alc662_add_sw_ctl(spec, pfx, mix, 3);
19105 if (err < 0)
19106 return err;
19107 return nid;
19108 }
19109
19110 /* create playback/capture controls for input pins */
19111 #define alc662_auto_create_input_ctls \
19112 alc882_auto_create_input_ctls
19113
19114 static void alc662_auto_set_output_and_unmute(struct hda_codec *codec,
19115 hda_nid_t nid, int pin_type,
19116 hda_nid_t dac)
19117 {
19118 int i, num;
19119 hda_nid_t srcs[HDA_MAX_CONNECTIONS];
19120
19121 alc_set_pin_output(codec, nid, pin_type);
19122 num = snd_hda_get_connections(codec, nid, srcs, ARRAY_SIZE(srcs));
19123 for (i = 0; i < num; i++) {
19124 if (alc_auto_mix_to_dac(codec, srcs[i]) != dac)
19125 continue;
19126 /* need the manual connection? */
19127 if (num > 1)
19128 snd_hda_codec_write(codec, nid, 0,
19129 AC_VERB_SET_CONNECT_SEL, i);
19130 /* unmute mixer widget inputs */
19131 snd_hda_codec_write(codec, srcs[i], 0,
19132 AC_VERB_SET_AMP_GAIN_MUTE,
19133 AMP_IN_UNMUTE(0));
19134 snd_hda_codec_write(codec, srcs[i], 0,
19135 AC_VERB_SET_AMP_GAIN_MUTE,
19136 AMP_IN_UNMUTE(1));
19137 return;
19138 }
19139 }
19140
19141 static void alc662_auto_init_multi_out(struct hda_codec *codec)
19142 {
19143 struct alc_spec *spec = codec->spec;
19144 int pin_type = get_pin_type(spec->autocfg.line_out_type);
19145 int i;
19146
19147 for (i = 0; i <= HDA_SIDE; i++) {
19148 hda_nid_t nid = spec->autocfg.line_out_pins[i];
19149 if (nid)
19150 alc662_auto_set_output_and_unmute(codec, nid, pin_type,
19151 spec->multiout.dac_nids[i]);
19152 }
19153 }
19154
19155 static void alc662_auto_init_hp_out(struct hda_codec *codec)
19156 {
19157 struct alc_spec *spec = codec->spec;
19158 hda_nid_t pin;
19159
19160 pin = spec->autocfg.hp_pins[0];
19161 if (pin)
19162 alc662_auto_set_output_and_unmute(codec, pin, PIN_HP,
19163 spec->multiout.hp_nid);
19164 pin = spec->autocfg.speaker_pins[0];
19165 if (pin)
19166 alc662_auto_set_output_and_unmute(codec, pin, PIN_OUT,
19167 spec->multiout.extra_out_nid[0]);
19168 }
19169
19170 #define ALC662_PIN_CD_NID ALC880_PIN_CD_NID
19171
19172 static void alc662_auto_init_analog_input(struct hda_codec *codec)
19173 {
19174 struct alc_spec *spec = codec->spec;
19175 struct auto_pin_cfg *cfg = &spec->autocfg;
19176 int i;
19177
19178 for (i = 0; i < cfg->num_inputs; i++) {
19179 hda_nid_t nid = cfg->inputs[i].pin;
19180 if (alc_is_input_pin(codec, nid)) {
19181 alc_set_input_pin(codec, nid, cfg->inputs[i].type);
19182 if (nid != ALC662_PIN_CD_NID &&
19183 (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP))
19184 snd_hda_codec_write(codec, nid, 0,
19185 AC_VERB_SET_AMP_GAIN_MUTE,
19186 AMP_OUT_MUTE);
19187 }
19188 }
19189 }
19190
19191 #define alc662_auto_init_input_src alc882_auto_init_input_src
19192
19193 /*
19194 * multi-io helper
19195 */
19196 static int alc_auto_fill_multi_ios(struct hda_codec *codec,
19197 unsigned int location)
19198 {
19199 struct alc_spec *spec = codec->spec;
19200 struct auto_pin_cfg *cfg = &spec->autocfg;
19201 int type, i, num_pins = 0;
19202
19203 for (type = AUTO_PIN_LINE_IN; type >= AUTO_PIN_MIC; type--) {
19204 for (i = 0; i < cfg->num_inputs; i++) {
19205 hda_nid_t nid = cfg->inputs[i].pin;
19206 hda_nid_t dac;
19207 unsigned int defcfg, caps;
19208 if (cfg->inputs[i].type != type)
19209 continue;
19210 defcfg = snd_hda_codec_get_pincfg(codec, nid);
19211 if (get_defcfg_connect(defcfg) != AC_JACK_PORT_COMPLEX)
19212 continue;
19213 if (location && get_defcfg_location(defcfg) != location)
19214 continue;
19215 caps = snd_hda_query_pin_caps(codec, nid);
19216 if (!(caps & AC_PINCAP_OUT))
19217 continue;
19218 dac = alc_auto_look_for_dac(codec, nid);
19219 if (!dac)
19220 continue;
19221 spec->multi_io[num_pins].pin = nid;
19222 spec->multi_io[num_pins].dac = dac;
19223 num_pins++;
19224 spec->private_dac_nids[spec->multiout.num_dacs++] = dac;
19225 }
19226 }
19227 spec->multiout.num_dacs = 1;
19228 if (num_pins < 2)
19229 return 0;
19230 return num_pins;
19231 }
19232
19233 static int alc_auto_ch_mode_info(struct snd_kcontrol *kcontrol,
19234 struct snd_ctl_elem_info *uinfo)
19235 {
19236 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
19237 struct alc_spec *spec = codec->spec;
19238
19239 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
19240 uinfo->count = 1;
19241 uinfo->value.enumerated.items = spec->multi_ios + 1;
19242 if (uinfo->value.enumerated.item > spec->multi_ios)
19243 uinfo->value.enumerated.item = spec->multi_ios;
19244 sprintf(uinfo->value.enumerated.name, "%dch",
19245 (uinfo->value.enumerated.item + 1) * 2);
19246 return 0;
19247 }
19248
19249 static int alc_auto_ch_mode_get(struct snd_kcontrol *kcontrol,
19250 struct snd_ctl_elem_value *ucontrol)
19251 {
19252 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
19253 struct alc_spec *spec = codec->spec;
19254 ucontrol->value.enumerated.item[0] = (spec->ext_channel_count - 1) / 2;
19255 return 0;
19256 }
19257
19258 static int alc_set_multi_io(struct hda_codec *codec, int idx, bool output)
19259 {
19260 struct alc_spec *spec = codec->spec;
19261 hda_nid_t nid = spec->multi_io[idx].pin;
19262
19263 if (!spec->multi_io[idx].ctl_in)
19264 spec->multi_io[idx].ctl_in =
19265 snd_hda_codec_read(codec, nid, 0,
19266 AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
19267 if (output) {
19268 snd_hda_codec_update_cache(codec, nid, 0,
19269 AC_VERB_SET_PIN_WIDGET_CONTROL,
19270 PIN_OUT);
19271 if (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP)
19272 snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
19273 HDA_AMP_MUTE, 0);
19274 alc_auto_select_dac(codec, nid, spec->multi_io[idx].dac);
19275 } else {
19276 if (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP)
19277 snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
19278 HDA_AMP_MUTE, HDA_AMP_MUTE);
19279 snd_hda_codec_update_cache(codec, nid, 0,
19280 AC_VERB_SET_PIN_WIDGET_CONTROL,
19281 spec->multi_io[idx].ctl_in);
19282 }
19283 return 0;
19284 }
19285
19286 static int alc_auto_ch_mode_put(struct snd_kcontrol *kcontrol,
19287 struct snd_ctl_elem_value *ucontrol)
19288 {
19289 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
19290 struct alc_spec *spec = codec->spec;
19291 int i, ch;
19292
19293 ch = ucontrol->value.enumerated.item[0];
19294 if (ch < 0 || ch > spec->multi_ios)
19295 return -EINVAL;
19296 if (ch == (spec->ext_channel_count - 1) / 2)
19297 return 0;
19298 spec->ext_channel_count = (ch + 1) * 2;
19299 for (i = 0; i < spec->multi_ios; i++)
19300 alc_set_multi_io(codec, i, i < ch);
19301 spec->multiout.max_channels = spec->ext_channel_count;
19302 return 1;
19303 }
19304
19305 static const struct snd_kcontrol_new alc_auto_channel_mode_enum = {
19306 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
19307 .name = "Channel Mode",
19308 .info = alc_auto_ch_mode_info,
19309 .get = alc_auto_ch_mode_get,
19310 .put = alc_auto_ch_mode_put,
19311 };
19312
19313 static int alc_auto_add_multi_channel_mode(struct hda_codec *codec)
19314 {
19315 struct alc_spec *spec = codec->spec;
19316 struct auto_pin_cfg *cfg = &spec->autocfg;
19317 unsigned int location, defcfg;
19318 int num_pins;
19319
19320 if (cfg->line_outs != 1 ||
19321 cfg->line_out_type != AUTO_PIN_LINE_OUT)
19322 return 0;
19323
19324 defcfg = snd_hda_codec_get_pincfg(codec, cfg->line_out_pins[0]);
19325 location = get_defcfg_location(defcfg);
19326
19327 num_pins = alc_auto_fill_multi_ios(codec, location);
19328 if (num_pins > 0) {
19329 struct snd_kcontrol_new *knew;
19330
19331 knew = alc_kcontrol_new(spec);
19332 if (!knew)
19333 return -ENOMEM;
19334 *knew = alc_auto_channel_mode_enum;
19335 knew->name = kstrdup("Channel Mode", GFP_KERNEL);
19336 if (!knew->name)
19337 return -ENOMEM;
19338
19339 spec->multi_ios = num_pins;
19340 spec->ext_channel_count = 2;
19341 spec->multiout.num_dacs = num_pins + 1;
19342 }
19343 return 0;
19344 }
19345
19346 static int alc662_parse_auto_config(struct hda_codec *codec)
19347 {
19348 struct alc_spec *spec = codec->spec;
19349 int err;
19350 static const hda_nid_t alc662_ignore[] = { 0x1d, 0 };
19351
19352 err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
19353 alc662_ignore);
19354 if (err < 0)
19355 return err;
19356 if (!spec->autocfg.line_outs)
19357 return 0; /* can't find valid BIOS pin config */
19358
19359 err = alc662_auto_fill_dac_nids(codec, &spec->autocfg);
19360 if (err < 0)
19361 return err;
19362 err = alc_auto_add_multi_channel_mode(codec);
19363 if (err < 0)
19364 return err;
19365 err = alc662_auto_create_multi_out_ctls(codec, &spec->autocfg);
19366 if (err < 0)
19367 return err;
19368 err = alc662_auto_create_extra_out(codec,
19369 spec->autocfg.speaker_pins[0],
19370 "Speaker");
19371 if (err < 0)
19372 return err;
19373 if (err)
19374 spec->multiout.extra_out_nid[0] = err;
19375 err = alc662_auto_create_extra_out(codec, spec->autocfg.hp_pins[0],
19376 "Headphone");
19377 if (err < 0)
19378 return err;
19379 if (err)
19380 spec->multiout.hp_nid = err;
19381 err = alc662_auto_create_input_ctls(codec, &spec->autocfg);
19382 if (err < 0)
19383 return err;
19384
19385 spec->multiout.max_channels = spec->multiout.num_dacs * 2;
19386
19387 alc_auto_parse_digital(codec);
19388
19389 if (spec->kctls.list)
19390 add_mixer(spec, spec->kctls.list);
19391
19392 spec->num_mux_defs = 1;
19393 spec->input_mux = &spec->private_imux[0];
19394
19395 err = alc_auto_add_mic_boost(codec);
19396 if (err < 0)
19397 return err;
19398
19399 if (codec->vendor_id == 0x10ec0272 || codec->vendor_id == 0x10ec0663 ||
19400 codec->vendor_id == 0x10ec0665 || codec->vendor_id == 0x10ec0670)
19401 alc_ssid_check(codec, 0x15, 0x1b, 0x14, 0x21);
19402 else
19403 alc_ssid_check(codec, 0x15, 0x1b, 0x14, 0);
19404
19405 return 1;
19406 }
19407
19408 /* additional initialization for auto-configuration model */
19409 static void alc662_auto_init(struct hda_codec *codec)
19410 {
19411 struct alc_spec *spec = codec->spec;
19412 alc662_auto_init_multi_out(codec);
19413 alc662_auto_init_hp_out(codec);
19414 alc662_auto_init_analog_input(codec);
19415 alc662_auto_init_input_src(codec);
19416 alc_auto_init_digital(codec);
19417 if (spec->unsol_event)
19418 alc_inithook(codec);
19419 }
19420
19421 static void alc272_fixup_mario(struct hda_codec *codec,
19422 const struct alc_fixup *fix, int action)
19423 {
19424 if (action != ALC_FIXUP_ACT_PROBE)
19425 return;
19426 if (snd_hda_override_amp_caps(codec, 0x2, HDA_OUTPUT,
19427 (0x3b << AC_AMPCAP_OFFSET_SHIFT) |
19428 (0x3b << AC_AMPCAP_NUM_STEPS_SHIFT) |
19429 (0x03 << AC_AMPCAP_STEP_SIZE_SHIFT) |
19430 (0 << AC_AMPCAP_MUTE_SHIFT)))
19431 printk(KERN_WARNING
19432 "hda_codec: failed to override amp caps for NID 0x2\n");
19433 }
19434
19435 enum {
19436 ALC662_FIXUP_ASPIRE,
19437 ALC662_FIXUP_IDEAPAD,
19438 ALC272_FIXUP_MARIO,
19439 ALC662_FIXUP_CZC_P10T,
19440 ALC662_FIXUP_SKU_IGNORE,
19441 };
19442
19443 static const struct alc_fixup alc662_fixups[] = {
19444 [ALC662_FIXUP_ASPIRE] = {
19445 .type = ALC_FIXUP_PINS,
19446 .v.pins = (const struct alc_pincfg[]) {
19447 { 0x15, 0x99130112 }, /* subwoofer */
19448 { }
19449 }
19450 },
19451 [ALC662_FIXUP_IDEAPAD] = {
19452 .type = ALC_FIXUP_PINS,
19453 .v.pins = (const struct alc_pincfg[]) {
19454 { 0x17, 0x99130112 }, /* subwoofer */
19455 { }
19456 }
19457 },
19458 [ALC272_FIXUP_MARIO] = {
19459 .type = ALC_FIXUP_FUNC,
19460 .v.func = alc272_fixup_mario,
19461 },
19462 [ALC662_FIXUP_CZC_P10T] = {
19463 .type = ALC_FIXUP_VERBS,
19464 .v.verbs = (const struct hda_verb[]) {
19465 {0x14, AC_VERB_SET_EAPD_BTLENABLE, 0},
19466 {}
19467 }
19468 },
19469 [ALC662_FIXUP_SKU_IGNORE] = {
19470 .type = ALC_FIXUP_SKU,
19471 .v.sku = ALC_FIXUP_SKU_IGNORE,
19472 },
19473 };
19474
19475 static const struct snd_pci_quirk alc662_fixup_tbl[] = {
19476 SND_PCI_QUIRK(0x1025, 0x0308, "Acer Aspire 8942G", ALC662_FIXUP_ASPIRE),
19477 SND_PCI_QUIRK(0x1025, 0x031c, "Gateway NV79", ALC662_FIXUP_SKU_IGNORE),
19478 SND_PCI_QUIRK(0x1025, 0x038b, "Acer Aspire 8943G", ALC662_FIXUP_ASPIRE),
19479 SND_PCI_QUIRK(0x144d, 0xc051, "Samsung R720", ALC662_FIXUP_IDEAPAD),
19480 SND_PCI_QUIRK(0x17aa, 0x38af, "Lenovo Ideapad Y550P", ALC662_FIXUP_IDEAPAD),
19481 SND_PCI_QUIRK(0x17aa, 0x3a0d, "Lenovo Ideapad Y550", ALC662_FIXUP_IDEAPAD),
19482 SND_PCI_QUIRK(0x1b35, 0x2206, "CZC P10T", ALC662_FIXUP_CZC_P10T),
19483 {}
19484 };
19485
19486 static const struct alc_model_fixup alc662_fixup_models[] = {
19487 {.id = ALC272_FIXUP_MARIO, .name = "mario"},
19488 {}
19489 };
19490
19491
19492 static int patch_alc662(struct hda_codec *codec)
19493 {
19494 struct alc_spec *spec;
19495 int err, board_config;
19496 int coef;
19497
19498 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
19499 if (!spec)
19500 return -ENOMEM;
19501
19502 codec->spec = spec;
19503
19504 alc_auto_parse_customize_define(codec);
19505
19506 alc_fix_pll_init(codec, 0x20, 0x04, 15);
19507
19508 coef = alc_read_coef_idx(codec, 0);
19509 if (coef == 0x8020 || coef == 0x8011)
19510 alc_codec_rename(codec, "ALC661");
19511 else if (coef & (1 << 14) &&
19512 codec->bus->pci->subsystem_vendor == 0x1025 &&
19513 spec->cdefine.platform_type == 1)
19514 alc_codec_rename(codec, "ALC272X");
19515 else if (coef == 0x4011)
19516 alc_codec_rename(codec, "ALC656");
19517
19518 board_config = snd_hda_check_board_config(codec, ALC662_MODEL_LAST,
19519 alc662_models,
19520 alc662_cfg_tbl);
19521 if (board_config < 0) {
19522 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
19523 codec->chip_name);
19524 board_config = ALC662_AUTO;
19525 }
19526
19527 if (board_config == ALC662_AUTO) {
19528 alc_pick_fixup(codec, alc662_fixup_models,
19529 alc662_fixup_tbl, alc662_fixups);
19530 alc_apply_fixup(codec, ALC_FIXUP_ACT_PRE_PROBE);
19531 /* automatic parse from the BIOS config */
19532 err = alc662_parse_auto_config(codec);
19533 if (err < 0) {
19534 alc_free(codec);
19535 return err;
19536 } else if (!err) {
19537 printk(KERN_INFO
19538 "hda_codec: Cannot set up configuration "
19539 "from BIOS. Using base mode...\n");
19540 board_config = ALC662_3ST_2ch_DIG;
19541 }
19542 }
19543
19544 if (has_cdefine_beep(codec)) {
19545 err = snd_hda_attach_beep_device(codec, 0x1);
19546 if (err < 0) {
19547 alc_free(codec);
19548 return err;
19549 }
19550 }
19551
19552 if (board_config != ALC662_AUTO)
19553 setup_preset(codec, &alc662_presets[board_config]);
19554
19555 spec->stream_analog_playback = &alc662_pcm_analog_playback;
19556 spec->stream_analog_capture = &alc662_pcm_analog_capture;
19557
19558 spec->stream_digital_playback = &alc662_pcm_digital_playback;
19559 spec->stream_digital_capture = &alc662_pcm_digital_capture;
19560
19561 if (!spec->adc_nids) {
19562 spec->adc_nids = alc662_adc_nids;
19563 spec->num_adc_nids = ARRAY_SIZE(alc662_adc_nids);
19564 }
19565 if (!spec->capsrc_nids)
19566 spec->capsrc_nids = alc662_capsrc_nids;
19567
19568 if (!spec->cap_mixer)
19569 set_capture_mixer(codec);
19570
19571 if (has_cdefine_beep(codec)) {
19572 switch (codec->vendor_id) {
19573 case 0x10ec0662:
19574 set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
19575 break;
19576 case 0x10ec0272:
19577 case 0x10ec0663:
19578 case 0x10ec0665:
19579 set_beep_amp(spec, 0x0b, 0x04, HDA_INPUT);
19580 break;
19581 case 0x10ec0273:
19582 set_beep_amp(spec, 0x0b, 0x03, HDA_INPUT);
19583 break;
19584 }
19585 }
19586 spec->vmaster_nid = 0x02;
19587
19588 alc_apply_fixup(codec, ALC_FIXUP_ACT_PROBE);
19589
19590 codec->patch_ops = alc_patch_ops;
19591 if (board_config == ALC662_AUTO)
19592 spec->init_hook = alc662_auto_init;
19593 spec->shutup = alc_eapd_shutup;
19594
19595 alc_init_jacks(codec);
19596
19597 #ifdef CONFIG_SND_HDA_POWER_SAVE
19598 if (!spec->loopback.amplist)
19599 spec->loopback.amplist = alc662_loopbacks;
19600 #endif
19601
19602 return 0;
19603 }
19604
19605 static int patch_alc888(struct hda_codec *codec)
19606 {
19607 if ((alc_read_coef_idx(codec, 0) & 0x00f0)==0x0030){
19608 kfree(codec->chip_name);
19609 if (codec->vendor_id == 0x10ec0887)
19610 codec->chip_name = kstrdup("ALC887-VD", GFP_KERNEL);
19611 else
19612 codec->chip_name = kstrdup("ALC888-VD", GFP_KERNEL);
19613 if (!codec->chip_name) {
19614 alc_free(codec);
19615 return -ENOMEM;
19616 }
19617 return patch_alc662(codec);
19618 }
19619 return patch_alc882(codec);
19620 }
19621
19622 static int patch_alc899(struct hda_codec *codec)
19623 {
19624 if ((alc_read_coef_idx(codec, 0) & 0x2000) != 0x2000) {
19625 kfree(codec->chip_name);
19626 codec->chip_name = kstrdup("ALC898", GFP_KERNEL);
19627 }
19628 return patch_alc882(codec);
19629 }
19630
19631 /*
19632 * ALC680 support
19633 */
19634 #define ALC680_DIGIN_NID ALC880_DIGIN_NID
19635 #define ALC680_DIGOUT_NID ALC880_DIGOUT_NID
19636 #define alc680_modes alc260_modes
19637
19638 static const hda_nid_t alc680_dac_nids[3] = {
19639 /* Lout1, Lout2, hp */
19640 0x02, 0x03, 0x04
19641 };
19642
19643 static const hda_nid_t alc680_adc_nids[3] = {
19644 /* ADC0-2 */
19645 /* DMIC, MIC, Line-in*/
19646 0x07, 0x08, 0x09
19647 };
19648
19649 /*
19650 * Analog capture ADC cgange
19651 */
19652 static void alc680_rec_autoswitch(struct hda_codec *codec)
19653 {
19654 struct alc_spec *spec = codec->spec;
19655 struct auto_pin_cfg *cfg = &spec->autocfg;
19656 int pin_found = 0;
19657 int type_found = AUTO_PIN_LAST;
19658 hda_nid_t nid;
19659 int i;
19660
19661 for (i = 0; i < cfg->num_inputs; i++) {
19662 nid = cfg->inputs[i].pin;
19663 if (!is_jack_detectable(codec, nid))
19664 continue;
19665 if (snd_hda_jack_detect(codec, nid)) {
19666 if (cfg->inputs[i].type < type_found) {
19667 type_found = cfg->inputs[i].type;
19668 pin_found = nid;
19669 }
19670 }
19671 }
19672
19673 nid = 0x07;
19674 if (pin_found)
19675 snd_hda_get_connections(codec, pin_found, &nid, 1);
19676
19677 if (nid != spec->cur_adc)
19678 __snd_hda_codec_cleanup_stream(codec, spec->cur_adc, 1);
19679 spec->cur_adc = nid;
19680 snd_hda_codec_setup_stream(codec, nid, spec->cur_adc_stream_tag, 0,
19681 spec->cur_adc_format);
19682 }
19683
19684 static int alc680_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
19685 struct hda_codec *codec,
19686 unsigned int stream_tag,
19687 unsigned int format,
19688 struct snd_pcm_substream *substream)
19689 {
19690 struct alc_spec *spec = codec->spec;
19691
19692 spec->cur_adc = 0x07;
19693 spec->cur_adc_stream_tag = stream_tag;
19694 spec->cur_adc_format = format;
19695
19696 alc680_rec_autoswitch(codec);
19697 return 0;
19698 }
19699
19700 static int alc680_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
19701 struct hda_codec *codec,
19702 struct snd_pcm_substream *substream)
19703 {
19704 snd_hda_codec_cleanup_stream(codec, 0x07);
19705 snd_hda_codec_cleanup_stream(codec, 0x08);
19706 snd_hda_codec_cleanup_stream(codec, 0x09);
19707 return 0;
19708 }
19709
19710 static const struct hda_pcm_stream alc680_pcm_analog_auto_capture = {
19711 .substreams = 1, /* can be overridden */
19712 .channels_min = 2,
19713 .channels_max = 2,
19714 /* NID is set in alc_build_pcms */
19715 .ops = {
19716 .prepare = alc680_capture_pcm_prepare,
19717 .cleanup = alc680_capture_pcm_cleanup
19718 },
19719 };
19720
19721 static const struct snd_kcontrol_new alc680_base_mixer[] = {
19722 /* output mixer control */
19723 HDA_CODEC_VOLUME("Front Playback Volume", 0x2, 0x0, HDA_OUTPUT),
19724 HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
19725 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x4, 0x0, HDA_OUTPUT),
19726 HDA_CODEC_MUTE("Headphone Playback Switch", 0x16, 0x0, HDA_OUTPUT),
19727 HDA_CODEC_VOLUME("Internal Mic Boost Volume", 0x12, 0, HDA_INPUT),
19728 HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
19729 HDA_CODEC_VOLUME("Line In Boost Volume", 0x19, 0, HDA_INPUT),
19730 { }
19731 };
19732
19733 static const struct hda_bind_ctls alc680_bind_cap_vol = {
19734 .ops = &snd_hda_bind_vol,
19735 .values = {
19736 HDA_COMPOSE_AMP_VAL(0x07, 3, 0, HDA_INPUT),
19737 HDA_COMPOSE_AMP_VAL(0x08, 3, 0, HDA_INPUT),
19738 HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_INPUT),
19739 0
19740 },
19741 };
19742
19743 static const struct hda_bind_ctls alc680_bind_cap_switch = {
19744 .ops = &snd_hda_bind_sw,
19745 .values = {
19746 HDA_COMPOSE_AMP_VAL(0x07, 3, 0, HDA_INPUT),
19747 HDA_COMPOSE_AMP_VAL(0x08, 3, 0, HDA_INPUT),
19748 HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_INPUT),
19749 0
19750 },
19751 };
19752
19753 static const struct snd_kcontrol_new alc680_master_capture_mixer[] = {
19754 HDA_BIND_VOL("Capture Volume", &alc680_bind_cap_vol),
19755 HDA_BIND_SW("Capture Switch", &alc680_bind_cap_switch),
19756 { } /* end */
19757 };
19758
19759 /*
19760 * generic initialization of ADC, input mixers and output mixers
19761 */
19762 static const struct hda_verb alc680_init_verbs[] = {
19763 {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
19764 {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
19765 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
19766
19767 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
19768 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
19769 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
19770 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
19771 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
19772 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
19773
19774 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
19775 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
19776 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
19777 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
19778 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
19779
19780 {0x16, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
19781 {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN},
19782 {0x19, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN},
19783
19784 { }
19785 };
19786
19787 /* toggle speaker-output according to the hp-jack state */
19788 static void alc680_base_setup(struct hda_codec *codec)
19789 {
19790 struct alc_spec *spec = codec->spec;
19791
19792 spec->autocfg.hp_pins[0] = 0x16;
19793 spec->autocfg.speaker_pins[0] = 0x14;
19794 spec->autocfg.speaker_pins[1] = 0x15;
19795 spec->autocfg.num_inputs = 2;
19796 spec->autocfg.inputs[0].pin = 0x18;
19797 spec->autocfg.inputs[0].type = AUTO_PIN_MIC;
19798 spec->autocfg.inputs[1].pin = 0x19;
19799 spec->autocfg.inputs[1].type = AUTO_PIN_LINE_IN;
19800 spec->automute = 1;
19801 spec->automute_mode = ALC_AUTOMUTE_AMP;
19802 }
19803
19804 static void alc680_unsol_event(struct hda_codec *codec,
19805 unsigned int res)
19806 {
19807 if ((res >> 26) == ALC880_HP_EVENT)
19808 alc_hp_automute(codec);
19809 if ((res >> 26) == ALC880_MIC_EVENT)
19810 alc680_rec_autoswitch(codec);
19811 }
19812
19813 static void alc680_inithook(struct hda_codec *codec)
19814 {
19815 alc_hp_automute(codec);
19816 alc680_rec_autoswitch(codec);
19817 }
19818
19819 /* create input playback/capture controls for the given pin */
19820 static int alc680_new_analog_output(struct alc_spec *spec, hda_nid_t nid,
19821 const char *ctlname, int idx)
19822 {
19823 hda_nid_t dac;
19824 int err;
19825
19826 switch (nid) {
19827 case 0x14:
19828 dac = 0x02;
19829 break;
19830 case 0x15:
19831 dac = 0x03;
19832 break;
19833 case 0x16:
19834 dac = 0x04;
19835 break;
19836 default:
19837 return 0;
19838 }
19839 if (spec->multiout.dac_nids[0] != dac &&
19840 spec->multiout.dac_nids[1] != dac) {
19841 err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, ctlname,
19842 HDA_COMPOSE_AMP_VAL(dac, 3, idx,
19843 HDA_OUTPUT));
19844 if (err < 0)
19845 return err;
19846
19847 err = add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, ctlname,
19848 HDA_COMPOSE_AMP_VAL(nid, 3, idx, HDA_OUTPUT));
19849
19850 if (err < 0)
19851 return err;
19852 spec->private_dac_nids[spec->multiout.num_dacs++] = dac;
19853 }
19854
19855 return 0;
19856 }
19857
19858 /* add playback controls from the parsed DAC table */
19859 static int alc680_auto_create_multi_out_ctls(struct alc_spec *spec,
19860 const struct auto_pin_cfg *cfg)
19861 {
19862 hda_nid_t nid;
19863 int err;
19864
19865 spec->multiout.dac_nids = spec->private_dac_nids;
19866
19867 nid = cfg->line_out_pins[0];
19868 if (nid) {
19869 const char *name;
19870 if (cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
19871 name = "Speaker";
19872 else
19873 name = "Front";
19874 err = alc680_new_analog_output(spec, nid, name, 0);
19875 if (err < 0)
19876 return err;
19877 }
19878
19879 nid = cfg->speaker_pins[0];
19880 if (nid) {
19881 err = alc680_new_analog_output(spec, nid, "Speaker", 0);
19882 if (err < 0)
19883 return err;
19884 }
19885 nid = cfg->hp_pins[0];
19886 if (nid) {
19887 err = alc680_new_analog_output(spec, nid, "Headphone", 0);
19888 if (err < 0)
19889 return err;
19890 }
19891
19892 return 0;
19893 }
19894
19895 static void alc680_auto_set_output_and_unmute(struct hda_codec *codec,
19896 hda_nid_t nid, int pin_type)
19897 {
19898 alc_set_pin_output(codec, nid, pin_type);
19899 }
19900
19901 static void alc680_auto_init_multi_out(struct hda_codec *codec)
19902 {
19903 struct alc_spec *spec = codec->spec;
19904 hda_nid_t nid = spec->autocfg.line_out_pins[0];
19905 if (nid) {
19906 int pin_type = get_pin_type(spec->autocfg.line_out_type);
19907 alc680_auto_set_output_and_unmute(codec, nid, pin_type);
19908 }
19909 }
19910
19911 static void alc680_auto_init_hp_out(struct hda_codec *codec)
19912 {
19913 struct alc_spec *spec = codec->spec;
19914 hda_nid_t pin;
19915
19916 pin = spec->autocfg.hp_pins[0];
19917 if (pin)
19918 alc680_auto_set_output_and_unmute(codec, pin, PIN_HP);
19919 pin = spec->autocfg.speaker_pins[0];
19920 if (pin)
19921 alc680_auto_set_output_and_unmute(codec, pin, PIN_OUT);
19922 }
19923
19924 /* pcm configuration: identical with ALC880 */
19925 #define alc680_pcm_analog_playback alc880_pcm_analog_playback
19926 #define alc680_pcm_analog_capture alc880_pcm_analog_capture
19927 #define alc680_pcm_analog_alt_capture alc880_pcm_analog_alt_capture
19928 #define alc680_pcm_digital_playback alc880_pcm_digital_playback
19929 #define alc680_pcm_digital_capture alc880_pcm_digital_capture
19930
19931 /*
19932 * BIOS auto configuration
19933 */
19934 static int alc680_parse_auto_config(struct hda_codec *codec)
19935 {
19936 struct alc_spec *spec = codec->spec;
19937 int err;
19938 static const hda_nid_t alc680_ignore[] = { 0 };
19939
19940 err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
19941 alc680_ignore);
19942 if (err < 0)
19943 return err;
19944
19945 if (!spec->autocfg.line_outs) {
19946 if (spec->autocfg.dig_outs || spec->autocfg.dig_in_pin) {
19947 spec->multiout.max_channels = 2;
19948 spec->no_analog = 1;
19949 goto dig_only;
19950 }
19951 return 0; /* can't find valid BIOS pin config */
19952 }
19953 err = alc680_auto_create_multi_out_ctls(spec, &spec->autocfg);
19954 if (err < 0)
19955 return err;
19956
19957 spec->multiout.max_channels = 2;
19958
19959 dig_only:
19960 /* digital only support output */
19961 alc_auto_parse_digital(codec);
19962 if (spec->kctls.list)
19963 add_mixer(spec, spec->kctls.list);
19964
19965 add_verb(spec, alc680_init_verbs);
19966
19967 err = alc_auto_add_mic_boost(codec);
19968 if (err < 0)
19969 return err;
19970
19971 return 1;
19972 }
19973
19974 #define alc680_auto_init_analog_input alc882_auto_init_analog_input
19975
19976 /* init callback for auto-configuration model -- overriding the default init */
19977 static void alc680_auto_init(struct hda_codec *codec)
19978 {
19979 struct alc_spec *spec = codec->spec;
19980 alc680_auto_init_multi_out(codec);
19981 alc680_auto_init_hp_out(codec);
19982 alc680_auto_init_analog_input(codec);
19983 alc_auto_init_digital(codec);
19984 if (spec->unsol_event)
19985 alc_inithook(codec);
19986 }
19987
19988 /*
19989 * configuration and preset
19990 */
19991 static const char * const alc680_models[ALC680_MODEL_LAST] = {
19992 [ALC680_BASE] = "base",
19993 [ALC680_AUTO] = "auto",
19994 };
19995
19996 static const struct snd_pci_quirk alc680_cfg_tbl[] = {
19997 SND_PCI_QUIRK(0x1043, 0x12f3, "ASUS NX90", ALC680_BASE),
19998 {}
19999 };
20000
20001 static const struct alc_config_preset alc680_presets[] = {
20002 [ALC680_BASE] = {
20003 .mixers = { alc680_base_mixer },
20004 .cap_mixer = alc680_master_capture_mixer,
20005 .init_verbs = { alc680_init_verbs },
20006 .num_dacs = ARRAY_SIZE(alc680_dac_nids),
20007 .dac_nids = alc680_dac_nids,
20008 .dig_out_nid = ALC680_DIGOUT_NID,
20009 .num_channel_mode = ARRAY_SIZE(alc680_modes),
20010 .channel_mode = alc680_modes,
20011 .unsol_event = alc680_unsol_event,
20012 .setup = alc680_base_setup,
20013 .init_hook = alc680_inithook,
20014
20015 },
20016 };
20017
20018 static int patch_alc680(struct hda_codec *codec)
20019 {
20020 struct alc_spec *spec;
20021 int board_config;
20022 int err;
20023
20024 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
20025 if (spec == NULL)
20026 return -ENOMEM;
20027
20028 codec->spec = spec;
20029
20030 board_config = snd_hda_check_board_config(codec, ALC680_MODEL_LAST,
20031 alc680_models,
20032 alc680_cfg_tbl);
20033
20034 if (board_config < 0 || board_config >= ALC680_MODEL_LAST) {
20035 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
20036 codec->chip_name);
20037 board_config = ALC680_AUTO;
20038 }
20039
20040 if (board_config == ALC680_AUTO) {
20041 /* automatic parse from the BIOS config */
20042 err = alc680_parse_auto_config(codec);
20043 if (err < 0) {
20044 alc_free(codec);
20045 return err;
20046 } else if (!err) {
20047 printk(KERN_INFO
20048 "hda_codec: Cannot set up configuration "
20049 "from BIOS. Using base mode...\n");
20050 board_config = ALC680_BASE;
20051 }
20052 }
20053
20054 if (board_config != ALC680_AUTO)
20055 setup_preset(codec, &alc680_presets[board_config]);
20056
20057 spec->stream_analog_playback = &alc680_pcm_analog_playback;
20058 spec->stream_analog_capture = &alc680_pcm_analog_auto_capture;
20059 spec->stream_digital_playback = &alc680_pcm_digital_playback;
20060 spec->stream_digital_capture = &alc680_pcm_digital_capture;
20061
20062 if (!spec->adc_nids) {
20063 spec->adc_nids = alc680_adc_nids;
20064 spec->num_adc_nids = ARRAY_SIZE(alc680_adc_nids);
20065 }
20066
20067 if (!spec->cap_mixer)
20068 set_capture_mixer(codec);
20069
20070 spec->vmaster_nid = 0x02;
20071
20072 codec->patch_ops = alc_patch_ops;
20073 if (board_config == ALC680_AUTO)
20074 spec->init_hook = alc680_auto_init;
20075
20076 return 0;
20077 }
20078
20079 /*
20080 * patch entries
20081 */
20082 static const struct hda_codec_preset snd_hda_preset_realtek[] = {
20083 { .id = 0x10ec0221, .name = "ALC221", .patch = patch_alc269 },
20084 { .id = 0x10ec0260, .name = "ALC260", .patch = patch_alc260 },
20085 { .id = 0x10ec0262, .name = "ALC262", .patch = patch_alc262 },
20086 { .id = 0x10ec0267, .name = "ALC267", .patch = patch_alc268 },
20087 { .id = 0x10ec0268, .name = "ALC268", .patch = patch_alc268 },
20088 { .id = 0x10ec0269, .name = "ALC269", .patch = patch_alc269 },
20089 { .id = 0x10ec0270, .name = "ALC270", .patch = patch_alc269 },
20090 { .id = 0x10ec0272, .name = "ALC272", .patch = patch_alc662 },
20091 { .id = 0x10ec0275, .name = "ALC275", .patch = patch_alc269 },
20092 { .id = 0x10ec0276, .name = "ALC276", .patch = patch_alc269 },
20093 { .id = 0x10ec0861, .rev = 0x100340, .name = "ALC660",
20094 .patch = patch_alc861 },
20095 { .id = 0x10ec0660, .name = "ALC660-VD", .patch = patch_alc861vd },
20096 { .id = 0x10ec0861, .name = "ALC861", .patch = patch_alc861 },
20097 { .id = 0x10ec0862, .name = "ALC861-VD", .patch = patch_alc861vd },
20098 { .id = 0x10ec0662, .rev = 0x100002, .name = "ALC662 rev2",
20099 .patch = patch_alc882 },
20100 { .id = 0x10ec0662, .rev = 0x100101, .name = "ALC662 rev1",
20101 .patch = patch_alc662 },
20102 { .id = 0x10ec0663, .name = "ALC663", .patch = patch_alc662 },
20103 { .id = 0x10ec0665, .name = "ALC665", .patch = patch_alc662 },
20104 { .id = 0x10ec0670, .name = "ALC670", .patch = patch_alc662 },
20105 { .id = 0x10ec0680, .name = "ALC680", .patch = patch_alc680 },
20106 { .id = 0x10ec0880, .name = "ALC880", .patch = patch_alc880 },
20107 { .id = 0x10ec0882, .name = "ALC882", .patch = patch_alc882 },
20108 { .id = 0x10ec0883, .name = "ALC883", .patch = patch_alc882 },
20109 { .id = 0x10ec0885, .rev = 0x100101, .name = "ALC889A",
20110 .patch = patch_alc882 },
20111 { .id = 0x10ec0885, .rev = 0x100103, .name = "ALC889A",
20112 .patch = patch_alc882 },
20113 { .id = 0x10ec0885, .name = "ALC885", .patch = patch_alc882 },
20114 { .id = 0x10ec0887, .name = "ALC887", .patch = patch_alc888 },
20115 { .id = 0x10ec0888, .rev = 0x100101, .name = "ALC1200",
20116 .patch = patch_alc882 },
20117 { .id = 0x10ec0888, .name = "ALC888", .patch = patch_alc888 },
20118 { .id = 0x10ec0889, .name = "ALC889", .patch = patch_alc882 },
20119 { .id = 0x10ec0892, .name = "ALC892", .patch = patch_alc662 },
20120 { .id = 0x10ec0899, .name = "ALC899", .patch = patch_alc899 },
20121 {} /* terminator */
20122 };
20123
20124 MODULE_ALIAS("snd-hda-codec-id:10ec*");
20125
20126 MODULE_LICENSE("GPL");
20127 MODULE_DESCRIPTION("Realtek HD-audio codec");
20128
20129 static struct hda_codec_preset_list realtek_list = {
20130 .preset = snd_hda_preset_realtek,
20131 .owner = THIS_MODULE,
20132 };
20133
20134 static int __init patch_realtek_init(void)
20135 {
20136 return snd_hda_add_codec_preset(&realtek_list);
20137 }
20138
20139 static void __exit patch_realtek_exit(void)
20140 {
20141 snd_hda_delete_codec_preset(&realtek_list);
20142 }
20143
20144 module_init(patch_realtek_init)
20145 module_exit(patch_realtek_exit)
A mirror of Linus' kernel repository