]> git.proxmox.com Git - mirror_ubuntu-bionic-kernel.git/blob - sound/pci/hda/patch_realtek.c
projects / mirror_ubuntu-bionic-kernel.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge git://git.kernel.org/pub/scm/linux/kernel/git/brodo/pcmcia-2.6
[mirror_ubuntu-bionic-kernel.git] / sound / pci / hda / patch_realtek.c
1 /*
2 * Universal Interface for Intel High Definition Audio Codec
3 *
4 * HD audio interface patch for 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 "hda_codec.h"
32 #include "hda_local.h"
33 #include "hda_patch.h"
34
35 #define ALC880_FRONT_EVENT 0x01
36 #define ALC880_DCVOL_EVENT 0x02
37 #define ALC880_HP_EVENT 0x04
38 #define ALC880_MIC_EVENT 0x08
39
40 /* ALC880 board config type */
41 enum {
42 ALC880_3ST,
43 ALC880_3ST_DIG,
44 ALC880_5ST,
45 ALC880_5ST_DIG,
46 ALC880_W810,
47 ALC880_Z71V,
48 ALC880_6ST,
49 ALC880_6ST_DIG,
50 ALC880_F1734,
51 ALC880_ASUS,
52 ALC880_ASUS_DIG,
53 ALC880_ASUS_W1V,
54 ALC880_ASUS_DIG2,
55 ALC880_FUJITSU,
56 ALC880_UNIWILL_DIG,
57 ALC880_UNIWILL,
58 ALC880_UNIWILL_P53,
59 ALC880_CLEVO,
60 ALC880_TCL_S700,
61 ALC880_LG,
62 ALC880_LG_LW,
63 ALC880_MEDION_RIM,
64 #ifdef CONFIG_SND_DEBUG
65 ALC880_TEST,
66 #endif
67 ALC880_AUTO,
68 ALC880_MODEL_LAST /* last tag */
69 };
70
71 /* ALC260 models */
72 enum {
73 ALC260_BASIC,
74 ALC260_HP,
75 ALC260_HP_DC7600,
76 ALC260_HP_3013,
77 ALC260_FUJITSU_S702X,
78 ALC260_ACER,
79 ALC260_WILL,
80 ALC260_REPLACER_672V,
81 #ifdef CONFIG_SND_DEBUG
82 ALC260_TEST,
83 #endif
84 ALC260_AUTO,
85 ALC260_MODEL_LAST /* last tag */
86 };
87
88 /* ALC262 models */
89 enum {
90 ALC262_BASIC,
91 ALC262_HIPPO,
92 ALC262_HIPPO_1,
93 ALC262_FUJITSU,
94 ALC262_HP_BPC,
95 ALC262_HP_BPC_D7000_WL,
96 ALC262_HP_BPC_D7000_WF,
97 ALC262_HP_TC_T5735,
98 ALC262_HP_RP5700,
99 ALC262_BENQ_ED8,
100 ALC262_SONY_ASSAMD,
101 ALC262_BENQ_T31,
102 ALC262_ULTRA,
103 ALC262_LENOVO_3000,
104 ALC262_NEC,
105 ALC262_TOSHIBA_S06,
106 ALC262_TOSHIBA_RX1,
107 ALC262_AUTO,
108 ALC262_MODEL_LAST /* last tag */
109 };
110
111 /* ALC268 models */
112 enum {
113 ALC267_QUANTA_IL1,
114 ALC268_3ST,
115 ALC268_TOSHIBA,
116 ALC268_ACER,
117 ALC268_ACER_ASPIRE_ONE,
118 ALC268_DELL,
119 ALC268_ZEPTO,
120 #ifdef CONFIG_SND_DEBUG
121 ALC268_TEST,
122 #endif
123 ALC268_AUTO,
124 ALC268_MODEL_LAST /* last tag */
125 };
126
127 /* ALC269 models */
128 enum {
129 ALC269_BASIC,
130 ALC269_QUANTA_FL1,
131 ALC269_ASUS_EEEPC_P703,
132 ALC269_ASUS_EEEPC_P901,
133 ALC269_AUTO,
134 ALC269_MODEL_LAST /* last tag */
135 };
136
137 /* ALC861 models */
138 enum {
139 ALC861_3ST,
140 ALC660_3ST,
141 ALC861_3ST_DIG,
142 ALC861_6ST_DIG,
143 ALC861_UNIWILL_M31,
144 ALC861_TOSHIBA,
145 ALC861_ASUS,
146 ALC861_ASUS_LAPTOP,
147 ALC861_AUTO,
148 ALC861_MODEL_LAST,
149 };
150
151 /* ALC861-VD models */
152 enum {
153 ALC660VD_3ST,
154 ALC660VD_3ST_DIG,
155 ALC861VD_3ST,
156 ALC861VD_3ST_DIG,
157 ALC861VD_6ST_DIG,
158 ALC861VD_LENOVO,
159 ALC861VD_DALLAS,
160 ALC861VD_HP,
161 ALC861VD_AUTO,
162 ALC861VD_MODEL_LAST,
163 };
164
165 /* ALC662 models */
166 enum {
167 ALC662_3ST_2ch_DIG,
168 ALC662_3ST_6ch_DIG,
169 ALC662_3ST_6ch,
170 ALC662_5ST_DIG,
171 ALC662_LENOVO_101E,
172 ALC662_ASUS_EEEPC_P701,
173 ALC662_ASUS_EEEPC_EP20,
174 ALC663_ASUS_M51VA,
175 ALC663_ASUS_G71V,
176 ALC663_ASUS_H13,
177 ALC663_ASUS_G50V,
178 ALC662_ECS,
179 ALC663_ASUS_MODE1,
180 ALC662_ASUS_MODE2,
181 ALC663_ASUS_MODE3,
182 ALC663_ASUS_MODE4,
183 ALC663_ASUS_MODE5,
184 ALC663_ASUS_MODE6,
185 ALC662_AUTO,
186 ALC662_MODEL_LAST,
187 };
188
189 /* ALC882 models */
190 enum {
191 ALC882_3ST_DIG,
192 ALC882_6ST_DIG,
193 ALC882_ARIMA,
194 ALC882_W2JC,
195 ALC882_TARGA,
196 ALC882_ASUS_A7J,
197 ALC882_ASUS_A7M,
198 ALC885_MACPRO,
199 ALC885_MBP3,
200 ALC885_IMAC24,
201 ALC882_AUTO,
202 ALC882_MODEL_LAST,
203 };
204
205 /* ALC883 models */
206 enum {
207 ALC883_3ST_2ch_DIG,
208 ALC883_3ST_6ch_DIG,
209 ALC883_3ST_6ch,
210 ALC883_6ST_DIG,
211 ALC883_TARGA_DIG,
212 ALC883_TARGA_2ch_DIG,
213 ALC883_ACER,
214 ALC883_ACER_ASPIRE,
215 ALC883_MEDION,
216 ALC883_MEDION_MD2,
217 ALC883_LAPTOP_EAPD,
218 ALC883_LENOVO_101E_2ch,
219 ALC883_LENOVO_NB0763,
220 ALC888_LENOVO_MS7195_DIG,
221 ALC888_LENOVO_SKY,
222 ALC883_HAIER_W66,
223 ALC888_3ST_HP,
224 ALC888_6ST_DELL,
225 ALC883_MITAC,
226 ALC883_CLEVO_M720,
227 ALC883_FUJITSU_PI2515,
228 ALC883_3ST_6ch_INTEL,
229 ALC888_ASUS_M90V,
230 ALC888_ASUS_EEE1601,
231 ALC883_AUTO,
232 ALC883_MODEL_LAST,
233 };
234
235 /* for GPIO Poll */
236 #define GPIO_MASK 0x03
237
238 struct alc_spec {
239 /* codec parameterization */
240 struct snd_kcontrol_new *mixers[5]; /* mixer arrays */
241 unsigned int num_mixers;
242
243 const struct hda_verb *init_verbs[5]; /* initialization verbs
244 * don't forget NULL
245 * termination!
246 */
247 unsigned int num_init_verbs;
248
249 char *stream_name_analog; /* analog PCM stream */
250 struct hda_pcm_stream *stream_analog_playback;
251 struct hda_pcm_stream *stream_analog_capture;
252 struct hda_pcm_stream *stream_analog_alt_playback;
253 struct hda_pcm_stream *stream_analog_alt_capture;
254
255 char *stream_name_digital; /* digital PCM stream */
256 struct hda_pcm_stream *stream_digital_playback;
257 struct hda_pcm_stream *stream_digital_capture;
258
259 /* playback */
260 struct hda_multi_out multiout; /* playback set-up
261 * max_channels, dacs must be set
262 * dig_out_nid and hp_nid are optional
263 */
264 hda_nid_t alt_dac_nid;
265
266 /* capture */
267 unsigned int num_adc_nids;
268 hda_nid_t *adc_nids;
269 hda_nid_t *capsrc_nids;
270 hda_nid_t dig_in_nid; /* digital-in NID; optional */
271
272 /* capture source */
273 unsigned int num_mux_defs;
274 const struct hda_input_mux *input_mux;
275 unsigned int cur_mux[3];
276
277 /* channel model */
278 const struct hda_channel_mode *channel_mode;
279 int num_channel_mode;
280 int need_dac_fix;
281
282 /* PCM information */
283 struct hda_pcm pcm_rec[3]; /* used in alc_build_pcms() */
284
285 /* dynamic controls, init_verbs and input_mux */
286 struct auto_pin_cfg autocfg;
287 unsigned int num_kctl_alloc, num_kctl_used;
288 struct snd_kcontrol_new *kctl_alloc;
289 struct hda_input_mux private_imux;
290 hda_nid_t private_dac_nids[AUTO_CFG_MAX_OUTS];
291
292 /* hooks */
293 void (*init_hook)(struct hda_codec *codec);
294 void (*unsol_event)(struct hda_codec *codec, unsigned int res);
295
296 /* for pin sensing */
297 unsigned int sense_updated: 1;
298 unsigned int jack_present: 1;
299 unsigned int master_sw: 1;
300
301 /* for virtual master */
302 hda_nid_t vmaster_nid;
303 #ifdef CONFIG_SND_HDA_POWER_SAVE
304 struct hda_loopback_check loopback;
305 #endif
306
307 /* for PLL fix */
308 hda_nid_t pll_nid;
309 unsigned int pll_coef_idx, pll_coef_bit;
310
311 #ifdef SND_HDA_NEEDS_RESUME
312 #define ALC_MAX_PINS 16
313 unsigned int num_pins;
314 hda_nid_t pin_nids[ALC_MAX_PINS];
315 unsigned int pin_cfgs[ALC_MAX_PINS];
316 #endif
317 };
318
319 /*
320 * configuration template - to be copied to the spec instance
321 */
322 struct alc_config_preset {
323 struct snd_kcontrol_new *mixers[5]; /* should be identical size
324 * with spec
325 */
326 const struct hda_verb *init_verbs[5];
327 unsigned int num_dacs;
328 hda_nid_t *dac_nids;
329 hda_nid_t dig_out_nid; /* optional */
330 hda_nid_t hp_nid; /* optional */
331 unsigned int num_adc_nids;
332 hda_nid_t *adc_nids;
333 hda_nid_t *capsrc_nids;
334 hda_nid_t dig_in_nid;
335 unsigned int num_channel_mode;
336 const struct hda_channel_mode *channel_mode;
337 int need_dac_fix;
338 unsigned int num_mux_defs;
339 const struct hda_input_mux *input_mux;
340 void (*unsol_event)(struct hda_codec *, unsigned int);
341 void (*init_hook)(struct hda_codec *);
342 #ifdef CONFIG_SND_HDA_POWER_SAVE
343 struct hda_amp_list *loopbacks;
344 #endif
345 };
346
347
348 /*
349 * input MUX handling
350 */
351 static int alc_mux_enum_info(struct snd_kcontrol *kcontrol,
352 struct snd_ctl_elem_info *uinfo)
353 {
354 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
355 struct alc_spec *spec = codec->spec;
356 unsigned int mux_idx = snd_ctl_get_ioffidx(kcontrol, &uinfo->id);
357 if (mux_idx >= spec->num_mux_defs)
358 mux_idx = 0;
359 return snd_hda_input_mux_info(&spec->input_mux[mux_idx], uinfo);
360 }
361
362 static int alc_mux_enum_get(struct snd_kcontrol *kcontrol,
363 struct snd_ctl_elem_value *ucontrol)
364 {
365 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
366 struct alc_spec *spec = codec->spec;
367 unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
368
369 ucontrol->value.enumerated.item[0] = spec->cur_mux[adc_idx];
370 return 0;
371 }
372
373 static int alc_mux_enum_put(struct snd_kcontrol *kcontrol,
374 struct snd_ctl_elem_value *ucontrol)
375 {
376 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
377 struct alc_spec *spec = codec->spec;
378 unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
379 unsigned int mux_idx = adc_idx >= spec->num_mux_defs ? 0 : adc_idx;
380 hda_nid_t nid = spec->capsrc_nids ?
381 spec->capsrc_nids[adc_idx] : spec->adc_nids[adc_idx];
382 return snd_hda_input_mux_put(codec, &spec->input_mux[mux_idx], ucontrol,
383 nid, &spec->cur_mux[adc_idx]);
384 }
385
386
387 /*
388 * channel mode setting
389 */
390 static int alc_ch_mode_info(struct snd_kcontrol *kcontrol,
391 struct snd_ctl_elem_info *uinfo)
392 {
393 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
394 struct alc_spec *spec = codec->spec;
395 return snd_hda_ch_mode_info(codec, uinfo, spec->channel_mode,
396 spec->num_channel_mode);
397 }
398
399 static int alc_ch_mode_get(struct snd_kcontrol *kcontrol,
400 struct snd_ctl_elem_value *ucontrol)
401 {
402 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
403 struct alc_spec *spec = codec->spec;
404 return snd_hda_ch_mode_get(codec, ucontrol, spec->channel_mode,
405 spec->num_channel_mode,
406 spec->multiout.max_channels);
407 }
408
409 static int alc_ch_mode_put(struct snd_kcontrol *kcontrol,
410 struct snd_ctl_elem_value *ucontrol)
411 {
412 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
413 struct alc_spec *spec = codec->spec;
414 int err = snd_hda_ch_mode_put(codec, ucontrol, spec->channel_mode,
415 spec->num_channel_mode,
416 &spec->multiout.max_channels);
417 if (err >= 0 && spec->need_dac_fix)
418 spec->multiout.num_dacs = spec->multiout.max_channels / 2;
419 return err;
420 }
421
422 /*
423 * Control the mode of pin widget settings via the mixer. "pc" is used
424 * instead of "%" to avoid consequences of accidently treating the % as
425 * being part of a format specifier. Maximum allowed length of a value is
426 * 63 characters plus NULL terminator.
427 *
428 * Note: some retasking pin complexes seem to ignore requests for input
429 * states other than HiZ (eg: PIN_VREFxx) and revert to HiZ if any of these
430 * are requested. Therefore order this list so that this behaviour will not
431 * cause problems when mixer clients move through the enum sequentially.
432 * NIDs 0x0f and 0x10 have been observed to have this behaviour as of
433 * March 2006.
434 */
435 static char *alc_pin_mode_names[] = {
436 "Mic 50pc bias", "Mic 80pc bias",
437 "Line in", "Line out", "Headphone out",
438 };
439 static unsigned char alc_pin_mode_values[] = {
440 PIN_VREF50, PIN_VREF80, PIN_IN, PIN_OUT, PIN_HP,
441 };
442 /* The control can present all 5 options, or it can limit the options based
443 * in the pin being assumed to be exclusively an input or an output pin. In
444 * addition, "input" pins may or may not process the mic bias option
445 * depending on actual widget capability (NIDs 0x0f and 0x10 don't seem to
446 * accept requests for bias as of chip versions up to March 2006) and/or
447 * wiring in the computer.
448 */
449 #define ALC_PIN_DIR_IN 0x00
450 #define ALC_PIN_DIR_OUT 0x01
451 #define ALC_PIN_DIR_INOUT 0x02
452 #define ALC_PIN_DIR_IN_NOMICBIAS 0x03
453 #define ALC_PIN_DIR_INOUT_NOMICBIAS 0x04
454
455 /* Info about the pin modes supported by the different pin direction modes.
456 * For each direction the minimum and maximum values are given.
457 */
458 static signed char alc_pin_mode_dir_info[5][2] = {
459 { 0, 2 }, /* ALC_PIN_DIR_IN */
460 { 3, 4 }, /* ALC_PIN_DIR_OUT */
461 { 0, 4 }, /* ALC_PIN_DIR_INOUT */
462 { 2, 2 }, /* ALC_PIN_DIR_IN_NOMICBIAS */
463 { 2, 4 }, /* ALC_PIN_DIR_INOUT_NOMICBIAS */
464 };
465 #define alc_pin_mode_min(_dir) (alc_pin_mode_dir_info[_dir][0])
466 #define alc_pin_mode_max(_dir) (alc_pin_mode_dir_info[_dir][1])
467 #define alc_pin_mode_n_items(_dir) \
468 (alc_pin_mode_max(_dir)-alc_pin_mode_min(_dir)+1)
469
470 static int alc_pin_mode_info(struct snd_kcontrol *kcontrol,
471 struct snd_ctl_elem_info *uinfo)
472 {
473 unsigned int item_num = uinfo->value.enumerated.item;
474 unsigned char dir = (kcontrol->private_value >> 16) & 0xff;
475
476 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
477 uinfo->count = 1;
478 uinfo->value.enumerated.items = alc_pin_mode_n_items(dir);
479
480 if (item_num<alc_pin_mode_min(dir) || item_num>alc_pin_mode_max(dir))
481 item_num = alc_pin_mode_min(dir);
482 strcpy(uinfo->value.enumerated.name, alc_pin_mode_names[item_num]);
483 return 0;
484 }
485
486 static int alc_pin_mode_get(struct snd_kcontrol *kcontrol,
487 struct snd_ctl_elem_value *ucontrol)
488 {
489 unsigned int i;
490 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
491 hda_nid_t nid = kcontrol->private_value & 0xffff;
492 unsigned char dir = (kcontrol->private_value >> 16) & 0xff;
493 long *valp = ucontrol->value.integer.value;
494 unsigned int pinctl = snd_hda_codec_read(codec, nid, 0,
495 AC_VERB_GET_PIN_WIDGET_CONTROL,
496 0x00);
497
498 /* Find enumerated value for current pinctl setting */
499 i = alc_pin_mode_min(dir);
500 while (alc_pin_mode_values[i] != pinctl && i <= alc_pin_mode_max(dir))
501 i++;
502 *valp = i <= alc_pin_mode_max(dir) ? i: alc_pin_mode_min(dir);
503 return 0;
504 }
505
506 static int alc_pin_mode_put(struct snd_kcontrol *kcontrol,
507 struct snd_ctl_elem_value *ucontrol)
508 {
509 signed int change;
510 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
511 hda_nid_t nid = kcontrol->private_value & 0xffff;
512 unsigned char dir = (kcontrol->private_value >> 16) & 0xff;
513 long val = *ucontrol->value.integer.value;
514 unsigned int pinctl = snd_hda_codec_read(codec, nid, 0,
515 AC_VERB_GET_PIN_WIDGET_CONTROL,
516 0x00);
517
518 if (val < alc_pin_mode_min(dir) || val > alc_pin_mode_max(dir))
519 val = alc_pin_mode_min(dir);
520
521 change = pinctl != alc_pin_mode_values[val];
522 if (change) {
523 /* Set pin mode to that requested */
524 snd_hda_codec_write_cache(codec, nid, 0,
525 AC_VERB_SET_PIN_WIDGET_CONTROL,
526 alc_pin_mode_values[val]);
527
528 /* Also enable the retasking pin's input/output as required
529 * for the requested pin mode. Enum values of 2 or less are
530 * input modes.
531 *
532 * Dynamically switching the input/output buffers probably
533 * reduces noise slightly (particularly on input) so we'll
534 * do it. However, having both input and output buffers
535 * enabled simultaneously doesn't seem to be problematic if
536 * this turns out to be necessary in the future.
537 */
538 if (val <= 2) {
539 snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
540 HDA_AMP_MUTE, HDA_AMP_MUTE);
541 snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT, 0,
542 HDA_AMP_MUTE, 0);
543 } else {
544 snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT, 0,
545 HDA_AMP_MUTE, HDA_AMP_MUTE);
546 snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
547 HDA_AMP_MUTE, 0);
548 }
549 }
550 return change;
551 }
552
553 #define ALC_PIN_MODE(xname, nid, dir) \
554 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0, \
555 .info = alc_pin_mode_info, \
556 .get = alc_pin_mode_get, \
557 .put = alc_pin_mode_put, \
558 .private_value = nid | (dir<<16) }
559
560 /* A switch control for ALC260 GPIO pins. Multiple GPIOs can be ganged
561 * together using a mask with more than one bit set. This control is
562 * currently used only by the ALC260 test model. At this stage they are not
563 * needed for any "production" models.
564 */
565 #ifdef CONFIG_SND_DEBUG
566 #define alc_gpio_data_info snd_ctl_boolean_mono_info
567
568 static int alc_gpio_data_get(struct snd_kcontrol *kcontrol,
569 struct snd_ctl_elem_value *ucontrol)
570 {
571 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
572 hda_nid_t nid = kcontrol->private_value & 0xffff;
573 unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
574 long *valp = ucontrol->value.integer.value;
575 unsigned int val = snd_hda_codec_read(codec, nid, 0,
576 AC_VERB_GET_GPIO_DATA, 0x00);
577
578 *valp = (val & mask) != 0;
579 return 0;
580 }
581 static int alc_gpio_data_put(struct snd_kcontrol *kcontrol,
582 struct snd_ctl_elem_value *ucontrol)
583 {
584 signed int change;
585 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
586 hda_nid_t nid = kcontrol->private_value & 0xffff;
587 unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
588 long val = *ucontrol->value.integer.value;
589 unsigned int gpio_data = snd_hda_codec_read(codec, nid, 0,
590 AC_VERB_GET_GPIO_DATA,
591 0x00);
592
593 /* Set/unset the masked GPIO bit(s) as needed */
594 change = (val == 0 ? 0 : mask) != (gpio_data & mask);
595 if (val == 0)
596 gpio_data &= ~mask;
597 else
598 gpio_data |= mask;
599 snd_hda_codec_write_cache(codec, nid, 0,
600 AC_VERB_SET_GPIO_DATA, gpio_data);
601
602 return change;
603 }
604 #define ALC_GPIO_DATA_SWITCH(xname, nid, mask) \
605 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0, \
606 .info = alc_gpio_data_info, \
607 .get = alc_gpio_data_get, \
608 .put = alc_gpio_data_put, \
609 .private_value = nid | (mask<<16) }
610 #endif /* CONFIG_SND_DEBUG */
611
612 /* A switch control to allow the enabling of the digital IO pins on the
613 * ALC260. This is incredibly simplistic; the intention of this control is
614 * to provide something in the test model allowing digital outputs to be
615 * identified if present. If models are found which can utilise these
616 * outputs a more complete mixer control can be devised for those models if
617 * necessary.
618 */
619 #ifdef CONFIG_SND_DEBUG
620 #define alc_spdif_ctrl_info snd_ctl_boolean_mono_info
621
622 static int alc_spdif_ctrl_get(struct snd_kcontrol *kcontrol,
623 struct snd_ctl_elem_value *ucontrol)
624 {
625 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
626 hda_nid_t nid = kcontrol->private_value & 0xffff;
627 unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
628 long *valp = ucontrol->value.integer.value;
629 unsigned int val = snd_hda_codec_read(codec, nid, 0,
630 AC_VERB_GET_DIGI_CONVERT_1, 0x00);
631
632 *valp = (val & mask) != 0;
633 return 0;
634 }
635 static int alc_spdif_ctrl_put(struct snd_kcontrol *kcontrol,
636 struct snd_ctl_elem_value *ucontrol)
637 {
638 signed int change;
639 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
640 hda_nid_t nid = kcontrol->private_value & 0xffff;
641 unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
642 long val = *ucontrol->value.integer.value;
643 unsigned int ctrl_data = snd_hda_codec_read(codec, nid, 0,
644 AC_VERB_GET_DIGI_CONVERT_1,
645 0x00);
646
647 /* Set/unset the masked control bit(s) as needed */
648 change = (val == 0 ? 0 : mask) != (ctrl_data & mask);
649 if (val==0)
650 ctrl_data &= ~mask;
651 else
652 ctrl_data |= mask;
653 snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_DIGI_CONVERT_1,
654 ctrl_data);
655
656 return change;
657 }
658 #define ALC_SPDIF_CTRL_SWITCH(xname, nid, mask) \
659 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0, \
660 .info = alc_spdif_ctrl_info, \
661 .get = alc_spdif_ctrl_get, \
662 .put = alc_spdif_ctrl_put, \
663 .private_value = nid | (mask<<16) }
664 #endif /* CONFIG_SND_DEBUG */
665
666 /* A switch control to allow the enabling EAPD digital outputs on the ALC26x.
667 * Again, this is only used in the ALC26x test models to help identify when
668 * the EAPD line must be asserted for features to work.
669 */
670 #ifdef CONFIG_SND_DEBUG
671 #define alc_eapd_ctrl_info snd_ctl_boolean_mono_info
672
673 static int alc_eapd_ctrl_get(struct snd_kcontrol *kcontrol,
674 struct snd_ctl_elem_value *ucontrol)
675 {
676 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
677 hda_nid_t nid = kcontrol->private_value & 0xffff;
678 unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
679 long *valp = ucontrol->value.integer.value;
680 unsigned int val = snd_hda_codec_read(codec, nid, 0,
681 AC_VERB_GET_EAPD_BTLENABLE, 0x00);
682
683 *valp = (val & mask) != 0;
684 return 0;
685 }
686
687 static int alc_eapd_ctrl_put(struct snd_kcontrol *kcontrol,
688 struct snd_ctl_elem_value *ucontrol)
689 {
690 int change;
691 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
692 hda_nid_t nid = kcontrol->private_value & 0xffff;
693 unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
694 long val = *ucontrol->value.integer.value;
695 unsigned int ctrl_data = snd_hda_codec_read(codec, nid, 0,
696 AC_VERB_GET_EAPD_BTLENABLE,
697 0x00);
698
699 /* Set/unset the masked control bit(s) as needed */
700 change = (!val ? 0 : mask) != (ctrl_data & mask);
701 if (!val)
702 ctrl_data &= ~mask;
703 else
704 ctrl_data |= mask;
705 snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_EAPD_BTLENABLE,
706 ctrl_data);
707
708 return change;
709 }
710
711 #define ALC_EAPD_CTRL_SWITCH(xname, nid, mask) \
712 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0, \
713 .info = alc_eapd_ctrl_info, \
714 .get = alc_eapd_ctrl_get, \
715 .put = alc_eapd_ctrl_put, \
716 .private_value = nid | (mask<<16) }
717 #endif /* CONFIG_SND_DEBUG */
718
719 /*
720 * set up from the preset table
721 */
722 static void setup_preset(struct alc_spec *spec,
723 const struct alc_config_preset *preset)
724 {
725 int i;
726
727 for (i = 0; i < ARRAY_SIZE(preset->mixers) && preset->mixers[i]; i++)
728 spec->mixers[spec->num_mixers++] = preset->mixers[i];
729 for (i = 0; i < ARRAY_SIZE(preset->init_verbs) && preset->init_verbs[i];
730 i++)
731 spec->init_verbs[spec->num_init_verbs++] =
732 preset->init_verbs[i];
733
734 spec->channel_mode = preset->channel_mode;
735 spec->num_channel_mode = preset->num_channel_mode;
736 spec->need_dac_fix = preset->need_dac_fix;
737
738 spec->multiout.max_channels = spec->channel_mode[0].channels;
739
740 spec->multiout.num_dacs = preset->num_dacs;
741 spec->multiout.dac_nids = preset->dac_nids;
742 spec->multiout.dig_out_nid = preset->dig_out_nid;
743 spec->multiout.hp_nid = preset->hp_nid;
744
745 spec->num_mux_defs = preset->num_mux_defs;
746 if (!spec->num_mux_defs)
747 spec->num_mux_defs = 1;
748 spec->input_mux = preset->input_mux;
749
750 spec->num_adc_nids = preset->num_adc_nids;
751 spec->adc_nids = preset->adc_nids;
752 spec->capsrc_nids = preset->capsrc_nids;
753 spec->dig_in_nid = preset->dig_in_nid;
754
755 spec->unsol_event = preset->unsol_event;
756 spec->init_hook = preset->init_hook;
757 #ifdef CONFIG_SND_HDA_POWER_SAVE
758 spec->loopback.amplist = preset->loopbacks;
759 #endif
760 }
761
762 /* Enable GPIO mask and set output */
763 static struct hda_verb alc_gpio1_init_verbs[] = {
764 {0x01, AC_VERB_SET_GPIO_MASK, 0x01},
765 {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
766 {0x01, AC_VERB_SET_GPIO_DATA, 0x01},
767 { }
768 };
769
770 static struct hda_verb alc_gpio2_init_verbs[] = {
771 {0x01, AC_VERB_SET_GPIO_MASK, 0x02},
772 {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x02},
773 {0x01, AC_VERB_SET_GPIO_DATA, 0x02},
774 { }
775 };
776
777 static struct hda_verb alc_gpio3_init_verbs[] = {
778 {0x01, AC_VERB_SET_GPIO_MASK, 0x03},
779 {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x03},
780 {0x01, AC_VERB_SET_GPIO_DATA, 0x03},
781 { }
782 };
783
784 /*
785 * Fix hardware PLL issue
786 * On some codecs, the analog PLL gating control must be off while
787 * the default value is 1.
788 */
789 static void alc_fix_pll(struct hda_codec *codec)
790 {
791 struct alc_spec *spec = codec->spec;
792 unsigned int val;
793
794 if (!spec->pll_nid)
795 return;
796 snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_COEF_INDEX,
797 spec->pll_coef_idx);
798 val = snd_hda_codec_read(codec, spec->pll_nid, 0,
799 AC_VERB_GET_PROC_COEF, 0);
800 snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_COEF_INDEX,
801 spec->pll_coef_idx);
802 snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_PROC_COEF,
803 val & ~(1 << spec->pll_coef_bit));
804 }
805
806 static void alc_fix_pll_init(struct hda_codec *codec, hda_nid_t nid,
807 unsigned int coef_idx, unsigned int coef_bit)
808 {
809 struct alc_spec *spec = codec->spec;
810 spec->pll_nid = nid;
811 spec->pll_coef_idx = coef_idx;
812 spec->pll_coef_bit = coef_bit;
813 alc_fix_pll(codec);
814 }
815
816 static void alc_sku_automute(struct hda_codec *codec)
817 {
818 struct alc_spec *spec = codec->spec;
819 unsigned int present;
820 unsigned int hp_nid = spec->autocfg.hp_pins[0];
821 unsigned int sp_nid = spec->autocfg.speaker_pins[0];
822
823 /* need to execute and sync at first */
824 snd_hda_codec_read(codec, hp_nid, 0, AC_VERB_SET_PIN_SENSE, 0);
825 present = snd_hda_codec_read(codec, hp_nid, 0,
826 AC_VERB_GET_PIN_SENSE, 0);
827 spec->jack_present = (present & 0x80000000) != 0;
828 snd_hda_codec_write(codec, sp_nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
829 spec->jack_present ? 0 : PIN_OUT);
830 }
831
832 static void alc_mic_automute(struct hda_codec *codec)
833 {
834 struct alc_spec *spec = codec->spec;
835 unsigned int present;
836 unsigned int mic_nid = spec->autocfg.input_pins[AUTO_PIN_MIC];
837 unsigned int fmic_nid = spec->autocfg.input_pins[AUTO_PIN_FRONT_MIC];
838 unsigned int mix_nid = spec->capsrc_nids[0];
839 unsigned int capsrc_idx_mic, capsrc_idx_fmic;
840
841 capsrc_idx_mic = mic_nid - 0x18;
842 capsrc_idx_fmic = fmic_nid - 0x18;
843 present = snd_hda_codec_read(codec, mic_nid, 0,
844 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
845 snd_hda_codec_write(codec, mix_nid, 0, AC_VERB_SET_AMP_GAIN_MUTE,
846 0x7000 | (capsrc_idx_mic << 8) | (present ? 0 : 0x80));
847 snd_hda_codec_write(codec, mix_nid, 0, AC_VERB_SET_AMP_GAIN_MUTE,
848 0x7000 | (capsrc_idx_fmic << 8) | (present ? 0x80 : 0));
849 snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, capsrc_idx_fmic,
850 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
851 }
852
853 /* unsolicited event for HP jack sensing */
854 static void alc_sku_unsol_event(struct hda_codec *codec, unsigned int res)
855 {
856 if (codec->vendor_id == 0x10ec0880)
857 res >>= 28;
858 else
859 res >>= 26;
860 if (res == ALC880_HP_EVENT)
861 alc_sku_automute(codec);
862
863 if (res == ALC880_MIC_EVENT)
864 alc_mic_automute(codec);
865 }
866
867 static void alc_inithook(struct hda_codec *codec)
868 {
869 alc_sku_automute(codec);
870 alc_mic_automute(codec);
871 }
872
873 /* additional initialization for ALC888 variants */
874 static void alc888_coef_init(struct hda_codec *codec)
875 {
876 unsigned int tmp;
877
878 snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 0);
879 tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0);
880 snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 7);
881 if ((tmp & 0xf0) == 2)
882 /* alc888S-VC */
883 snd_hda_codec_read(codec, 0x20, 0,
884 AC_VERB_SET_PROC_COEF, 0x830);
885 else
886 /* alc888-VB */
887 snd_hda_codec_read(codec, 0x20, 0,
888 AC_VERB_SET_PROC_COEF, 0x3030);
889 }
890
891 /* 32-bit subsystem ID for BIOS loading in HD Audio codec.
892 * 31 ~ 16 : Manufacture ID
893 * 15 ~ 8 : SKU ID
894 * 7 ~ 0 : Assembly ID
895 * port-A --> pin 39/41, port-E --> pin 14/15, port-D --> pin 35/36
896 */
897 static void alc_subsystem_id(struct hda_codec *codec,
898 unsigned int porta, unsigned int porte,
899 unsigned int portd)
900 {
901 unsigned int ass, tmp, i;
902 unsigned nid;
903 struct alc_spec *spec = codec->spec;
904
905 ass = codec->subsystem_id & 0xffff;
906 if ((ass != codec->bus->pci->subsystem_device) && (ass & 1))
907 goto do_sku;
908
909 /*
910 * 31~30 : port conetcivity
911 * 29~21 : reserve
912 * 20 : PCBEEP input
913 * 19~16 : Check sum (15:1)
914 * 15~1 : Custom
915 * 0 : override
916 */
917 nid = 0x1d;
918 if (codec->vendor_id == 0x10ec0260)
919 nid = 0x17;
920 ass = snd_hda_codec_read(codec, nid, 0,
921 AC_VERB_GET_CONFIG_DEFAULT, 0);
922 if (!(ass & 1) && !(ass & 0x100000))
923 return;
924 if ((ass >> 30) != 1) /* no physical connection */
925 return;
926
927 /* check sum */
928 tmp = 0;
929 for (i = 1; i < 16; i++) {
930 if ((ass >> i) & 1)
931 tmp++;
932 }
933 if (((ass >> 16) & 0xf) != tmp)
934 return;
935 do_sku:
936 /*
937 * 0 : override
938 * 1 : Swap Jack
939 * 2 : 0 --> Desktop, 1 --> Laptop
940 * 3~5 : External Amplifier control
941 * 7~6 : Reserved
942 */
943 tmp = (ass & 0x38) >> 3; /* external Amp control */
944 switch (tmp) {
945 case 1:
946 snd_hda_sequence_write(codec, alc_gpio1_init_verbs);
947 break;
948 case 3:
949 snd_hda_sequence_write(codec, alc_gpio2_init_verbs);
950 break;
951 case 7:
952 snd_hda_sequence_write(codec, alc_gpio3_init_verbs);
953 break;
954 case 5: /* set EAPD output high */
955 switch (codec->vendor_id) {
956 case 0x10ec0260:
957 snd_hda_codec_write(codec, 0x0f, 0,
958 AC_VERB_SET_EAPD_BTLENABLE, 2);
959 snd_hda_codec_write(codec, 0x10, 0,
960 AC_VERB_SET_EAPD_BTLENABLE, 2);
961 break;
962 case 0x10ec0262:
963 case 0x10ec0267:
964 case 0x10ec0268:
965 case 0x10ec0269:
966 case 0x10ec0660:
967 case 0x10ec0662:
968 case 0x10ec0663:
969 case 0x10ec0862:
970 case 0x10ec0889:
971 snd_hda_codec_write(codec, 0x14, 0,
972 AC_VERB_SET_EAPD_BTLENABLE, 2);
973 snd_hda_codec_write(codec, 0x15, 0,
974 AC_VERB_SET_EAPD_BTLENABLE, 2);
975 break;
976 }
977 switch (codec->vendor_id) {
978 case 0x10ec0260:
979 snd_hda_codec_write(codec, 0x1a, 0,
980 AC_VERB_SET_COEF_INDEX, 7);
981 tmp = snd_hda_codec_read(codec, 0x1a, 0,
982 AC_VERB_GET_PROC_COEF, 0);
983 snd_hda_codec_write(codec, 0x1a, 0,
984 AC_VERB_SET_COEF_INDEX, 7);
985 snd_hda_codec_write(codec, 0x1a, 0,
986 AC_VERB_SET_PROC_COEF,
987 tmp | 0x2010);
988 break;
989 case 0x10ec0262:
990 case 0x10ec0880:
991 case 0x10ec0882:
992 case 0x10ec0883:
993 case 0x10ec0885:
994 case 0x10ec0889:
995 snd_hda_codec_write(codec, 0x20, 0,
996 AC_VERB_SET_COEF_INDEX, 7);
997 tmp = snd_hda_codec_read(codec, 0x20, 0,
998 AC_VERB_GET_PROC_COEF, 0);
999 snd_hda_codec_write(codec, 0x20, 0,
1000 AC_VERB_SET_COEF_INDEX, 7);
1001 snd_hda_codec_write(codec, 0x20, 0,
1002 AC_VERB_SET_PROC_COEF,
1003 tmp | 0x2010);
1004 break;
1005 case 0x10ec0888:
1006 /*alc888_coef_init(codec);*/ /* called in alc_init() */
1007 break;
1008 case 0x10ec0267:
1009 case 0x10ec0268:
1010 snd_hda_codec_write(codec, 0x20, 0,
1011 AC_VERB_SET_COEF_INDEX, 7);
1012 tmp = snd_hda_codec_read(codec, 0x20, 0,
1013 AC_VERB_GET_PROC_COEF, 0);
1014 snd_hda_codec_write(codec, 0x20, 0,
1015 AC_VERB_SET_COEF_INDEX, 7);
1016 snd_hda_codec_write(codec, 0x20, 0,
1017 AC_VERB_SET_PROC_COEF,
1018 tmp | 0x3000);
1019 break;
1020 }
1021 default:
1022 break;
1023 }
1024
1025 /* is laptop or Desktop and enable the function "Mute internal speaker
1026 * when the external headphone out jack is plugged"
1027 */
1028 if (!(ass & 0x8000))
1029 return;
1030 /*
1031 * 10~8 : Jack location
1032 * 12~11: Headphone out -> 00: PortA, 01: PortE, 02: PortD, 03: Resvered
1033 * 14~13: Resvered
1034 * 15 : 1 --> enable the function "Mute internal speaker
1035 * when the external headphone out jack is plugged"
1036 */
1037 if (!spec->autocfg.speaker_pins[0]) {
1038 if (spec->autocfg.line_out_pins[0])
1039 spec->autocfg.speaker_pins[0] =
1040 spec->autocfg.line_out_pins[0];
1041 else
1042 return;
1043 }
1044
1045 if (!spec->autocfg.hp_pins[0]) {
1046 tmp = (ass >> 11) & 0x3; /* HP to chassis */
1047 if (tmp == 0)
1048 spec->autocfg.hp_pins[0] = porta;
1049 else if (tmp == 1)
1050 spec->autocfg.hp_pins[0] = porte;
1051 else if (tmp == 2)
1052 spec->autocfg.hp_pins[0] = portd;
1053 else
1054 return;
1055 }
1056 if (spec->autocfg.hp_pins[0])
1057 snd_hda_codec_write(codec, spec->autocfg.hp_pins[0], 0,
1058 AC_VERB_SET_UNSOLICITED_ENABLE,
1059 AC_USRSP_EN | ALC880_HP_EVENT);
1060
1061 if (spec->autocfg.input_pins[AUTO_PIN_MIC] &&
1062 spec->autocfg.input_pins[AUTO_PIN_FRONT_MIC])
1063 snd_hda_codec_write(codec,
1064 spec->autocfg.input_pins[AUTO_PIN_MIC], 0,
1065 AC_VERB_SET_UNSOLICITED_ENABLE,
1066 AC_USRSP_EN | ALC880_MIC_EVENT);
1067
1068 spec->unsol_event = alc_sku_unsol_event;
1069 }
1070
1071 /*
1072 * Fix-up pin default configurations
1073 */
1074
1075 struct alc_pincfg {
1076 hda_nid_t nid;
1077 u32 val;
1078 };
1079
1080 static void alc_fix_pincfg(struct hda_codec *codec,
1081 const struct snd_pci_quirk *quirk,
1082 const struct alc_pincfg **pinfix)
1083 {
1084 const struct alc_pincfg *cfg;
1085
1086 quirk = snd_pci_quirk_lookup(codec->bus->pci, quirk);
1087 if (!quirk)
1088 return;
1089
1090 cfg = pinfix[quirk->value];
1091 for (; cfg->nid; cfg++) {
1092 int i;
1093 u32 val = cfg->val;
1094 for (i = 0; i < 4; i++) {
1095 snd_hda_codec_write(codec, cfg->nid, 0,
1096 AC_VERB_SET_CONFIG_DEFAULT_BYTES_0 + i,
1097 val & 0xff);
1098 val >>= 8;
1099 }
1100 }
1101 }
1102
1103 /*
1104 * ALC880 3-stack model
1105 *
1106 * DAC: Front = 0x02 (0x0c), Surr = 0x05 (0x0f), CLFE = 0x04 (0x0e)
1107 * Pin assignment: Front = 0x14, Line-In/Surr = 0x1a, Mic/CLFE = 0x18,
1108 * F-Mic = 0x1b, HP = 0x19
1109 */
1110
1111 static hda_nid_t alc880_dac_nids[4] = {
1112 /* front, rear, clfe, rear_surr */
1113 0x02, 0x05, 0x04, 0x03
1114 };
1115
1116 static hda_nid_t alc880_adc_nids[3] = {
1117 /* ADC0-2 */
1118 0x07, 0x08, 0x09,
1119 };
1120
1121 /* The datasheet says the node 0x07 is connected from inputs,
1122 * but it shows zero connection in the real implementation on some devices.
1123 * Note: this is a 915GAV bug, fixed on 915GLV
1124 */
1125 static hda_nid_t alc880_adc_nids_alt[2] = {
1126 /* ADC1-2 */
1127 0x08, 0x09,
1128 };
1129
1130 #define ALC880_DIGOUT_NID 0x06
1131 #define ALC880_DIGIN_NID 0x0a
1132
1133 static struct hda_input_mux alc880_capture_source = {
1134 .num_items = 4,
1135 .items = {
1136 { "Mic", 0x0 },
1137 { "Front Mic", 0x3 },
1138 { "Line", 0x2 },
1139 { "CD", 0x4 },
1140 },
1141 };
1142
1143 /* channel source setting (2/6 channel selection for 3-stack) */
1144 /* 2ch mode */
1145 static struct hda_verb alc880_threestack_ch2_init[] = {
1146 /* set line-in to input, mute it */
1147 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
1148 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
1149 /* set mic-in to input vref 80%, mute it */
1150 { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
1151 { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
1152 { } /* end */
1153 };
1154
1155 /* 6ch mode */
1156 static struct hda_verb alc880_threestack_ch6_init[] = {
1157 /* set line-in to output, unmute it */
1158 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1159 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1160 /* set mic-in to output, unmute it */
1161 { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1162 { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1163 { } /* end */
1164 };
1165
1166 static struct hda_channel_mode alc880_threestack_modes[2] = {
1167 { 2, alc880_threestack_ch2_init },
1168 { 6, alc880_threestack_ch6_init },
1169 };
1170
1171 static struct snd_kcontrol_new alc880_three_stack_mixer[] = {
1172 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1173 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
1174 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
1175 HDA_BIND_MUTE("Surround Playback Switch", 0x0f, 2, HDA_INPUT),
1176 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
1177 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
1178 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
1179 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
1180 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
1181 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
1182 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
1183 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
1184 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
1185 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
1186 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x3, HDA_INPUT),
1187 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x3, HDA_INPUT),
1188 HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
1189 HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
1190 HDA_CODEC_MUTE("Headphone Playback Switch", 0x19, 0x0, HDA_OUTPUT),
1191 {
1192 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1193 .name = "Channel Mode",
1194 .info = alc_ch_mode_info,
1195 .get = alc_ch_mode_get,
1196 .put = alc_ch_mode_put,
1197 },
1198 { } /* end */
1199 };
1200
1201 /* capture mixer elements */
1202 static struct snd_kcontrol_new alc880_capture_mixer[] = {
1203 HDA_CODEC_VOLUME("Capture Volume", 0x07, 0x0, HDA_INPUT),
1204 HDA_CODEC_MUTE("Capture Switch", 0x07, 0x0, HDA_INPUT),
1205 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x08, 0x0, HDA_INPUT),
1206 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x08, 0x0, HDA_INPUT),
1207 HDA_CODEC_VOLUME_IDX("Capture Volume", 2, 0x09, 0x0, HDA_INPUT),
1208 HDA_CODEC_MUTE_IDX("Capture Switch", 2, 0x09, 0x0, HDA_INPUT),
1209 {
1210 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1211 /* The multiple "Capture Source" controls confuse alsamixer
1212 * So call somewhat different..
1213 */
1214 /* .name = "Capture Source", */
1215 .name = "Input Source",
1216 .count = 3,
1217 .info = alc_mux_enum_info,
1218 .get = alc_mux_enum_get,
1219 .put = alc_mux_enum_put,
1220 },
1221 { } /* end */
1222 };
1223
1224 /* capture mixer elements (in case NID 0x07 not available) */
1225 static struct snd_kcontrol_new alc880_capture_alt_mixer[] = {
1226 HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
1227 HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
1228 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT),
1229 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT),
1230 {
1231 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1232 /* The multiple "Capture Source" controls confuse alsamixer
1233 * So call somewhat different..
1234 */
1235 /* .name = "Capture Source", */
1236 .name = "Input Source",
1237 .count = 2,
1238 .info = alc_mux_enum_info,
1239 .get = alc_mux_enum_get,
1240 .put = alc_mux_enum_put,
1241 },
1242 { } /* end */
1243 };
1244
1245
1246
1247 /*
1248 * ALC880 5-stack model
1249 *
1250 * DAC: Front = 0x02 (0x0c), Surr = 0x05 (0x0f), CLFE = 0x04 (0x0d),
1251 * Side = 0x02 (0xd)
1252 * Pin assignment: Front = 0x14, Surr = 0x17, CLFE = 0x16
1253 * Line-In/Side = 0x1a, Mic = 0x18, F-Mic = 0x1b, HP = 0x19
1254 */
1255
1256 /* additional mixers to alc880_three_stack_mixer */
1257 static struct snd_kcontrol_new alc880_five_stack_mixer[] = {
1258 HDA_CODEC_VOLUME("Side Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1259 HDA_BIND_MUTE("Side Playback Switch", 0x0d, 2, HDA_INPUT),
1260 { } /* end */
1261 };
1262
1263 /* channel source setting (6/8 channel selection for 5-stack) */
1264 /* 6ch mode */
1265 static struct hda_verb alc880_fivestack_ch6_init[] = {
1266 /* set line-in to input, mute it */
1267 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
1268 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
1269 { } /* end */
1270 };
1271
1272 /* 8ch mode */
1273 static struct hda_verb alc880_fivestack_ch8_init[] = {
1274 /* set line-in to output, unmute it */
1275 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1276 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1277 { } /* end */
1278 };
1279
1280 static struct hda_channel_mode alc880_fivestack_modes[2] = {
1281 { 6, alc880_fivestack_ch6_init },
1282 { 8, alc880_fivestack_ch8_init },
1283 };
1284
1285
1286 /*
1287 * ALC880 6-stack model
1288 *
1289 * DAC: Front = 0x02 (0x0c), Surr = 0x03 (0x0d), CLFE = 0x04 (0x0e),
1290 * Side = 0x05 (0x0f)
1291 * Pin assignment: Front = 0x14, Surr = 0x15, CLFE = 0x16, Side = 0x17,
1292 * Mic = 0x18, F-Mic = 0x19, Line = 0x1a, HP = 0x1b
1293 */
1294
1295 static hda_nid_t alc880_6st_dac_nids[4] = {
1296 /* front, rear, clfe, rear_surr */
1297 0x02, 0x03, 0x04, 0x05
1298 };
1299
1300 static struct hda_input_mux alc880_6stack_capture_source = {
1301 .num_items = 4,
1302 .items = {
1303 { "Mic", 0x0 },
1304 { "Front Mic", 0x1 },
1305 { "Line", 0x2 },
1306 { "CD", 0x4 },
1307 },
1308 };
1309
1310 /* fixed 8-channels */
1311 static struct hda_channel_mode alc880_sixstack_modes[1] = {
1312 { 8, NULL },
1313 };
1314
1315 static struct snd_kcontrol_new alc880_six_stack_mixer[] = {
1316 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1317 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
1318 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1319 HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
1320 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
1321 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
1322 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
1323 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
1324 HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
1325 HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
1326 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
1327 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
1328 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
1329 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
1330 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
1331 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
1332 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
1333 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
1334 HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
1335 HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
1336 {
1337 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1338 .name = "Channel Mode",
1339 .info = alc_ch_mode_info,
1340 .get = alc_ch_mode_get,
1341 .put = alc_ch_mode_put,
1342 },
1343 { } /* end */
1344 };
1345
1346
1347 /*
1348 * ALC880 W810 model
1349 *
1350 * W810 has rear IO for:
1351 * Front (DAC 02)
1352 * Surround (DAC 03)
1353 * Center/LFE (DAC 04)
1354 * Digital out (06)
1355 *
1356 * The system also has a pair of internal speakers, and a headphone jack.
1357 * These are both connected to Line2 on the codec, hence to DAC 02.
1358 *
1359 * There is a variable resistor to control the speaker or headphone
1360 * volume. This is a hardware-only device without a software API.
1361 *
1362 * Plugging headphones in will disable the internal speakers. This is
1363 * implemented in hardware, not via the driver using jack sense. In
1364 * a similar fashion, plugging into the rear socket marked "front" will
1365 * disable both the speakers and headphones.
1366 *
1367 * For input, there's a microphone jack, and an "audio in" jack.
1368 * These may not do anything useful with this driver yet, because I
1369 * haven't setup any initialization verbs for these yet...
1370 */
1371
1372 static hda_nid_t alc880_w810_dac_nids[3] = {
1373 /* front, rear/surround, clfe */
1374 0x02, 0x03, 0x04
1375 };
1376
1377 /* fixed 6 channels */
1378 static struct hda_channel_mode alc880_w810_modes[1] = {
1379 { 6, NULL }
1380 };
1381
1382 /* Pin assignment: Front = 0x14, Surr = 0x15, CLFE = 0x16, HP = 0x1b */
1383 static struct snd_kcontrol_new alc880_w810_base_mixer[] = {
1384 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1385 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
1386 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1387 HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
1388 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
1389 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
1390 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
1391 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
1392 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
1393 { } /* end */
1394 };
1395
1396
1397 /*
1398 * Z710V model
1399 *
1400 * DAC: Front = 0x02 (0x0c), HP = 0x03 (0x0d)
1401 * Pin assignment: Front = 0x14, HP = 0x15, Mic = 0x18, Mic2 = 0x19(?),
1402 * Line = 0x1a
1403 */
1404
1405 static hda_nid_t alc880_z71v_dac_nids[1] = {
1406 0x02
1407 };
1408 #define ALC880_Z71V_HP_DAC 0x03
1409
1410 /* fixed 2 channels */
1411 static struct hda_channel_mode alc880_2_jack_modes[1] = {
1412 { 2, NULL }
1413 };
1414
1415 static struct snd_kcontrol_new alc880_z71v_mixer[] = {
1416 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1417 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
1418 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1419 HDA_BIND_MUTE("Headphone Playback Switch", 0x0d, 2, HDA_INPUT),
1420 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
1421 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
1422 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
1423 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
1424 { } /* end */
1425 };
1426
1427
1428 /*
1429 * ALC880 F1734 model
1430 *
1431 * DAC: HP = 0x02 (0x0c), Front = 0x03 (0x0d)
1432 * Pin assignment: HP = 0x14, Front = 0x15, Mic = 0x18
1433 */
1434
1435 static hda_nid_t alc880_f1734_dac_nids[1] = {
1436 0x03
1437 };
1438 #define ALC880_F1734_HP_DAC 0x02
1439
1440 static struct snd_kcontrol_new alc880_f1734_mixer[] = {
1441 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1442 HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
1443 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1444 HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
1445 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
1446 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
1447 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
1448 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
1449 { } /* end */
1450 };
1451
1452 static struct hda_input_mux alc880_f1734_capture_source = {
1453 .num_items = 2,
1454 .items = {
1455 { "Mic", 0x1 },
1456 { "CD", 0x4 },
1457 },
1458 };
1459
1460
1461 /*
1462 * ALC880 ASUS model
1463 *
1464 * DAC: HP/Front = 0x02 (0x0c), Surr = 0x03 (0x0d), CLFE = 0x04 (0x0e)
1465 * Pin assignment: HP/Front = 0x14, Surr = 0x15, CLFE = 0x16,
1466 * Mic = 0x18, Line = 0x1a
1467 */
1468
1469 #define alc880_asus_dac_nids alc880_w810_dac_nids /* identical with w810 */
1470 #define alc880_asus_modes alc880_threestack_modes /* 2/6 channel mode */
1471
1472 static struct snd_kcontrol_new alc880_asus_mixer[] = {
1473 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1474 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
1475 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1476 HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
1477 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
1478 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
1479 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
1480 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
1481 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
1482 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
1483 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
1484 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
1485 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
1486 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
1487 {
1488 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1489 .name = "Channel Mode",
1490 .info = alc_ch_mode_info,
1491 .get = alc_ch_mode_get,
1492 .put = alc_ch_mode_put,
1493 },
1494 { } /* end */
1495 };
1496
1497 /*
1498 * ALC880 ASUS W1V model
1499 *
1500 * DAC: HP/Front = 0x02 (0x0c), Surr = 0x03 (0x0d), CLFE = 0x04 (0x0e)
1501 * Pin assignment: HP/Front = 0x14, Surr = 0x15, CLFE = 0x16,
1502 * Mic = 0x18, Line = 0x1a, Line2 = 0x1b
1503 */
1504
1505 /* additional mixers to alc880_asus_mixer */
1506 static struct snd_kcontrol_new alc880_asus_w1v_mixer[] = {
1507 HDA_CODEC_VOLUME("Line2 Playback Volume", 0x0b, 0x03, HDA_INPUT),
1508 HDA_CODEC_MUTE("Line2 Playback Switch", 0x0b, 0x03, HDA_INPUT),
1509 { } /* end */
1510 };
1511
1512 /* additional mixers to alc880_asus_mixer */
1513 static struct snd_kcontrol_new alc880_pcbeep_mixer[] = {
1514 HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
1515 HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
1516 { } /* end */
1517 };
1518
1519 /* TCL S700 */
1520 static struct snd_kcontrol_new alc880_tcl_s700_mixer[] = {
1521 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1522 HDA_CODEC_MUTE("Front Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
1523 HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
1524 HDA_CODEC_VOLUME("CD Playback Volume", 0x0B, 0x04, HDA_INPUT),
1525 HDA_CODEC_MUTE("CD Playback Switch", 0x0B, 0x04, HDA_INPUT),
1526 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0B, 0x0, HDA_INPUT),
1527 HDA_CODEC_MUTE("Mic Playback Switch", 0x0B, 0x0, HDA_INPUT),
1528 HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
1529 HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
1530 {
1531 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1532 /* The multiple "Capture Source" controls confuse alsamixer
1533 * So call somewhat different..
1534 */
1535 /* .name = "Capture Source", */
1536 .name = "Input Source",
1537 .count = 1,
1538 .info = alc_mux_enum_info,
1539 .get = alc_mux_enum_get,
1540 .put = alc_mux_enum_put,
1541 },
1542 { } /* end */
1543 };
1544
1545 /* Uniwill */
1546 static struct snd_kcontrol_new alc880_uniwill_mixer[] = {
1547 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1548 HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
1549 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1550 HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
1551 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
1552 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
1553 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
1554 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
1555 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
1556 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
1557 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
1558 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
1559 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
1560 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
1561 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
1562 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
1563 HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
1564 HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
1565 {
1566 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1567 .name = "Channel Mode",
1568 .info = alc_ch_mode_info,
1569 .get = alc_ch_mode_get,
1570 .put = alc_ch_mode_put,
1571 },
1572 { } /* end */
1573 };
1574
1575 static struct snd_kcontrol_new alc880_fujitsu_mixer[] = {
1576 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1577 HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
1578 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1579 HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
1580 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
1581 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
1582 HDA_CODEC_VOLUME("Ext Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
1583 HDA_CODEC_MUTE("Ext Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
1584 HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
1585 HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
1586 { } /* end */
1587 };
1588
1589 static struct snd_kcontrol_new alc880_uniwill_p53_mixer[] = {
1590 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1591 HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
1592 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1593 HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
1594 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
1595 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
1596 { } /* end */
1597 };
1598
1599 /*
1600 * virtual master controls
1601 */
1602
1603 /*
1604 * slave controls for virtual master
1605 */
1606 static const char *alc_slave_vols[] = {
1607 "Front Playback Volume",
1608 "Surround Playback Volume",
1609 "Center Playback Volume",
1610 "LFE Playback Volume",
1611 "Side Playback Volume",
1612 "Headphone Playback Volume",
1613 "Speaker Playback Volume",
1614 "Mono Playback Volume",
1615 "Line-Out Playback Volume",
1616 NULL,
1617 };
1618
1619 static const char *alc_slave_sws[] = {
1620 "Front Playback Switch",
1621 "Surround Playback Switch",
1622 "Center Playback Switch",
1623 "LFE Playback Switch",
1624 "Side Playback Switch",
1625 "Headphone Playback Switch",
1626 "Speaker Playback Switch",
1627 "Mono Playback Switch",
1628 "IEC958 Playback Switch",
1629 NULL,
1630 };
1631
1632 /*
1633 * build control elements
1634 */
1635 static int alc_build_controls(struct hda_codec *codec)
1636 {
1637 struct alc_spec *spec = codec->spec;
1638 int err;
1639 int i;
1640
1641 for (i = 0; i < spec->num_mixers; i++) {
1642 err = snd_hda_add_new_ctls(codec, spec->mixers[i]);
1643 if (err < 0)
1644 return err;
1645 }
1646
1647 if (spec->multiout.dig_out_nid) {
1648 err = snd_hda_create_spdif_out_ctls(codec,
1649 spec->multiout.dig_out_nid);
1650 if (err < 0)
1651 return err;
1652 err = snd_hda_create_spdif_share_sw(codec,
1653 &spec->multiout);
1654 if (err < 0)
1655 return err;
1656 spec->multiout.share_spdif = 1;
1657 }
1658 if (spec->dig_in_nid) {
1659 err = snd_hda_create_spdif_in_ctls(codec, spec->dig_in_nid);
1660 if (err < 0)
1661 return err;
1662 }
1663
1664 /* if we have no master control, let's create it */
1665 if (!snd_hda_find_mixer_ctl(codec, "Master Playback Volume")) {
1666 unsigned int vmaster_tlv[4];
1667 snd_hda_set_vmaster_tlv(codec, spec->vmaster_nid,
1668 HDA_OUTPUT, vmaster_tlv);
1669 err = snd_hda_add_vmaster(codec, "Master Playback Volume",
1670 vmaster_tlv, alc_slave_vols);
1671 if (err < 0)
1672 return err;
1673 }
1674 if (!snd_hda_find_mixer_ctl(codec, "Master Playback Switch")) {
1675 err = snd_hda_add_vmaster(codec, "Master Playback Switch",
1676 NULL, alc_slave_sws);
1677 if (err < 0)
1678 return err;
1679 }
1680
1681 return 0;
1682 }
1683
1684
1685 /*
1686 * initialize the codec volumes, etc
1687 */
1688
1689 /*
1690 * generic initialization of ADC, input mixers and output mixers
1691 */
1692 static struct hda_verb alc880_volume_init_verbs[] = {
1693 /*
1694 * Unmute ADC0-2 and set the default input to mic-in
1695 */
1696 {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
1697 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
1698 {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
1699 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
1700 {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
1701 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
1702
1703 /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
1704 * mixer widget
1705 * Note: PASD motherboards uses the Line In 2 as the input for front
1706 * panel mic (mic 2)
1707 */
1708 /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
1709 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
1710 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
1711 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
1712 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
1713 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
1714 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
1715 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
1716
1717 /*
1718 * Set up output mixers (0x0c - 0x0f)
1719 */
1720 /* set vol=0 to output mixers */
1721 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
1722 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
1723 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
1724 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
1725 /* set up input amps for analog loopback */
1726 /* Amp Indices: DAC = 0, mixer = 1 */
1727 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
1728 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
1729 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
1730 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
1731 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
1732 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
1733 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
1734 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
1735
1736 { }
1737 };
1738
1739 /*
1740 * 3-stack pin configuration:
1741 * front = 0x14, mic/clfe = 0x18, HP = 0x19, line/surr = 0x1a, f-mic = 0x1b
1742 */
1743 static struct hda_verb alc880_pin_3stack_init_verbs[] = {
1744 /*
1745 * preset connection lists of input pins
1746 * 0 = front, 1 = rear_surr, 2 = CLFE, 3 = surround
1747 */
1748 {0x10, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
1749 {0x11, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
1750 {0x12, AC_VERB_SET_CONNECT_SEL, 0x03}, /* line/surround */
1751
1752 /*
1753 * Set pin mode and muting
1754 */
1755 /* set front pin widgets 0x14 for output */
1756 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1757 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1758 /* Mic1 (rear panel) pin widget for input and vref at 80% */
1759 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
1760 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
1761 /* Mic2 (as headphone out) for HP output */
1762 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
1763 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1764 /* Line In pin widget for input */
1765 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1766 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
1767 /* Line2 (as front mic) pin widget for input and vref at 80% */
1768 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
1769 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
1770 /* CD pin widget for input */
1771 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1772
1773 { }
1774 };
1775
1776 /*
1777 * 5-stack pin configuration:
1778 * front = 0x14, surround = 0x17, clfe = 0x16, mic = 0x18, HP = 0x19,
1779 * line-in/side = 0x1a, f-mic = 0x1b
1780 */
1781 static struct hda_verb alc880_pin_5stack_init_verbs[] = {
1782 /*
1783 * preset connection lists of input pins
1784 * 0 = front, 1 = rear_surr, 2 = CLFE, 3 = surround
1785 */
1786 {0x11, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
1787 {0x12, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/side */
1788
1789 /*
1790 * Set pin mode and muting
1791 */
1792 /* set pin widgets 0x14-0x17 for output */
1793 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1794 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1795 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1796 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1797 /* unmute pins for output (no gain on this amp) */
1798 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1799 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1800 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1801 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1802
1803 /* Mic1 (rear panel) pin widget for input and vref at 80% */
1804 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
1805 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
1806 /* Mic2 (as headphone out) for HP output */
1807 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
1808 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1809 /* Line In pin widget for input */
1810 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1811 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
1812 /* Line2 (as front mic) pin widget for input and vref at 80% */
1813 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
1814 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
1815 /* CD pin widget for input */
1816 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1817
1818 { }
1819 };
1820
1821 /*
1822 * W810 pin configuration:
1823 * front = 0x14, surround = 0x15, clfe = 0x16, HP = 0x1b
1824 */
1825 static struct hda_verb alc880_pin_w810_init_verbs[] = {
1826 /* hphone/speaker input selector: front DAC */
1827 {0x13, AC_VERB_SET_CONNECT_SEL, 0x0},
1828
1829 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1830 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1831 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1832 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1833 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1834 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1835
1836 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
1837 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
1838
1839 { }
1840 };
1841
1842 /*
1843 * Z71V pin configuration:
1844 * Speaker-out = 0x14, HP = 0x15, Mic = 0x18, Line-in = 0x1a, Mic2 = 0x1b (?)
1845 */
1846 static struct hda_verb alc880_pin_z71v_init_verbs[] = {
1847 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1848 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1849 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
1850 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1851
1852 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
1853 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1854 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
1855 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1856
1857 { }
1858 };
1859
1860 /*
1861 * 6-stack pin configuration:
1862 * front = 0x14, surr = 0x15, clfe = 0x16, side = 0x17, mic = 0x18,
1863 * f-mic = 0x19, line = 0x1a, HP = 0x1b
1864 */
1865 static struct hda_verb alc880_pin_6stack_init_verbs[] = {
1866 {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
1867
1868 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1869 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1870 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1871 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1872 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1873 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1874 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1875 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1876
1877 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
1878 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
1879 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
1880 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
1881 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1882 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
1883 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
1884 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1885 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1886
1887 { }
1888 };
1889
1890 /*
1891 * Uniwill pin configuration:
1892 * HP = 0x14, InternalSpeaker = 0x15, mic = 0x18, internal mic = 0x19,
1893 * line = 0x1a
1894 */
1895 static struct hda_verb alc880_uniwill_init_verbs[] = {
1896 {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
1897
1898 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
1899 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1900 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
1901 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1902 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
1903 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1904 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1905 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1906 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
1907 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
1908 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
1909 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
1910 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
1911 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
1912
1913 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
1914 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
1915 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
1916 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
1917 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1918 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
1919 /* {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, */
1920 /* {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, */
1921 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1922
1923 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
1924 {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
1925
1926 { }
1927 };
1928
1929 /*
1930 * Uniwill P53
1931 * HP = 0x14, InternalSpeaker = 0x15, mic = 0x19,
1932 */
1933 static struct hda_verb alc880_uniwill_p53_init_verbs[] = {
1934 {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
1935
1936 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
1937 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1938 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
1939 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1940 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
1941 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1942 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
1943 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
1944 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
1945 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
1946 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
1947 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
1948
1949 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
1950 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
1951 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
1952 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
1953 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1954 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
1955
1956 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
1957 {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_DCVOL_EVENT},
1958
1959 { }
1960 };
1961
1962 static struct hda_verb alc880_beep_init_verbs[] = {
1963 { 0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(5) },
1964 { }
1965 };
1966
1967 /* toggle speaker-output according to the hp-jack state */
1968 static void alc880_uniwill_hp_automute(struct hda_codec *codec)
1969 {
1970 unsigned int present;
1971 unsigned char bits;
1972
1973 present = snd_hda_codec_read(codec, 0x14, 0,
1974 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
1975 bits = present ? HDA_AMP_MUTE : 0;
1976 snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
1977 HDA_AMP_MUTE, bits);
1978 snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
1979 HDA_AMP_MUTE, bits);
1980 }
1981
1982 /* auto-toggle front mic */
1983 static void alc880_uniwill_mic_automute(struct hda_codec *codec)
1984 {
1985 unsigned int present;
1986 unsigned char bits;
1987
1988 present = snd_hda_codec_read(codec, 0x18, 0,
1989 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
1990 bits = present ? HDA_AMP_MUTE : 0;
1991 snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1, HDA_AMP_MUTE, bits);
1992 }
1993
1994 static void alc880_uniwill_automute(struct hda_codec *codec)
1995 {
1996 alc880_uniwill_hp_automute(codec);
1997 alc880_uniwill_mic_automute(codec);
1998 }
1999
2000 static void alc880_uniwill_unsol_event(struct hda_codec *codec,
2001 unsigned int res)
2002 {
2003 /* Looks like the unsol event is incompatible with the standard
2004 * definition. 4bit tag is placed at 28 bit!
2005 */
2006 switch (res >> 28) {
2007 case ALC880_HP_EVENT:
2008 alc880_uniwill_hp_automute(codec);
2009 break;
2010 case ALC880_MIC_EVENT:
2011 alc880_uniwill_mic_automute(codec);
2012 break;
2013 }
2014 }
2015
2016 static void alc880_uniwill_p53_hp_automute(struct hda_codec *codec)
2017 {
2018 unsigned int present;
2019 unsigned char bits;
2020
2021 present = snd_hda_codec_read(codec, 0x14, 0,
2022 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
2023 bits = present ? HDA_AMP_MUTE : 0;
2024 snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0, HDA_AMP_MUTE, bits);
2025 }
2026
2027 static void alc880_uniwill_p53_dcvol_automute(struct hda_codec *codec)
2028 {
2029 unsigned int present;
2030
2031 present = snd_hda_codec_read(codec, 0x21, 0,
2032 AC_VERB_GET_VOLUME_KNOB_CONTROL, 0);
2033 present &= HDA_AMP_VOLMASK;
2034 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_OUTPUT, 0,
2035 HDA_AMP_VOLMASK, present);
2036 snd_hda_codec_amp_stereo(codec, 0x0d, HDA_OUTPUT, 0,
2037 HDA_AMP_VOLMASK, present);
2038 }
2039
2040 static void alc880_uniwill_p53_unsol_event(struct hda_codec *codec,
2041 unsigned int res)
2042 {
2043 /* Looks like the unsol event is incompatible with the standard
2044 * definition. 4bit tag is placed at 28 bit!
2045 */
2046 if ((res >> 28) == ALC880_HP_EVENT)
2047 alc880_uniwill_p53_hp_automute(codec);
2048 if ((res >> 28) == ALC880_DCVOL_EVENT)
2049 alc880_uniwill_p53_dcvol_automute(codec);
2050 }
2051
2052 /*
2053 * F1734 pin configuration:
2054 * HP = 0x14, speaker-out = 0x15, mic = 0x18
2055 */
2056 static struct hda_verb alc880_pin_f1734_init_verbs[] = {
2057 {0x07, AC_VERB_SET_CONNECT_SEL, 0x01},
2058 {0x10, AC_VERB_SET_CONNECT_SEL, 0x02},
2059 {0x11, AC_VERB_SET_CONNECT_SEL, 0x00},
2060 {0x12, AC_VERB_SET_CONNECT_SEL, 0x01},
2061 {0x13, AC_VERB_SET_CONNECT_SEL, 0x00},
2062
2063 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2064 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2065 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2066 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2067
2068 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2069 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2070 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
2071 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2072 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2073 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2074 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2075 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2076 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2077
2078 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_HP_EVENT},
2079 {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_DCVOL_EVENT},
2080
2081 { }
2082 };
2083
2084 /*
2085 * ASUS pin configuration:
2086 * HP/front = 0x14, surr = 0x15, clfe = 0x16, mic = 0x18, line = 0x1a
2087 */
2088 static struct hda_verb alc880_pin_asus_init_verbs[] = {
2089 {0x10, AC_VERB_SET_CONNECT_SEL, 0x02},
2090 {0x11, AC_VERB_SET_CONNECT_SEL, 0x00},
2091 {0x12, AC_VERB_SET_CONNECT_SEL, 0x01},
2092 {0x13, AC_VERB_SET_CONNECT_SEL, 0x00},
2093
2094 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2095 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2096 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2097 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2098 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2099 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2100 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2101 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2102
2103 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2104 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2105 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2106 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2107 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2108 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2109 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2110 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2111 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2112
2113 { }
2114 };
2115
2116 /* Enable GPIO mask and set output */
2117 #define alc880_gpio1_init_verbs alc_gpio1_init_verbs
2118 #define alc880_gpio2_init_verbs alc_gpio2_init_verbs
2119
2120 /* Clevo m520g init */
2121 static struct hda_verb alc880_pin_clevo_init_verbs[] = {
2122 /* headphone output */
2123 {0x11, AC_VERB_SET_CONNECT_SEL, 0x01},
2124 /* line-out */
2125 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2126 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2127 /* Line-in */
2128 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2129 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2130 /* CD */
2131 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2132 {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2133 /* Mic1 (rear panel) */
2134 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2135 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2136 /* Mic2 (front panel) */
2137 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2138 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2139 /* headphone */
2140 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2141 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2142 /* change to EAPD mode */
2143 {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
2144 {0x20, AC_VERB_SET_PROC_COEF, 0x3060},
2145
2146 { }
2147 };
2148
2149 static struct hda_verb alc880_pin_tcl_S700_init_verbs[] = {
2150 /* change to EAPD mode */
2151 {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
2152 {0x20, AC_VERB_SET_PROC_COEF, 0x3060},
2153
2154 /* Headphone output */
2155 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2156 /* Front output*/
2157 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2158 {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
2159
2160 /* Line In pin widget for input */
2161 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2162 /* CD pin widget for input */
2163 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2164 /* Mic1 (rear panel) pin widget for input and vref at 80% */
2165 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2166
2167 /* change to EAPD mode */
2168 {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
2169 {0x20, AC_VERB_SET_PROC_COEF, 0x3070},
2170
2171 { }
2172 };
2173
2174 /*
2175 * LG m1 express dual
2176 *
2177 * Pin assignment:
2178 * Rear Line-In/Out (blue): 0x14
2179 * Build-in Mic-In: 0x15
2180 * Speaker-out: 0x17
2181 * HP-Out (green): 0x1b
2182 * Mic-In/Out (red): 0x19
2183 * SPDIF-Out: 0x1e
2184 */
2185
2186 /* To make 5.1 output working (green=Front, blue=Surr, red=CLFE) */
2187 static hda_nid_t alc880_lg_dac_nids[3] = {
2188 0x05, 0x02, 0x03
2189 };
2190
2191 /* seems analog CD is not working */
2192 static struct hda_input_mux alc880_lg_capture_source = {
2193 .num_items = 3,
2194 .items = {
2195 { "Mic", 0x1 },
2196 { "Line", 0x5 },
2197 { "Internal Mic", 0x6 },
2198 },
2199 };
2200
2201 /* 2,4,6 channel modes */
2202 static struct hda_verb alc880_lg_ch2_init[] = {
2203 /* set line-in and mic-in to input */
2204 { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
2205 { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
2206 { }
2207 };
2208
2209 static struct hda_verb alc880_lg_ch4_init[] = {
2210 /* set line-in to out and mic-in to input */
2211 { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },
2212 { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
2213 { }
2214 };
2215
2216 static struct hda_verb alc880_lg_ch6_init[] = {
2217 /* set line-in and mic-in to output */
2218 { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },
2219 { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },
2220 { }
2221 };
2222
2223 static struct hda_channel_mode alc880_lg_ch_modes[3] = {
2224 { 2, alc880_lg_ch2_init },
2225 { 4, alc880_lg_ch4_init },
2226 { 6, alc880_lg_ch6_init },
2227 };
2228
2229 static struct snd_kcontrol_new alc880_lg_mixer[] = {
2230 HDA_CODEC_VOLUME("Front Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
2231 HDA_BIND_MUTE("Front Playback Switch", 0x0f, 2, HDA_INPUT),
2232 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2233 HDA_BIND_MUTE("Surround Playback Switch", 0x0c, 2, HDA_INPUT),
2234 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0d, 1, 0x0, HDA_OUTPUT),
2235 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0d, 2, 0x0, HDA_OUTPUT),
2236 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0d, 1, 2, HDA_INPUT),
2237 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0d, 2, 2, HDA_INPUT),
2238 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
2239 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
2240 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x06, HDA_INPUT),
2241 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x06, HDA_INPUT),
2242 HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x07, HDA_INPUT),
2243 HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x07, HDA_INPUT),
2244 {
2245 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2246 .name = "Channel Mode",
2247 .info = alc_ch_mode_info,
2248 .get = alc_ch_mode_get,
2249 .put = alc_ch_mode_put,
2250 },
2251 { } /* end */
2252 };
2253
2254 static struct hda_verb alc880_lg_init_verbs[] = {
2255 /* set capture source to mic-in */
2256 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
2257 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
2258 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
2259 /* mute all amp mixer inputs */
2260 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(5)},
2261 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
2262 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
2263 /* line-in to input */
2264 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2265 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2266 /* built-in mic */
2267 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2268 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2269 /* speaker-out */
2270 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2271 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2272 /* mic-in to input */
2273 {0x11, AC_VERB_SET_CONNECT_SEL, 0x01},
2274 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2275 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2276 /* HP-out */
2277 {0x13, AC_VERB_SET_CONNECT_SEL, 0x03},
2278 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2279 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2280 /* jack sense */
2281 {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | 0x1},
2282 { }
2283 };
2284
2285 /* toggle speaker-output according to the hp-jack state */
2286 static void alc880_lg_automute(struct hda_codec *codec)
2287 {
2288 unsigned int present;
2289 unsigned char bits;
2290
2291 present = snd_hda_codec_read(codec, 0x1b, 0,
2292 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
2293 bits = present ? HDA_AMP_MUTE : 0;
2294 snd_hda_codec_amp_stereo(codec, 0x17, HDA_OUTPUT, 0,
2295 HDA_AMP_MUTE, bits);
2296 }
2297
2298 static void alc880_lg_unsol_event(struct hda_codec *codec, unsigned int res)
2299 {
2300 /* Looks like the unsol event is incompatible with the standard
2301 * definition. 4bit tag is placed at 28 bit!
2302 */
2303 if ((res >> 28) == 0x01)
2304 alc880_lg_automute(codec);
2305 }
2306
2307 /*
2308 * LG LW20
2309 *
2310 * Pin assignment:
2311 * Speaker-out: 0x14
2312 * Mic-In: 0x18
2313 * Built-in Mic-In: 0x19
2314 * Line-In: 0x1b
2315 * HP-Out: 0x1a
2316 * SPDIF-Out: 0x1e
2317 */
2318
2319 static struct hda_input_mux alc880_lg_lw_capture_source = {
2320 .num_items = 3,
2321 .items = {
2322 { "Mic", 0x0 },
2323 { "Internal Mic", 0x1 },
2324 { "Line In", 0x2 },
2325 },
2326 };
2327
2328 #define alc880_lg_lw_modes alc880_threestack_modes
2329
2330 static struct snd_kcontrol_new alc880_lg_lw_mixer[] = {
2331 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2332 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
2333 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
2334 HDA_BIND_MUTE("Surround Playback Switch", 0x0f, 2, HDA_INPUT),
2335 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
2336 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
2337 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
2338 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
2339 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
2340 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
2341 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2342 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2343 HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
2344 HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
2345 {
2346 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2347 .name = "Channel Mode",
2348 .info = alc_ch_mode_info,
2349 .get = alc_ch_mode_get,
2350 .put = alc_ch_mode_put,
2351 },
2352 { } /* end */
2353 };
2354
2355 static struct hda_verb alc880_lg_lw_init_verbs[] = {
2356 {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
2357 {0x10, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
2358 {0x12, AC_VERB_SET_CONNECT_SEL, 0x03}, /* line/surround */
2359
2360 /* set capture source to mic-in */
2361 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2362 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2363 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2364 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
2365 /* speaker-out */
2366 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2367 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2368 /* HP-out */
2369 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2370 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2371 /* mic-in to input */
2372 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2373 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2374 /* built-in mic */
2375 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2376 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2377 /* jack sense */
2378 {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | 0x1},
2379 { }
2380 };
2381
2382 /* toggle speaker-output according to the hp-jack state */
2383 static void alc880_lg_lw_automute(struct hda_codec *codec)
2384 {
2385 unsigned int present;
2386 unsigned char bits;
2387
2388 present = snd_hda_codec_read(codec, 0x1b, 0,
2389 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
2390 bits = present ? HDA_AMP_MUTE : 0;
2391 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
2392 HDA_AMP_MUTE, bits);
2393 }
2394
2395 static void alc880_lg_lw_unsol_event(struct hda_codec *codec, unsigned int res)
2396 {
2397 /* Looks like the unsol event is incompatible with the standard
2398 * definition. 4bit tag is placed at 28 bit!
2399 */
2400 if ((res >> 28) == 0x01)
2401 alc880_lg_lw_automute(codec);
2402 }
2403
2404 static struct snd_kcontrol_new alc880_medion_rim_mixer[] = {
2405 HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2406 HDA_BIND_MUTE("Master Playback Switch", 0x0c, 2, HDA_INPUT),
2407 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2408 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2409 HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
2410 HDA_CODEC_MUTE("Internal Playback Switch", 0x0b, 0x1, HDA_INPUT),
2411 { } /* end */
2412 };
2413
2414 static struct hda_input_mux alc880_medion_rim_capture_source = {
2415 .num_items = 2,
2416 .items = {
2417 { "Mic", 0x0 },
2418 { "Internal Mic", 0x1 },
2419 },
2420 };
2421
2422 static struct hda_verb alc880_medion_rim_init_verbs[] = {
2423 {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
2424
2425 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2426 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2427
2428 /* Mic1 (rear panel) pin widget for input and vref at 80% */
2429 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2430 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2431 /* Mic2 (as headphone out) for HP output */
2432 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2433 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2434 /* Internal Speaker */
2435 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2436 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2437
2438 {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
2439 {0x20, AC_VERB_SET_PROC_COEF, 0x3060},
2440
2441 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
2442 { }
2443 };
2444
2445 /* toggle speaker-output according to the hp-jack state */
2446 static void alc880_medion_rim_automute(struct hda_codec *codec)
2447 {
2448 unsigned int present;
2449 unsigned char bits;
2450
2451 present = snd_hda_codec_read(codec, 0x14, 0,
2452 AC_VERB_GET_PIN_SENSE, 0)
2453 & AC_PINSENSE_PRESENCE;
2454 bits = present ? HDA_AMP_MUTE : 0;
2455 snd_hda_codec_amp_stereo(codec, 0x1b, HDA_OUTPUT, 0,
2456 HDA_AMP_MUTE, bits);
2457 if (present)
2458 snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA, 0);
2459 else
2460 snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA, 2);
2461 }
2462
2463 static void alc880_medion_rim_unsol_event(struct hda_codec *codec,
2464 unsigned int res)
2465 {
2466 /* Looks like the unsol event is incompatible with the standard
2467 * definition. 4bit tag is placed at 28 bit!
2468 */
2469 if ((res >> 28) == ALC880_HP_EVENT)
2470 alc880_medion_rim_automute(codec);
2471 }
2472
2473 #ifdef CONFIG_SND_HDA_POWER_SAVE
2474 static struct hda_amp_list alc880_loopbacks[] = {
2475 { 0x0b, HDA_INPUT, 0 },
2476 { 0x0b, HDA_INPUT, 1 },
2477 { 0x0b, HDA_INPUT, 2 },
2478 { 0x0b, HDA_INPUT, 3 },
2479 { 0x0b, HDA_INPUT, 4 },
2480 { } /* end */
2481 };
2482
2483 static struct hda_amp_list alc880_lg_loopbacks[] = {
2484 { 0x0b, HDA_INPUT, 1 },
2485 { 0x0b, HDA_INPUT, 6 },
2486 { 0x0b, HDA_INPUT, 7 },
2487 { } /* end */
2488 };
2489 #endif
2490
2491 /*
2492 * Common callbacks
2493 */
2494
2495 static int alc_init(struct hda_codec *codec)
2496 {
2497 struct alc_spec *spec = codec->spec;
2498 unsigned int i;
2499
2500 alc_fix_pll(codec);
2501 if (codec->vendor_id == 0x10ec0888)
2502 alc888_coef_init(codec);
2503
2504 for (i = 0; i < spec->num_init_verbs; i++)
2505 snd_hda_sequence_write(codec, spec->init_verbs[i]);
2506
2507 if (spec->init_hook)
2508 spec->init_hook(codec);
2509
2510 return 0;
2511 }
2512
2513 static void alc_unsol_event(struct hda_codec *codec, unsigned int res)
2514 {
2515 struct alc_spec *spec = codec->spec;
2516
2517 if (spec->unsol_event)
2518 spec->unsol_event(codec, res);
2519 }
2520
2521 #ifdef CONFIG_SND_HDA_POWER_SAVE
2522 static int alc_check_power_status(struct hda_codec *codec, hda_nid_t nid)
2523 {
2524 struct alc_spec *spec = codec->spec;
2525 return snd_hda_check_amp_list_power(codec, &spec->loopback, nid);
2526 }
2527 #endif
2528
2529 /*
2530 * Analog playback callbacks
2531 */
2532 static int alc880_playback_pcm_open(struct hda_pcm_stream *hinfo,
2533 struct hda_codec *codec,
2534 struct snd_pcm_substream *substream)
2535 {
2536 struct alc_spec *spec = codec->spec;
2537 return snd_hda_multi_out_analog_open(codec, &spec->multiout, substream,
2538 hinfo);
2539 }
2540
2541 static int alc880_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
2542 struct hda_codec *codec,
2543 unsigned int stream_tag,
2544 unsigned int format,
2545 struct snd_pcm_substream *substream)
2546 {
2547 struct alc_spec *spec = codec->spec;
2548 return snd_hda_multi_out_analog_prepare(codec, &spec->multiout,
2549 stream_tag, format, substream);
2550 }
2551
2552 static int alc880_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
2553 struct hda_codec *codec,
2554 struct snd_pcm_substream *substream)
2555 {
2556 struct alc_spec *spec = codec->spec;
2557 return snd_hda_multi_out_analog_cleanup(codec, &spec->multiout);
2558 }
2559
2560 /*
2561 * Digital out
2562 */
2563 static int alc880_dig_playback_pcm_open(struct hda_pcm_stream *hinfo,
2564 struct hda_codec *codec,
2565 struct snd_pcm_substream *substream)
2566 {
2567 struct alc_spec *spec = codec->spec;
2568 return snd_hda_multi_out_dig_open(codec, &spec->multiout);
2569 }
2570
2571 static int alc880_dig_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
2572 struct hda_codec *codec,
2573 unsigned int stream_tag,
2574 unsigned int format,
2575 struct snd_pcm_substream *substream)
2576 {
2577 struct alc_spec *spec = codec->spec;
2578 return snd_hda_multi_out_dig_prepare(codec, &spec->multiout,
2579 stream_tag, format, substream);
2580 }
2581
2582 static int alc880_dig_playback_pcm_close(struct hda_pcm_stream *hinfo,
2583 struct hda_codec *codec,
2584 struct snd_pcm_substream *substream)
2585 {
2586 struct alc_spec *spec = codec->spec;
2587 return snd_hda_multi_out_dig_close(codec, &spec->multiout);
2588 }
2589
2590 /*
2591 * Analog capture
2592 */
2593 static int alc880_alt_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
2594 struct hda_codec *codec,
2595 unsigned int stream_tag,
2596 unsigned int format,
2597 struct snd_pcm_substream *substream)
2598 {
2599 struct alc_spec *spec = codec->spec;
2600
2601 snd_hda_codec_setup_stream(codec, spec->adc_nids[substream->number + 1],
2602 stream_tag, 0, format);
2603 return 0;
2604 }
2605
2606 static int alc880_alt_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
2607 struct hda_codec *codec,
2608 struct snd_pcm_substream *substream)
2609 {
2610 struct alc_spec *spec = codec->spec;
2611
2612 snd_hda_codec_cleanup_stream(codec,
2613 spec->adc_nids[substream->number + 1]);
2614 return 0;
2615 }
2616
2617
2618 /*
2619 */
2620 static struct hda_pcm_stream alc880_pcm_analog_playback = {
2621 .substreams = 1,
2622 .channels_min = 2,
2623 .channels_max = 8,
2624 /* NID is set in alc_build_pcms */
2625 .ops = {
2626 .open = alc880_playback_pcm_open,
2627 .prepare = alc880_playback_pcm_prepare,
2628 .cleanup = alc880_playback_pcm_cleanup
2629 },
2630 };
2631
2632 static struct hda_pcm_stream alc880_pcm_analog_capture = {
2633 .substreams = 1,
2634 .channels_min = 2,
2635 .channels_max = 2,
2636 /* NID is set in alc_build_pcms */
2637 };
2638
2639 static struct hda_pcm_stream alc880_pcm_analog_alt_playback = {
2640 .substreams = 1,
2641 .channels_min = 2,
2642 .channels_max = 2,
2643 /* NID is set in alc_build_pcms */
2644 };
2645
2646 static struct hda_pcm_stream alc880_pcm_analog_alt_capture = {
2647 .substreams = 2, /* can be overridden */
2648 .channels_min = 2,
2649 .channels_max = 2,
2650 /* NID is set in alc_build_pcms */
2651 .ops = {
2652 .prepare = alc880_alt_capture_pcm_prepare,
2653 .cleanup = alc880_alt_capture_pcm_cleanup
2654 },
2655 };
2656
2657 static struct hda_pcm_stream alc880_pcm_digital_playback = {
2658 .substreams = 1,
2659 .channels_min = 2,
2660 .channels_max = 2,
2661 /* NID is set in alc_build_pcms */
2662 .ops = {
2663 .open = alc880_dig_playback_pcm_open,
2664 .close = alc880_dig_playback_pcm_close,
2665 .prepare = alc880_dig_playback_pcm_prepare
2666 },
2667 };
2668
2669 static struct hda_pcm_stream alc880_pcm_digital_capture = {
2670 .substreams = 1,
2671 .channels_min = 2,
2672 .channels_max = 2,
2673 /* NID is set in alc_build_pcms */
2674 };
2675
2676 /* Used by alc_build_pcms to flag that a PCM has no playback stream */
2677 static struct hda_pcm_stream alc_pcm_null_stream = {
2678 .substreams = 0,
2679 .channels_min = 0,
2680 .channels_max = 0,
2681 };
2682
2683 static int alc_build_pcms(struct hda_codec *codec)
2684 {
2685 struct alc_spec *spec = codec->spec;
2686 struct hda_pcm *info = spec->pcm_rec;
2687 int i;
2688
2689 codec->num_pcms = 1;
2690 codec->pcm_info = info;
2691
2692 info->name = spec->stream_name_analog;
2693 if (spec->stream_analog_playback) {
2694 if (snd_BUG_ON(!spec->multiout.dac_nids))
2695 return -EINVAL;
2696 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *(spec->stream_analog_playback);
2697 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dac_nids[0];
2698 }
2699 if (spec->stream_analog_capture) {
2700 if (snd_BUG_ON(!spec->adc_nids))
2701 return -EINVAL;
2702 info->stream[SNDRV_PCM_STREAM_CAPTURE] = *(spec->stream_analog_capture);
2703 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adc_nids[0];
2704 }
2705
2706 if (spec->channel_mode) {
2707 info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max = 0;
2708 for (i = 0; i < spec->num_channel_mode; i++) {
2709 if (spec->channel_mode[i].channels > info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max) {
2710 info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max = spec->channel_mode[i].channels;
2711 }
2712 }
2713 }
2714
2715 /* SPDIF for stream index #1 */
2716 if (spec->multiout.dig_out_nid || spec->dig_in_nid) {
2717 codec->num_pcms = 2;
2718 info = spec->pcm_rec + 1;
2719 info->name = spec->stream_name_digital;
2720 info->pcm_type = HDA_PCM_TYPE_SPDIF;
2721 if (spec->multiout.dig_out_nid &&
2722 spec->stream_digital_playback) {
2723 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *(spec->stream_digital_playback);
2724 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dig_out_nid;
2725 }
2726 if (spec->dig_in_nid &&
2727 spec->stream_digital_capture) {
2728 info->stream[SNDRV_PCM_STREAM_CAPTURE] = *(spec->stream_digital_capture);
2729 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->dig_in_nid;
2730 }
2731 /* FIXME: do we need this for all Realtek codec models? */
2732 codec->spdif_status_reset = 1;
2733 }
2734
2735 /* If the use of more than one ADC is requested for the current
2736 * model, configure a second analog capture-only PCM.
2737 */
2738 /* Additional Analaog capture for index #2 */
2739 if ((spec->alt_dac_nid && spec->stream_analog_alt_playback) ||
2740 (spec->num_adc_nids > 1 && spec->stream_analog_alt_capture)) {
2741 codec->num_pcms = 3;
2742 info = spec->pcm_rec + 2;
2743 info->name = spec->stream_name_analog;
2744 if (spec->alt_dac_nid) {
2745 info->stream[SNDRV_PCM_STREAM_PLAYBACK] =
2746 *spec->stream_analog_alt_playback;
2747 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid =
2748 spec->alt_dac_nid;
2749 } else {
2750 info->stream[SNDRV_PCM_STREAM_PLAYBACK] =
2751 alc_pcm_null_stream;
2752 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = 0;
2753 }
2754 if (spec->num_adc_nids > 1) {
2755 info->stream[SNDRV_PCM_STREAM_CAPTURE] =
2756 *spec->stream_analog_alt_capture;
2757 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid =
2758 spec->adc_nids[1];
2759 info->stream[SNDRV_PCM_STREAM_CAPTURE].substreams =
2760 spec->num_adc_nids - 1;
2761 } else {
2762 info->stream[SNDRV_PCM_STREAM_CAPTURE] =
2763 alc_pcm_null_stream;
2764 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = 0;
2765 }
2766 }
2767
2768 return 0;
2769 }
2770
2771 static void alc_free(struct hda_codec *codec)
2772 {
2773 struct alc_spec *spec = codec->spec;
2774 unsigned int i;
2775
2776 if (!spec)
2777 return;
2778
2779 if (spec->kctl_alloc) {
2780 for (i = 0; i < spec->num_kctl_used; i++)
2781 kfree(spec->kctl_alloc[i].name);
2782 kfree(spec->kctl_alloc);
2783 }
2784 kfree(spec);
2785 codec->spec = NULL; /* to be sure */
2786 }
2787
2788 #ifdef SND_HDA_NEEDS_RESUME
2789 static void store_pin_configs(struct hda_codec *codec)
2790 {
2791 struct alc_spec *spec = codec->spec;
2792 hda_nid_t nid, end_nid;
2793
2794 end_nid = codec->start_nid + codec->num_nodes;
2795 for (nid = codec->start_nid; nid < end_nid; nid++) {
2796 unsigned int wid_caps = get_wcaps(codec, nid);
2797 unsigned int wid_type =
2798 (wid_caps & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
2799 if (wid_type != AC_WID_PIN)
2800 continue;
2801 if (spec->num_pins >= ARRAY_SIZE(spec->pin_nids))
2802 break;
2803 spec->pin_nids[spec->num_pins] = nid;
2804 spec->pin_cfgs[spec->num_pins] =
2805 snd_hda_codec_read(codec, nid, 0,
2806 AC_VERB_GET_CONFIG_DEFAULT, 0);
2807 spec->num_pins++;
2808 }
2809 }
2810
2811 static void resume_pin_configs(struct hda_codec *codec)
2812 {
2813 struct alc_spec *spec = codec->spec;
2814 int i;
2815
2816 for (i = 0; i < spec->num_pins; i++) {
2817 hda_nid_t pin_nid = spec->pin_nids[i];
2818 unsigned int pin_config = spec->pin_cfgs[i];
2819 snd_hda_codec_write(codec, pin_nid, 0,
2820 AC_VERB_SET_CONFIG_DEFAULT_BYTES_0,
2821 pin_config & 0x000000ff);
2822 snd_hda_codec_write(codec, pin_nid, 0,
2823 AC_VERB_SET_CONFIG_DEFAULT_BYTES_1,
2824 (pin_config & 0x0000ff00) >> 8);
2825 snd_hda_codec_write(codec, pin_nid, 0,
2826 AC_VERB_SET_CONFIG_DEFAULT_BYTES_2,
2827 (pin_config & 0x00ff0000) >> 16);
2828 snd_hda_codec_write(codec, pin_nid, 0,
2829 AC_VERB_SET_CONFIG_DEFAULT_BYTES_3,
2830 pin_config >> 24);
2831 }
2832 }
2833
2834 static int alc_resume(struct hda_codec *codec)
2835 {
2836 resume_pin_configs(codec);
2837 codec->patch_ops.init(codec);
2838 snd_hda_codec_resume_amp(codec);
2839 snd_hda_codec_resume_cache(codec);
2840 return 0;
2841 }
2842 #else
2843 #define store_pin_configs(codec)
2844 #endif
2845
2846 /*
2847 */
2848 static struct hda_codec_ops alc_patch_ops = {
2849 .build_controls = alc_build_controls,
2850 .build_pcms = alc_build_pcms,
2851 .init = alc_init,
2852 .free = alc_free,
2853 .unsol_event = alc_unsol_event,
2854 #ifdef SND_HDA_NEEDS_RESUME
2855 .resume = alc_resume,
2856 #endif
2857 #ifdef CONFIG_SND_HDA_POWER_SAVE
2858 .check_power_status = alc_check_power_status,
2859 #endif
2860 };
2861
2862
2863 /*
2864 * Test configuration for debugging
2865 *
2866 * Almost all inputs/outputs are enabled. I/O pins can be configured via
2867 * enum controls.
2868 */
2869 #ifdef CONFIG_SND_DEBUG
2870 static hda_nid_t alc880_test_dac_nids[4] = {
2871 0x02, 0x03, 0x04, 0x05
2872 };
2873
2874 static struct hda_input_mux alc880_test_capture_source = {
2875 .num_items = 7,
2876 .items = {
2877 { "In-1", 0x0 },
2878 { "In-2", 0x1 },
2879 { "In-3", 0x2 },
2880 { "In-4", 0x3 },
2881 { "CD", 0x4 },
2882 { "Front", 0x5 },
2883 { "Surround", 0x6 },
2884 },
2885 };
2886
2887 static struct hda_channel_mode alc880_test_modes[4] = {
2888 { 2, NULL },
2889 { 4, NULL },
2890 { 6, NULL },
2891 { 8, NULL },
2892 };
2893
2894 static int alc_test_pin_ctl_info(struct snd_kcontrol *kcontrol,
2895 struct snd_ctl_elem_info *uinfo)
2896 {
2897 static char *texts[] = {
2898 "N/A", "Line Out", "HP Out",
2899 "In Hi-Z", "In 50%", "In Grd", "In 80%", "In 100%"
2900 };
2901 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
2902 uinfo->count = 1;
2903 uinfo->value.enumerated.items = 8;
2904 if (uinfo->value.enumerated.item >= 8)
2905 uinfo->value.enumerated.item = 7;
2906 strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
2907 return 0;
2908 }
2909
2910 static int alc_test_pin_ctl_get(struct snd_kcontrol *kcontrol,
2911 struct snd_ctl_elem_value *ucontrol)
2912 {
2913 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2914 hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
2915 unsigned int pin_ctl, item = 0;
2916
2917 pin_ctl = snd_hda_codec_read(codec, nid, 0,
2918 AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
2919 if (pin_ctl & AC_PINCTL_OUT_EN) {
2920 if (pin_ctl & AC_PINCTL_HP_EN)
2921 item = 2;
2922 else
2923 item = 1;
2924 } else if (pin_ctl & AC_PINCTL_IN_EN) {
2925 switch (pin_ctl & AC_PINCTL_VREFEN) {
2926 case AC_PINCTL_VREF_HIZ: item = 3; break;
2927 case AC_PINCTL_VREF_50: item = 4; break;
2928 case AC_PINCTL_VREF_GRD: item = 5; break;
2929 case AC_PINCTL_VREF_80: item = 6; break;
2930 case AC_PINCTL_VREF_100: item = 7; break;
2931 }
2932 }
2933 ucontrol->value.enumerated.item[0] = item;
2934 return 0;
2935 }
2936
2937 static int alc_test_pin_ctl_put(struct snd_kcontrol *kcontrol,
2938 struct snd_ctl_elem_value *ucontrol)
2939 {
2940 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2941 hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
2942 static unsigned int ctls[] = {
2943 0, AC_PINCTL_OUT_EN, AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN,
2944 AC_PINCTL_IN_EN | AC_PINCTL_VREF_HIZ,
2945 AC_PINCTL_IN_EN | AC_PINCTL_VREF_50,
2946 AC_PINCTL_IN_EN | AC_PINCTL_VREF_GRD,
2947 AC_PINCTL_IN_EN | AC_PINCTL_VREF_80,
2948 AC_PINCTL_IN_EN | AC_PINCTL_VREF_100,
2949 };
2950 unsigned int old_ctl, new_ctl;
2951
2952 old_ctl = snd_hda_codec_read(codec, nid, 0,
2953 AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
2954 new_ctl = ctls[ucontrol->value.enumerated.item[0]];
2955 if (old_ctl != new_ctl) {
2956 int val;
2957 snd_hda_codec_write_cache(codec, nid, 0,
2958 AC_VERB_SET_PIN_WIDGET_CONTROL,
2959 new_ctl);
2960 val = ucontrol->value.enumerated.item[0] >= 3 ?
2961 HDA_AMP_MUTE : 0;
2962 snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
2963 HDA_AMP_MUTE, val);
2964 return 1;
2965 }
2966 return 0;
2967 }
2968
2969 static int alc_test_pin_src_info(struct snd_kcontrol *kcontrol,
2970 struct snd_ctl_elem_info *uinfo)
2971 {
2972 static char *texts[] = {
2973 "Front", "Surround", "CLFE", "Side"
2974 };
2975 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
2976 uinfo->count = 1;
2977 uinfo->value.enumerated.items = 4;
2978 if (uinfo->value.enumerated.item >= 4)
2979 uinfo->value.enumerated.item = 3;
2980 strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
2981 return 0;
2982 }
2983
2984 static int alc_test_pin_src_get(struct snd_kcontrol *kcontrol,
2985 struct snd_ctl_elem_value *ucontrol)
2986 {
2987 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2988 hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
2989 unsigned int sel;
2990
2991 sel = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_CONNECT_SEL, 0);
2992 ucontrol->value.enumerated.item[0] = sel & 3;
2993 return 0;
2994 }
2995
2996 static int alc_test_pin_src_put(struct snd_kcontrol *kcontrol,
2997 struct snd_ctl_elem_value *ucontrol)
2998 {
2999 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3000 hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
3001 unsigned int sel;
3002
3003 sel = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_CONNECT_SEL, 0) & 3;
3004 if (ucontrol->value.enumerated.item[0] != sel) {
3005 sel = ucontrol->value.enumerated.item[0] & 3;
3006 snd_hda_codec_write_cache(codec, nid, 0,
3007 AC_VERB_SET_CONNECT_SEL, sel);
3008 return 1;
3009 }
3010 return 0;
3011 }
3012
3013 #define PIN_CTL_TEST(xname,nid) { \
3014 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
3015 .name = xname, \
3016 .info = alc_test_pin_ctl_info, \
3017 .get = alc_test_pin_ctl_get, \
3018 .put = alc_test_pin_ctl_put, \
3019 .private_value = nid \
3020 }
3021
3022 #define PIN_SRC_TEST(xname,nid) { \
3023 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
3024 .name = xname, \
3025 .info = alc_test_pin_src_info, \
3026 .get = alc_test_pin_src_get, \
3027 .put = alc_test_pin_src_put, \
3028 .private_value = nid \
3029 }
3030
3031 static struct snd_kcontrol_new alc880_test_mixer[] = {
3032 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
3033 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
3034 HDA_CODEC_VOLUME("CLFE Playback Volume", 0x0e, 0x0, HDA_OUTPUT),
3035 HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
3036 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
3037 HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
3038 HDA_BIND_MUTE("CLFE Playback Switch", 0x0e, 2, HDA_INPUT),
3039 HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
3040 PIN_CTL_TEST("Front Pin Mode", 0x14),
3041 PIN_CTL_TEST("Surround Pin Mode", 0x15),
3042 PIN_CTL_TEST("CLFE Pin Mode", 0x16),
3043 PIN_CTL_TEST("Side Pin Mode", 0x17),
3044 PIN_CTL_TEST("In-1 Pin Mode", 0x18),
3045 PIN_CTL_TEST("In-2 Pin Mode", 0x19),
3046 PIN_CTL_TEST("In-3 Pin Mode", 0x1a),
3047 PIN_CTL_TEST("In-4 Pin Mode", 0x1b),
3048 PIN_SRC_TEST("In-1 Pin Source", 0x18),
3049 PIN_SRC_TEST("In-2 Pin Source", 0x19),
3050 PIN_SRC_TEST("In-3 Pin Source", 0x1a),
3051 PIN_SRC_TEST("In-4 Pin Source", 0x1b),
3052 HDA_CODEC_VOLUME("In-1 Playback Volume", 0x0b, 0x0, HDA_INPUT),
3053 HDA_CODEC_MUTE("In-1 Playback Switch", 0x0b, 0x0, HDA_INPUT),
3054 HDA_CODEC_VOLUME("In-2 Playback Volume", 0x0b, 0x1, HDA_INPUT),
3055 HDA_CODEC_MUTE("In-2 Playback Switch", 0x0b, 0x1, HDA_INPUT),
3056 HDA_CODEC_VOLUME("In-3 Playback Volume", 0x0b, 0x2, HDA_INPUT),
3057 HDA_CODEC_MUTE("In-3 Playback Switch", 0x0b, 0x2, HDA_INPUT),
3058 HDA_CODEC_VOLUME("In-4 Playback Volume", 0x0b, 0x3, HDA_INPUT),
3059 HDA_CODEC_MUTE("In-4 Playback Switch", 0x0b, 0x3, HDA_INPUT),
3060 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x4, HDA_INPUT),
3061 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x4, HDA_INPUT),
3062 {
3063 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3064 .name = "Channel Mode",
3065 .info = alc_ch_mode_info,
3066 .get = alc_ch_mode_get,
3067 .put = alc_ch_mode_put,
3068 },
3069 { } /* end */
3070 };
3071
3072 static struct hda_verb alc880_test_init_verbs[] = {
3073 /* Unmute inputs of 0x0c - 0x0f */
3074 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3075 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3076 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3077 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3078 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3079 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3080 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3081 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3082 /* Vol output for 0x0c-0x0f */
3083 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3084 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3085 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3086 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3087 /* Set output pins 0x14-0x17 */
3088 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3089 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3090 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3091 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3092 /* Unmute output pins 0x14-0x17 */
3093 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3094 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3095 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3096 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3097 /* Set input pins 0x18-0x1c */
3098 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3099 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3100 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3101 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3102 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3103 /* Mute input pins 0x18-0x1b */
3104 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3105 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3106 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3107 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3108 /* ADC set up */
3109 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3110 {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
3111 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3112 {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
3113 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3114 {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
3115 /* Analog input/passthru */
3116 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3117 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
3118 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
3119 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
3120 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
3121 { }
3122 };
3123 #endif
3124
3125 /*
3126 */
3127
3128 static const char *alc880_models[ALC880_MODEL_LAST] = {
3129 [ALC880_3ST] = "3stack",
3130 [ALC880_TCL_S700] = "tcl",
3131 [ALC880_3ST_DIG] = "3stack-digout",
3132 [ALC880_CLEVO] = "clevo",
3133 [ALC880_5ST] = "5stack",
3134 [ALC880_5ST_DIG] = "5stack-digout",
3135 [ALC880_W810] = "w810",
3136 [ALC880_Z71V] = "z71v",
3137 [ALC880_6ST] = "6stack",
3138 [ALC880_6ST_DIG] = "6stack-digout",
3139 [ALC880_ASUS] = "asus",
3140 [ALC880_ASUS_W1V] = "asus-w1v",
3141 [ALC880_ASUS_DIG] = "asus-dig",
3142 [ALC880_ASUS_DIG2] = "asus-dig2",
3143 [ALC880_UNIWILL_DIG] = "uniwill",
3144 [ALC880_UNIWILL_P53] = "uniwill-p53",
3145 [ALC880_FUJITSU] = "fujitsu",
3146 [ALC880_F1734] = "F1734",
3147 [ALC880_LG] = "lg",
3148 [ALC880_LG_LW] = "lg-lw",
3149 [ALC880_MEDION_RIM] = "medion",
3150 #ifdef CONFIG_SND_DEBUG
3151 [ALC880_TEST] = "test",
3152 #endif
3153 [ALC880_AUTO] = "auto",
3154 };
3155
3156 static struct snd_pci_quirk alc880_cfg_tbl[] = {
3157 SND_PCI_QUIRK(0x1019, 0x0f69, "Coeus G610P", ALC880_W810),
3158 SND_PCI_QUIRK(0x1019, 0xa880, "ECS", ALC880_5ST_DIG),
3159 SND_PCI_QUIRK(0x1019, 0xa884, "Acer APFV", ALC880_6ST),
3160 SND_PCI_QUIRK(0x1025, 0x0070, "ULI", ALC880_3ST_DIG),
3161 SND_PCI_QUIRK(0x1025, 0x0077, "ULI", ALC880_6ST_DIG),
3162 SND_PCI_QUIRK(0x1025, 0x0078, "ULI", ALC880_6ST_DIG),
3163 SND_PCI_QUIRK(0x1025, 0x0087, "ULI", ALC880_6ST_DIG),
3164 SND_PCI_QUIRK(0x1025, 0xe309, "ULI", ALC880_3ST_DIG),
3165 SND_PCI_QUIRK(0x1025, 0xe310, "ULI", ALC880_3ST),
3166 SND_PCI_QUIRK(0x1039, 0x1234, NULL, ALC880_6ST_DIG),
3167 SND_PCI_QUIRK(0x103c, 0x2a09, "HP", ALC880_5ST),
3168 SND_PCI_QUIRK(0x1043, 0x10b3, "ASUS W1V", ALC880_ASUS_W1V),
3169 SND_PCI_QUIRK(0x1043, 0x10c2, "ASUS W6A", ALC880_ASUS_DIG),
3170 SND_PCI_QUIRK(0x1043, 0x10c3, "ASUS Wxx", ALC880_ASUS_DIG),
3171 SND_PCI_QUIRK(0x1043, 0x1113, "ASUS", ALC880_ASUS_DIG),
3172 SND_PCI_QUIRK(0x1043, 0x1123, "ASUS", ALC880_ASUS_DIG),
3173 SND_PCI_QUIRK(0x1043, 0x1173, "ASUS", ALC880_ASUS_DIG),
3174 SND_PCI_QUIRK(0x1043, 0x1964, "ASUS Z71V", ALC880_Z71V),
3175 /* SND_PCI_QUIRK(0x1043, 0x1964, "ASUS", ALC880_ASUS_DIG), */
3176 SND_PCI_QUIRK(0x1043, 0x1973, "ASUS", ALC880_ASUS_DIG),
3177 SND_PCI_QUIRK(0x1043, 0x19b3, "ASUS", ALC880_ASUS_DIG),
3178 SND_PCI_QUIRK(0x1043, 0x814e, "ASUS P5GD1 w/SPDIF", ALC880_6ST_DIG),
3179 SND_PCI_QUIRK(0x1043, 0x8181, "ASUS P4GPL", ALC880_ASUS_DIG),
3180 SND_PCI_QUIRK(0x1043, 0x8196, "ASUS P5GD1", ALC880_6ST),
3181 SND_PCI_QUIRK(0x1043, 0x81b4, "ASUS", ALC880_6ST),
3182 SND_PCI_QUIRK(0x1043, 0, "ASUS", ALC880_ASUS), /* default ASUS */
3183 SND_PCI_QUIRK(0x104d, 0x81a0, "Sony", ALC880_3ST),
3184 SND_PCI_QUIRK(0x104d, 0x81d6, "Sony", ALC880_3ST),
3185 SND_PCI_QUIRK(0x107b, 0x3032, "Gateway", ALC880_5ST),
3186 SND_PCI_QUIRK(0x107b, 0x3033, "Gateway", ALC880_5ST),
3187 SND_PCI_QUIRK(0x107b, 0x4039, "Gateway", ALC880_5ST),
3188 SND_PCI_QUIRK(0x1297, 0xc790, "Shuttle ST20G5", ALC880_6ST_DIG),
3189 SND_PCI_QUIRK(0x1458, 0xa102, "Gigabyte K8", ALC880_6ST_DIG),
3190 SND_PCI_QUIRK(0x1462, 0x1150, "MSI", ALC880_6ST_DIG),
3191 SND_PCI_QUIRK(0x1509, 0x925d, "FIC P4M", ALC880_6ST_DIG),
3192 SND_PCI_QUIRK(0x1558, 0x0520, "Clevo m520G", ALC880_CLEVO),
3193 SND_PCI_QUIRK(0x1558, 0x0660, "Clevo m655n", ALC880_CLEVO),
3194 SND_PCI_QUIRK(0x1558, 0x5401, "ASUS", ALC880_ASUS_DIG2),
3195 SND_PCI_QUIRK(0x1565, 0x8202, "Biostar", ALC880_5ST_DIG),
3196 SND_PCI_QUIRK(0x1584, 0x9050, "Uniwill", ALC880_UNIWILL_DIG),
3197 SND_PCI_QUIRK(0x1584, 0x9054, "Uniwlll", ALC880_F1734),
3198 SND_PCI_QUIRK(0x1584, 0x9070, "Uniwill", ALC880_UNIWILL),
3199 SND_PCI_QUIRK(0x1584, 0x9077, "Uniwill P53", ALC880_UNIWILL_P53),
3200 SND_PCI_QUIRK(0x161f, 0x203d, "W810", ALC880_W810),
3201 SND_PCI_QUIRK(0x161f, 0x205d, "Medion Rim 2150", ALC880_MEDION_RIM),
3202 SND_PCI_QUIRK(0x1695, 0x400d, "EPoX", ALC880_5ST_DIG),
3203 SND_PCI_QUIRK(0x1695, 0x4012, "EPox EP-5LDA", ALC880_5ST_DIG),
3204 SND_PCI_QUIRK(0x1734, 0x107c, "FSC F1734", ALC880_F1734),
3205 SND_PCI_QUIRK(0x1734, 0x1094, "FSC Amilo M1451G", ALC880_FUJITSU),
3206 SND_PCI_QUIRK(0x1734, 0x10ac, "FSC", ALC880_UNIWILL),
3207 SND_PCI_QUIRK(0x1734, 0x10b0, "Fujitsu", ALC880_FUJITSU),
3208 SND_PCI_QUIRK(0x1854, 0x0018, "LG LW20", ALC880_LG_LW),
3209 SND_PCI_QUIRK(0x1854, 0x003b, "LG", ALC880_LG),
3210 SND_PCI_QUIRK(0x1854, 0x0068, "LG w1", ALC880_LG),
3211 SND_PCI_QUIRK(0x1854, 0x0077, "LG LW25", ALC880_LG_LW),
3212 SND_PCI_QUIRK(0x19db, 0x4188, "TCL S700", ALC880_TCL_S700),
3213 SND_PCI_QUIRK(0x2668, 0x8086, NULL, ALC880_6ST_DIG), /* broken BIOS */
3214 SND_PCI_QUIRK(0x8086, 0x2668, NULL, ALC880_6ST_DIG),
3215 SND_PCI_QUIRK(0x8086, 0xa100, "Intel mobo", ALC880_5ST_DIG),
3216 SND_PCI_QUIRK(0x8086, 0xd400, "Intel mobo", ALC880_5ST_DIG),
3217 SND_PCI_QUIRK(0x8086, 0xd401, "Intel mobo", ALC880_5ST_DIG),
3218 SND_PCI_QUIRK(0x8086, 0xd402, "Intel mobo", ALC880_3ST_DIG),
3219 SND_PCI_QUIRK(0x8086, 0xe224, "Intel mobo", ALC880_5ST_DIG),
3220 SND_PCI_QUIRK(0x8086, 0xe305, "Intel mobo", ALC880_3ST_DIG),
3221 SND_PCI_QUIRK(0x8086, 0xe308, "Intel mobo", ALC880_3ST_DIG),
3222 SND_PCI_QUIRK(0x8086, 0xe400, "Intel mobo", ALC880_5ST_DIG),
3223 SND_PCI_QUIRK(0x8086, 0xe401, "Intel mobo", ALC880_5ST_DIG),
3224 SND_PCI_QUIRK(0x8086, 0xe402, "Intel mobo", ALC880_5ST_DIG),
3225 SND_PCI_QUIRK(0x8086, 0, "Intel mobo", ALC880_3ST), /* default Intel */
3226 SND_PCI_QUIRK(0xa0a0, 0x0560, "AOpen i915GMm-HFS", ALC880_5ST_DIG),
3227 SND_PCI_QUIRK(0xe803, 0x1019, NULL, ALC880_6ST_DIG),
3228 {}
3229 };
3230
3231 /*
3232 * ALC880 codec presets
3233 */
3234 static struct alc_config_preset alc880_presets[] = {
3235 [ALC880_3ST] = {
3236 .mixers = { alc880_three_stack_mixer },
3237 .init_verbs = { alc880_volume_init_verbs,
3238 alc880_pin_3stack_init_verbs },
3239 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
3240 .dac_nids = alc880_dac_nids,
3241 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
3242 .channel_mode = alc880_threestack_modes,
3243 .need_dac_fix = 1,
3244 .input_mux = &alc880_capture_source,
3245 },
3246 [ALC880_3ST_DIG] = {
3247 .mixers = { alc880_three_stack_mixer },
3248 .init_verbs = { alc880_volume_init_verbs,
3249 alc880_pin_3stack_init_verbs },
3250 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
3251 .dac_nids = alc880_dac_nids,
3252 .dig_out_nid = ALC880_DIGOUT_NID,
3253 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
3254 .channel_mode = alc880_threestack_modes,
3255 .need_dac_fix = 1,
3256 .input_mux = &alc880_capture_source,
3257 },
3258 [ALC880_TCL_S700] = {
3259 .mixers = { alc880_tcl_s700_mixer },
3260 .init_verbs = { alc880_volume_init_verbs,
3261 alc880_pin_tcl_S700_init_verbs,
3262 alc880_gpio2_init_verbs },
3263 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
3264 .dac_nids = alc880_dac_nids,
3265 .hp_nid = 0x03,
3266 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
3267 .channel_mode = alc880_2_jack_modes,
3268 .input_mux = &alc880_capture_source,
3269 },
3270 [ALC880_5ST] = {
3271 .mixers = { alc880_three_stack_mixer,
3272 alc880_five_stack_mixer},
3273 .init_verbs = { alc880_volume_init_verbs,
3274 alc880_pin_5stack_init_verbs },
3275 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
3276 .dac_nids = alc880_dac_nids,
3277 .num_channel_mode = ARRAY_SIZE(alc880_fivestack_modes),
3278 .channel_mode = alc880_fivestack_modes,
3279 .input_mux = &alc880_capture_source,
3280 },
3281 [ALC880_5ST_DIG] = {
3282 .mixers = { alc880_three_stack_mixer,
3283 alc880_five_stack_mixer },
3284 .init_verbs = { alc880_volume_init_verbs,
3285 alc880_pin_5stack_init_verbs },
3286 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
3287 .dac_nids = alc880_dac_nids,
3288 .dig_out_nid = ALC880_DIGOUT_NID,
3289 .num_channel_mode = ARRAY_SIZE(alc880_fivestack_modes),
3290 .channel_mode = alc880_fivestack_modes,
3291 .input_mux = &alc880_capture_source,
3292 },
3293 [ALC880_6ST] = {
3294 .mixers = { alc880_six_stack_mixer },
3295 .init_verbs = { alc880_volume_init_verbs,
3296 alc880_pin_6stack_init_verbs },
3297 .num_dacs = ARRAY_SIZE(alc880_6st_dac_nids),
3298 .dac_nids = alc880_6st_dac_nids,
3299 .num_channel_mode = ARRAY_SIZE(alc880_sixstack_modes),
3300 .channel_mode = alc880_sixstack_modes,
3301 .input_mux = &alc880_6stack_capture_source,
3302 },
3303 [ALC880_6ST_DIG] = {
3304 .mixers = { alc880_six_stack_mixer },
3305 .init_verbs = { alc880_volume_init_verbs,
3306 alc880_pin_6stack_init_verbs },
3307 .num_dacs = ARRAY_SIZE(alc880_6st_dac_nids),
3308 .dac_nids = alc880_6st_dac_nids,
3309 .dig_out_nid = ALC880_DIGOUT_NID,
3310 .num_channel_mode = ARRAY_SIZE(alc880_sixstack_modes),
3311 .channel_mode = alc880_sixstack_modes,
3312 .input_mux = &alc880_6stack_capture_source,
3313 },
3314 [ALC880_W810] = {
3315 .mixers = { alc880_w810_base_mixer },
3316 .init_verbs = { alc880_volume_init_verbs,
3317 alc880_pin_w810_init_verbs,
3318 alc880_gpio2_init_verbs },
3319 .num_dacs = ARRAY_SIZE(alc880_w810_dac_nids),
3320 .dac_nids = alc880_w810_dac_nids,
3321 .dig_out_nid = ALC880_DIGOUT_NID,
3322 .num_channel_mode = ARRAY_SIZE(alc880_w810_modes),
3323 .channel_mode = alc880_w810_modes,
3324 .input_mux = &alc880_capture_source,
3325 },
3326 [ALC880_Z71V] = {
3327 .mixers = { alc880_z71v_mixer },
3328 .init_verbs = { alc880_volume_init_verbs,
3329 alc880_pin_z71v_init_verbs },
3330 .num_dacs = ARRAY_SIZE(alc880_z71v_dac_nids),
3331 .dac_nids = alc880_z71v_dac_nids,
3332 .dig_out_nid = ALC880_DIGOUT_NID,
3333 .hp_nid = 0x03,
3334 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
3335 .channel_mode = alc880_2_jack_modes,
3336 .input_mux = &alc880_capture_source,
3337 },
3338 [ALC880_F1734] = {
3339 .mixers = { alc880_f1734_mixer },
3340 .init_verbs = { alc880_volume_init_verbs,
3341 alc880_pin_f1734_init_verbs },
3342 .num_dacs = ARRAY_SIZE(alc880_f1734_dac_nids),
3343 .dac_nids = alc880_f1734_dac_nids,
3344 .hp_nid = 0x02,
3345 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
3346 .channel_mode = alc880_2_jack_modes,
3347 .input_mux = &alc880_f1734_capture_source,
3348 .unsol_event = alc880_uniwill_p53_unsol_event,
3349 .init_hook = alc880_uniwill_p53_hp_automute,
3350 },
3351 [ALC880_ASUS] = {
3352 .mixers = { alc880_asus_mixer },
3353 .init_verbs = { alc880_volume_init_verbs,
3354 alc880_pin_asus_init_verbs,
3355 alc880_gpio1_init_verbs },
3356 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
3357 .dac_nids = alc880_asus_dac_nids,
3358 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
3359 .channel_mode = alc880_asus_modes,
3360 .need_dac_fix = 1,
3361 .input_mux = &alc880_capture_source,
3362 },
3363 [ALC880_ASUS_DIG] = {
3364 .mixers = { alc880_asus_mixer },
3365 .init_verbs = { alc880_volume_init_verbs,
3366 alc880_pin_asus_init_verbs,
3367 alc880_gpio1_init_verbs },
3368 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
3369 .dac_nids = alc880_asus_dac_nids,
3370 .dig_out_nid = ALC880_DIGOUT_NID,
3371 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
3372 .channel_mode = alc880_asus_modes,
3373 .need_dac_fix = 1,
3374 .input_mux = &alc880_capture_source,
3375 },
3376 [ALC880_ASUS_DIG2] = {
3377 .mixers = { alc880_asus_mixer },
3378 .init_verbs = { alc880_volume_init_verbs,
3379 alc880_pin_asus_init_verbs,
3380 alc880_gpio2_init_verbs }, /* use GPIO2 */
3381 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
3382 .dac_nids = alc880_asus_dac_nids,
3383 .dig_out_nid = ALC880_DIGOUT_NID,
3384 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
3385 .channel_mode = alc880_asus_modes,
3386 .need_dac_fix = 1,
3387 .input_mux = &alc880_capture_source,
3388 },
3389 [ALC880_ASUS_W1V] = {
3390 .mixers = { alc880_asus_mixer, alc880_asus_w1v_mixer },
3391 .init_verbs = { alc880_volume_init_verbs,
3392 alc880_pin_asus_init_verbs,
3393 alc880_gpio1_init_verbs },
3394 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
3395 .dac_nids = alc880_asus_dac_nids,
3396 .dig_out_nid = ALC880_DIGOUT_NID,
3397 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
3398 .channel_mode = alc880_asus_modes,
3399 .need_dac_fix = 1,
3400 .input_mux = &alc880_capture_source,
3401 },
3402 [ALC880_UNIWILL_DIG] = {
3403 .mixers = { alc880_asus_mixer, alc880_pcbeep_mixer },
3404 .init_verbs = { alc880_volume_init_verbs,
3405 alc880_pin_asus_init_verbs },
3406 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
3407 .dac_nids = alc880_asus_dac_nids,
3408 .dig_out_nid = ALC880_DIGOUT_NID,
3409 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
3410 .channel_mode = alc880_asus_modes,
3411 .need_dac_fix = 1,
3412 .input_mux = &alc880_capture_source,
3413 },
3414 [ALC880_UNIWILL] = {
3415 .mixers = { alc880_uniwill_mixer },
3416 .init_verbs = { alc880_volume_init_verbs,
3417 alc880_uniwill_init_verbs },
3418 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
3419 .dac_nids = alc880_asus_dac_nids,
3420 .dig_out_nid = ALC880_DIGOUT_NID,
3421 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
3422 .channel_mode = alc880_threestack_modes,
3423 .need_dac_fix = 1,
3424 .input_mux = &alc880_capture_source,
3425 .unsol_event = alc880_uniwill_unsol_event,
3426 .init_hook = alc880_uniwill_automute,
3427 },
3428 [ALC880_UNIWILL_P53] = {
3429 .mixers = { alc880_uniwill_p53_mixer },
3430 .init_verbs = { alc880_volume_init_verbs,
3431 alc880_uniwill_p53_init_verbs },
3432 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
3433 .dac_nids = alc880_asus_dac_nids,
3434 .num_channel_mode = ARRAY_SIZE(alc880_w810_modes),
3435 .channel_mode = alc880_threestack_modes,
3436 .input_mux = &alc880_capture_source,
3437 .unsol_event = alc880_uniwill_p53_unsol_event,
3438 .init_hook = alc880_uniwill_p53_hp_automute,
3439 },
3440 [ALC880_FUJITSU] = {
3441 .mixers = { alc880_fujitsu_mixer,
3442 alc880_pcbeep_mixer, },
3443 .init_verbs = { alc880_volume_init_verbs,
3444 alc880_uniwill_p53_init_verbs,
3445 alc880_beep_init_verbs },
3446 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
3447 .dac_nids = alc880_dac_nids,
3448 .dig_out_nid = ALC880_DIGOUT_NID,
3449 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
3450 .channel_mode = alc880_2_jack_modes,
3451 .input_mux = &alc880_capture_source,
3452 .unsol_event = alc880_uniwill_p53_unsol_event,
3453 .init_hook = alc880_uniwill_p53_hp_automute,
3454 },
3455 [ALC880_CLEVO] = {
3456 .mixers = { alc880_three_stack_mixer },
3457 .init_verbs = { alc880_volume_init_verbs,
3458 alc880_pin_clevo_init_verbs },
3459 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
3460 .dac_nids = alc880_dac_nids,
3461 .hp_nid = 0x03,
3462 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
3463 .channel_mode = alc880_threestack_modes,
3464 .need_dac_fix = 1,
3465 .input_mux = &alc880_capture_source,
3466 },
3467 [ALC880_LG] = {
3468 .mixers = { alc880_lg_mixer },
3469 .init_verbs = { alc880_volume_init_verbs,
3470 alc880_lg_init_verbs },
3471 .num_dacs = ARRAY_SIZE(alc880_lg_dac_nids),
3472 .dac_nids = alc880_lg_dac_nids,
3473 .dig_out_nid = ALC880_DIGOUT_NID,
3474 .num_channel_mode = ARRAY_SIZE(alc880_lg_ch_modes),
3475 .channel_mode = alc880_lg_ch_modes,
3476 .need_dac_fix = 1,
3477 .input_mux = &alc880_lg_capture_source,
3478 .unsol_event = alc880_lg_unsol_event,
3479 .init_hook = alc880_lg_automute,
3480 #ifdef CONFIG_SND_HDA_POWER_SAVE
3481 .loopbacks = alc880_lg_loopbacks,
3482 #endif
3483 },
3484 [ALC880_LG_LW] = {
3485 .mixers = { alc880_lg_lw_mixer },
3486 .init_verbs = { alc880_volume_init_verbs,
3487 alc880_lg_lw_init_verbs },
3488 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
3489 .dac_nids = alc880_dac_nids,
3490 .dig_out_nid = ALC880_DIGOUT_NID,
3491 .num_channel_mode = ARRAY_SIZE(alc880_lg_lw_modes),
3492 .channel_mode = alc880_lg_lw_modes,
3493 .input_mux = &alc880_lg_lw_capture_source,
3494 .unsol_event = alc880_lg_lw_unsol_event,
3495 .init_hook = alc880_lg_lw_automute,
3496 },
3497 [ALC880_MEDION_RIM] = {
3498 .mixers = { alc880_medion_rim_mixer },
3499 .init_verbs = { alc880_volume_init_verbs,
3500 alc880_medion_rim_init_verbs,
3501 alc_gpio2_init_verbs },
3502 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
3503 .dac_nids = alc880_dac_nids,
3504 .dig_out_nid = ALC880_DIGOUT_NID,
3505 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
3506 .channel_mode = alc880_2_jack_modes,
3507 .input_mux = &alc880_medion_rim_capture_source,
3508 .unsol_event = alc880_medion_rim_unsol_event,
3509 .init_hook = alc880_medion_rim_automute,
3510 },
3511 #ifdef CONFIG_SND_DEBUG
3512 [ALC880_TEST] = {
3513 .mixers = { alc880_test_mixer },
3514 .init_verbs = { alc880_test_init_verbs },
3515 .num_dacs = ARRAY_SIZE(alc880_test_dac_nids),
3516 .dac_nids = alc880_test_dac_nids,
3517 .dig_out_nid = ALC880_DIGOUT_NID,
3518 .num_channel_mode = ARRAY_SIZE(alc880_test_modes),
3519 .channel_mode = alc880_test_modes,
3520 .input_mux = &alc880_test_capture_source,
3521 },
3522 #endif
3523 };
3524
3525 /*
3526 * Automatic parse of I/O pins from the BIOS configuration
3527 */
3528
3529 #define NUM_CONTROL_ALLOC 32
3530 #define NUM_VERB_ALLOC 32
3531
3532 enum {
3533 ALC_CTL_WIDGET_VOL,
3534 ALC_CTL_WIDGET_MUTE,
3535 ALC_CTL_BIND_MUTE,
3536 };
3537 static struct snd_kcontrol_new alc880_control_templates[] = {
3538 HDA_CODEC_VOLUME(NULL, 0, 0, 0),
3539 HDA_CODEC_MUTE(NULL, 0, 0, 0),
3540 HDA_BIND_MUTE(NULL, 0, 0, 0),
3541 };
3542
3543 /* add dynamic controls */
3544 static int add_control(struct alc_spec *spec, int type, const char *name,
3545 unsigned long val)
3546 {
3547 struct snd_kcontrol_new *knew;
3548
3549 if (spec->num_kctl_used >= spec->num_kctl_alloc) {
3550 int num = spec->num_kctl_alloc + NUM_CONTROL_ALLOC;
3551
3552 /* array + terminator */
3553 knew = kcalloc(num + 1, sizeof(*knew), GFP_KERNEL);
3554 if (!knew)
3555 return -ENOMEM;
3556 if (spec->kctl_alloc) {
3557 memcpy(knew, spec->kctl_alloc,
3558 sizeof(*knew) * spec->num_kctl_alloc);
3559 kfree(spec->kctl_alloc);
3560 }
3561 spec->kctl_alloc = knew;
3562 spec->num_kctl_alloc = num;
3563 }
3564
3565 knew = &spec->kctl_alloc[spec->num_kctl_used];
3566 *knew = alc880_control_templates[type];
3567 knew->name = kstrdup(name, GFP_KERNEL);
3568 if (!knew->name)
3569 return -ENOMEM;
3570 knew->private_value = val;
3571 spec->num_kctl_used++;
3572 return 0;
3573 }
3574
3575 #define alc880_is_fixed_pin(nid) ((nid) >= 0x14 && (nid) <= 0x17)
3576 #define alc880_fixed_pin_idx(nid) ((nid) - 0x14)
3577 #define alc880_is_multi_pin(nid) ((nid) >= 0x18)
3578 #define alc880_multi_pin_idx(nid) ((nid) - 0x18)
3579 #define alc880_is_input_pin(nid) ((nid) >= 0x18)
3580 #define alc880_input_pin_idx(nid) ((nid) - 0x18)
3581 #define alc880_idx_to_dac(nid) ((nid) + 0x02)
3582 #define alc880_dac_to_idx(nid) ((nid) - 0x02)
3583 #define alc880_idx_to_mixer(nid) ((nid) + 0x0c)
3584 #define alc880_idx_to_selector(nid) ((nid) + 0x10)
3585 #define ALC880_PIN_CD_NID 0x1c
3586
3587 /* fill in the dac_nids table from the parsed pin configuration */
3588 static int alc880_auto_fill_dac_nids(struct alc_spec *spec,
3589 const struct auto_pin_cfg *cfg)
3590 {
3591 hda_nid_t nid;
3592 int assigned[4];
3593 int i, j;
3594
3595 memset(assigned, 0, sizeof(assigned));
3596 spec->multiout.dac_nids = spec->private_dac_nids;
3597
3598 /* check the pins hardwired to audio widget */
3599 for (i = 0; i < cfg->line_outs; i++) {
3600 nid = cfg->line_out_pins[i];
3601 if (alc880_is_fixed_pin(nid)) {
3602 int idx = alc880_fixed_pin_idx(nid);
3603 spec->multiout.dac_nids[i] = alc880_idx_to_dac(idx);
3604 assigned[idx] = 1;
3605 }
3606 }
3607 /* left pins can be connect to any audio widget */
3608 for (i = 0; i < cfg->line_outs; i++) {
3609 nid = cfg->line_out_pins[i];
3610 if (alc880_is_fixed_pin(nid))
3611 continue;
3612 /* search for an empty channel */
3613 for (j = 0; j < cfg->line_outs; j++) {
3614 if (!assigned[j]) {
3615 spec->multiout.dac_nids[i] =
3616 alc880_idx_to_dac(j);
3617 assigned[j] = 1;
3618 break;
3619 }
3620 }
3621 }
3622 spec->multiout.num_dacs = cfg->line_outs;
3623 return 0;
3624 }
3625
3626 /* add playback controls from the parsed DAC table */
3627 static int alc880_auto_create_multi_out_ctls(struct alc_spec *spec,
3628 const struct auto_pin_cfg *cfg)
3629 {
3630 char name[32];
3631 static const char *chname[4] = {
3632 "Front", "Surround", NULL /*CLFE*/, "Side"
3633 };
3634 hda_nid_t nid;
3635 int i, err;
3636
3637 for (i = 0; i < cfg->line_outs; i++) {
3638 if (!spec->multiout.dac_nids[i])
3639 continue;
3640 nid = alc880_idx_to_mixer(alc880_dac_to_idx(spec->multiout.dac_nids[i]));
3641 if (i == 2) {
3642 /* Center/LFE */
3643 err = add_control(spec, ALC_CTL_WIDGET_VOL,
3644 "Center Playback Volume",
3645 HDA_COMPOSE_AMP_VAL(nid, 1, 0,
3646 HDA_OUTPUT));
3647 if (err < 0)
3648 return err;
3649 err = add_control(spec, ALC_CTL_WIDGET_VOL,
3650 "LFE Playback Volume",
3651 HDA_COMPOSE_AMP_VAL(nid, 2, 0,
3652 HDA_OUTPUT));
3653 if (err < 0)
3654 return err;
3655 err = add_control(spec, ALC_CTL_BIND_MUTE,
3656 "Center Playback Switch",
3657 HDA_COMPOSE_AMP_VAL(nid, 1, 2,
3658 HDA_INPUT));
3659 if (err < 0)
3660 return err;
3661 err = add_control(spec, ALC_CTL_BIND_MUTE,
3662 "LFE Playback Switch",
3663 HDA_COMPOSE_AMP_VAL(nid, 2, 2,
3664 HDA_INPUT));
3665 if (err < 0)
3666 return err;
3667 } else {
3668 sprintf(name, "%s Playback Volume", chname[i]);
3669 err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
3670 HDA_COMPOSE_AMP_VAL(nid, 3, 0,
3671 HDA_OUTPUT));
3672 if (err < 0)
3673 return err;
3674 sprintf(name, "%s Playback Switch", chname[i]);
3675 err = add_control(spec, ALC_CTL_BIND_MUTE, name,
3676 HDA_COMPOSE_AMP_VAL(nid, 3, 2,
3677 HDA_INPUT));
3678 if (err < 0)
3679 return err;
3680 }
3681 }
3682 return 0;
3683 }
3684
3685 /* add playback controls for speaker and HP outputs */
3686 static int alc880_auto_create_extra_out(struct alc_spec *spec, hda_nid_t pin,
3687 const char *pfx)
3688 {
3689 hda_nid_t nid;
3690 int err;
3691 char name[32];
3692
3693 if (!pin)
3694 return 0;
3695
3696 if (alc880_is_fixed_pin(pin)) {
3697 nid = alc880_idx_to_dac(alc880_fixed_pin_idx(pin));
3698 /* specify the DAC as the extra output */
3699 if (!spec->multiout.hp_nid)
3700 spec->multiout.hp_nid = nid;
3701 else
3702 spec->multiout.extra_out_nid[0] = nid;
3703 /* control HP volume/switch on the output mixer amp */
3704 nid = alc880_idx_to_mixer(alc880_fixed_pin_idx(pin));
3705 sprintf(name, "%s Playback Volume", pfx);
3706 err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
3707 HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT));
3708 if (err < 0)
3709 return err;
3710 sprintf(name, "%s Playback Switch", pfx);
3711 err = add_control(spec, ALC_CTL_BIND_MUTE, name,
3712 HDA_COMPOSE_AMP_VAL(nid, 3, 2, HDA_INPUT));
3713 if (err < 0)
3714 return err;
3715 } else if (alc880_is_multi_pin(pin)) {
3716 /* set manual connection */
3717 /* we have only a switch on HP-out PIN */
3718 sprintf(name, "%s Playback Switch", pfx);
3719 err = add_control(spec, ALC_CTL_WIDGET_MUTE, name,
3720 HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
3721 if (err < 0)
3722 return err;
3723 }
3724 return 0;
3725 }
3726
3727 /* create input playback/capture controls for the given pin */
3728 static int new_analog_input(struct alc_spec *spec, hda_nid_t pin,
3729 const char *ctlname,
3730 int idx, hda_nid_t mix_nid)
3731 {
3732 char name[32];
3733 int err;
3734
3735 sprintf(name, "%s Playback Volume", ctlname);
3736 err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
3737 HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT));
3738 if (err < 0)
3739 return err;
3740 sprintf(name, "%s Playback Switch", ctlname);
3741 err = add_control(spec, ALC_CTL_WIDGET_MUTE, name,
3742 HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT));
3743 if (err < 0)
3744 return err;
3745 return 0;
3746 }
3747
3748 /* create playback/capture controls for input pins */
3749 static int alc880_auto_create_analog_input_ctls(struct alc_spec *spec,
3750 const struct auto_pin_cfg *cfg)
3751 {
3752 struct hda_input_mux *imux = &spec->private_imux;
3753 int i, err, idx;
3754
3755 for (i = 0; i < AUTO_PIN_LAST; i++) {
3756 if (alc880_is_input_pin(cfg->input_pins[i])) {
3757 idx = alc880_input_pin_idx(cfg->input_pins[i]);
3758 err = new_analog_input(spec, cfg->input_pins[i],
3759 auto_pin_cfg_labels[i],
3760 idx, 0x0b);
3761 if (err < 0)
3762 return err;
3763 imux->items[imux->num_items].label =
3764 auto_pin_cfg_labels[i];
3765 imux->items[imux->num_items].index =
3766 alc880_input_pin_idx(cfg->input_pins[i]);
3767 imux->num_items++;
3768 }
3769 }
3770 return 0;
3771 }
3772
3773 static void alc_set_pin_output(struct hda_codec *codec, hda_nid_t nid,
3774 unsigned int pin_type)
3775 {
3776 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
3777 pin_type);
3778 /* unmute pin */
3779 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE,
3780 AMP_OUT_UNMUTE);
3781 }
3782
3783 static void alc880_auto_set_output_and_unmute(struct hda_codec *codec,
3784 hda_nid_t nid, int pin_type,
3785 int dac_idx)
3786 {
3787 alc_set_pin_output(codec, nid, pin_type);
3788 /* need the manual connection? */
3789 if (alc880_is_multi_pin(nid)) {
3790 struct alc_spec *spec = codec->spec;
3791 int idx = alc880_multi_pin_idx(nid);
3792 snd_hda_codec_write(codec, alc880_idx_to_selector(idx), 0,
3793 AC_VERB_SET_CONNECT_SEL,
3794 alc880_dac_to_idx(spec->multiout.dac_nids[dac_idx]));
3795 }
3796 }
3797
3798 static int get_pin_type(int line_out_type)
3799 {
3800 if (line_out_type == AUTO_PIN_HP_OUT)
3801 return PIN_HP;
3802 else
3803 return PIN_OUT;
3804 }
3805
3806 static void alc880_auto_init_multi_out(struct hda_codec *codec)
3807 {
3808 struct alc_spec *spec = codec->spec;
3809 int i;
3810
3811 alc_subsystem_id(codec, 0x15, 0x1b, 0x14);
3812 for (i = 0; i < spec->autocfg.line_outs; i++) {
3813 hda_nid_t nid = spec->autocfg.line_out_pins[i];
3814 int pin_type = get_pin_type(spec->autocfg.line_out_type);
3815 alc880_auto_set_output_and_unmute(codec, nid, pin_type, i);
3816 }
3817 }
3818
3819 static void alc880_auto_init_extra_out(struct hda_codec *codec)
3820 {
3821 struct alc_spec *spec = codec->spec;
3822 hda_nid_t pin;
3823
3824 pin = spec->autocfg.speaker_pins[0];
3825 if (pin) /* connect to front */
3826 alc880_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
3827 pin = spec->autocfg.hp_pins[0];
3828 if (pin) /* connect to front */
3829 alc880_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
3830 }
3831
3832 static void alc880_auto_init_analog_input(struct hda_codec *codec)
3833 {
3834 struct alc_spec *spec = codec->spec;
3835 int i;
3836
3837 for (i = 0; i < AUTO_PIN_LAST; i++) {
3838 hda_nid_t nid = spec->autocfg.input_pins[i];
3839 if (alc880_is_input_pin(nid)) {
3840 snd_hda_codec_write(codec, nid, 0,
3841 AC_VERB_SET_PIN_WIDGET_CONTROL,
3842 i <= AUTO_PIN_FRONT_MIC ?
3843 PIN_VREF80 : PIN_IN);
3844 if (nid != ALC880_PIN_CD_NID)
3845 snd_hda_codec_write(codec, nid, 0,
3846 AC_VERB_SET_AMP_GAIN_MUTE,
3847 AMP_OUT_MUTE);
3848 }
3849 }
3850 }
3851
3852 /* parse the BIOS configuration and set up the alc_spec */
3853 /* return 1 if successful, 0 if the proper config is not found,
3854 * or a negative error code
3855 */
3856 static int alc880_parse_auto_config(struct hda_codec *codec)
3857 {
3858 struct alc_spec *spec = codec->spec;
3859 int err;
3860 static hda_nid_t alc880_ignore[] = { 0x1d, 0 };
3861
3862 err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
3863 alc880_ignore);
3864 if (err < 0)
3865 return err;
3866 if (!spec->autocfg.line_outs)
3867 return 0; /* can't find valid BIOS pin config */
3868
3869 err = alc880_auto_fill_dac_nids(spec, &spec->autocfg);
3870 if (err < 0)
3871 return err;
3872 err = alc880_auto_create_multi_out_ctls(spec, &spec->autocfg);
3873 if (err < 0)
3874 return err;
3875 err = alc880_auto_create_extra_out(spec,
3876 spec->autocfg.speaker_pins[0],
3877 "Speaker");
3878 if (err < 0)
3879 return err;
3880 err = alc880_auto_create_extra_out(spec, spec->autocfg.hp_pins[0],
3881 "Headphone");
3882 if (err < 0)
3883 return err;
3884 err = alc880_auto_create_analog_input_ctls(spec, &spec->autocfg);
3885 if (err < 0)
3886 return err;
3887
3888 spec->multiout.max_channels = spec->multiout.num_dacs * 2;
3889
3890 if (spec->autocfg.dig_out_pin)
3891 spec->multiout.dig_out_nid = ALC880_DIGOUT_NID;
3892 if (spec->autocfg.dig_in_pin)
3893 spec->dig_in_nid = ALC880_DIGIN_NID;
3894
3895 if (spec->kctl_alloc)
3896 spec->mixers[spec->num_mixers++] = spec->kctl_alloc;
3897
3898 spec->init_verbs[spec->num_init_verbs++] = alc880_volume_init_verbs;
3899
3900 spec->num_mux_defs = 1;
3901 spec->input_mux = &spec->private_imux;
3902
3903 store_pin_configs(codec);
3904 return 1;
3905 }
3906
3907 /* additional initialization for auto-configuration model */
3908 static void alc880_auto_init(struct hda_codec *codec)
3909 {
3910 struct alc_spec *spec = codec->spec;
3911 alc880_auto_init_multi_out(codec);
3912 alc880_auto_init_extra_out(codec);
3913 alc880_auto_init_analog_input(codec);
3914 if (spec->unsol_event)
3915 alc_inithook(codec);
3916 }
3917
3918 /*
3919 * OK, here we have finally the patch for ALC880
3920 */
3921
3922 static int patch_alc880(struct hda_codec *codec)
3923 {
3924 struct alc_spec *spec;
3925 int board_config;
3926 int err;
3927
3928 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
3929 if (spec == NULL)
3930 return -ENOMEM;
3931
3932 codec->spec = spec;
3933
3934 board_config = snd_hda_check_board_config(codec, ALC880_MODEL_LAST,
3935 alc880_models,
3936 alc880_cfg_tbl);
3937 if (board_config < 0) {
3938 printk(KERN_INFO "hda_codec: Unknown model for ALC880, "
3939 "trying auto-probe from BIOS...\n");
3940 board_config = ALC880_AUTO;
3941 }
3942
3943 if (board_config == ALC880_AUTO) {
3944 /* automatic parse from the BIOS config */
3945 err = alc880_parse_auto_config(codec);
3946 if (err < 0) {
3947 alc_free(codec);
3948 return err;
3949 } else if (!err) {
3950 printk(KERN_INFO
3951 "hda_codec: Cannot set up configuration "
3952 "from BIOS. Using 3-stack mode...\n");
3953 board_config = ALC880_3ST;
3954 }
3955 }
3956
3957 if (board_config != ALC880_AUTO)
3958 setup_preset(spec, &alc880_presets[board_config]);
3959
3960 spec->stream_name_analog = "ALC880 Analog";
3961 spec->stream_analog_playback = &alc880_pcm_analog_playback;
3962 spec->stream_analog_capture = &alc880_pcm_analog_capture;
3963 spec->stream_analog_alt_capture = &alc880_pcm_analog_alt_capture;
3964
3965 spec->stream_name_digital = "ALC880 Digital";
3966 spec->stream_digital_playback = &alc880_pcm_digital_playback;
3967 spec->stream_digital_capture = &alc880_pcm_digital_capture;
3968
3969 if (!spec->adc_nids && spec->input_mux) {
3970 /* check whether NID 0x07 is valid */
3971 unsigned int wcap = get_wcaps(codec, alc880_adc_nids[0]);
3972 /* get type */
3973 wcap = (wcap & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
3974 if (wcap != AC_WID_AUD_IN) {
3975 spec->adc_nids = alc880_adc_nids_alt;
3976 spec->num_adc_nids = ARRAY_SIZE(alc880_adc_nids_alt);
3977 spec->mixers[spec->num_mixers] =
3978 alc880_capture_alt_mixer;
3979 spec->num_mixers++;
3980 } else {
3981 spec->adc_nids = alc880_adc_nids;
3982 spec->num_adc_nids = ARRAY_SIZE(alc880_adc_nids);
3983 spec->mixers[spec->num_mixers] = alc880_capture_mixer;
3984 spec->num_mixers++;
3985 }
3986 }
3987
3988 spec->vmaster_nid = 0x0c;
3989
3990 codec->patch_ops = alc_patch_ops;
3991 if (board_config == ALC880_AUTO)
3992 spec->init_hook = alc880_auto_init;
3993 #ifdef CONFIG_SND_HDA_POWER_SAVE
3994 if (!spec->loopback.amplist)
3995 spec->loopback.amplist = alc880_loopbacks;
3996 #endif
3997
3998 return 0;
3999 }
4000
4001
4002 /*
4003 * ALC260 support
4004 */
4005
4006 static hda_nid_t alc260_dac_nids[1] = {
4007 /* front */
4008 0x02,
4009 };
4010
4011 static hda_nid_t alc260_adc_nids[1] = {
4012 /* ADC0 */
4013 0x04,
4014 };
4015
4016 static hda_nid_t alc260_adc_nids_alt[1] = {
4017 /* ADC1 */
4018 0x05,
4019 };
4020
4021 static hda_nid_t alc260_hp_adc_nids[2] = {
4022 /* ADC1, 0 */
4023 0x05, 0x04
4024 };
4025
4026 /* NIDs used when simultaneous access to both ADCs makes sense. Note that
4027 * alc260_capture_mixer assumes ADC0 (nid 0x04) is the first ADC.
4028 */
4029 static hda_nid_t alc260_dual_adc_nids[2] = {
4030 /* ADC0, ADC1 */
4031 0x04, 0x05
4032 };
4033
4034 #define ALC260_DIGOUT_NID 0x03
4035 #define ALC260_DIGIN_NID 0x06
4036
4037 static struct hda_input_mux alc260_capture_source = {
4038 .num_items = 4,
4039 .items = {
4040 { "Mic", 0x0 },
4041 { "Front Mic", 0x1 },
4042 { "Line", 0x2 },
4043 { "CD", 0x4 },
4044 },
4045 };
4046
4047 /* On Fujitsu S702x laptops capture only makes sense from Mic/LineIn jack,
4048 * headphone jack and the internal CD lines since these are the only pins at
4049 * which audio can appear. For flexibility, also allow the option of
4050 * recording the mixer output on the second ADC (ADC0 doesn't have a
4051 * connection to the mixer output).
4052 */
4053 static struct hda_input_mux alc260_fujitsu_capture_sources[2] = {
4054 {
4055 .num_items = 3,
4056 .items = {
4057 { "Mic/Line", 0x0 },
4058 { "CD", 0x4 },
4059 { "Headphone", 0x2 },
4060 },
4061 },
4062 {
4063 .num_items = 4,
4064 .items = {
4065 { "Mic/Line", 0x0 },
4066 { "CD", 0x4 },
4067 { "Headphone", 0x2 },
4068 { "Mixer", 0x5 },
4069 },
4070 },
4071
4072 };
4073
4074 /* Acer TravelMate(/Extensa/Aspire) notebooks have similar configuration to
4075 * the Fujitsu S702x, but jacks are marked differently.
4076 */
4077 static struct hda_input_mux alc260_acer_capture_sources[2] = {
4078 {
4079 .num_items = 4,
4080 .items = {
4081 { "Mic", 0x0 },
4082 { "Line", 0x2 },
4083 { "CD", 0x4 },
4084 { "Headphone", 0x5 },
4085 },
4086 },
4087 {
4088 .num_items = 5,
4089 .items = {
4090 { "Mic", 0x0 },
4091 { "Line", 0x2 },
4092 { "CD", 0x4 },
4093 { "Headphone", 0x6 },
4094 { "Mixer", 0x5 },
4095 },
4096 },
4097 };
4098 /*
4099 * This is just place-holder, so there's something for alc_build_pcms to look
4100 * at when it calculates the maximum number of channels. ALC260 has no mixer
4101 * element which allows changing the channel mode, so the verb list is
4102 * never used.
4103 */
4104 static struct hda_channel_mode alc260_modes[1] = {
4105 { 2, NULL },
4106 };
4107
4108
4109 /* Mixer combinations
4110 *
4111 * basic: base_output + input + pc_beep + capture
4112 * HP: base_output + input + capture_alt
4113 * HP_3013: hp_3013 + input + capture
4114 * fujitsu: fujitsu + capture
4115 * acer: acer + capture
4116 */
4117
4118 static struct snd_kcontrol_new alc260_base_output_mixer[] = {
4119 HDA_CODEC_VOLUME("Front Playback Volume", 0x08, 0x0, HDA_OUTPUT),
4120 HDA_BIND_MUTE("Front Playback Switch", 0x08, 2, HDA_INPUT),
4121 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x09, 0x0, HDA_OUTPUT),
4122 HDA_BIND_MUTE("Headphone Playback Switch", 0x09, 2, HDA_INPUT),
4123 HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT),
4124 HDA_BIND_MUTE_MONO("Mono Playback Switch", 0x0a, 1, 2, HDA_INPUT),
4125 { } /* end */
4126 };
4127
4128 static struct snd_kcontrol_new alc260_input_mixer[] = {
4129 HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
4130 HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
4131 HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
4132 HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
4133 HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
4134 HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
4135 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x07, 0x01, HDA_INPUT),
4136 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x07, 0x01, HDA_INPUT),
4137 { } /* end */
4138 };
4139
4140 static struct snd_kcontrol_new alc260_pc_beep_mixer[] = {
4141 HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x07, 0x05, HDA_INPUT),
4142 HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x07, 0x05, HDA_INPUT),
4143 { } /* end */
4144 };
4145
4146 /* update HP, line and mono out pins according to the master switch */
4147 static void alc260_hp_master_update(struct hda_codec *codec,
4148 hda_nid_t hp, hda_nid_t line,
4149 hda_nid_t mono)
4150 {
4151 struct alc_spec *spec = codec->spec;
4152 unsigned int val = spec->master_sw ? PIN_HP : 0;
4153 /* change HP and line-out pins */
4154 snd_hda_codec_write(codec, 0x0f, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
4155 val);
4156 snd_hda_codec_write(codec, 0x10, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
4157 val);
4158 /* mono (speaker) depending on the HP jack sense */
4159 val = (val && !spec->jack_present) ? PIN_OUT : 0;
4160 snd_hda_codec_write(codec, 0x11, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
4161 val);
4162 }
4163
4164 static int alc260_hp_master_sw_get(struct snd_kcontrol *kcontrol,
4165 struct snd_ctl_elem_value *ucontrol)
4166 {
4167 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
4168 struct alc_spec *spec = codec->spec;
4169 *ucontrol->value.integer.value = spec->master_sw;
4170 return 0;
4171 }
4172
4173 static int alc260_hp_master_sw_put(struct snd_kcontrol *kcontrol,
4174 struct snd_ctl_elem_value *ucontrol)
4175 {
4176 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
4177 struct alc_spec *spec = codec->spec;
4178 int val = !!*ucontrol->value.integer.value;
4179 hda_nid_t hp, line, mono;
4180
4181 if (val == spec->master_sw)
4182 return 0;
4183 spec->master_sw = val;
4184 hp = (kcontrol->private_value >> 16) & 0xff;
4185 line = (kcontrol->private_value >> 8) & 0xff;
4186 mono = kcontrol->private_value & 0xff;
4187 alc260_hp_master_update(codec, hp, line, mono);
4188 return 1;
4189 }
4190
4191 static struct snd_kcontrol_new alc260_hp_output_mixer[] = {
4192 {
4193 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
4194 .name = "Master Playback Switch",
4195 .info = snd_ctl_boolean_mono_info,
4196 .get = alc260_hp_master_sw_get,
4197 .put = alc260_hp_master_sw_put,
4198 .private_value = (0x0f << 16) | (0x10 << 8) | 0x11
4199 },
4200 HDA_CODEC_VOLUME("Front Playback Volume", 0x08, 0x0, HDA_OUTPUT),
4201 HDA_BIND_MUTE("Front Playback Switch", 0x08, 2, HDA_INPUT),
4202 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x09, 0x0, HDA_OUTPUT),
4203 HDA_BIND_MUTE("Headphone Playback Switch", 0x09, 2, HDA_INPUT),
4204 HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0a, 1, 0x0,
4205 HDA_OUTPUT),
4206 HDA_BIND_MUTE_MONO("Speaker Playback Switch", 0x0a, 1, 2, HDA_INPUT),
4207 { } /* end */
4208 };
4209
4210 static struct hda_verb alc260_hp_unsol_verbs[] = {
4211 {0x10, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
4212 {},
4213 };
4214
4215 static void alc260_hp_automute(struct hda_codec *codec)
4216 {
4217 struct alc_spec *spec = codec->spec;
4218 unsigned int present;
4219
4220 present = snd_hda_codec_read(codec, 0x10, 0,
4221 AC_VERB_GET_PIN_SENSE, 0);
4222 spec->jack_present = (present & AC_PINSENSE_PRESENCE) != 0;
4223 alc260_hp_master_update(codec, 0x0f, 0x10, 0x11);
4224 }
4225
4226 static void alc260_hp_unsol_event(struct hda_codec *codec, unsigned int res)
4227 {
4228 if ((res >> 26) == ALC880_HP_EVENT)
4229 alc260_hp_automute(codec);
4230 }
4231
4232 static struct snd_kcontrol_new alc260_hp_3013_mixer[] = {
4233 {
4234 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
4235 .name = "Master Playback Switch",
4236 .info = snd_ctl_boolean_mono_info,
4237 .get = alc260_hp_master_sw_get,
4238 .put = alc260_hp_master_sw_put,
4239 .private_value = (0x10 << 16) | (0x15 << 8) | 0x11
4240 },
4241 HDA_CODEC_VOLUME("Front Playback Volume", 0x09, 0x0, HDA_OUTPUT),
4242 HDA_CODEC_MUTE("Front Playback Switch", 0x10, 0x0, HDA_OUTPUT),
4243 HDA_CODEC_VOLUME("Aux-In Playback Volume", 0x07, 0x06, HDA_INPUT),
4244 HDA_CODEC_MUTE("Aux-In Playback Switch", 0x07, 0x06, HDA_INPUT),
4245 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x08, 0x0, HDA_OUTPUT),
4246 HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
4247 HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT),
4248 HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x11, 1, 0x0, HDA_OUTPUT),
4249 { } /* end */
4250 };
4251
4252 static struct hda_bind_ctls alc260_dc7600_bind_master_vol = {
4253 .ops = &snd_hda_bind_vol,
4254 .values = {
4255 HDA_COMPOSE_AMP_VAL(0x08, 3, 0, HDA_OUTPUT),
4256 HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_OUTPUT),
4257 HDA_COMPOSE_AMP_VAL(0x0a, 3, 0, HDA_OUTPUT),
4258 0
4259 },
4260 };
4261
4262 static struct hda_bind_ctls alc260_dc7600_bind_switch = {
4263 .ops = &snd_hda_bind_sw,
4264 .values = {
4265 HDA_COMPOSE_AMP_VAL(0x11, 3, 0, HDA_OUTPUT),
4266 HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT),
4267 0
4268 },
4269 };
4270
4271 static struct snd_kcontrol_new alc260_hp_dc7600_mixer[] = {
4272 HDA_BIND_VOL("Master Playback Volume", &alc260_dc7600_bind_master_vol),
4273 HDA_BIND_SW("LineOut Playback Switch", &alc260_dc7600_bind_switch),
4274 HDA_CODEC_MUTE("Speaker Playback Switch", 0x0f, 0x0, HDA_OUTPUT),
4275 HDA_CODEC_MUTE("Headphone Playback Switch", 0x10, 0x0, HDA_OUTPUT),
4276 { } /* end */
4277 };
4278
4279 static struct hda_verb alc260_hp_3013_unsol_verbs[] = {
4280 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
4281 {},
4282 };
4283
4284 static void alc260_hp_3013_automute(struct hda_codec *codec)
4285 {
4286 struct alc_spec *spec = codec->spec;
4287 unsigned int present;
4288
4289 present = snd_hda_codec_read(codec, 0x15, 0,
4290 AC_VERB_GET_PIN_SENSE, 0);
4291 spec->jack_present = (present & AC_PINSENSE_PRESENCE) != 0;
4292 alc260_hp_master_update(codec, 0x10, 0x15, 0x11);
4293 }
4294
4295 static void alc260_hp_3013_unsol_event(struct hda_codec *codec,
4296 unsigned int res)
4297 {
4298 if ((res >> 26) == ALC880_HP_EVENT)
4299 alc260_hp_3013_automute(codec);
4300 }
4301
4302 static void alc260_hp_3012_automute(struct hda_codec *codec)
4303 {
4304 unsigned int present, bits;
4305
4306 present = snd_hda_codec_read(codec, 0x10, 0,
4307 AC_VERB_GET_PIN_SENSE, 0) & AC_PINSENSE_PRESENCE;
4308
4309 bits = present ? 0 : PIN_OUT;
4310 snd_hda_codec_write(codec, 0x0f, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
4311 bits);
4312 snd_hda_codec_write(codec, 0x11, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
4313 bits);
4314 snd_hda_codec_write(codec, 0x15, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
4315 bits);
4316 }
4317
4318 static void alc260_hp_3012_unsol_event(struct hda_codec *codec,
4319 unsigned int res)
4320 {
4321 if ((res >> 26) == ALC880_HP_EVENT)
4322 alc260_hp_3012_automute(codec);
4323 }
4324
4325 /* Fujitsu S702x series laptops. ALC260 pin usage: Mic/Line jack = 0x12,
4326 * HP jack = 0x14, CD audio = 0x16, internal speaker = 0x10.
4327 */
4328 static struct snd_kcontrol_new alc260_fujitsu_mixer[] = {
4329 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x08, 0x0, HDA_OUTPUT),
4330 HDA_BIND_MUTE("Headphone Playback Switch", 0x08, 2, HDA_INPUT),
4331 ALC_PIN_MODE("Headphone Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
4332 HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
4333 HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
4334 HDA_CODEC_VOLUME("Mic/Line Playback Volume", 0x07, 0x0, HDA_INPUT),
4335 HDA_CODEC_MUTE("Mic/Line Playback Switch", 0x07, 0x0, HDA_INPUT),
4336 ALC_PIN_MODE("Mic/Line Jack Mode", 0x12, ALC_PIN_DIR_IN),
4337 HDA_CODEC_VOLUME("Beep Playback Volume", 0x07, 0x05, HDA_INPUT),
4338 HDA_CODEC_MUTE("Beep Playback Switch", 0x07, 0x05, HDA_INPUT),
4339 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x09, 0x0, HDA_OUTPUT),
4340 HDA_BIND_MUTE("Speaker Playback Switch", 0x09, 2, HDA_INPUT),
4341 { } /* end */
4342 };
4343
4344 /* Mixer for Acer TravelMate(/Extensa/Aspire) notebooks. Note that current
4345 * versions of the ALC260 don't act on requests to enable mic bias from NID
4346 * 0x0f (used to drive the headphone jack in these laptops). The ALC260
4347 * datasheet doesn't mention this restriction. At this stage it's not clear
4348 * whether this behaviour is intentional or is a hardware bug in chip
4349 * revisions available in early 2006. Therefore for now allow the
4350 * "Headphone Jack Mode" control to span all choices, but if it turns out
4351 * that the lack of mic bias for this NID is intentional we could change the
4352 * mode from ALC_PIN_DIR_INOUT to ALC_PIN_DIR_INOUT_NOMICBIAS.
4353 *
4354 * In addition, Acer TravelMate(/Extensa/Aspire) notebooks in early 2006
4355 * don't appear to make the mic bias available from the "line" jack, even
4356 * though the NID used for this jack (0x14) can supply it. The theory is
4357 * that perhaps Acer have included blocking capacitors between the ALC260
4358 * and the output jack. If this turns out to be the case for all such
4359 * models the "Line Jack Mode" mode could be changed from ALC_PIN_DIR_INOUT
4360 * to ALC_PIN_DIR_INOUT_NOMICBIAS.
4361 *
4362 * The C20x Tablet series have a mono internal speaker which is controlled
4363 * via the chip's Mono sum widget and pin complex, so include the necessary
4364 * controls for such models. On models without a "mono speaker" the control
4365 * won't do anything.
4366 */
4367 static struct snd_kcontrol_new alc260_acer_mixer[] = {
4368 HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT),
4369 HDA_BIND_MUTE("Master Playback Switch", 0x08, 2, HDA_INPUT),
4370 ALC_PIN_MODE("Headphone Jack Mode", 0x0f, ALC_PIN_DIR_INOUT),
4371 HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0a, 1, 0x0,
4372 HDA_OUTPUT),
4373 HDA_BIND_MUTE_MONO("Speaker Playback Switch", 0x0a, 1, 2,
4374 HDA_INPUT),
4375 HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
4376 HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
4377 HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
4378 HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
4379 ALC_PIN_MODE("Mic Jack Mode", 0x12, ALC_PIN_DIR_IN),
4380 HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
4381 HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
4382 ALC_PIN_MODE("Line Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
4383 HDA_CODEC_VOLUME("Beep Playback Volume", 0x07, 0x05, HDA_INPUT),
4384 HDA_CODEC_MUTE("Beep Playback Switch", 0x07, 0x05, HDA_INPUT),
4385 { } /* end */
4386 };
4387
4388 /* Packard bell V7900 ALC260 pin usage: HP = 0x0f, Mic jack = 0x12,
4389 * Line In jack = 0x14, CD audio = 0x16, pc beep = 0x17.
4390 */
4391 static struct snd_kcontrol_new alc260_will_mixer[] = {
4392 HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT),
4393 HDA_BIND_MUTE("Master Playback Switch", 0x08, 0x2, HDA_INPUT),
4394 HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
4395 HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
4396 ALC_PIN_MODE("Mic Jack Mode", 0x12, ALC_PIN_DIR_IN),
4397 HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
4398 HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
4399 ALC_PIN_MODE("Line Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
4400 HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
4401 HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
4402 HDA_CODEC_VOLUME("Beep Playback Volume", 0x07, 0x05, HDA_INPUT),
4403 HDA_CODEC_MUTE("Beep Playback Switch", 0x07, 0x05, HDA_INPUT),
4404 { } /* end */
4405 };
4406
4407 /* Replacer 672V ALC260 pin usage: Mic jack = 0x12,
4408 * Line In jack = 0x14, ATAPI Mic = 0x13, speaker = 0x0f.
4409 */
4410 static struct snd_kcontrol_new alc260_replacer_672v_mixer[] = {
4411 HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT),
4412 HDA_BIND_MUTE("Master Playback Switch", 0x08, 0x2, HDA_INPUT),
4413 HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
4414 HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
4415 ALC_PIN_MODE("Mic Jack Mode", 0x12, ALC_PIN_DIR_IN),
4416 HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x07, 0x1, HDA_INPUT),
4417 HDA_CODEC_MUTE("ATATI Mic Playback Switch", 0x07, 0x1, HDA_INPUT),
4418 HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
4419 HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
4420 ALC_PIN_MODE("Line Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
4421 { } /* end */
4422 };
4423
4424 /* capture mixer elements */
4425 static struct snd_kcontrol_new alc260_capture_mixer[] = {
4426 HDA_CODEC_VOLUME("Capture Volume", 0x04, 0x0, HDA_INPUT),
4427 HDA_CODEC_MUTE("Capture Switch", 0x04, 0x0, HDA_INPUT),
4428 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x05, 0x0, HDA_INPUT),
4429 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x05, 0x0, HDA_INPUT),
4430 {
4431 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
4432 /* The multiple "Capture Source" controls confuse alsamixer
4433 * So call somewhat different..
4434 */
4435 /* .name = "Capture Source", */
4436 .name = "Input Source",
4437 .count = 2,
4438 .info = alc_mux_enum_info,
4439 .get = alc_mux_enum_get,
4440 .put = alc_mux_enum_put,
4441 },
4442 { } /* end */
4443 };
4444
4445 static struct snd_kcontrol_new alc260_capture_alt_mixer[] = {
4446 HDA_CODEC_VOLUME("Capture Volume", 0x05, 0x0, HDA_INPUT),
4447 HDA_CODEC_MUTE("Capture Switch", 0x05, 0x0, HDA_INPUT),
4448 {
4449 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
4450 /* The multiple "Capture Source" controls confuse alsamixer
4451 * So call somewhat different..
4452 */
4453 /* .name = "Capture Source", */
4454 .name = "Input Source",
4455 .count = 1,
4456 .info = alc_mux_enum_info,
4457 .get = alc_mux_enum_get,
4458 .put = alc_mux_enum_put,
4459 },
4460 { } /* end */
4461 };
4462
4463 /*
4464 * initialization verbs
4465 */
4466 static struct hda_verb alc260_init_verbs[] = {
4467 /* Line In pin widget for input */
4468 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
4469 /* CD pin widget for input */
4470 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
4471 /* Mic1 (rear panel) pin widget for input and vref at 80% */
4472 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
4473 /* Mic2 (front panel) pin widget for input and vref at 80% */
4474 {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
4475 /* LINE-2 is used for line-out in rear */
4476 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4477 /* select line-out */
4478 {0x0e, AC_VERB_SET_CONNECT_SEL, 0x00},
4479 /* LINE-OUT pin */
4480 {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4481 /* enable HP */
4482 {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
4483 /* enable Mono */
4484 {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4485 /* mute capture amp left and right */
4486 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4487 /* set connection select to line in (default select for this ADC) */
4488 {0x04, AC_VERB_SET_CONNECT_SEL, 0x02},
4489 /* mute capture amp left and right */
4490 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4491 /* set connection select to line in (default select for this ADC) */
4492 {0x05, AC_VERB_SET_CONNECT_SEL, 0x02},
4493 /* set vol=0 Line-Out mixer amp left and right */
4494 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4495 /* unmute pin widget amp left and right (no gain on this amp) */
4496 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4497 /* set vol=0 HP mixer amp left and right */
4498 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4499 /* unmute pin widget amp left and right (no gain on this amp) */
4500 {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4501 /* set vol=0 Mono mixer amp left and right */
4502 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4503 /* unmute pin widget amp left and right (no gain on this amp) */
4504 {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4505 /* unmute LINE-2 out pin */
4506 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4507 /* Amp Indexes: CD = 0x04, Line In 1 = 0x02, Mic 1 = 0x00 &
4508 * Line In 2 = 0x03
4509 */
4510 /* mute analog inputs */
4511 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4512 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4513 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
4514 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
4515 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
4516 /* Amp Indexes: DAC = 0x01 & mixer = 0x00 */
4517 /* mute Front out path */
4518 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4519 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4520 /* mute Headphone out path */
4521 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4522 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4523 /* mute Mono out path */
4524 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4525 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4526 { }
4527 };
4528
4529 #if 0 /* should be identical with alc260_init_verbs? */
4530 static struct hda_verb alc260_hp_init_verbs[] = {
4531 /* Headphone and output */
4532 {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
4533 /* mono output */
4534 {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
4535 /* Mic1 (rear panel) pin widget for input and vref at 80% */
4536 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
4537 /* Mic2 (front panel) pin widget for input and vref at 80% */
4538 {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
4539 /* Line In pin widget for input */
4540 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
4541 /* Line-2 pin widget for output */
4542 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
4543 /* CD pin widget for input */
4544 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
4545 /* unmute amp left and right */
4546 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000},
4547 /* set connection select to line in (default select for this ADC) */
4548 {0x04, AC_VERB_SET_CONNECT_SEL, 0x02},
4549 /* unmute Line-Out mixer amp left and right (volume = 0) */
4550 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
4551 /* mute pin widget amp left and right (no gain on this amp) */
4552 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
4553 /* unmute HP mixer amp left and right (volume = 0) */
4554 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
4555 /* mute pin widget amp left and right (no gain on this amp) */
4556 {0x10, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
4557 /* Amp Indexes: CD = 0x04, Line In 1 = 0x02, Mic 1 = 0x00 &
4558 * Line In 2 = 0x03
4559 */
4560 /* mute analog inputs */
4561 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4562 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4563 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
4564 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
4565 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
4566 /* Amp Indexes: DAC = 0x01 & mixer = 0x00 */
4567 /* Unmute Front out path */
4568 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
4569 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
4570 /* Unmute Headphone out path */
4571 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
4572 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
4573 /* Unmute Mono out path */
4574 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
4575 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
4576 { }
4577 };
4578 #endif
4579
4580 static struct hda_verb alc260_hp_3013_init_verbs[] = {
4581 /* Line out and output */
4582 {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
4583 /* mono output */
4584 {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
4585 /* Mic1 (rear panel) pin widget for input and vref at 80% */
4586 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
4587 /* Mic2 (front panel) pin widget for input and vref at 80% */
4588 {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
4589 /* Line In pin widget for input */
4590 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
4591 /* Headphone pin widget for output */
4592 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
4593 /* CD pin widget for input */
4594 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
4595 /* unmute amp left and right */
4596 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000},
4597 /* set connection select to line in (default select for this ADC) */
4598 {0x04, AC_VERB_SET_CONNECT_SEL, 0x02},
4599 /* unmute Line-Out mixer amp left and right (volume = 0) */
4600 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
4601 /* mute pin widget amp left and right (no gain on this amp) */
4602 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
4603 /* unmute HP mixer amp left and right (volume = 0) */
4604 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
4605 /* mute pin widget amp left and right (no gain on this amp) */
4606 {0x10, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
4607 /* Amp Indexes: CD = 0x04, Line In 1 = 0x02, Mic 1 = 0x00 &
4608 * Line In 2 = 0x03
4609 */
4610 /* mute analog inputs */
4611 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4612 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4613 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
4614 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
4615 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
4616 /* Amp Indexes: DAC = 0x01 & mixer = 0x00 */
4617 /* Unmute Front out path */
4618 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
4619 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
4620 /* Unmute Headphone out path */
4621 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
4622 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
4623 /* Unmute Mono out path */
4624 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
4625 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
4626 { }
4627 };
4628
4629 /* Initialisation sequence for ALC260 as configured in Fujitsu S702x
4630 * laptops. ALC260 pin usage: Mic/Line jack = 0x12, HP jack = 0x14, CD
4631 * audio = 0x16, internal speaker = 0x10.
4632 */
4633 static struct hda_verb alc260_fujitsu_init_verbs[] = {
4634 /* Disable all GPIOs */
4635 {0x01, AC_VERB_SET_GPIO_MASK, 0},
4636 /* Internal speaker is connected to headphone pin */
4637 {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
4638 /* Headphone/Line-out jack connects to Line1 pin; make it an output */
4639 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4640 /* Mic/Line-in jack is connected to mic1 pin, so make it an input */
4641 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
4642 /* Ensure all other unused pins are disabled and muted. */
4643 {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
4644 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4645 {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
4646 {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4647 {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
4648 {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4649 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
4650 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4651
4652 /* Disable digital (SPDIF) pins */
4653 {0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
4654 {0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
4655
4656 /* Ensure Line1 pin widget takes its input from the OUT1 sum bus
4657 * when acting as an output.
4658 */
4659 {0x0d, AC_VERB_SET_CONNECT_SEL, 0},
4660
4661 /* Start with output sum widgets muted and their output gains at min */
4662 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4663 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4664 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4665 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4666 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4667 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4668 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4669 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4670 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4671
4672 /* Unmute HP pin widget amp left and right (no equiv mixer ctrl) */
4673 {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4674 /* Unmute Line1 pin widget output buffer since it starts as an output.
4675 * If the pin mode is changed by the user the pin mode control will
4676 * take care of enabling the pin's input/output buffers as needed.
4677 * Therefore there's no need to enable the input buffer at this
4678 * stage.
4679 */
4680 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4681 /* Unmute input buffer of pin widget used for Line-in (no equiv
4682 * mixer ctrl)
4683 */
4684 {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4685
4686 /* Mute capture amp left and right */
4687 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4688 /* Set ADC connection select to match default mixer setting - line
4689 * in (on mic1 pin)
4690 */
4691 {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
4692
4693 /* Do the same for the second ADC: mute capture input amp and
4694 * set ADC connection to line in (on mic1 pin)
4695 */
4696 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4697 {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
4698
4699 /* Mute all inputs to mixer widget (even unconnected ones) */
4700 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
4701 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
4702 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
4703 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
4704 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
4705 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
4706 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
4707 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
4708
4709 { }
4710 };
4711
4712 /* Initialisation sequence for ALC260 as configured in Acer TravelMate and
4713 * similar laptops (adapted from Fujitsu init verbs).
4714 */
4715 static struct hda_verb alc260_acer_init_verbs[] = {
4716 /* On TravelMate laptops, GPIO 0 enables the internal speaker and
4717 * the headphone jack. Turn this on and rely on the standard mute
4718 * methods whenever the user wants to turn these outputs off.
4719 */
4720 {0x01, AC_VERB_SET_GPIO_MASK, 0x01},
4721 {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
4722 {0x01, AC_VERB_SET_GPIO_DATA, 0x01},
4723 /* Internal speaker/Headphone jack is connected to Line-out pin */
4724 {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
4725 /* Internal microphone/Mic jack is connected to Mic1 pin */
4726 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
4727 /* Line In jack is connected to Line1 pin */
4728 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
4729 /* Some Acers (eg: C20x Tablets) use Mono pin for internal speaker */
4730 {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
4731 /* Ensure all other unused pins are disabled and muted. */
4732 {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
4733 {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4734 {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
4735 {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4736 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
4737 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4738 /* Disable digital (SPDIF) pins */
4739 {0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
4740 {0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
4741
4742 /* Ensure Mic1 and Line1 pin widgets take input from the OUT1 sum
4743 * bus when acting as outputs.
4744 */
4745 {0x0b, AC_VERB_SET_CONNECT_SEL, 0},
4746 {0x0d, AC_VERB_SET_CONNECT_SEL, 0},
4747
4748 /* Start with output sum widgets muted and their output gains at min */
4749 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4750 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4751 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4752 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4753 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4754 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4755 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4756 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4757 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4758
4759 /* Unmute Line-out pin widget amp left and right
4760 * (no equiv mixer ctrl)
4761 */
4762 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4763 /* Unmute mono pin widget amp output (no equiv mixer ctrl) */
4764 {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4765 /* Unmute Mic1 and Line1 pin widget input buffers since they start as
4766 * inputs. If the pin mode is changed by the user the pin mode control
4767 * will take care of enabling the pin's input/output buffers as needed.
4768 * Therefore there's no need to enable the input buffer at this
4769 * stage.
4770 */
4771 {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4772 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4773
4774 /* Mute capture amp left and right */
4775 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4776 /* Set ADC connection select to match default mixer setting - mic
4777 * (on mic1 pin)
4778 */
4779 {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
4780
4781 /* Do similar with the second ADC: mute capture input amp and
4782 * set ADC connection to mic to match ALSA's default state.
4783 */
4784 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4785 {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
4786
4787 /* Mute all inputs to mixer widget (even unconnected ones) */
4788 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
4789 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
4790 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
4791 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
4792 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
4793 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
4794 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
4795 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
4796
4797 { }
4798 };
4799
4800 static struct hda_verb alc260_will_verbs[] = {
4801 {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
4802 {0x0b, AC_VERB_SET_CONNECT_SEL, 0x00},
4803 {0x0d, AC_VERB_SET_CONNECT_SEL, 0x00},
4804 {0x0f, AC_VERB_SET_EAPD_BTLENABLE, 0x02},
4805 {0x1a, AC_VERB_SET_COEF_INDEX, 0x07},
4806 {0x1a, AC_VERB_SET_PROC_COEF, 0x3040},
4807 {}
4808 };
4809
4810 static struct hda_verb alc260_replacer_672v_verbs[] = {
4811 {0x0f, AC_VERB_SET_EAPD_BTLENABLE, 0x02},
4812 {0x1a, AC_VERB_SET_COEF_INDEX, 0x07},
4813 {0x1a, AC_VERB_SET_PROC_COEF, 0x3050},
4814
4815 {0x01, AC_VERB_SET_GPIO_MASK, 0x01},
4816 {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
4817 {0x01, AC_VERB_SET_GPIO_DATA, 0x00},
4818
4819 {0x0f, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
4820 {}
4821 };
4822
4823 /* toggle speaker-output according to the hp-jack state */
4824 static void alc260_replacer_672v_automute(struct hda_codec *codec)
4825 {
4826 unsigned int present;
4827
4828 /* speaker --> GPIO Data 0, hp or spdif --> GPIO data 1 */
4829 present = snd_hda_codec_read(codec, 0x0f, 0,
4830 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
4831 if (present) {
4832 snd_hda_codec_write_cache(codec, 0x01, 0,
4833 AC_VERB_SET_GPIO_DATA, 1);
4834 snd_hda_codec_write_cache(codec, 0x0f, 0,
4835 AC_VERB_SET_PIN_WIDGET_CONTROL,
4836 PIN_HP);
4837 } else {
4838 snd_hda_codec_write_cache(codec, 0x01, 0,
4839 AC_VERB_SET_GPIO_DATA, 0);
4840 snd_hda_codec_write_cache(codec, 0x0f, 0,
4841 AC_VERB_SET_PIN_WIDGET_CONTROL,
4842 PIN_OUT);
4843 }
4844 }
4845
4846 static void alc260_replacer_672v_unsol_event(struct hda_codec *codec,
4847 unsigned int res)
4848 {
4849 if ((res >> 26) == ALC880_HP_EVENT)
4850 alc260_replacer_672v_automute(codec);
4851 }
4852
4853 static struct hda_verb alc260_hp_dc7600_verbs[] = {
4854 {0x05, AC_VERB_SET_CONNECT_SEL, 0x01},
4855 {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
4856 {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4857 {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
4858 {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4859 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4860 {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
4861 {0x10, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
4862 {0x11, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
4863 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
4864 {}
4865 };
4866
4867 /* Test configuration for debugging, modelled after the ALC880 test
4868 * configuration.
4869 */
4870 #ifdef CONFIG_SND_DEBUG
4871 static hda_nid_t alc260_test_dac_nids[1] = {
4872 0x02,
4873 };
4874 static hda_nid_t alc260_test_adc_nids[2] = {
4875 0x04, 0x05,
4876 };
4877 /* For testing the ALC260, each input MUX needs its own definition since
4878 * the signal assignments are different. This assumes that the first ADC
4879 * is NID 0x04.
4880 */
4881 static struct hda_input_mux alc260_test_capture_sources[2] = {
4882 {
4883 .num_items = 7,
4884 .items = {
4885 { "MIC1 pin", 0x0 },
4886 { "MIC2 pin", 0x1 },
4887 { "LINE1 pin", 0x2 },
4888 { "LINE2 pin", 0x3 },
4889 { "CD pin", 0x4 },
4890 { "LINE-OUT pin", 0x5 },
4891 { "HP-OUT pin", 0x6 },
4892 },
4893 },
4894 {
4895 .num_items = 8,
4896 .items = {
4897 { "MIC1 pin", 0x0 },
4898 { "MIC2 pin", 0x1 },
4899 { "LINE1 pin", 0x2 },
4900 { "LINE2 pin", 0x3 },
4901 { "CD pin", 0x4 },
4902 { "Mixer", 0x5 },
4903 { "LINE-OUT pin", 0x6 },
4904 { "HP-OUT pin", 0x7 },
4905 },
4906 },
4907 };
4908 static struct snd_kcontrol_new alc260_test_mixer[] = {
4909 /* Output driver widgets */
4910 HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT),
4911 HDA_BIND_MUTE_MONO("Mono Playback Switch", 0x0a, 1, 2, HDA_INPUT),
4912 HDA_CODEC_VOLUME("LOUT2 Playback Volume", 0x09, 0x0, HDA_OUTPUT),
4913 HDA_BIND_MUTE("LOUT2 Playback Switch", 0x09, 2, HDA_INPUT),
4914 HDA_CODEC_VOLUME("LOUT1 Playback Volume", 0x08, 0x0, HDA_OUTPUT),
4915 HDA_BIND_MUTE("LOUT1 Playback Switch", 0x08, 2, HDA_INPUT),
4916
4917 /* Modes for retasking pin widgets
4918 * Note: the ALC260 doesn't seem to act on requests to enable mic
4919 * bias from NIDs 0x0f and 0x10. The ALC260 datasheet doesn't
4920 * mention this restriction. At this stage it's not clear whether
4921 * this behaviour is intentional or is a hardware bug in chip
4922 * revisions available at least up until early 2006. Therefore for
4923 * now allow the "HP-OUT" and "LINE-OUT" Mode controls to span all
4924 * choices, but if it turns out that the lack of mic bias for these
4925 * NIDs is intentional we could change their modes from
4926 * ALC_PIN_DIR_INOUT to ALC_PIN_DIR_INOUT_NOMICBIAS.
4927 */
4928 ALC_PIN_MODE("HP-OUT pin mode", 0x10, ALC_PIN_DIR_INOUT),
4929 ALC_PIN_MODE("LINE-OUT pin mode", 0x0f, ALC_PIN_DIR_INOUT),
4930 ALC_PIN_MODE("LINE2 pin mode", 0x15, ALC_PIN_DIR_INOUT),
4931 ALC_PIN_MODE("LINE1 pin mode", 0x14, ALC_PIN_DIR_INOUT),
4932 ALC_PIN_MODE("MIC2 pin mode", 0x13, ALC_PIN_DIR_INOUT),
4933 ALC_PIN_MODE("MIC1 pin mode", 0x12, ALC_PIN_DIR_INOUT),
4934
4935 /* Loopback mixer controls */
4936 HDA_CODEC_VOLUME("MIC1 Playback Volume", 0x07, 0x00, HDA_INPUT),
4937 HDA_CODEC_MUTE("MIC1 Playback Switch", 0x07, 0x00, HDA_INPUT),
4938 HDA_CODEC_VOLUME("MIC2 Playback Volume", 0x07, 0x01, HDA_INPUT),
4939 HDA_CODEC_MUTE("MIC2 Playback Switch", 0x07, 0x01, HDA_INPUT),
4940 HDA_CODEC_VOLUME("LINE1 Playback Volume", 0x07, 0x02, HDA_INPUT),
4941 HDA_CODEC_MUTE("LINE1 Playback Switch", 0x07, 0x02, HDA_INPUT),
4942 HDA_CODEC_VOLUME("LINE2 Playback Volume", 0x07, 0x03, HDA_INPUT),
4943 HDA_CODEC_MUTE("LINE2 Playback Switch", 0x07, 0x03, HDA_INPUT),
4944 HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
4945 HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
4946 HDA_CODEC_VOLUME("Beep Playback Volume", 0x07, 0x05, HDA_INPUT),
4947 HDA_CODEC_MUTE("Beep Playback Switch", 0x07, 0x05, HDA_INPUT),
4948 HDA_CODEC_VOLUME("LINE-OUT loopback Playback Volume", 0x07, 0x06, HDA_INPUT),
4949 HDA_CODEC_MUTE("LINE-OUT loopback Playback Switch", 0x07, 0x06, HDA_INPUT),
4950 HDA_CODEC_VOLUME("HP-OUT loopback Playback Volume", 0x07, 0x7, HDA_INPUT),
4951 HDA_CODEC_MUTE("HP-OUT loopback Playback Switch", 0x07, 0x7, HDA_INPUT),
4952
4953 /* Controls for GPIO pins, assuming they are configured as outputs */
4954 ALC_GPIO_DATA_SWITCH("GPIO pin 0", 0x01, 0x01),
4955 ALC_GPIO_DATA_SWITCH("GPIO pin 1", 0x01, 0x02),
4956 ALC_GPIO_DATA_SWITCH("GPIO pin 2", 0x01, 0x04),
4957 ALC_GPIO_DATA_SWITCH("GPIO pin 3", 0x01, 0x08),
4958
4959 /* Switches to allow the digital IO pins to be enabled. The datasheet
4960 * is ambigious as to which NID is which; testing on laptops which
4961 * make this output available should provide clarification.
4962 */
4963 ALC_SPDIF_CTRL_SWITCH("SPDIF Playback Switch", 0x03, 0x01),
4964 ALC_SPDIF_CTRL_SWITCH("SPDIF Capture Switch", 0x06, 0x01),
4965
4966 /* A switch allowing EAPD to be enabled. Some laptops seem to use
4967 * this output to turn on an external amplifier.
4968 */
4969 ALC_EAPD_CTRL_SWITCH("LINE-OUT EAPD Enable Switch", 0x0f, 0x02),
4970 ALC_EAPD_CTRL_SWITCH("HP-OUT EAPD Enable Switch", 0x10, 0x02),
4971
4972 { } /* end */
4973 };
4974 static struct hda_verb alc260_test_init_verbs[] = {
4975 /* Enable all GPIOs as outputs with an initial value of 0 */
4976 {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x0f},
4977 {0x01, AC_VERB_SET_GPIO_DATA, 0x00},
4978 {0x01, AC_VERB_SET_GPIO_MASK, 0x0f},
4979
4980 /* Enable retasking pins as output, initially without power amp */
4981 {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4982 {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4983 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4984 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4985 {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4986 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4987
4988 /* Disable digital (SPDIF) pins initially, but users can enable
4989 * them via a mixer switch. In the case of SPDIF-out, this initverb
4990 * payload also sets the generation to 0, output to be in "consumer"
4991 * PCM format, copyright asserted, no pre-emphasis and no validity
4992 * control.
4993 */
4994 {0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
4995 {0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
4996
4997 /* Ensure mic1, mic2, line1 and line2 pin widgets take input from the
4998 * OUT1 sum bus when acting as an output.
4999 */
5000 {0x0b, AC_VERB_SET_CONNECT_SEL, 0},
5001 {0x0c, AC_VERB_SET_CONNECT_SEL, 0},
5002 {0x0d, AC_VERB_SET_CONNECT_SEL, 0},
5003 {0x0e, AC_VERB_SET_CONNECT_SEL, 0},
5004
5005 /* Start with output sum widgets muted and their output gains at min */
5006 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5007 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5008 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5009 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5010 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5011 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5012 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5013 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5014 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5015
5016 /* Unmute retasking pin widget output buffers since the default
5017 * state appears to be output. As the pin mode is changed by the
5018 * user the pin mode control will take care of enabling the pin's
5019 * input/output buffers as needed.
5020 */
5021 {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5022 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5023 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5024 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5025 {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5026 {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5027 /* Also unmute the mono-out pin widget */
5028 {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5029
5030 /* Mute capture amp left and right */
5031 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5032 /* Set ADC connection select to match default mixer setting (mic1
5033 * pin)
5034 */
5035 {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
5036
5037 /* Do the same for the second ADC: mute capture input amp and
5038 * set ADC connection to mic1 pin
5039 */
5040 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5041 {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
5042
5043 /* Mute all inputs to mixer widget (even unconnected ones) */
5044 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
5045 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
5046 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
5047 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
5048 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
5049 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
5050 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
5051 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
5052
5053 { }
5054 };
5055 #endif
5056
5057 #define alc260_pcm_analog_playback alc880_pcm_analog_alt_playback
5058 #define alc260_pcm_analog_capture alc880_pcm_analog_capture
5059
5060 #define alc260_pcm_digital_playback alc880_pcm_digital_playback
5061 #define alc260_pcm_digital_capture alc880_pcm_digital_capture
5062
5063 /*
5064 * for BIOS auto-configuration
5065 */
5066
5067 static int alc260_add_playback_controls(struct alc_spec *spec, hda_nid_t nid,
5068 const char *pfx, int *vol_bits)
5069 {
5070 hda_nid_t nid_vol;
5071 unsigned long vol_val, sw_val;
5072 char name[32];
5073 int err;
5074
5075 if (nid >= 0x0f && nid < 0x11) {
5076 nid_vol = nid - 0x7;
5077 vol_val = HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, HDA_OUTPUT);
5078 sw_val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
5079 } else if (nid == 0x11) {
5080 nid_vol = nid - 0x7;
5081 vol_val = HDA_COMPOSE_AMP_VAL(nid_vol, 2, 0, HDA_OUTPUT);
5082 sw_val = HDA_COMPOSE_AMP_VAL(nid, 2, 0, HDA_OUTPUT);
5083 } else if (nid >= 0x12 && nid <= 0x15) {
5084 nid_vol = 0x08;
5085 vol_val = HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, HDA_OUTPUT);
5086 sw_val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
5087 } else
5088 return 0; /* N/A */
5089
5090 if (!(*vol_bits & (1 << nid_vol))) {
5091 /* first control for the volume widget */
5092 snprintf(name, sizeof(name), "%s Playback Volume", pfx);
5093 err = add_control(spec, ALC_CTL_WIDGET_VOL, name, vol_val);
5094 if (err < 0)
5095 return err;
5096 *vol_bits |= (1 << nid_vol);
5097 }
5098 snprintf(name, sizeof(name), "%s Playback Switch", pfx);
5099 err = add_control(spec, ALC_CTL_WIDGET_MUTE, name, sw_val);
5100 if (err < 0)
5101 return err;
5102 return 1;
5103 }
5104
5105 /* add playback controls from the parsed DAC table */
5106 static int alc260_auto_create_multi_out_ctls(struct alc_spec *spec,
5107 const struct auto_pin_cfg *cfg)
5108 {
5109 hda_nid_t nid;
5110 int err;
5111 int vols = 0;
5112
5113 spec->multiout.num_dacs = 1;
5114 spec->multiout.dac_nids = spec->private_dac_nids;
5115 spec->multiout.dac_nids[0] = 0x02;
5116
5117 nid = cfg->line_out_pins[0];
5118 if (nid) {
5119 err = alc260_add_playback_controls(spec, nid, "Front", &vols);
5120 if (err < 0)
5121 return err;
5122 }
5123
5124 nid = cfg->speaker_pins[0];
5125 if (nid) {
5126 err = alc260_add_playback_controls(spec, nid, "Speaker", &vols);
5127 if (err < 0)
5128 return err;
5129 }
5130
5131 nid = cfg->hp_pins[0];
5132 if (nid) {
5133 err = alc260_add_playback_controls(spec, nid, "Headphone",
5134 &vols);
5135 if (err < 0)
5136 return err;
5137 }
5138 return 0;
5139 }
5140
5141 /* create playback/capture controls for input pins */
5142 static int alc260_auto_create_analog_input_ctls(struct alc_spec *spec,
5143 const struct auto_pin_cfg *cfg)
5144 {
5145 struct hda_input_mux *imux = &spec->private_imux;
5146 int i, err, idx;
5147
5148 for (i = 0; i < AUTO_PIN_LAST; i++) {
5149 if (cfg->input_pins[i] >= 0x12) {
5150 idx = cfg->input_pins[i] - 0x12;
5151 err = new_analog_input(spec, cfg->input_pins[i],
5152 auto_pin_cfg_labels[i], idx,
5153 0x07);
5154 if (err < 0)
5155 return err;
5156 imux->items[imux->num_items].label =
5157 auto_pin_cfg_labels[i];
5158 imux->items[imux->num_items].index = idx;
5159 imux->num_items++;
5160 }
5161 if (cfg->input_pins[i] >= 0x0f && cfg->input_pins[i] <= 0x10){
5162 idx = cfg->input_pins[i] - 0x09;
5163 err = new_analog_input(spec, cfg->input_pins[i],
5164 auto_pin_cfg_labels[i], idx,
5165 0x07);
5166 if (err < 0)
5167 return err;
5168 imux->items[imux->num_items].label =
5169 auto_pin_cfg_labels[i];
5170 imux->items[imux->num_items].index = idx;
5171 imux->num_items++;
5172 }
5173 }
5174 return 0;
5175 }
5176
5177 static void alc260_auto_set_output_and_unmute(struct hda_codec *codec,
5178 hda_nid_t nid, int pin_type,
5179 int sel_idx)
5180 {
5181 alc_set_pin_output(codec, nid, pin_type);
5182 /* need the manual connection? */
5183 if (nid >= 0x12) {
5184 int idx = nid - 0x12;
5185 snd_hda_codec_write(codec, idx + 0x0b, 0,
5186 AC_VERB_SET_CONNECT_SEL, sel_idx);
5187 }
5188 }
5189
5190 static void alc260_auto_init_multi_out(struct hda_codec *codec)
5191 {
5192 struct alc_spec *spec = codec->spec;
5193 hda_nid_t nid;
5194
5195 alc_subsystem_id(codec, 0x10, 0x15, 0x0f);
5196 nid = spec->autocfg.line_out_pins[0];
5197 if (nid) {
5198 int pin_type = get_pin_type(spec->autocfg.line_out_type);
5199 alc260_auto_set_output_and_unmute(codec, nid, pin_type, 0);
5200 }
5201
5202 nid = spec->autocfg.speaker_pins[0];
5203 if (nid)
5204 alc260_auto_set_output_and_unmute(codec, nid, PIN_OUT, 0);
5205
5206 nid = spec->autocfg.hp_pins[0];
5207 if (nid)
5208 alc260_auto_set_output_and_unmute(codec, nid, PIN_HP, 0);
5209 }
5210
5211 #define ALC260_PIN_CD_NID 0x16
5212 static void alc260_auto_init_analog_input(struct hda_codec *codec)
5213 {
5214 struct alc_spec *spec = codec->spec;
5215 int i;
5216
5217 for (i = 0; i < AUTO_PIN_LAST; i++) {
5218 hda_nid_t nid = spec->autocfg.input_pins[i];
5219 if (nid >= 0x12) {
5220 snd_hda_codec_write(codec, nid, 0,
5221 AC_VERB_SET_PIN_WIDGET_CONTROL,
5222 i <= AUTO_PIN_FRONT_MIC ?
5223 PIN_VREF80 : PIN_IN);
5224 if (nid != ALC260_PIN_CD_NID)
5225 snd_hda_codec_write(codec, nid, 0,
5226 AC_VERB_SET_AMP_GAIN_MUTE,
5227 AMP_OUT_MUTE);
5228 }
5229 }
5230 }
5231
5232 /*
5233 * generic initialization of ADC, input mixers and output mixers
5234 */
5235 static struct hda_verb alc260_volume_init_verbs[] = {
5236 /*
5237 * Unmute ADC0-1 and set the default input to mic-in
5238 */
5239 {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
5240 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5241 {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
5242 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5243
5244 /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
5245 * mixer widget
5246 * Note: PASD motherboards uses the Line In 2 as the input for
5247 * front panel mic (mic 2)
5248 */
5249 /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
5250 /* mute analog inputs */
5251 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5252 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5253 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
5254 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
5255 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
5256
5257 /*
5258 * Set up output mixers (0x08 - 0x0a)
5259 */
5260 /* set vol=0 to output mixers */
5261 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5262 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5263 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5264 /* set up input amps for analog loopback */
5265 /* Amp Indices: DAC = 0, mixer = 1 */
5266 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5267 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
5268 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5269 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
5270 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5271 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
5272
5273 { }
5274 };
5275
5276 static int alc260_parse_auto_config(struct hda_codec *codec)
5277 {
5278 struct alc_spec *spec = codec->spec;
5279 unsigned int wcap;
5280 int err;
5281 static hda_nid_t alc260_ignore[] = { 0x17, 0 };
5282
5283 err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
5284 alc260_ignore);
5285 if (err < 0)
5286 return err;
5287 err = alc260_auto_create_multi_out_ctls(spec, &spec->autocfg);
5288 if (err < 0)
5289 return err;
5290 if (!spec->kctl_alloc)
5291 return 0; /* can't find valid BIOS pin config */
5292 err = alc260_auto_create_analog_input_ctls(spec, &spec->autocfg);
5293 if (err < 0)
5294 return err;
5295
5296 spec->multiout.max_channels = 2;
5297
5298 if (spec->autocfg.dig_out_pin)
5299 spec->multiout.dig_out_nid = ALC260_DIGOUT_NID;
5300 if (spec->kctl_alloc)
5301 spec->mixers[spec->num_mixers++] = spec->kctl_alloc;
5302
5303 spec->init_verbs[spec->num_init_verbs++] = alc260_volume_init_verbs;
5304
5305 spec->num_mux_defs = 1;
5306 spec->input_mux = &spec->private_imux;
5307
5308 /* check whether NID 0x04 is valid */
5309 wcap = get_wcaps(codec, 0x04);
5310 wcap = (wcap & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT; /* get type */
5311 if (wcap != AC_WID_AUD_IN || spec->input_mux->num_items == 1) {
5312 spec->adc_nids = alc260_adc_nids_alt;
5313 spec->num_adc_nids = ARRAY_SIZE(alc260_adc_nids_alt);
5314 spec->mixers[spec->num_mixers] = alc260_capture_alt_mixer;
5315 } else {
5316 spec->adc_nids = alc260_adc_nids;
5317 spec->num_adc_nids = ARRAY_SIZE(alc260_adc_nids);
5318 spec->mixers[spec->num_mixers] = alc260_capture_mixer;
5319 }
5320 spec->num_mixers++;
5321
5322 store_pin_configs(codec);
5323 return 1;
5324 }
5325
5326 /* additional initialization for auto-configuration model */
5327 static void alc260_auto_init(struct hda_codec *codec)
5328 {
5329 struct alc_spec *spec = codec->spec;
5330 alc260_auto_init_multi_out(codec);
5331 alc260_auto_init_analog_input(codec);
5332 if (spec->unsol_event)
5333 alc_inithook(codec);
5334 }
5335
5336 #ifdef CONFIG_SND_HDA_POWER_SAVE
5337 static struct hda_amp_list alc260_loopbacks[] = {
5338 { 0x07, HDA_INPUT, 0 },
5339 { 0x07, HDA_INPUT, 1 },
5340 { 0x07, HDA_INPUT, 2 },
5341 { 0x07, HDA_INPUT, 3 },
5342 { 0x07, HDA_INPUT, 4 },
5343 { } /* end */
5344 };
5345 #endif
5346
5347 /*
5348 * ALC260 configurations
5349 */
5350 static const char *alc260_models[ALC260_MODEL_LAST] = {
5351 [ALC260_BASIC] = "basic",
5352 [ALC260_HP] = "hp",
5353 [ALC260_HP_3013] = "hp-3013",
5354 [ALC260_HP_DC7600] = "hp-dc7600",
5355 [ALC260_FUJITSU_S702X] = "fujitsu",
5356 [ALC260_ACER] = "acer",
5357 [ALC260_WILL] = "will",
5358 [ALC260_REPLACER_672V] = "replacer",
5359 #ifdef CONFIG_SND_DEBUG
5360 [ALC260_TEST] = "test",
5361 #endif
5362 [ALC260_AUTO] = "auto",
5363 };
5364
5365 static struct snd_pci_quirk alc260_cfg_tbl[] = {
5366 SND_PCI_QUIRK(0x1025, 0x007b, "Acer C20x", ALC260_ACER),
5367 SND_PCI_QUIRK(0x1025, 0x008f, "Acer", ALC260_ACER),
5368 SND_PCI_QUIRK(0x103c, 0x2808, "HP d5700", ALC260_HP_3013),
5369 SND_PCI_QUIRK(0x103c, 0x280a, "HP d5750", ALC260_HP_3013),
5370 SND_PCI_QUIRK(0x103c, 0x3010, "HP", ALC260_HP_3013),
5371 SND_PCI_QUIRK(0x103c, 0x3011, "HP", ALC260_HP_3013),
5372 SND_PCI_QUIRK(0x103c, 0x3012, "HP", ALC260_HP_DC7600),
5373 SND_PCI_QUIRK(0x103c, 0x3013, "HP", ALC260_HP_3013),
5374 SND_PCI_QUIRK(0x103c, 0x3014, "HP", ALC260_HP),
5375 SND_PCI_QUIRK(0x103c, 0x3015, "HP", ALC260_HP),
5376 SND_PCI_QUIRK(0x103c, 0x3016, "HP", ALC260_HP),
5377 SND_PCI_QUIRK(0x104d, 0x81bb, "Sony VAIO", ALC260_BASIC),
5378 SND_PCI_QUIRK(0x104d, 0x81cc, "Sony VAIO", ALC260_BASIC),
5379 SND_PCI_QUIRK(0x104d, 0x81cd, "Sony VAIO", ALC260_BASIC),
5380 SND_PCI_QUIRK(0x10cf, 0x1326, "Fujitsu S702X", ALC260_FUJITSU_S702X),
5381 SND_PCI_QUIRK(0x152d, 0x0729, "CTL U553W", ALC260_BASIC),
5382 SND_PCI_QUIRK(0x161f, 0x2057, "Replacer 672V", ALC260_REPLACER_672V),
5383 SND_PCI_QUIRK(0x1631, 0xc017, "PB V7900", ALC260_WILL),
5384 {}
5385 };
5386
5387 static struct alc_config_preset alc260_presets[] = {
5388 [ALC260_BASIC] = {
5389 .mixers = { alc260_base_output_mixer,
5390 alc260_input_mixer,
5391 alc260_pc_beep_mixer,
5392 alc260_capture_mixer },
5393 .init_verbs = { alc260_init_verbs },
5394 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
5395 .dac_nids = alc260_dac_nids,
5396 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids),
5397 .adc_nids = alc260_adc_nids,
5398 .num_channel_mode = ARRAY_SIZE(alc260_modes),
5399 .channel_mode = alc260_modes,
5400 .input_mux = &alc260_capture_source,
5401 },
5402 [ALC260_HP] = {
5403 .mixers = { alc260_hp_output_mixer,
5404 alc260_input_mixer,
5405 alc260_capture_alt_mixer },
5406 .init_verbs = { alc260_init_verbs,
5407 alc260_hp_unsol_verbs },
5408 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
5409 .dac_nids = alc260_dac_nids,
5410 .num_adc_nids = ARRAY_SIZE(alc260_hp_adc_nids),
5411 .adc_nids = alc260_hp_adc_nids,
5412 .num_channel_mode = ARRAY_SIZE(alc260_modes),
5413 .channel_mode = alc260_modes,
5414 .input_mux = &alc260_capture_source,
5415 .unsol_event = alc260_hp_unsol_event,
5416 .init_hook = alc260_hp_automute,
5417 },
5418 [ALC260_HP_DC7600] = {
5419 .mixers = { alc260_hp_dc7600_mixer,
5420 alc260_input_mixer,
5421 alc260_capture_alt_mixer },
5422 .init_verbs = { alc260_init_verbs,
5423 alc260_hp_dc7600_verbs },
5424 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
5425 .dac_nids = alc260_dac_nids,
5426 .num_adc_nids = ARRAY_SIZE(alc260_hp_adc_nids),
5427 .adc_nids = alc260_hp_adc_nids,
5428 .num_channel_mode = ARRAY_SIZE(alc260_modes),
5429 .channel_mode = alc260_modes,
5430 .input_mux = &alc260_capture_source,
5431 .unsol_event = alc260_hp_3012_unsol_event,
5432 .init_hook = alc260_hp_3012_automute,
5433 },
5434 [ALC260_HP_3013] = {
5435 .mixers = { alc260_hp_3013_mixer,
5436 alc260_input_mixer,
5437 alc260_capture_alt_mixer },
5438 .init_verbs = { alc260_hp_3013_init_verbs,
5439 alc260_hp_3013_unsol_verbs },
5440 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
5441 .dac_nids = alc260_dac_nids,
5442 .num_adc_nids = ARRAY_SIZE(alc260_hp_adc_nids),
5443 .adc_nids = alc260_hp_adc_nids,
5444 .num_channel_mode = ARRAY_SIZE(alc260_modes),
5445 .channel_mode = alc260_modes,
5446 .input_mux = &alc260_capture_source,
5447 .unsol_event = alc260_hp_3013_unsol_event,
5448 .init_hook = alc260_hp_3013_automute,
5449 },
5450 [ALC260_FUJITSU_S702X] = {
5451 .mixers = { alc260_fujitsu_mixer,
5452 alc260_capture_mixer },
5453 .init_verbs = { alc260_fujitsu_init_verbs },
5454 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
5455 .dac_nids = alc260_dac_nids,
5456 .num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids),
5457 .adc_nids = alc260_dual_adc_nids,
5458 .num_channel_mode = ARRAY_SIZE(alc260_modes),
5459 .channel_mode = alc260_modes,
5460 .num_mux_defs = ARRAY_SIZE(alc260_fujitsu_capture_sources),
5461 .input_mux = alc260_fujitsu_capture_sources,
5462 },
5463 [ALC260_ACER] = {
5464 .mixers = { alc260_acer_mixer,
5465 alc260_capture_mixer },
5466 .init_verbs = { alc260_acer_init_verbs },
5467 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
5468 .dac_nids = alc260_dac_nids,
5469 .num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids),
5470 .adc_nids = alc260_dual_adc_nids,
5471 .num_channel_mode = ARRAY_SIZE(alc260_modes),
5472 .channel_mode = alc260_modes,
5473 .num_mux_defs = ARRAY_SIZE(alc260_acer_capture_sources),
5474 .input_mux = alc260_acer_capture_sources,
5475 },
5476 [ALC260_WILL] = {
5477 .mixers = { alc260_will_mixer,
5478 alc260_capture_mixer },
5479 .init_verbs = { alc260_init_verbs, alc260_will_verbs },
5480 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
5481 .dac_nids = alc260_dac_nids,
5482 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids),
5483 .adc_nids = alc260_adc_nids,
5484 .dig_out_nid = ALC260_DIGOUT_NID,
5485 .num_channel_mode = ARRAY_SIZE(alc260_modes),
5486 .channel_mode = alc260_modes,
5487 .input_mux = &alc260_capture_source,
5488 },
5489 [ALC260_REPLACER_672V] = {
5490 .mixers = { alc260_replacer_672v_mixer,
5491 alc260_capture_mixer },
5492 .init_verbs = { alc260_init_verbs, alc260_replacer_672v_verbs },
5493 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
5494 .dac_nids = alc260_dac_nids,
5495 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids),
5496 .adc_nids = alc260_adc_nids,
5497 .dig_out_nid = ALC260_DIGOUT_NID,
5498 .num_channel_mode = ARRAY_SIZE(alc260_modes),
5499 .channel_mode = alc260_modes,
5500 .input_mux = &alc260_capture_source,
5501 .unsol_event = alc260_replacer_672v_unsol_event,
5502 .init_hook = alc260_replacer_672v_automute,
5503 },
5504 #ifdef CONFIG_SND_DEBUG
5505 [ALC260_TEST] = {
5506 .mixers = { alc260_test_mixer,
5507 alc260_capture_mixer },
5508 .init_verbs = { alc260_test_init_verbs },
5509 .num_dacs = ARRAY_SIZE(alc260_test_dac_nids),
5510 .dac_nids = alc260_test_dac_nids,
5511 .num_adc_nids = ARRAY_SIZE(alc260_test_adc_nids),
5512 .adc_nids = alc260_test_adc_nids,
5513 .num_channel_mode = ARRAY_SIZE(alc260_modes),
5514 .channel_mode = alc260_modes,
5515 .num_mux_defs = ARRAY_SIZE(alc260_test_capture_sources),
5516 .input_mux = alc260_test_capture_sources,
5517 },
5518 #endif
5519 };
5520
5521 static int patch_alc260(struct hda_codec *codec)
5522 {
5523 struct alc_spec *spec;
5524 int err, board_config;
5525
5526 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
5527 if (spec == NULL)
5528 return -ENOMEM;
5529
5530 codec->spec = spec;
5531
5532 board_config = snd_hda_check_board_config(codec, ALC260_MODEL_LAST,
5533 alc260_models,
5534 alc260_cfg_tbl);
5535 if (board_config < 0) {
5536 snd_printd(KERN_INFO "hda_codec: Unknown model for ALC260, "
5537 "trying auto-probe from BIOS...\n");
5538 board_config = ALC260_AUTO;
5539 }
5540
5541 if (board_config == ALC260_AUTO) {
5542 /* automatic parse from the BIOS config */
5543 err = alc260_parse_auto_config(codec);
5544 if (err < 0) {
5545 alc_free(codec);
5546 return err;
5547 } else if (!err) {
5548 printk(KERN_INFO
5549 "hda_codec: Cannot set up configuration "
5550 "from BIOS. Using base mode...\n");
5551 board_config = ALC260_BASIC;
5552 }
5553 }
5554
5555 if (board_config != ALC260_AUTO)
5556 setup_preset(spec, &alc260_presets[board_config]);
5557
5558 spec->stream_name_analog = "ALC260 Analog";
5559 spec->stream_analog_playback = &alc260_pcm_analog_playback;
5560 spec->stream_analog_capture = &alc260_pcm_analog_capture;
5561
5562 spec->stream_name_digital = "ALC260 Digital";
5563 spec->stream_digital_playback = &alc260_pcm_digital_playback;
5564 spec->stream_digital_capture = &alc260_pcm_digital_capture;
5565
5566 spec->vmaster_nid = 0x08;
5567
5568 codec->patch_ops = alc_patch_ops;
5569 if (board_config == ALC260_AUTO)
5570 spec->init_hook = alc260_auto_init;
5571 #ifdef CONFIG_SND_HDA_POWER_SAVE
5572 if (!spec->loopback.amplist)
5573 spec->loopback.amplist = alc260_loopbacks;
5574 #endif
5575
5576 return 0;
5577 }
5578
5579
5580 /*
5581 * ALC882 support
5582 *
5583 * ALC882 is almost identical with ALC880 but has cleaner and more flexible
5584 * configuration. Each pin widget can choose any input DACs and a mixer.
5585 * Each ADC is connected from a mixer of all inputs. This makes possible
5586 * 6-channel independent captures.
5587 *
5588 * In addition, an independent DAC for the multi-playback (not used in this
5589 * driver yet).
5590 */
5591 #define ALC882_DIGOUT_NID 0x06
5592 #define ALC882_DIGIN_NID 0x0a
5593
5594 static struct hda_channel_mode alc882_ch_modes[1] = {
5595 { 8, NULL }
5596 };
5597
5598 static hda_nid_t alc882_dac_nids[4] = {
5599 /* front, rear, clfe, rear_surr */
5600 0x02, 0x03, 0x04, 0x05
5601 };
5602
5603 /* identical with ALC880 */
5604 #define alc882_adc_nids alc880_adc_nids
5605 #define alc882_adc_nids_alt alc880_adc_nids_alt
5606
5607 static hda_nid_t alc882_capsrc_nids[3] = { 0x24, 0x23, 0x22 };
5608 static hda_nid_t alc882_capsrc_nids_alt[2] = { 0x23, 0x22 };
5609
5610 /* input MUX */
5611 /* FIXME: should be a matrix-type input source selection */
5612
5613 static struct hda_input_mux alc882_capture_source = {
5614 .num_items = 4,
5615 .items = {
5616 { "Mic", 0x0 },
5617 { "Front Mic", 0x1 },
5618 { "Line", 0x2 },
5619 { "CD", 0x4 },
5620 },
5621 };
5622 #define alc882_mux_enum_info alc_mux_enum_info
5623 #define alc882_mux_enum_get alc_mux_enum_get
5624
5625 static int alc882_mux_enum_put(struct snd_kcontrol *kcontrol,
5626 struct snd_ctl_elem_value *ucontrol)
5627 {
5628 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
5629 struct alc_spec *spec = codec->spec;
5630 const struct hda_input_mux *imux = spec->input_mux;
5631 unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
5632 hda_nid_t nid = spec->capsrc_nids ?
5633 spec->capsrc_nids[adc_idx] : spec->adc_nids[adc_idx];
5634 unsigned int *cur_val = &spec->cur_mux[adc_idx];
5635 unsigned int i, idx;
5636
5637 idx = ucontrol->value.enumerated.item[0];
5638 if (idx >= imux->num_items)
5639 idx = imux->num_items - 1;
5640 if (*cur_val == idx)
5641 return 0;
5642 for (i = 0; i < imux->num_items; i++) {
5643 unsigned int v = (i == idx) ? 0 : HDA_AMP_MUTE;
5644 snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT,
5645 imux->items[i].index,
5646 HDA_AMP_MUTE, v);
5647 }
5648 *cur_val = idx;
5649 return 1;
5650 }
5651
5652 /*
5653 * 2ch mode
5654 */
5655 static struct hda_verb alc882_3ST_ch2_init[] = {
5656 { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
5657 { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
5658 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
5659 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
5660 { } /* end */
5661 };
5662
5663 /*
5664 * 6ch mode
5665 */
5666 static struct hda_verb alc882_3ST_ch6_init[] = {
5667 { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
5668 { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
5669 { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
5670 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
5671 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
5672 { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
5673 { } /* end */
5674 };
5675
5676 static struct hda_channel_mode alc882_3ST_6ch_modes[2] = {
5677 { 2, alc882_3ST_ch2_init },
5678 { 6, alc882_3ST_ch6_init },
5679 };
5680
5681 /*
5682 * 6ch mode
5683 */
5684 static struct hda_verb alc882_sixstack_ch6_init[] = {
5685 { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
5686 { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
5687 { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
5688 { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
5689 { } /* end */
5690 };
5691
5692 /*
5693 * 8ch mode
5694 */
5695 static struct hda_verb alc882_sixstack_ch8_init[] = {
5696 { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
5697 { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
5698 { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
5699 { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
5700 { } /* end */
5701 };
5702
5703 static struct hda_channel_mode alc882_sixstack_modes[2] = {
5704 { 6, alc882_sixstack_ch6_init },
5705 { 8, alc882_sixstack_ch8_init },
5706 };
5707
5708 /*
5709 * macbook pro ALC885 can switch LineIn to LineOut without loosing Mic
5710 */
5711
5712 /*
5713 * 2ch mode
5714 */
5715 static struct hda_verb alc885_mbp_ch2_init[] = {
5716 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
5717 { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5718 { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5719 { } /* end */
5720 };
5721
5722 /*
5723 * 6ch mode
5724 */
5725 static struct hda_verb alc885_mbp_ch6_init[] = {
5726 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
5727 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5728 { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
5729 { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5730 { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
5731 { } /* end */
5732 };
5733
5734 static struct hda_channel_mode alc885_mbp_6ch_modes[2] = {
5735 { 2, alc885_mbp_ch2_init },
5736 { 6, alc885_mbp_ch6_init },
5737 };
5738
5739
5740 /* Pin assignment: Front=0x14, Rear=0x15, CLFE=0x16, Side=0x17
5741 * Mic=0x18, Front Mic=0x19, Line-In=0x1a, HP=0x1b
5742 */
5743 static struct snd_kcontrol_new alc882_base_mixer[] = {
5744 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
5745 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
5746 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
5747 HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
5748 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
5749 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
5750 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
5751 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
5752 HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
5753 HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
5754 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
5755 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
5756 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
5757 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
5758 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
5759 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
5760 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
5761 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
5762 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
5763 HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
5764 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
5765 HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
5766 HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
5767 { } /* end */
5768 };
5769
5770 static struct snd_kcontrol_new alc885_mbp3_mixer[] = {
5771 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
5772 HDA_BIND_MUTE ("Front Playback Switch", 0x0c, 0x02, HDA_INPUT),
5773 HDA_CODEC_MUTE ("Speaker Playback Switch", 0x14, 0x00, HDA_OUTPUT),
5774 HDA_CODEC_VOLUME("Line-Out Playback Volume", 0x0d, 0x00, HDA_OUTPUT),
5775 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
5776 HDA_CODEC_MUTE ("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
5777 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x00, HDA_INPUT),
5778 HDA_CODEC_MUTE ("Mic Playback Switch", 0x0b, 0x00, HDA_INPUT),
5779 HDA_CODEC_VOLUME("Line Boost", 0x1a, 0x00, HDA_INPUT),
5780 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0x00, HDA_INPUT),
5781 { } /* end */
5782 };
5783 static struct snd_kcontrol_new alc882_w2jc_mixer[] = {
5784 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
5785 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
5786 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
5787 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
5788 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
5789 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
5790 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
5791 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
5792 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
5793 HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
5794 HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
5795 { } /* end */
5796 };
5797
5798 static struct snd_kcontrol_new alc882_targa_mixer[] = {
5799 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
5800 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
5801 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
5802 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
5803 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
5804 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
5805 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
5806 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
5807 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
5808 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
5809 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
5810 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
5811 HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
5812 { } /* end */
5813 };
5814
5815 /* Pin assignment: Front=0x14, HP = 0x15, Front = 0x16, ???
5816 * Front Mic=0x18, Line In = 0x1a, Line In = 0x1b, CD = 0x1c
5817 */
5818 static struct snd_kcontrol_new alc882_asus_a7j_mixer[] = {
5819 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
5820 HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
5821 HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
5822 HDA_CODEC_MUTE("Mobile Front Playback Switch", 0x16, 0x0, HDA_OUTPUT),
5823 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
5824 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
5825 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
5826 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
5827 HDA_CODEC_VOLUME("Mobile Line Playback Volume", 0x0b, 0x03, HDA_INPUT),
5828 HDA_CODEC_MUTE("Mobile Line Playback Switch", 0x0b, 0x03, HDA_INPUT),
5829 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
5830 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
5831 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
5832 { } /* end */
5833 };
5834
5835 static struct snd_kcontrol_new alc882_asus_a7m_mixer[] = {
5836 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
5837 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
5838 HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
5839 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
5840 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
5841 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
5842 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
5843 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
5844 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
5845 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
5846 HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
5847 HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
5848 { } /* end */
5849 };
5850
5851 static struct snd_kcontrol_new alc882_chmode_mixer[] = {
5852 {
5853 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
5854 .name = "Channel Mode",
5855 .info = alc_ch_mode_info,
5856 .get = alc_ch_mode_get,
5857 .put = alc_ch_mode_put,
5858 },
5859 { } /* end */
5860 };
5861
5862 static struct hda_verb alc882_init_verbs[] = {
5863 /* Front mixer: unmute input/output amp left and right (volume = 0) */
5864 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5865 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5866 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5867 /* Rear mixer */
5868 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5869 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5870 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5871 /* CLFE mixer */
5872 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5873 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5874 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5875 /* Side mixer */
5876 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5877 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5878 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5879
5880 /* Front Pin: output 0 (0x0c) */
5881 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5882 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5883 {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
5884 /* Rear Pin: output 1 (0x0d) */
5885 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5886 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5887 {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
5888 /* CLFE Pin: output 2 (0x0e) */
5889 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5890 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5891 {0x16, AC_VERB_SET_CONNECT_SEL, 0x02},
5892 /* Side Pin: output 3 (0x0f) */
5893 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5894 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5895 {0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
5896 /* Mic (rear) pin: input vref at 80% */
5897 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
5898 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
5899 /* Front Mic pin: input vref at 80% */
5900 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
5901 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
5902 /* Line In pin: input */
5903 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
5904 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
5905 /* Line-2 In: Headphone output (output 0 - 0x0c) */
5906 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
5907 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5908 {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
5909 /* CD pin widget for input */
5910 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
5911
5912 /* FIXME: use matrix-type input source selection */
5913 /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
5914 /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
5915 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5916 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
5917 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
5918 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
5919 /* Input mixer2 */
5920 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5921 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
5922 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
5923 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
5924 /* Input mixer3 */
5925 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5926 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
5927 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
5928 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
5929 /* ADC1: mute amp left and right */
5930 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5931 {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
5932 /* ADC2: mute amp left and right */
5933 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5934 {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
5935 /* ADC3: mute amp left and right */
5936 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5937 {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
5938
5939 { }
5940 };
5941
5942 static struct hda_verb alc882_eapd_verbs[] = {
5943 /* change to EAPD mode */
5944 {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
5945 {0x20, AC_VERB_SET_PROC_COEF, 0x3060},
5946 { }
5947 };
5948
5949 /* Mac Pro test */
5950 static struct snd_kcontrol_new alc882_macpro_mixer[] = {
5951 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
5952 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
5953 HDA_CODEC_MUTE("Headphone Playback Switch", 0x18, 0x0, HDA_OUTPUT),
5954 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x01, HDA_INPUT),
5955 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x01, HDA_INPUT),
5956 HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x02, HDA_INPUT),
5957 HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x02, HDA_INPUT),
5958 { } /* end */
5959 };
5960
5961 static struct hda_verb alc882_macpro_init_verbs[] = {
5962 /* Front mixer: unmute input/output amp left and right (volume = 0) */
5963 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5964 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5965 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5966 /* Front Pin: output 0 (0x0c) */
5967 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5968 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5969 {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
5970 /* Front Mic pin: input vref at 80% */
5971 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
5972 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
5973 /* Speaker: output */
5974 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5975 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5976 {0x1a, AC_VERB_SET_CONNECT_SEL, 0x04},
5977 /* Headphone output (output 0 - 0x0c) */
5978 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
5979 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5980 {0x18, AC_VERB_SET_CONNECT_SEL, 0x00},
5981
5982 /* FIXME: use matrix-type input source selection */
5983 /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
5984 /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
5985 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5986 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
5987 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
5988 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
5989 /* Input mixer2 */
5990 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5991 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
5992 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
5993 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
5994 /* Input mixer3 */
5995 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5996 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
5997 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
5998 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
5999 /* ADC1: mute amp left and right */
6000 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6001 {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
6002 /* ADC2: mute amp left and right */
6003 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6004 {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
6005 /* ADC3: mute amp left and right */
6006 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6007 {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
6008
6009 { }
6010 };
6011
6012 /* Macbook Pro rev3 */
6013 static struct hda_verb alc885_mbp3_init_verbs[] = {
6014 /* Front mixer: unmute input/output amp left and right (volume = 0) */
6015 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6016 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6017 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6018 /* Rear mixer */
6019 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6020 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6021 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6022 /* Front Pin: output 0 (0x0c) */
6023 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6024 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6025 {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
6026 /* HP Pin: output 0 (0x0d) */
6027 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc4},
6028 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
6029 {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
6030 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
6031 /* Mic (rear) pin: input vref at 80% */
6032 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
6033 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
6034 /* Front Mic pin: input vref at 80% */
6035 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
6036 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
6037 /* Line In pin: use output 1 when in LineOut mode */
6038 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
6039 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
6040 {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01},
6041
6042 /* FIXME: use matrix-type input source selection */
6043 /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
6044 /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
6045 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6046 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
6047 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
6048 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
6049 /* Input mixer2 */
6050 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6051 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
6052 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
6053 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
6054 /* Input mixer3 */
6055 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6056 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
6057 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
6058 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
6059 /* ADC1: mute amp left and right */
6060 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6061 {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
6062 /* ADC2: mute amp left and right */
6063 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6064 {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
6065 /* ADC3: mute amp left and right */
6066 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6067 {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
6068
6069 { }
6070 };
6071
6072 /* iMac 24 mixer. */
6073 static struct snd_kcontrol_new alc885_imac24_mixer[] = {
6074 HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
6075 HDA_CODEC_MUTE("Master Playback Switch", 0x0c, 0x00, HDA_INPUT),
6076 { } /* end */
6077 };
6078
6079 /* iMac 24 init verbs. */
6080 static struct hda_verb alc885_imac24_init_verbs[] = {
6081 /* Internal speakers: output 0 (0x0c) */
6082 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6083 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6084 {0x18, AC_VERB_SET_CONNECT_SEL, 0x00},
6085 /* Internal speakers: output 0 (0x0c) */
6086 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6087 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6088 {0x1a, AC_VERB_SET_CONNECT_SEL, 0x00},
6089 /* Headphone: output 0 (0x0c) */
6090 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
6091 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6092 {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
6093 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
6094 /* Front Mic: input vref at 80% */
6095 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
6096 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
6097 { }
6098 };
6099
6100 /* Toggle speaker-output according to the hp-jack state */
6101 static void alc885_imac24_automute(struct hda_codec *codec)
6102 {
6103 unsigned int present;
6104
6105 present = snd_hda_codec_read(codec, 0x14, 0,
6106 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
6107 snd_hda_codec_amp_stereo(codec, 0x18, HDA_OUTPUT, 0,
6108 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
6109 snd_hda_codec_amp_stereo(codec, 0x1a, HDA_OUTPUT, 0,
6110 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
6111 }
6112
6113 /* Processes unsolicited events. */
6114 static void alc885_imac24_unsol_event(struct hda_codec *codec,
6115 unsigned int res)
6116 {
6117 /* Headphone insertion or removal. */
6118 if ((res >> 26) == ALC880_HP_EVENT)
6119 alc885_imac24_automute(codec);
6120 }
6121
6122 static void alc885_mbp3_automute(struct hda_codec *codec)
6123 {
6124 unsigned int present;
6125
6126 present = snd_hda_codec_read(codec, 0x15, 0,
6127 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
6128 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
6129 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
6130 snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
6131 HDA_AMP_MUTE, present ? 0 : HDA_AMP_MUTE);
6132
6133 }
6134 static void alc885_mbp3_unsol_event(struct hda_codec *codec,
6135 unsigned int res)
6136 {
6137 /* Headphone insertion or removal. */
6138 if ((res >> 26) == ALC880_HP_EVENT)
6139 alc885_mbp3_automute(codec);
6140 }
6141
6142
6143 static struct hda_verb alc882_targa_verbs[] = {
6144 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6145 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6146
6147 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
6148 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6149
6150 {0x18, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
6151 {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/surround */
6152 {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
6153
6154 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
6155 {0x01, AC_VERB_SET_GPIO_MASK, 0x03},
6156 {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x03},
6157 {0x01, AC_VERB_SET_GPIO_DATA, 0x03},
6158 { } /* end */
6159 };
6160
6161 /* toggle speaker-output according to the hp-jack state */
6162 static void alc882_targa_automute(struct hda_codec *codec)
6163 {
6164 unsigned int present;
6165
6166 present = snd_hda_codec_read(codec, 0x14, 0,
6167 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
6168 snd_hda_codec_amp_stereo(codec, 0x1b, HDA_OUTPUT, 0,
6169 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
6170 snd_hda_codec_write_cache(codec, 1, 0, AC_VERB_SET_GPIO_DATA,
6171 present ? 1 : 3);
6172 }
6173
6174 static void alc882_targa_unsol_event(struct hda_codec *codec, unsigned int res)
6175 {
6176 /* Looks like the unsol event is incompatible with the standard
6177 * definition. 4bit tag is placed at 26 bit!
6178 */
6179 if (((res >> 26) == ALC880_HP_EVENT)) {
6180 alc882_targa_automute(codec);
6181 }
6182 }
6183
6184 static struct hda_verb alc882_asus_a7j_verbs[] = {
6185 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6186 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6187
6188 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
6189 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6190 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6191
6192 {0x14, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */
6193 {0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
6194 {0x16, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */
6195
6196 {0x18, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
6197 {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/surround */
6198 {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
6199 { } /* end */
6200 };
6201
6202 static struct hda_verb alc882_asus_a7m_verbs[] = {
6203 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6204 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6205
6206 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
6207 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6208 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6209
6210 {0x14, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */
6211 {0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
6212 {0x16, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */
6213
6214 {0x18, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
6215 {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/surround */
6216 {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
6217 { } /* end */
6218 };
6219
6220 static void alc882_gpio_mute(struct hda_codec *codec, int pin, int muted)
6221 {
6222 unsigned int gpiostate, gpiomask, gpiodir;
6223
6224 gpiostate = snd_hda_codec_read(codec, codec->afg, 0,
6225 AC_VERB_GET_GPIO_DATA, 0);
6226
6227 if (!muted)
6228 gpiostate |= (1 << pin);
6229 else
6230 gpiostate &= ~(1 << pin);
6231
6232 gpiomask = snd_hda_codec_read(codec, codec->afg, 0,
6233 AC_VERB_GET_GPIO_MASK, 0);
6234 gpiomask |= (1 << pin);
6235
6236 gpiodir = snd_hda_codec_read(codec, codec->afg, 0,
6237 AC_VERB_GET_GPIO_DIRECTION, 0);
6238 gpiodir |= (1 << pin);
6239
6240
6241 snd_hda_codec_write(codec, codec->afg, 0,
6242 AC_VERB_SET_GPIO_MASK, gpiomask);
6243 snd_hda_codec_write(codec, codec->afg, 0,
6244 AC_VERB_SET_GPIO_DIRECTION, gpiodir);
6245
6246 msleep(1);
6247
6248 snd_hda_codec_write(codec, codec->afg, 0,
6249 AC_VERB_SET_GPIO_DATA, gpiostate);
6250 }
6251
6252 /* set up GPIO at initialization */
6253 static void alc885_macpro_init_hook(struct hda_codec *codec)
6254 {
6255 alc882_gpio_mute(codec, 0, 0);
6256 alc882_gpio_mute(codec, 1, 0);
6257 }
6258
6259 /* set up GPIO and update auto-muting at initialization */
6260 static void alc885_imac24_init_hook(struct hda_codec *codec)
6261 {
6262 alc885_macpro_init_hook(codec);
6263 alc885_imac24_automute(codec);
6264 }
6265
6266 /*
6267 * generic initialization of ADC, input mixers and output mixers
6268 */
6269 static struct hda_verb alc882_auto_init_verbs[] = {
6270 /*
6271 * Unmute ADC0-2 and set the default input to mic-in
6272 */
6273 {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
6274 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6275 {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
6276 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6277 {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
6278 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6279
6280 /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
6281 * mixer widget
6282 * Note: PASD motherboards uses the Line In 2 as the input for
6283 * front panel mic (mic 2)
6284 */
6285 /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
6286 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6287 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6288 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
6289 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
6290 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
6291
6292 /*
6293 * Set up output mixers (0x0c - 0x0f)
6294 */
6295 /* set vol=0 to output mixers */
6296 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6297 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6298 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6299 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6300 /* set up input amps for analog loopback */
6301 /* Amp Indices: DAC = 0, mixer = 1 */
6302 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6303 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6304 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6305 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6306 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6307 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6308 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6309 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6310 {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6311 {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6312
6313 /* FIXME: use matrix-type input source selection */
6314 /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
6315 /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
6316 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
6317 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
6318 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
6319 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
6320 /* Input mixer2 */
6321 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
6322 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
6323 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
6324 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
6325 /* Input mixer3 */
6326 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
6327 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
6328 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
6329 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
6330
6331 { }
6332 };
6333
6334 /* capture mixer elements */
6335 static struct snd_kcontrol_new alc882_capture_alt_mixer[] = {
6336 HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
6337 HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
6338 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT),
6339 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT),
6340 {
6341 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
6342 /* The multiple "Capture Source" controls confuse alsamixer
6343 * So call somewhat different..
6344 */
6345 /* .name = "Capture Source", */
6346 .name = "Input Source",
6347 .count = 2,
6348 .info = alc882_mux_enum_info,
6349 .get = alc882_mux_enum_get,
6350 .put = alc882_mux_enum_put,
6351 },
6352 { } /* end */
6353 };
6354
6355 static struct snd_kcontrol_new alc882_capture_mixer[] = {
6356 HDA_CODEC_VOLUME("Capture Volume", 0x07, 0x0, HDA_INPUT),
6357 HDA_CODEC_MUTE("Capture Switch", 0x07, 0x0, HDA_INPUT),
6358 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x08, 0x0, HDA_INPUT),
6359 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x08, 0x0, HDA_INPUT),
6360 HDA_CODEC_VOLUME_IDX("Capture Volume", 2, 0x09, 0x0, HDA_INPUT),
6361 HDA_CODEC_MUTE_IDX("Capture Switch", 2, 0x09, 0x0, HDA_INPUT),
6362 {
6363 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
6364 /* The multiple "Capture Source" controls confuse alsamixer
6365 * So call somewhat different..
6366 */
6367 /* .name = "Capture Source", */
6368 .name = "Input Source",
6369 .count = 3,
6370 .info = alc882_mux_enum_info,
6371 .get = alc882_mux_enum_get,
6372 .put = alc882_mux_enum_put,
6373 },
6374 { } /* end */
6375 };
6376
6377 #ifdef CONFIG_SND_HDA_POWER_SAVE
6378 #define alc882_loopbacks alc880_loopbacks
6379 #endif
6380
6381 /* pcm configuration: identiacal with ALC880 */
6382 #define alc882_pcm_analog_playback alc880_pcm_analog_playback
6383 #define alc882_pcm_analog_capture alc880_pcm_analog_capture
6384 #define alc882_pcm_digital_playback alc880_pcm_digital_playback
6385 #define alc882_pcm_digital_capture alc880_pcm_digital_capture
6386
6387 /*
6388 * configuration and preset
6389 */
6390 static const char *alc882_models[ALC882_MODEL_LAST] = {
6391 [ALC882_3ST_DIG] = "3stack-dig",
6392 [ALC882_6ST_DIG] = "6stack-dig",
6393 [ALC882_ARIMA] = "arima",
6394 [ALC882_W2JC] = "w2jc",
6395 [ALC882_TARGA] = "targa",
6396 [ALC882_ASUS_A7J] = "asus-a7j",
6397 [ALC882_ASUS_A7M] = "asus-a7m",
6398 [ALC885_MACPRO] = "macpro",
6399 [ALC885_MBP3] = "mbp3",
6400 [ALC885_IMAC24] = "imac24",
6401 [ALC882_AUTO] = "auto",
6402 };
6403
6404 static struct snd_pci_quirk alc882_cfg_tbl[] = {
6405 SND_PCI_QUIRK(0x1019, 0x6668, "ECS", ALC882_6ST_DIG),
6406 SND_PCI_QUIRK(0x1043, 0x060d, "Asus A7J", ALC882_ASUS_A7J),
6407 SND_PCI_QUIRK(0x1043, 0x1243, "Asus A7J", ALC882_ASUS_A7J),
6408 SND_PCI_QUIRK(0x1043, 0x13c2, "Asus A7M", ALC882_ASUS_A7M),
6409 SND_PCI_QUIRK(0x1043, 0x1971, "Asus W2JC", ALC882_W2JC),
6410 SND_PCI_QUIRK(0x1043, 0x817f, "Asus P5LD2", ALC882_6ST_DIG),
6411 SND_PCI_QUIRK(0x1043, 0x81d8, "Asus P5WD", ALC882_6ST_DIG),
6412 SND_PCI_QUIRK(0x105b, 0x6668, "Foxconn", ALC882_6ST_DIG),
6413 SND_PCI_QUIRK(0x1458, 0xa002, "Gigabyte P35 DS3R", ALC882_6ST_DIG),
6414 SND_PCI_QUIRK(0x1462, 0x28fb, "Targa T8", ALC882_TARGA), /* MSI-1049 T8 */
6415 SND_PCI_QUIRK(0x1462, 0x6668, "MSI", ALC882_6ST_DIG),
6416 SND_PCI_QUIRK(0x161f, 0x2054, "Arima W820", ALC882_ARIMA),
6417 {}
6418 };
6419
6420 static struct alc_config_preset alc882_presets[] = {
6421 [ALC882_3ST_DIG] = {
6422 .mixers = { alc882_base_mixer },
6423 .init_verbs = { alc882_init_verbs },
6424 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
6425 .dac_nids = alc882_dac_nids,
6426 .dig_out_nid = ALC882_DIGOUT_NID,
6427 .dig_in_nid = ALC882_DIGIN_NID,
6428 .num_channel_mode = ARRAY_SIZE(alc882_ch_modes),
6429 .channel_mode = alc882_ch_modes,
6430 .need_dac_fix = 1,
6431 .input_mux = &alc882_capture_source,
6432 },
6433 [ALC882_6ST_DIG] = {
6434 .mixers = { alc882_base_mixer, alc882_chmode_mixer },
6435 .init_verbs = { alc882_init_verbs },
6436 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
6437 .dac_nids = alc882_dac_nids,
6438 .dig_out_nid = ALC882_DIGOUT_NID,
6439 .dig_in_nid = ALC882_DIGIN_NID,
6440 .num_channel_mode = ARRAY_SIZE(alc882_sixstack_modes),
6441 .channel_mode = alc882_sixstack_modes,
6442 .input_mux = &alc882_capture_source,
6443 },
6444 [ALC882_ARIMA] = {
6445 .mixers = { alc882_base_mixer, alc882_chmode_mixer },
6446 .init_verbs = { alc882_init_verbs, alc882_eapd_verbs },
6447 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
6448 .dac_nids = alc882_dac_nids,
6449 .num_channel_mode = ARRAY_SIZE(alc882_sixstack_modes),
6450 .channel_mode = alc882_sixstack_modes,
6451 .input_mux = &alc882_capture_source,
6452 },
6453 [ALC882_W2JC] = {
6454 .mixers = { alc882_w2jc_mixer, alc882_chmode_mixer },
6455 .init_verbs = { alc882_init_verbs, alc882_eapd_verbs,
6456 alc880_gpio1_init_verbs },
6457 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
6458 .dac_nids = alc882_dac_nids,
6459 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
6460 .channel_mode = alc880_threestack_modes,
6461 .need_dac_fix = 1,
6462 .input_mux = &alc882_capture_source,
6463 .dig_out_nid = ALC882_DIGOUT_NID,
6464 },
6465 [ALC885_MBP3] = {
6466 .mixers = { alc885_mbp3_mixer, alc882_chmode_mixer },
6467 .init_verbs = { alc885_mbp3_init_verbs,
6468 alc880_gpio1_init_verbs },
6469 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
6470 .dac_nids = alc882_dac_nids,
6471 .channel_mode = alc885_mbp_6ch_modes,
6472 .num_channel_mode = ARRAY_SIZE(alc885_mbp_6ch_modes),
6473 .input_mux = &alc882_capture_source,
6474 .dig_out_nid = ALC882_DIGOUT_NID,
6475 .dig_in_nid = ALC882_DIGIN_NID,
6476 .unsol_event = alc885_mbp3_unsol_event,
6477 .init_hook = alc885_mbp3_automute,
6478 },
6479 [ALC885_MACPRO] = {
6480 .mixers = { alc882_macpro_mixer },
6481 .init_verbs = { alc882_macpro_init_verbs },
6482 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
6483 .dac_nids = alc882_dac_nids,
6484 .dig_out_nid = ALC882_DIGOUT_NID,
6485 .dig_in_nid = ALC882_DIGIN_NID,
6486 .num_channel_mode = ARRAY_SIZE(alc882_ch_modes),
6487 .channel_mode = alc882_ch_modes,
6488 .input_mux = &alc882_capture_source,
6489 .init_hook = alc885_macpro_init_hook,
6490 },
6491 [ALC885_IMAC24] = {
6492 .mixers = { alc885_imac24_mixer },
6493 .init_verbs = { alc885_imac24_init_verbs },
6494 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
6495 .dac_nids = alc882_dac_nids,
6496 .dig_out_nid = ALC882_DIGOUT_NID,
6497 .dig_in_nid = ALC882_DIGIN_NID,
6498 .num_channel_mode = ARRAY_SIZE(alc882_ch_modes),
6499 .channel_mode = alc882_ch_modes,
6500 .input_mux = &alc882_capture_source,
6501 .unsol_event = alc885_imac24_unsol_event,
6502 .init_hook = alc885_imac24_init_hook,
6503 },
6504 [ALC882_TARGA] = {
6505 .mixers = { alc882_targa_mixer, alc882_chmode_mixer,
6506 alc882_capture_mixer },
6507 .init_verbs = { alc882_init_verbs, alc882_targa_verbs},
6508 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
6509 .dac_nids = alc882_dac_nids,
6510 .dig_out_nid = ALC882_DIGOUT_NID,
6511 .num_adc_nids = ARRAY_SIZE(alc882_adc_nids),
6512 .adc_nids = alc882_adc_nids,
6513 .capsrc_nids = alc882_capsrc_nids,
6514 .num_channel_mode = ARRAY_SIZE(alc882_3ST_6ch_modes),
6515 .channel_mode = alc882_3ST_6ch_modes,
6516 .need_dac_fix = 1,
6517 .input_mux = &alc882_capture_source,
6518 .unsol_event = alc882_targa_unsol_event,
6519 .init_hook = alc882_targa_automute,
6520 },
6521 [ALC882_ASUS_A7J] = {
6522 .mixers = { alc882_asus_a7j_mixer, alc882_chmode_mixer,
6523 alc882_capture_mixer },
6524 .init_verbs = { alc882_init_verbs, alc882_asus_a7j_verbs},
6525 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
6526 .dac_nids = alc882_dac_nids,
6527 .dig_out_nid = ALC882_DIGOUT_NID,
6528 .num_adc_nids = ARRAY_SIZE(alc882_adc_nids),
6529 .adc_nids = alc882_adc_nids,
6530 .capsrc_nids = alc882_capsrc_nids,
6531 .num_channel_mode = ARRAY_SIZE(alc882_3ST_6ch_modes),
6532 .channel_mode = alc882_3ST_6ch_modes,
6533 .need_dac_fix = 1,
6534 .input_mux = &alc882_capture_source,
6535 },
6536 [ALC882_ASUS_A7M] = {
6537 .mixers = { alc882_asus_a7m_mixer, alc882_chmode_mixer },
6538 .init_verbs = { alc882_init_verbs, alc882_eapd_verbs,
6539 alc880_gpio1_init_verbs,
6540 alc882_asus_a7m_verbs },
6541 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
6542 .dac_nids = alc882_dac_nids,
6543 .dig_out_nid = ALC882_DIGOUT_NID,
6544 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
6545 .channel_mode = alc880_threestack_modes,
6546 .need_dac_fix = 1,
6547 .input_mux = &alc882_capture_source,
6548 },
6549 };
6550
6551
6552 /*
6553 * Pin config fixes
6554 */
6555 enum {
6556 PINFIX_ABIT_AW9D_MAX
6557 };
6558
6559 static struct alc_pincfg alc882_abit_aw9d_pinfix[] = {
6560 { 0x15, 0x01080104 }, /* side */
6561 { 0x16, 0x01011012 }, /* rear */
6562 { 0x17, 0x01016011 }, /* clfe */
6563 { }
6564 };
6565
6566 static const struct alc_pincfg *alc882_pin_fixes[] = {
6567 [PINFIX_ABIT_AW9D_MAX] = alc882_abit_aw9d_pinfix,
6568 };
6569
6570 static struct snd_pci_quirk alc882_pinfix_tbl[] = {
6571 SND_PCI_QUIRK(0x147b, 0x107a, "Abit AW9D-MAX", PINFIX_ABIT_AW9D_MAX),
6572 {}
6573 };
6574
6575 /*
6576 * BIOS auto configuration
6577 */
6578 static void alc882_auto_set_output_and_unmute(struct hda_codec *codec,
6579 hda_nid_t nid, int pin_type,
6580 int dac_idx)
6581 {
6582 /* set as output */
6583 struct alc_spec *spec = codec->spec;
6584 int idx;
6585
6586 alc_set_pin_output(codec, nid, pin_type);
6587 if (spec->multiout.dac_nids[dac_idx] == 0x25)
6588 idx = 4;
6589 else
6590 idx = spec->multiout.dac_nids[dac_idx] - 2;
6591 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CONNECT_SEL, idx);
6592
6593 }
6594
6595 static void alc882_auto_init_multi_out(struct hda_codec *codec)
6596 {
6597 struct alc_spec *spec = codec->spec;
6598 int i;
6599
6600 alc_subsystem_id(codec, 0x15, 0x1b, 0x14);
6601 for (i = 0; i <= HDA_SIDE; i++) {
6602 hda_nid_t nid = spec->autocfg.line_out_pins[i];
6603 int pin_type = get_pin_type(spec->autocfg.line_out_type);
6604 if (nid)
6605 alc882_auto_set_output_and_unmute(codec, nid, pin_type,
6606 i);
6607 }
6608 }
6609
6610 static void alc882_auto_init_hp_out(struct hda_codec *codec)
6611 {
6612 struct alc_spec *spec = codec->spec;
6613 hda_nid_t pin;
6614
6615 pin = spec->autocfg.hp_pins[0];
6616 if (pin) /* connect to front */
6617 /* use dac 0 */
6618 alc882_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
6619 pin = spec->autocfg.speaker_pins[0];
6620 if (pin)
6621 alc882_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
6622 }
6623
6624 #define alc882_is_input_pin(nid) alc880_is_input_pin(nid)
6625 #define ALC882_PIN_CD_NID ALC880_PIN_CD_NID
6626
6627 static void alc882_auto_init_analog_input(struct hda_codec *codec)
6628 {
6629 struct alc_spec *spec = codec->spec;
6630 int i;
6631
6632 for (i = 0; i < AUTO_PIN_LAST; i++) {
6633 hda_nid_t nid = spec->autocfg.input_pins[i];
6634 unsigned int vref;
6635 if (!nid)
6636 continue;
6637 vref = PIN_IN;
6638 if (1 /*i <= AUTO_PIN_FRONT_MIC*/) {
6639 unsigned int pincap;
6640 pincap = snd_hda_param_read(codec, nid, AC_PAR_PIN_CAP);
6641 if ((pincap >> AC_PINCAP_VREF_SHIFT) &
6642 AC_PINCAP_VREF_80)
6643 vref = PIN_VREF80;
6644 }
6645 snd_hda_codec_write(codec, nid, 0,
6646 AC_VERB_SET_PIN_WIDGET_CONTROL, vref);
6647 if (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP)
6648 snd_hda_codec_write(codec, nid, 0,
6649 AC_VERB_SET_AMP_GAIN_MUTE,
6650 AMP_OUT_MUTE);
6651 }
6652 }
6653
6654 static void alc882_auto_init_input_src(struct hda_codec *codec)
6655 {
6656 struct alc_spec *spec = codec->spec;
6657 const struct hda_input_mux *imux = spec->input_mux;
6658 int c;
6659
6660 for (c = 0; c < spec->num_adc_nids; c++) {
6661 hda_nid_t conn_list[HDA_MAX_NUM_INPUTS];
6662 hda_nid_t nid = spec->capsrc_nids[c];
6663 int conns, mute, idx, item;
6664
6665 conns = snd_hda_get_connections(codec, nid, conn_list,
6666 ARRAY_SIZE(conn_list));
6667 if (conns < 0)
6668 continue;
6669 for (idx = 0; idx < conns; idx++) {
6670 /* if the current connection is the selected one,
6671 * unmute it as default - otherwise mute it
6672 */
6673 mute = AMP_IN_MUTE(idx);
6674 for (item = 0; item < imux->num_items; item++) {
6675 if (imux->items[item].index == idx) {
6676 if (spec->cur_mux[c] == item)
6677 mute = AMP_IN_UNMUTE(idx);
6678 break;
6679 }
6680 }
6681 snd_hda_codec_write(codec, nid, 0,
6682 AC_VERB_SET_AMP_GAIN_MUTE, mute);
6683 }
6684 }
6685 }
6686
6687 /* add mic boosts if needed */
6688 static int alc_auto_add_mic_boost(struct hda_codec *codec)
6689 {
6690 struct alc_spec *spec = codec->spec;
6691 int err;
6692 hda_nid_t nid;
6693
6694 nid = spec->autocfg.input_pins[AUTO_PIN_MIC];
6695 if (nid && (get_wcaps(codec, nid) & AC_WCAP_IN_AMP)) {
6696 err = add_control(spec, ALC_CTL_WIDGET_VOL,
6697 "Mic Boost",
6698 HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT));
6699 if (err < 0)
6700 return err;
6701 }
6702 nid = spec->autocfg.input_pins[AUTO_PIN_FRONT_MIC];
6703 if (nid && (get_wcaps(codec, nid) & AC_WCAP_IN_AMP)) {
6704 err = add_control(spec, ALC_CTL_WIDGET_VOL,
6705 "Front Mic Boost",
6706 HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT));
6707 if (err < 0)
6708 return err;
6709 }
6710 return 0;
6711 }
6712
6713 /* almost identical with ALC880 parser... */
6714 static int alc882_parse_auto_config(struct hda_codec *codec)
6715 {
6716 struct alc_spec *spec = codec->spec;
6717 int err = alc880_parse_auto_config(codec);
6718
6719 if (err < 0)
6720 return err;
6721 else if (!err)
6722 return 0; /* no config found */
6723
6724 err = alc_auto_add_mic_boost(codec);
6725 if (err < 0)
6726 return err;
6727
6728 /* hack - override the init verbs */
6729 spec->init_verbs[0] = alc882_auto_init_verbs;
6730
6731 return 1; /* config found */
6732 }
6733
6734 /* additional initialization for auto-configuration model */
6735 static void alc882_auto_init(struct hda_codec *codec)
6736 {
6737 struct alc_spec *spec = codec->spec;
6738 alc882_auto_init_multi_out(codec);
6739 alc882_auto_init_hp_out(codec);
6740 alc882_auto_init_analog_input(codec);
6741 alc882_auto_init_input_src(codec);
6742 if (spec->unsol_event)
6743 alc_inithook(codec);
6744 }
6745
6746 static int patch_alc883(struct hda_codec *codec); /* called in patch_alc882() */
6747
6748 static int patch_alc882(struct hda_codec *codec)
6749 {
6750 struct alc_spec *spec;
6751 int err, board_config;
6752
6753 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
6754 if (spec == NULL)
6755 return -ENOMEM;
6756
6757 codec->spec = spec;
6758
6759 board_config = snd_hda_check_board_config(codec, ALC882_MODEL_LAST,
6760 alc882_models,
6761 alc882_cfg_tbl);
6762
6763 if (board_config < 0 || board_config >= ALC882_MODEL_LAST) {
6764 /* Pick up systems that don't supply PCI SSID */
6765 switch (codec->subsystem_id) {
6766 case 0x106b0c00: /* Mac Pro */
6767 board_config = ALC885_MACPRO;
6768 break;
6769 case 0x106b1000: /* iMac 24 */
6770 case 0x106b2800: /* AppleTV */
6771 board_config = ALC885_IMAC24;
6772 break;
6773 case 0x106b00a1: /* Macbook (might be wrong - PCI SSID?) */
6774 case 0x106b00a4: /* MacbookPro4,1 */
6775 case 0x106b2c00: /* Macbook Pro rev3 */
6776 case 0x106b3600: /* Macbook 3.1 */
6777 board_config = ALC885_MBP3;
6778 break;
6779 default:
6780 /* ALC889A is handled better as ALC888-compatible */
6781 if (codec->revision_id == 0x100101 ||
6782 codec->revision_id == 0x100103) {
6783 alc_free(codec);
6784 return patch_alc883(codec);
6785 }
6786 printk(KERN_INFO "hda_codec: Unknown model for ALC882, "
6787 "trying auto-probe from BIOS...\n");
6788 board_config = ALC882_AUTO;
6789 }
6790 }
6791
6792 alc_fix_pincfg(codec, alc882_pinfix_tbl, alc882_pin_fixes);
6793
6794 if (board_config == ALC882_AUTO) {
6795 /* automatic parse from the BIOS config */
6796 err = alc882_parse_auto_config(codec);
6797 if (err < 0) {
6798 alc_free(codec);
6799 return err;
6800 } else if (!err) {
6801 printk(KERN_INFO
6802 "hda_codec: Cannot set up configuration "
6803 "from BIOS. Using base mode...\n");
6804 board_config = ALC882_3ST_DIG;
6805 }
6806 }
6807
6808 if (board_config != ALC882_AUTO)
6809 setup_preset(spec, &alc882_presets[board_config]);
6810
6811 if (codec->vendor_id == 0x10ec0885) {
6812 spec->stream_name_analog = "ALC885 Analog";
6813 spec->stream_name_digital = "ALC885 Digital";
6814 } else {
6815 spec->stream_name_analog = "ALC882 Analog";
6816 spec->stream_name_digital = "ALC882 Digital";
6817 }
6818
6819 spec->stream_analog_playback = &alc882_pcm_analog_playback;
6820 spec->stream_analog_capture = &alc882_pcm_analog_capture;
6821 /* FIXME: setup DAC5 */
6822 /*spec->stream_analog_alt_playback = &alc880_pcm_analog_alt_playback;*/
6823 spec->stream_analog_alt_capture = &alc880_pcm_analog_alt_capture;
6824
6825 spec->stream_digital_playback = &alc882_pcm_digital_playback;
6826 spec->stream_digital_capture = &alc882_pcm_digital_capture;
6827
6828 if (!spec->adc_nids && spec->input_mux) {
6829 /* check whether NID 0x07 is valid */
6830 unsigned int wcap = get_wcaps(codec, 0x07);
6831 /* get type */
6832 wcap = (wcap & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
6833 if (wcap != AC_WID_AUD_IN) {
6834 spec->adc_nids = alc882_adc_nids_alt;
6835 spec->num_adc_nids = ARRAY_SIZE(alc882_adc_nids_alt);
6836 spec->capsrc_nids = alc882_capsrc_nids_alt;
6837 spec->mixers[spec->num_mixers] =
6838 alc882_capture_alt_mixer;
6839 spec->num_mixers++;
6840 } else {
6841 spec->adc_nids = alc882_adc_nids;
6842 spec->num_adc_nids = ARRAY_SIZE(alc882_adc_nids);
6843 spec->capsrc_nids = alc882_capsrc_nids;
6844 spec->mixers[spec->num_mixers] = alc882_capture_mixer;
6845 spec->num_mixers++;
6846 }
6847 }
6848
6849 spec->vmaster_nid = 0x0c;
6850
6851 codec->patch_ops = alc_patch_ops;
6852 if (board_config == ALC882_AUTO)
6853 spec->init_hook = alc882_auto_init;
6854 #ifdef CONFIG_SND_HDA_POWER_SAVE
6855 if (!spec->loopback.amplist)
6856 spec->loopback.amplist = alc882_loopbacks;
6857 #endif
6858
6859 return 0;
6860 }
6861
6862 /*
6863 * ALC883 support
6864 *
6865 * ALC883 is almost identical with ALC880 but has cleaner and more flexible
6866 * configuration. Each pin widget can choose any input DACs and a mixer.
6867 * Each ADC is connected from a mixer of all inputs. This makes possible
6868 * 6-channel independent captures.
6869 *
6870 * In addition, an independent DAC for the multi-playback (not used in this
6871 * driver yet).
6872 */
6873 #define ALC883_DIGOUT_NID 0x06
6874 #define ALC883_DIGIN_NID 0x0a
6875
6876 static hda_nid_t alc883_dac_nids[4] = {
6877 /* front, rear, clfe, rear_surr */
6878 0x02, 0x03, 0x04, 0x05
6879 };
6880
6881 static hda_nid_t alc883_adc_nids[2] = {
6882 /* ADC1-2 */
6883 0x08, 0x09,
6884 };
6885
6886 static hda_nid_t alc883_capsrc_nids[2] = { 0x23, 0x22 };
6887
6888 /* input MUX */
6889 /* FIXME: should be a matrix-type input source selection */
6890
6891 static struct hda_input_mux alc883_capture_source = {
6892 .num_items = 4,
6893 .items = {
6894 { "Mic", 0x0 },
6895 { "Front Mic", 0x1 },
6896 { "Line", 0x2 },
6897 { "CD", 0x4 },
6898 },
6899 };
6900
6901 static struct hda_input_mux alc883_3stack_6ch_intel = {
6902 .num_items = 4,
6903 .items = {
6904 { "Mic", 0x1 },
6905 { "Front Mic", 0x0 },
6906 { "Line", 0x2 },
6907 { "CD", 0x4 },
6908 },
6909 };
6910
6911 static struct hda_input_mux alc883_lenovo_101e_capture_source = {
6912 .num_items = 2,
6913 .items = {
6914 { "Mic", 0x1 },
6915 { "Line", 0x2 },
6916 },
6917 };
6918
6919 static struct hda_input_mux alc883_lenovo_nb0763_capture_source = {
6920 .num_items = 4,
6921 .items = {
6922 { "Mic", 0x0 },
6923 { "iMic", 0x1 },
6924 { "Line", 0x2 },
6925 { "CD", 0x4 },
6926 },
6927 };
6928
6929 static struct hda_input_mux alc883_fujitsu_pi2515_capture_source = {
6930 .num_items = 2,
6931 .items = {
6932 { "Mic", 0x0 },
6933 { "Int Mic", 0x1 },
6934 },
6935 };
6936
6937 static struct hda_input_mux alc883_lenovo_sky_capture_source = {
6938 .num_items = 3,
6939 .items = {
6940 { "Mic", 0x0 },
6941 { "Front Mic", 0x1 },
6942 { "Line", 0x4 },
6943 },
6944 };
6945
6946 static struct hda_input_mux alc883_asus_eee1601_capture_source = {
6947 .num_items = 2,
6948 .items = {
6949 { "Mic", 0x0 },
6950 { "Line", 0x2 },
6951 },
6952 };
6953
6954 #define alc883_mux_enum_info alc_mux_enum_info
6955 #define alc883_mux_enum_get alc_mux_enum_get
6956 /* ALC883 has the ALC882-type input selection */
6957 #define alc883_mux_enum_put alc882_mux_enum_put
6958
6959 /*
6960 * 2ch mode
6961 */
6962 static struct hda_channel_mode alc883_3ST_2ch_modes[1] = {
6963 { 2, NULL }
6964 };
6965
6966 /*
6967 * 2ch mode
6968 */
6969 static struct hda_verb alc883_3ST_ch2_init[] = {
6970 { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
6971 { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6972 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
6973 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6974 { } /* end */
6975 };
6976
6977 /*
6978 * 4ch mode
6979 */
6980 static struct hda_verb alc883_3ST_ch4_init[] = {
6981 { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
6982 { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6983 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6984 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6985 { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
6986 { } /* end */
6987 };
6988
6989 /*
6990 * 6ch mode
6991 */
6992 static struct hda_verb alc883_3ST_ch6_init[] = {
6993 { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6994 { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6995 { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
6996 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6997 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6998 { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
6999 { } /* end */
7000 };
7001
7002 static struct hda_channel_mode alc883_3ST_6ch_modes[3] = {
7003 { 2, alc883_3ST_ch2_init },
7004 { 4, alc883_3ST_ch4_init },
7005 { 6, alc883_3ST_ch6_init },
7006 };
7007
7008 /*
7009 * 2ch mode
7010 */
7011 static struct hda_verb alc883_3ST_ch2_intel_init[] = {
7012 { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
7013 { 0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7014 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
7015 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7016 { } /* end */
7017 };
7018
7019 /*
7020 * 4ch mode
7021 */
7022 static struct hda_verb alc883_3ST_ch4_intel_init[] = {
7023 { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
7024 { 0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7025 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7026 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7027 { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
7028 { } /* end */
7029 };
7030
7031 /*
7032 * 6ch mode
7033 */
7034 static struct hda_verb alc883_3ST_ch6_intel_init[] = {
7035 { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7036 { 0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7037 { 0x19, AC_VERB_SET_CONNECT_SEL, 0x02 },
7038 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7039 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7040 { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
7041 { } /* end */
7042 };
7043
7044 static struct hda_channel_mode alc883_3ST_6ch_intel_modes[3] = {
7045 { 2, alc883_3ST_ch2_intel_init },
7046 { 4, alc883_3ST_ch4_intel_init },
7047 { 6, alc883_3ST_ch6_intel_init },
7048 };
7049
7050 /*
7051 * 6ch mode
7052 */
7053 static struct hda_verb alc883_sixstack_ch6_init[] = {
7054 { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
7055 { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7056 { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7057 { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7058 { } /* end */
7059 };
7060
7061 /*
7062 * 8ch mode
7063 */
7064 static struct hda_verb alc883_sixstack_ch8_init[] = {
7065 { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7066 { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7067 { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7068 { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7069 { } /* end */
7070 };
7071
7072 static struct hda_channel_mode alc883_sixstack_modes[2] = {
7073 { 6, alc883_sixstack_ch6_init },
7074 { 8, alc883_sixstack_ch8_init },
7075 };
7076
7077 static struct hda_verb alc883_medion_eapd_verbs[] = {
7078 /* eanable EAPD on medion laptop */
7079 {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
7080 {0x20, AC_VERB_SET_PROC_COEF, 0x3070},
7081 { }
7082 };
7083
7084 /* Pin assignment: Front=0x14, Rear=0x15, CLFE=0x16, Side=0x17
7085 * Mic=0x18, Front Mic=0x19, Line-In=0x1a, HP=0x1b
7086 */
7087
7088 static struct snd_kcontrol_new alc883_base_mixer[] = {
7089 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7090 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7091 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
7092 HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
7093 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
7094 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
7095 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
7096 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
7097 HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
7098 HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
7099 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
7100 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7101 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7102 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7103 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7104 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7105 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7106 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7107 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7108 HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
7109 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7110 HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
7111 HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
7112 HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
7113 HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
7114 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT),
7115 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT),
7116 {
7117 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
7118 /* .name = "Capture Source", */
7119 .name = "Input Source",
7120 .count = 2,
7121 .info = alc883_mux_enum_info,
7122 .get = alc883_mux_enum_get,
7123 .put = alc883_mux_enum_put,
7124 },
7125 { } /* end */
7126 };
7127
7128 static struct snd_kcontrol_new alc883_mitac_mixer[] = {
7129 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7130 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7131 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
7132 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
7133 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
7134 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
7135 HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
7136 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7137 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7138 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7139 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7140 HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
7141 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7142 HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
7143 HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
7144 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT),
7145 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT),
7146 {
7147 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
7148 /* .name = "Capture Source", */
7149 .name = "Input Source",
7150 .count = 2,
7151 .info = alc883_mux_enum_info,
7152 .get = alc883_mux_enum_get,
7153 .put = alc883_mux_enum_put,
7154 },
7155 { } /* end */
7156 };
7157
7158 static struct snd_kcontrol_new alc883_clevo_m720_mixer[] = {
7159 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7160 HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
7161 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
7162 HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
7163 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7164 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7165 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7166 HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7167 HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
7168 HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7169 HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
7170 HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
7171 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT),
7172 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT),
7173 {
7174 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
7175 /* .name = "Capture Source", */
7176 .name = "Input Source",
7177 .count = 2,
7178 .info = alc883_mux_enum_info,
7179 .get = alc883_mux_enum_get,
7180 .put = alc883_mux_enum_put,
7181 },
7182 { } /* end */
7183 };
7184
7185 static struct snd_kcontrol_new alc883_2ch_fujitsu_pi2515_mixer[] = {
7186 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7187 HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
7188 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
7189 HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
7190 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7191 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7192 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7193 HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7194 HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
7195 HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7196 HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
7197 HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
7198 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT),
7199 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT),
7200 {
7201 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
7202 /* .name = "Capture Source", */
7203 .name = "Input Source",
7204 .count = 2,
7205 .info = alc883_mux_enum_info,
7206 .get = alc883_mux_enum_get,
7207 .put = alc883_mux_enum_put,
7208 },
7209 { } /* end */
7210 };
7211
7212 static struct snd_kcontrol_new alc883_3ST_2ch_mixer[] = {
7213 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7214 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7215 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
7216 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7217 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7218 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7219 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7220 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7221 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7222 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7223 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7224 HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
7225 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7226 HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
7227 HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
7228 HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
7229 HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
7230 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT),
7231 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT),
7232 {
7233 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
7234 /* .name = "Capture Source", */
7235 .name = "Input Source",
7236 .count = 2,
7237 .info = alc883_mux_enum_info,
7238 .get = alc883_mux_enum_get,
7239 .put = alc883_mux_enum_put,
7240 },
7241 { } /* end */
7242 };
7243
7244 static struct snd_kcontrol_new alc883_3ST_6ch_mixer[] = {
7245 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7246 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7247 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
7248 HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
7249 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
7250 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
7251 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
7252 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
7253 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
7254 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7255 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7256 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7257 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7258 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7259 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7260 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7261 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7262 HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
7263 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7264 HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
7265 HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
7266 HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
7267 HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
7268 {
7269 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
7270 /* .name = "Capture Source", */
7271 .name = "Input Source",
7272 .count = 1,
7273 .info = alc883_mux_enum_info,
7274 .get = alc883_mux_enum_get,
7275 .put = alc883_mux_enum_put,
7276 },
7277 { } /* end */
7278 };
7279
7280 static struct snd_kcontrol_new alc883_3ST_6ch_intel_mixer[] = {
7281 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7282 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7283 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
7284 HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
7285 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0,
7286 HDA_OUTPUT),
7287 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
7288 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
7289 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
7290 HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
7291 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7292 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7293 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7294 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7295 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7296 HDA_CODEC_VOLUME("Mic Boost", 0x19, 0, HDA_INPUT),
7297 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7298 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7299 HDA_CODEC_VOLUME("Front Mic Boost", 0x18, 0, HDA_INPUT),
7300 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7301 HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
7302 HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
7303 HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
7304 HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
7305 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT),
7306 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT),
7307 {
7308 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
7309 /* .name = "Capture Source", */
7310 .name = "Input Source",
7311 .count = 2,
7312 .info = alc883_mux_enum_info,
7313 .get = alc883_mux_enum_get,
7314 .put = alc883_mux_enum_put,
7315 },
7316 { } /* end */
7317 };
7318
7319 static struct snd_kcontrol_new alc883_fivestack_mixer[] = {
7320 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7321 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7322 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
7323 HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
7324 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
7325 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
7326 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
7327 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
7328 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
7329 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7330 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7331 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7332 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7333 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7334 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7335 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7336 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7337 HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
7338 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7339 HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
7340 HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
7341 HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
7342 HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
7343
7344 {
7345 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
7346 /* .name = "Capture Source", */
7347 .name = "Input Source",
7348 .count = 1,
7349 .info = alc883_mux_enum_info,
7350 .get = alc883_mux_enum_get,
7351 .put = alc883_mux_enum_put,
7352 },
7353 { } /* end */
7354 };
7355
7356 static struct snd_kcontrol_new alc883_tagra_mixer[] = {
7357 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7358 HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
7359 HDA_CODEC_MUTE("Front Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
7360 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
7361 HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
7362 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
7363 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
7364 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
7365 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
7366 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7367 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7368 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7369 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7370 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7371 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7372 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7373 HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
7374 HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
7375 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT),
7376 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT),
7377 {
7378 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
7379 /* .name = "Capture Source", */
7380 .name = "Input Source",
7381 .count = 2,
7382 .info = alc883_mux_enum_info,
7383 .get = alc883_mux_enum_get,
7384 .put = alc883_mux_enum_put,
7385 },
7386 { } /* end */
7387 };
7388
7389 static struct snd_kcontrol_new alc883_tagra_2ch_mixer[] = {
7390 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7391 HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
7392 HDA_CODEC_MUTE("Front Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
7393 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7394 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7395 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7396 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7397 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7398 HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7399 HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
7400 HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7401 HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
7402 HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
7403 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT),
7404 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT),
7405 {
7406 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
7407 /* .name = "Capture Source", */
7408 .name = "Input Source",
7409 .count = 2,
7410 .info = alc883_mux_enum_info,
7411 .get = alc883_mux_enum_get,
7412 .put = alc883_mux_enum_put,
7413 },
7414 { } /* end */
7415 };
7416
7417 static struct snd_kcontrol_new alc883_lenovo_101e_2ch_mixer[] = {
7418 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7419 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7420 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
7421 HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
7422 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
7423 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7424 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7425 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7426 HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
7427 HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
7428 {
7429 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
7430 /* .name = "Capture Source", */
7431 .name = "Input Source",
7432 .count = 1,
7433 .info = alc883_mux_enum_info,
7434 .get = alc883_mux_enum_get,
7435 .put = alc883_mux_enum_put,
7436 },
7437 { } /* end */
7438 };
7439
7440 static struct snd_kcontrol_new alc883_lenovo_nb0763_mixer[] = {
7441 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7442 HDA_BIND_MUTE("Speaker Playback Switch", 0x0c, 2, HDA_INPUT),
7443 HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
7444 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7445 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7446 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7447 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7448 HDA_CODEC_VOLUME("iMic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7449 HDA_CODEC_MUTE("iMic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7450 HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
7451 HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
7452 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT),
7453 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT),
7454 {
7455 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
7456 /* .name = "Capture Source", */
7457 .name = "Input Source",
7458 .count = 2,
7459 .info = alc883_mux_enum_info,
7460 .get = alc883_mux_enum_get,
7461 .put = alc883_mux_enum_put,
7462 },
7463 { } /* end */
7464 };
7465
7466 static struct snd_kcontrol_new alc883_medion_md2_mixer[] = {
7467 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7468 HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
7469 HDA_CODEC_MUTE("Front Playback Switch", 0x15, 0x0, HDA_OUTPUT),
7470 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7471 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7472 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7473 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7474 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7475 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7476 HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
7477 HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
7478 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT),
7479 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT),
7480 {
7481 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
7482 /* .name = "Capture Source", */
7483 .name = "Input Source",
7484 .count = 2,
7485 .info = alc883_mux_enum_info,
7486 .get = alc883_mux_enum_get,
7487 .put = alc883_mux_enum_put,
7488 },
7489 { } /* end */
7490 };
7491
7492 static struct snd_kcontrol_new alc883_acer_aspire_mixer[] = {
7493 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7494 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7495 HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
7496 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7497 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7498 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7499 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7500 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7501 HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
7502 HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
7503 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT),
7504 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT),
7505 {
7506 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
7507 /* .name = "Capture Source", */
7508 .name = "Input Source",
7509 .count = 2,
7510 .info = alc883_mux_enum_info,
7511 .get = alc883_mux_enum_get,
7512 .put = alc883_mux_enum_put,
7513 },
7514 { } /* end */
7515 };
7516
7517 static struct snd_kcontrol_new alc888_lenovo_sky_mixer[] = {
7518 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7519 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7520 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0e, 0x0, HDA_OUTPUT),
7521 HDA_BIND_MUTE("Surround Playback Switch", 0x0e, 2, HDA_INPUT),
7522 HDA_CODEC_VOLUME_MONO("Center Playback Volume",
7523 0x0d, 1, 0x0, HDA_OUTPUT),
7524 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0d, 2, 0x0, HDA_OUTPUT),
7525 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0d, 1, 2, HDA_INPUT),
7526 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0d, 2, 2, HDA_INPUT),
7527 HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
7528 HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
7529 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
7530 HDA_CODEC_MUTE("iSpeaker Playback Switch", 0x1a, 0x0, HDA_OUTPUT),
7531 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7532 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7533 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7534 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7535 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7536 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7537 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7538 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7539 HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
7540 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7541 HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
7542 HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
7543 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT),
7544 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT),
7545 {
7546 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
7547 /* .name = "Capture Source", */
7548 .name = "Input Source",
7549 .count = 2,
7550 .info = alc883_mux_enum_info,
7551 .get = alc883_mux_enum_get,
7552 .put = alc883_mux_enum_put,
7553 },
7554 { } /* end */
7555 };
7556
7557 static struct hda_bind_ctls alc883_bind_cap_vol = {
7558 .ops = &snd_hda_bind_vol,
7559 .values = {
7560 HDA_COMPOSE_AMP_VAL(0x08, 3, 0, HDA_INPUT),
7561 HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_INPUT),
7562 0
7563 },
7564 };
7565
7566 static struct hda_bind_ctls alc883_bind_cap_switch = {
7567 .ops = &snd_hda_bind_sw,
7568 .values = {
7569 HDA_COMPOSE_AMP_VAL(0x08, 3, 0, HDA_INPUT),
7570 HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_INPUT),
7571 0
7572 },
7573 };
7574
7575 static struct snd_kcontrol_new alc883_asus_eee1601_mixer[] = {
7576 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7577 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7578 HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
7579 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7580 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7581 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7582 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7583 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7584 HDA_BIND_VOL("Capture Volume", &alc883_bind_cap_vol),
7585 HDA_BIND_SW("Capture Switch", &alc883_bind_cap_switch),
7586 {
7587 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
7588 /* .name = "Capture Source", */
7589 .name = "Input Source",
7590 .count = 1,
7591 .info = alc883_mux_enum_info,
7592 .get = alc883_mux_enum_get,
7593 .put = alc883_mux_enum_put,
7594 },
7595 { } /* end */
7596 };
7597
7598 static struct snd_kcontrol_new alc883_chmode_mixer[] = {
7599 {
7600 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
7601 .name = "Channel Mode",
7602 .info = alc_ch_mode_info,
7603 .get = alc_ch_mode_get,
7604 .put = alc_ch_mode_put,
7605 },
7606 { } /* end */
7607 };
7608
7609 static struct hda_verb alc883_init_verbs[] = {
7610 /* ADC1: mute amp left and right */
7611 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7612 {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
7613 /* ADC2: mute amp left and right */
7614 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7615 {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
7616 /* Front mixer: unmute input/output amp left and right (volume = 0) */
7617 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7618 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7619 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7620 /* Rear mixer */
7621 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7622 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7623 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7624 /* CLFE mixer */
7625 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7626 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7627 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7628 /* Side mixer */
7629 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7630 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7631 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7632
7633 /* mute analog input loopbacks */
7634 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7635 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7636 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7637 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7638 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7639
7640 /* Front Pin: output 0 (0x0c) */
7641 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7642 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7643 {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
7644 /* Rear Pin: output 1 (0x0d) */
7645 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7646 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7647 {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
7648 /* CLFE Pin: output 2 (0x0e) */
7649 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7650 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7651 {0x16, AC_VERB_SET_CONNECT_SEL, 0x02},
7652 /* Side Pin: output 3 (0x0f) */
7653 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7654 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7655 {0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
7656 /* Mic (rear) pin: input vref at 80% */
7657 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
7658 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7659 /* Front Mic pin: input vref at 80% */
7660 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
7661 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7662 /* Line In pin: input */
7663 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
7664 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7665 /* Line-2 In: Headphone output (output 0 - 0x0c) */
7666 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7667 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7668 {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
7669 /* CD pin widget for input */
7670 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
7671
7672 /* FIXME: use matrix-type input source selection */
7673 /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
7674 /* Input mixer2 */
7675 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7676 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7677 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7678 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7679 /* Input mixer3 */
7680 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7681 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7682 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7683 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7684 { }
7685 };
7686
7687 /* toggle speaker-output according to the hp-jack state */
7688 static void alc883_mitac_hp_automute(struct hda_codec *codec)
7689 {
7690 unsigned int present;
7691
7692 present = snd_hda_codec_read(codec, 0x15, 0,
7693 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
7694 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
7695 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
7696 snd_hda_codec_amp_stereo(codec, 0x17, HDA_OUTPUT, 0,
7697 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
7698 }
7699
7700 /* auto-toggle front mic */
7701 /*
7702 static void alc883_mitac_mic_automute(struct hda_codec *codec)
7703 {
7704 unsigned int present;
7705 unsigned char bits;
7706
7707 present = snd_hda_codec_read(codec, 0x18, 0,
7708 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
7709 bits = present ? HDA_AMP_MUTE : 0;
7710 snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1, HDA_AMP_MUTE, bits);
7711 }
7712 */
7713
7714 static void alc883_mitac_automute(struct hda_codec *codec)
7715 {
7716 alc883_mitac_hp_automute(codec);
7717 /* alc883_mitac_mic_automute(codec); */
7718 }
7719
7720 static void alc883_mitac_unsol_event(struct hda_codec *codec,
7721 unsigned int res)
7722 {
7723 switch (res >> 26) {
7724 case ALC880_HP_EVENT:
7725 alc883_mitac_hp_automute(codec);
7726 break;
7727 case ALC880_MIC_EVENT:
7728 /* alc883_mitac_mic_automute(codec); */
7729 break;
7730 }
7731 }
7732
7733 static struct hda_verb alc883_mitac_verbs[] = {
7734 /* HP */
7735 {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
7736 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7737 /* Subwoofer */
7738 {0x17, AC_VERB_SET_CONNECT_SEL, 0x02},
7739 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7740
7741 /* enable unsolicited event */
7742 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
7743 /* {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN}, */
7744
7745 { } /* end */
7746 };
7747
7748 static struct hda_verb alc883_clevo_m720_verbs[] = {
7749 /* HP */
7750 {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
7751 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7752 /* Int speaker */
7753 {0x14, AC_VERB_SET_CONNECT_SEL, 0x01},
7754 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7755
7756 /* enable unsolicited event */
7757 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
7758 {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN},
7759
7760 { } /* end */
7761 };
7762
7763 static struct hda_verb alc883_2ch_fujitsu_pi2515_verbs[] = {
7764 /* HP */
7765 {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
7766 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7767 /* Subwoofer */
7768 {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
7769 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7770
7771 /* enable unsolicited event */
7772 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
7773
7774 { } /* end */
7775 };
7776
7777 static struct hda_verb alc883_tagra_verbs[] = {
7778 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7779 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7780
7781 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7782 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7783
7784 {0x18, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
7785 {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/surround */
7786 {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
7787
7788 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
7789 {0x01, AC_VERB_SET_GPIO_MASK, 0x03},
7790 {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x03},
7791 {0x01, AC_VERB_SET_GPIO_DATA, 0x03},
7792
7793 { } /* end */
7794 };
7795
7796 static struct hda_verb alc883_lenovo_101e_verbs[] = {
7797 {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
7798 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_FRONT_EVENT|AC_USRSP_EN},
7799 {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT|AC_USRSP_EN},
7800 { } /* end */
7801 };
7802
7803 static struct hda_verb alc883_lenovo_nb0763_verbs[] = {
7804 {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
7805 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7806 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
7807 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7808 { } /* end */
7809 };
7810
7811 static struct hda_verb alc888_lenovo_ms7195_verbs[] = {
7812 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7813 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7814 {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
7815 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_FRONT_EVENT | AC_USRSP_EN},
7816 {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
7817 { } /* end */
7818 };
7819
7820 static struct hda_verb alc883_haier_w66_verbs[] = {
7821 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7822 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7823
7824 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7825
7826 {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
7827 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7828 {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
7829 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7830 { } /* end */
7831 };
7832
7833 static struct hda_verb alc888_lenovo_sky_verbs[] = {
7834 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7835 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7836 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7837 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7838 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7839 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7840 {0x1a, AC_VERB_SET_CONNECT_SEL, 0x00},
7841 {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
7842 { } /* end */
7843 };
7844
7845 static struct hda_verb alc888_3st_hp_verbs[] = {
7846 {0x14, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front: output 0 (0x0c) */
7847 {0x16, AC_VERB_SET_CONNECT_SEL, 0x01}, /* Rear : output 1 (0x0d) */
7848 {0x18, AC_VERB_SET_CONNECT_SEL, 0x02}, /* CLFE : output 2 (0x0e) */
7849 { }
7850 };
7851
7852 static struct hda_verb alc888_6st_dell_verbs[] = {
7853 {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
7854 { }
7855 };
7856
7857 static struct hda_verb alc888_3st_hp_2ch_init[] = {
7858 { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
7859 { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7860 { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
7861 { 0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7862 { }
7863 };
7864
7865 static struct hda_verb alc888_3st_hp_6ch_init[] = {
7866 { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7867 { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7868 { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7869 { 0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7870 { }
7871 };
7872
7873 static struct hda_channel_mode alc888_3st_hp_modes[2] = {
7874 { 2, alc888_3st_hp_2ch_init },
7875 { 6, alc888_3st_hp_6ch_init },
7876 };
7877
7878 /* toggle front-jack and RCA according to the hp-jack state */
7879 static void alc888_lenovo_ms7195_front_automute(struct hda_codec *codec)
7880 {
7881 unsigned int present;
7882
7883 present = snd_hda_codec_read(codec, 0x1b, 0,
7884 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
7885 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
7886 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
7887 snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
7888 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
7889 }
7890
7891 /* toggle RCA according to the front-jack state */
7892 static void alc888_lenovo_ms7195_rca_automute(struct hda_codec *codec)
7893 {
7894 unsigned int present;
7895
7896 present = snd_hda_codec_read(codec, 0x14, 0,
7897 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
7898 snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
7899 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
7900 }
7901
7902 static void alc883_lenovo_ms7195_unsol_event(struct hda_codec *codec,
7903 unsigned int res)
7904 {
7905 if ((res >> 26) == ALC880_HP_EVENT)
7906 alc888_lenovo_ms7195_front_automute(codec);
7907 if ((res >> 26) == ALC880_FRONT_EVENT)
7908 alc888_lenovo_ms7195_rca_automute(codec);
7909 }
7910
7911 static struct hda_verb alc883_medion_md2_verbs[] = {
7912 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7913 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7914
7915 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7916
7917 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
7918 { } /* end */
7919 };
7920
7921 /* toggle speaker-output according to the hp-jack state */
7922 static void alc883_medion_md2_automute(struct hda_codec *codec)
7923 {
7924 unsigned int present;
7925
7926 present = snd_hda_codec_read(codec, 0x14, 0,
7927 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
7928 snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
7929 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
7930 }
7931
7932 static void alc883_medion_md2_unsol_event(struct hda_codec *codec,
7933 unsigned int res)
7934 {
7935 if ((res >> 26) == ALC880_HP_EVENT)
7936 alc883_medion_md2_automute(codec);
7937 }
7938
7939 /* toggle speaker-output according to the hp-jack state */
7940 static void alc883_tagra_automute(struct hda_codec *codec)
7941 {
7942 unsigned int present;
7943 unsigned char bits;
7944
7945 present = snd_hda_codec_read(codec, 0x14, 0,
7946 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
7947 bits = present ? HDA_AMP_MUTE : 0;
7948 snd_hda_codec_amp_stereo(codec, 0x1b, HDA_OUTPUT, 0,
7949 HDA_AMP_MUTE, bits);
7950 snd_hda_codec_write_cache(codec, 1, 0, AC_VERB_SET_GPIO_DATA,
7951 present ? 1 : 3);
7952 }
7953
7954 static void alc883_tagra_unsol_event(struct hda_codec *codec, unsigned int res)
7955 {
7956 if ((res >> 26) == ALC880_HP_EVENT)
7957 alc883_tagra_automute(codec);
7958 }
7959
7960 /* toggle speaker-output according to the hp-jack state */
7961 static void alc883_clevo_m720_hp_automute(struct hda_codec *codec)
7962 {
7963 unsigned int present;
7964 unsigned char bits;
7965
7966 present = snd_hda_codec_read(codec, 0x15, 0, AC_VERB_GET_PIN_SENSE, 0)
7967 & AC_PINSENSE_PRESENCE;
7968 bits = present ? HDA_AMP_MUTE : 0;
7969 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
7970 HDA_AMP_MUTE, bits);
7971 }
7972
7973 static void alc883_clevo_m720_mic_automute(struct hda_codec *codec)
7974 {
7975 unsigned int present;
7976
7977 present = snd_hda_codec_read(codec, 0x18, 0,
7978 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
7979 snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1,
7980 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
7981 }
7982
7983 static void alc883_clevo_m720_automute(struct hda_codec *codec)
7984 {
7985 alc883_clevo_m720_hp_automute(codec);
7986 alc883_clevo_m720_mic_automute(codec);
7987 }
7988
7989 static void alc883_clevo_m720_unsol_event(struct hda_codec *codec,
7990 unsigned int res)
7991 {
7992 switch (res >> 26) {
7993 case ALC880_HP_EVENT:
7994 alc883_clevo_m720_hp_automute(codec);
7995 break;
7996 case ALC880_MIC_EVENT:
7997 alc883_clevo_m720_mic_automute(codec);
7998 break;
7999 }
8000 }
8001
8002 /* toggle speaker-output according to the hp-jack state */
8003 static void alc883_2ch_fujitsu_pi2515_automute(struct hda_codec *codec)
8004 {
8005 unsigned int present;
8006 unsigned char bits;
8007
8008 present = snd_hda_codec_read(codec, 0x14, 0, AC_VERB_GET_PIN_SENSE, 0)
8009 & AC_PINSENSE_PRESENCE;
8010 bits = present ? HDA_AMP_MUTE : 0;
8011 snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
8012 HDA_AMP_MUTE, bits);
8013 }
8014
8015 static void alc883_2ch_fujitsu_pi2515_unsol_event(struct hda_codec *codec,
8016 unsigned int res)
8017 {
8018 if ((res >> 26) == ALC880_HP_EVENT)
8019 alc883_2ch_fujitsu_pi2515_automute(codec);
8020 }
8021
8022 static void alc883_haier_w66_automute(struct hda_codec *codec)
8023 {
8024 unsigned int present;
8025 unsigned char bits;
8026
8027 present = snd_hda_codec_read(codec, 0x1b, 0,
8028 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
8029 bits = present ? 0x80 : 0;
8030 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
8031 0x80, bits);
8032 }
8033
8034 static void alc883_haier_w66_unsol_event(struct hda_codec *codec,
8035 unsigned int res)
8036 {
8037 if ((res >> 26) == ALC880_HP_EVENT)
8038 alc883_haier_w66_automute(codec);
8039 }
8040
8041 static void alc883_lenovo_101e_ispeaker_automute(struct hda_codec *codec)
8042 {
8043 unsigned int present;
8044 unsigned char bits;
8045
8046 present = snd_hda_codec_read(codec, 0x14, 0,
8047 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
8048 bits = present ? HDA_AMP_MUTE : 0;
8049 snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
8050 HDA_AMP_MUTE, bits);
8051 }
8052
8053 static void alc883_lenovo_101e_all_automute(struct hda_codec *codec)
8054 {
8055 unsigned int present;
8056 unsigned char bits;
8057
8058 present = snd_hda_codec_read(codec, 0x1b, 0,
8059 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
8060 bits = present ? HDA_AMP_MUTE : 0;
8061 snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
8062 HDA_AMP_MUTE, bits);
8063 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
8064 HDA_AMP_MUTE, bits);
8065 }
8066
8067 static void alc883_lenovo_101e_unsol_event(struct hda_codec *codec,
8068 unsigned int res)
8069 {
8070 if ((res >> 26) == ALC880_HP_EVENT)
8071 alc883_lenovo_101e_all_automute(codec);
8072 if ((res >> 26) == ALC880_FRONT_EVENT)
8073 alc883_lenovo_101e_ispeaker_automute(codec);
8074 }
8075
8076 /* toggle speaker-output according to the hp-jack state */
8077 static void alc883_acer_aspire_automute(struct hda_codec *codec)
8078 {
8079 unsigned int present;
8080
8081 present = snd_hda_codec_read(codec, 0x14, 0,
8082 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
8083 snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
8084 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
8085 snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
8086 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
8087 }
8088
8089 static void alc883_acer_aspire_unsol_event(struct hda_codec *codec,
8090 unsigned int res)
8091 {
8092 if ((res >> 26) == ALC880_HP_EVENT)
8093 alc883_acer_aspire_automute(codec);
8094 }
8095
8096 static struct hda_verb alc883_acer_eapd_verbs[] = {
8097 /* HP Pin: output 0 (0x0c) */
8098 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8099 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8100 {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
8101 /* Front Pin: output 0 (0x0c) */
8102 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8103 {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
8104 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8105 {0x16, AC_VERB_SET_CONNECT_SEL, 0x00},
8106 /* eanable EAPD on medion laptop */
8107 {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
8108 {0x20, AC_VERB_SET_PROC_COEF, 0x3050},
8109 /* enable unsolicited event */
8110 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8111 { }
8112 };
8113
8114 static void alc888_6st_dell_front_automute(struct hda_codec *codec)
8115 {
8116 unsigned int present;
8117
8118 present = snd_hda_codec_read(codec, 0x1b, 0,
8119 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
8120 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
8121 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
8122 snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
8123 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
8124 snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
8125 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
8126 snd_hda_codec_amp_stereo(codec, 0x17, HDA_OUTPUT, 0,
8127 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
8128 }
8129
8130 static void alc888_6st_dell_unsol_event(struct hda_codec *codec,
8131 unsigned int res)
8132 {
8133 switch (res >> 26) {
8134 case ALC880_HP_EVENT:
8135 printk("hp_event\n");
8136 alc888_6st_dell_front_automute(codec);
8137 break;
8138 }
8139 }
8140
8141 static void alc888_lenovo_sky_front_automute(struct hda_codec *codec)
8142 {
8143 unsigned int mute;
8144 unsigned int present;
8145
8146 snd_hda_codec_read(codec, 0x1b, 0, AC_VERB_SET_PIN_SENSE, 0);
8147 present = snd_hda_codec_read(codec, 0x1b, 0,
8148 AC_VERB_GET_PIN_SENSE, 0);
8149 present = (present & 0x80000000) != 0;
8150 if (present) {
8151 /* mute internal speaker */
8152 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
8153 HDA_AMP_MUTE, HDA_AMP_MUTE);
8154 snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
8155 HDA_AMP_MUTE, HDA_AMP_MUTE);
8156 snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
8157 HDA_AMP_MUTE, HDA_AMP_MUTE);
8158 snd_hda_codec_amp_stereo(codec, 0x17, HDA_OUTPUT, 0,
8159 HDA_AMP_MUTE, HDA_AMP_MUTE);
8160 snd_hda_codec_amp_stereo(codec, 0x1a, HDA_OUTPUT, 0,
8161 HDA_AMP_MUTE, HDA_AMP_MUTE);
8162 } else {
8163 /* unmute internal speaker if necessary */
8164 mute = snd_hda_codec_amp_read(codec, 0x1b, 0, HDA_OUTPUT, 0);
8165 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
8166 HDA_AMP_MUTE, mute);
8167 snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
8168 HDA_AMP_MUTE, mute);
8169 snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
8170 HDA_AMP_MUTE, mute);
8171 snd_hda_codec_amp_stereo(codec, 0x17, HDA_OUTPUT, 0,
8172 HDA_AMP_MUTE, mute);
8173 snd_hda_codec_amp_stereo(codec, 0x1a, HDA_OUTPUT, 0,
8174 HDA_AMP_MUTE, mute);
8175 }
8176 }
8177
8178 static void alc883_lenovo_sky_unsol_event(struct hda_codec *codec,
8179 unsigned int res)
8180 {
8181 if ((res >> 26) == ALC880_HP_EVENT)
8182 alc888_lenovo_sky_front_automute(codec);
8183 }
8184
8185 /*
8186 * generic initialization of ADC, input mixers and output mixers
8187 */
8188 static struct hda_verb alc883_auto_init_verbs[] = {
8189 /*
8190 * Unmute ADC0-2 and set the default input to mic-in
8191 */
8192 {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
8193 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8194 {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
8195 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8196
8197 /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
8198 * mixer widget
8199 * Note: PASD motherboards uses the Line In 2 as the input for
8200 * front panel mic (mic 2)
8201 */
8202 /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
8203 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8204 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8205 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
8206 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
8207 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
8208
8209 /*
8210 * Set up output mixers (0x0c - 0x0f)
8211 */
8212 /* set vol=0 to output mixers */
8213 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8214 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8215 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8216 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8217 /* set up input amps for analog loopback */
8218 /* Amp Indices: DAC = 0, mixer = 1 */
8219 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8220 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8221 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8222 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8223 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8224 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8225 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8226 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8227 {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8228 {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8229
8230 /* FIXME: use matrix-type input source selection */
8231 /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
8232 /* Input mixer1 */
8233 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8234 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8235 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
8236 /* {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)}, */
8237 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
8238 /* Input mixer2 */
8239 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8240 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8241 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
8242 /* {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)}, */
8243 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
8244
8245 { }
8246 };
8247
8248 /* capture mixer elements */
8249 static struct snd_kcontrol_new alc883_capture_mixer[] = {
8250 HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
8251 HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
8252 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT),
8253 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT),
8254 {
8255 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
8256 /* The multiple "Capture Source" controls confuse alsamixer
8257 * So call somewhat different..
8258 */
8259 /* .name = "Capture Source", */
8260 .name = "Input Source",
8261 .count = 2,
8262 .info = alc882_mux_enum_info,
8263 .get = alc882_mux_enum_get,
8264 .put = alc882_mux_enum_put,
8265 },
8266 { } /* end */
8267 };
8268
8269 static struct hda_verb alc888_asus_m90v_verbs[] = {
8270 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8271 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8272 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8273 /* enable unsolicited event */
8274 {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8275 {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN},
8276 { } /* end */
8277 };
8278
8279 static void alc883_nb_mic_automute(struct hda_codec *codec)
8280 {
8281 unsigned int present;
8282
8283 present = snd_hda_codec_read(codec, 0x18, 0,
8284 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
8285 snd_hda_codec_write(codec, 0x23, 0, AC_VERB_SET_AMP_GAIN_MUTE,
8286 0x7000 | (0x00 << 8) | (present ? 0 : 0x80));
8287 snd_hda_codec_write(codec, 0x23, 0, AC_VERB_SET_AMP_GAIN_MUTE,
8288 0x7000 | (0x01 << 8) | (present ? 0x80 : 0));
8289 }
8290
8291 static void alc883_M90V_speaker_automute(struct hda_codec *codec)
8292 {
8293 unsigned int present;
8294 unsigned char bits;
8295
8296 present = snd_hda_codec_read(codec, 0x1b, 0,
8297 AC_VERB_GET_PIN_SENSE, 0)
8298 & AC_PINSENSE_PRESENCE;
8299 bits = present ? 0 : PIN_OUT;
8300 snd_hda_codec_write(codec, 0x14, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
8301 bits);
8302 snd_hda_codec_write(codec, 0x15, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
8303 bits);
8304 snd_hda_codec_write(codec, 0x16, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
8305 bits);
8306 }
8307
8308 static void alc883_mode2_unsol_event(struct hda_codec *codec,
8309 unsigned int res)
8310 {
8311 switch (res >> 26) {
8312 case ALC880_HP_EVENT:
8313 alc883_M90V_speaker_automute(codec);
8314 break;
8315 case ALC880_MIC_EVENT:
8316 alc883_nb_mic_automute(codec);
8317 break;
8318 }
8319 }
8320
8321 static void alc883_mode2_inithook(struct hda_codec *codec)
8322 {
8323 alc883_M90V_speaker_automute(codec);
8324 alc883_nb_mic_automute(codec);
8325 }
8326
8327 static struct hda_verb alc888_asus_eee1601_verbs[] = {
8328 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8329 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8330 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8331 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8332 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8333 {0x20, AC_VERB_SET_COEF_INDEX, 0x0b},
8334 {0x20, AC_VERB_SET_PROC_COEF, 0x0838},
8335 /* enable unsolicited event */
8336 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8337 { } /* end */
8338 };
8339
8340 static void alc883_eee1601_speaker_automute(struct hda_codec *codec)
8341 {
8342 unsigned int present;
8343 unsigned char bits;
8344
8345 present = snd_hda_codec_read(codec, 0x14, 0,
8346 AC_VERB_GET_PIN_SENSE, 0)
8347 & AC_PINSENSE_PRESENCE;
8348 bits = present ? 0 : PIN_OUT;
8349 snd_hda_codec_write(codec, 0x1b, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
8350 bits);
8351 }
8352
8353 static void alc883_eee1601_unsol_event(struct hda_codec *codec,
8354 unsigned int res)
8355 {
8356 switch (res >> 26) {
8357 case ALC880_HP_EVENT:
8358 alc883_eee1601_speaker_automute(codec);
8359 break;
8360 }
8361 }
8362
8363 static void alc883_eee1601_inithook(struct hda_codec *codec)
8364 {
8365 alc883_eee1601_speaker_automute(codec);
8366 }
8367
8368 #ifdef CONFIG_SND_HDA_POWER_SAVE
8369 #define alc883_loopbacks alc880_loopbacks
8370 #endif
8371
8372 /* pcm configuration: identiacal with ALC880 */
8373 #define alc883_pcm_analog_playback alc880_pcm_analog_playback
8374 #define alc883_pcm_analog_capture alc880_pcm_analog_capture
8375 #define alc883_pcm_analog_alt_capture alc880_pcm_analog_alt_capture
8376 #define alc883_pcm_digital_playback alc880_pcm_digital_playback
8377 #define alc883_pcm_digital_capture alc880_pcm_digital_capture
8378
8379 /*
8380 * configuration and preset
8381 */
8382 static const char *alc883_models[ALC883_MODEL_LAST] = {
8383 [ALC883_3ST_2ch_DIG] = "3stack-dig",
8384 [ALC883_3ST_6ch_DIG] = "3stack-6ch-dig",
8385 [ALC883_3ST_6ch] = "3stack-6ch",
8386 [ALC883_6ST_DIG] = "6stack-dig",
8387 [ALC883_TARGA_DIG] = "targa-dig",
8388 [ALC883_TARGA_2ch_DIG] = "targa-2ch-dig",
8389 [ALC883_ACER] = "acer",
8390 [ALC883_ACER_ASPIRE] = "acer-aspire",
8391 [ALC883_MEDION] = "medion",
8392 [ALC883_MEDION_MD2] = "medion-md2",
8393 [ALC883_LAPTOP_EAPD] = "laptop-eapd",
8394 [ALC883_LENOVO_101E_2ch] = "lenovo-101e",
8395 [ALC883_LENOVO_NB0763] = "lenovo-nb0763",
8396 [ALC888_LENOVO_MS7195_DIG] = "lenovo-ms7195-dig",
8397 [ALC888_LENOVO_SKY] = "lenovo-sky",
8398 [ALC883_HAIER_W66] = "haier-w66",
8399 [ALC888_3ST_HP] = "3stack-hp",
8400 [ALC888_6ST_DELL] = "6stack-dell",
8401 [ALC883_MITAC] = "mitac",
8402 [ALC883_CLEVO_M720] = "clevo-m720",
8403 [ALC883_FUJITSU_PI2515] = "fujitsu-pi2515",
8404 [ALC883_3ST_6ch_INTEL] = "3stack-6ch-intel",
8405 [ALC883_AUTO] = "auto",
8406 };
8407
8408 static struct snd_pci_quirk alc883_cfg_tbl[] = {
8409 SND_PCI_QUIRK(0x1019, 0x6668, "ECS", ALC883_3ST_6ch_DIG),
8410 SND_PCI_QUIRK(0x1025, 0x006c, "Acer Aspire 9810", ALC883_ACER_ASPIRE),
8411 SND_PCI_QUIRK(0x1025, 0x0110, "Acer Aspire", ALC883_ACER_ASPIRE),
8412 SND_PCI_QUIRK(0x1025, 0x0112, "Acer Aspire 9303", ALC883_ACER_ASPIRE),
8413 SND_PCI_QUIRK(0x1025, 0x0121, "Acer Aspire 5920G", ALC883_ACER_ASPIRE),
8414 SND_PCI_QUIRK(0x1025, 0, "Acer laptop", ALC883_ACER), /* default Acer */
8415 SND_PCI_QUIRK(0x1028, 0x020d, "Dell Inspiron 530", ALC888_6ST_DELL),
8416 SND_PCI_QUIRK(0x103c, 0x2a3d, "HP Pavillion", ALC883_6ST_DIG),
8417 SND_PCI_QUIRK(0x103c, 0x2a4f, "HP Samba", ALC888_3ST_HP),
8418 SND_PCI_QUIRK(0x103c, 0x2a60, "HP Lucknow", ALC888_3ST_HP),
8419 SND_PCI_QUIRK(0x103c, 0x2a61, "HP Nettle", ALC883_6ST_DIG),
8420 SND_PCI_QUIRK(0x1043, 0x1873, "Asus M90V", ALC888_ASUS_M90V),
8421 SND_PCI_QUIRK(0x1043, 0x8249, "Asus M2A-VM HDMI", ALC883_3ST_6ch_DIG),
8422 SND_PCI_QUIRK(0x1043, 0x835f, "Asus Eee 1601", ALC888_ASUS_EEE1601),
8423 SND_PCI_QUIRK(0x105b, 0x0ce8, "Foxconn P35AX-S", ALC883_6ST_DIG),
8424 SND_PCI_QUIRK(0x105b, 0x6668, "Foxconn", ALC883_6ST_DIG),
8425 SND_PCI_QUIRK(0x1071, 0x8253, "Mitac 8252d", ALC883_MITAC),
8426 SND_PCI_QUIRK(0x1071, 0x8258, "Evesham Voyaeger", ALC883_LAPTOP_EAPD),
8427 SND_PCI_QUIRK(0x10f1, 0x2350, "TYAN-S2350", ALC888_6ST_DELL),
8428 SND_PCI_QUIRK(0x108e, 0x534d, NULL, ALC883_3ST_6ch),
8429 SND_PCI_QUIRK(0x1458, 0xa002, "MSI", ALC883_6ST_DIG),
8430 SND_PCI_QUIRK(0x1462, 0x0349, "MSI", ALC883_TARGA_2ch_DIG),
8431 SND_PCI_QUIRK(0x1462, 0x040d, "MSI", ALC883_TARGA_2ch_DIG),
8432 SND_PCI_QUIRK(0x1462, 0x0579, "MSI", ALC883_TARGA_2ch_DIG),
8433 SND_PCI_QUIRK(0x1462, 0x2fb3, "MSI", ALC883_TARGA_2ch_DIG),
8434 SND_PCI_QUIRK(0x1462, 0x3729, "MSI S420", ALC883_TARGA_DIG),
8435 SND_PCI_QUIRK(0x1462, 0x3783, "NEC S970", ALC883_TARGA_DIG),
8436 SND_PCI_QUIRK(0x1462, 0x3b7f, "MSI", ALC883_TARGA_2ch_DIG),
8437 SND_PCI_QUIRK(0x1462, 0x3ef9, "MSI", ALC883_TARGA_DIG),
8438 SND_PCI_QUIRK(0x1462, 0x3fc1, "MSI", ALC883_TARGA_DIG),
8439 SND_PCI_QUIRK(0x1462, 0x3fc3, "MSI", ALC883_TARGA_DIG),
8440 SND_PCI_QUIRK(0x1462, 0x3fcc, "MSI", ALC883_TARGA_DIG),
8441 SND_PCI_QUIRK(0x1462, 0x3fdf, "MSI", ALC883_TARGA_DIG),
8442 SND_PCI_QUIRK(0x1462, 0x4314, "MSI", ALC883_TARGA_DIG),
8443 SND_PCI_QUIRK(0x1462, 0x4319, "MSI", ALC883_TARGA_DIG),
8444 SND_PCI_QUIRK(0x1462, 0x4324, "MSI", ALC883_TARGA_DIG),
8445 SND_PCI_QUIRK(0x1462, 0x6668, "MSI", ALC883_6ST_DIG),
8446 SND_PCI_QUIRK(0x1462, 0x7187, "MSI", ALC883_6ST_DIG),
8447 SND_PCI_QUIRK(0x1462, 0x7250, "MSI", ALC883_6ST_DIG),
8448 SND_PCI_QUIRK(0x1462, 0x7267, "MSI", ALC883_3ST_6ch_DIG),
8449 SND_PCI_QUIRK(0x1462, 0x7280, "MSI", ALC883_6ST_DIG),
8450 SND_PCI_QUIRK(0x1462, 0x7327, "MSI", ALC883_6ST_DIG),
8451 SND_PCI_QUIRK(0x1462, 0xa422, "MSI", ALC883_TARGA_2ch_DIG),
8452 SND_PCI_QUIRK(0x147b, 0x1083, "Abit IP35-PRO", ALC883_6ST_DIG),
8453 SND_PCI_QUIRK(0x1558, 0x0721, "Clevo laptop M720R", ALC883_CLEVO_M720),
8454 SND_PCI_QUIRK(0x1558, 0x0722, "Clevo laptop M720SR", ALC883_CLEVO_M720),
8455 SND_PCI_QUIRK(0x1558, 0, "Clevo laptop", ALC883_LAPTOP_EAPD),
8456 SND_PCI_QUIRK(0x15d9, 0x8780, "Supermicro PDSBA", ALC883_3ST_6ch),
8457 SND_PCI_QUIRK(0x161f, 0x2054, "Medion laptop", ALC883_MEDION),
8458 SND_PCI_QUIRK(0x1734, 0x1108, "Fujitsu AMILO Pi2515", ALC883_FUJITSU_PI2515),
8459 SND_PCI_QUIRK(0x17aa, 0x101e, "Lenovo 101e", ALC883_LENOVO_101E_2ch),
8460 SND_PCI_QUIRK(0x17aa, 0x2085, "Lenovo NB0763", ALC883_LENOVO_NB0763),
8461 SND_PCI_QUIRK(0x17aa, 0x3bfc, "Lenovo NB0763", ALC883_LENOVO_NB0763),
8462 SND_PCI_QUIRK(0x17aa, 0x3bfd, "Lenovo NB0763", ALC883_LENOVO_NB0763),
8463 SND_PCI_QUIRK(0x17aa, 0x101d, "Lenovo Sky", ALC888_LENOVO_SKY),
8464 SND_PCI_QUIRK(0x17c0, 0x4071, "MEDION MD2", ALC883_MEDION_MD2),
8465 SND_PCI_QUIRK(0x17f2, 0x5000, "Albatron KI690-AM2", ALC883_6ST_DIG),
8466 SND_PCI_QUIRK(0x1991, 0x5625, "Haier W66", ALC883_HAIER_W66),
8467 SND_PCI_QUIRK(0x8086, 0x0001, "DG33BUC", ALC883_3ST_6ch_INTEL),
8468 SND_PCI_QUIRK(0x8086, 0x0002, "DG33FBC", ALC883_3ST_6ch_INTEL),
8469 SND_PCI_QUIRK(0x8086, 0xd601, "D102GGC", ALC883_3ST_6ch),
8470 {}
8471 };
8472
8473 static struct alc_config_preset alc883_presets[] = {
8474 [ALC883_3ST_2ch_DIG] = {
8475 .mixers = { alc883_3ST_2ch_mixer },
8476 .init_verbs = { alc883_init_verbs },
8477 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8478 .dac_nids = alc883_dac_nids,
8479 .dig_out_nid = ALC883_DIGOUT_NID,
8480 .dig_in_nid = ALC883_DIGIN_NID,
8481 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8482 .channel_mode = alc883_3ST_2ch_modes,
8483 .input_mux = &alc883_capture_source,
8484 },
8485 [ALC883_3ST_6ch_DIG] = {
8486 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
8487 .init_verbs = { alc883_init_verbs },
8488 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8489 .dac_nids = alc883_dac_nids,
8490 .dig_out_nid = ALC883_DIGOUT_NID,
8491 .dig_in_nid = ALC883_DIGIN_NID,
8492 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
8493 .channel_mode = alc883_3ST_6ch_modes,
8494 .need_dac_fix = 1,
8495 .input_mux = &alc883_capture_source,
8496 },
8497 [ALC883_3ST_6ch] = {
8498 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
8499 .init_verbs = { alc883_init_verbs },
8500 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8501 .dac_nids = alc883_dac_nids,
8502 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
8503 .channel_mode = alc883_3ST_6ch_modes,
8504 .need_dac_fix = 1,
8505 .input_mux = &alc883_capture_source,
8506 },
8507 [ALC883_3ST_6ch_INTEL] = {
8508 .mixers = { alc883_3ST_6ch_intel_mixer, alc883_chmode_mixer },
8509 .init_verbs = { alc883_init_verbs },
8510 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8511 .dac_nids = alc883_dac_nids,
8512 .dig_out_nid = ALC883_DIGOUT_NID,
8513 .dig_in_nid = ALC883_DIGIN_NID,
8514 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_intel_modes),
8515 .channel_mode = alc883_3ST_6ch_intel_modes,
8516 .need_dac_fix = 1,
8517 .input_mux = &alc883_3stack_6ch_intel,
8518 },
8519 [ALC883_6ST_DIG] = {
8520 .mixers = { alc883_base_mixer, alc883_chmode_mixer },
8521 .init_verbs = { alc883_init_verbs },
8522 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8523 .dac_nids = alc883_dac_nids,
8524 .dig_out_nid = ALC883_DIGOUT_NID,
8525 .dig_in_nid = ALC883_DIGIN_NID,
8526 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
8527 .channel_mode = alc883_sixstack_modes,
8528 .input_mux = &alc883_capture_source,
8529 },
8530 [ALC883_TARGA_DIG] = {
8531 .mixers = { alc883_tagra_mixer, alc883_chmode_mixer },
8532 .init_verbs = { alc883_init_verbs, alc883_tagra_verbs},
8533 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8534 .dac_nids = alc883_dac_nids,
8535 .dig_out_nid = ALC883_DIGOUT_NID,
8536 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
8537 .channel_mode = alc883_3ST_6ch_modes,
8538 .need_dac_fix = 1,
8539 .input_mux = &alc883_capture_source,
8540 .unsol_event = alc883_tagra_unsol_event,
8541 .init_hook = alc883_tagra_automute,
8542 },
8543 [ALC883_TARGA_2ch_DIG] = {
8544 .mixers = { alc883_tagra_2ch_mixer},
8545 .init_verbs = { alc883_init_verbs, alc883_tagra_verbs},
8546 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8547 .dac_nids = alc883_dac_nids,
8548 .dig_out_nid = ALC883_DIGOUT_NID,
8549 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8550 .channel_mode = alc883_3ST_2ch_modes,
8551 .input_mux = &alc883_capture_source,
8552 .unsol_event = alc883_tagra_unsol_event,
8553 .init_hook = alc883_tagra_automute,
8554 },
8555 [ALC883_ACER] = {
8556 .mixers = { alc883_base_mixer },
8557 /* On TravelMate laptops, GPIO 0 enables the internal speaker
8558 * and the headphone jack. Turn this on and rely on the
8559 * standard mute methods whenever the user wants to turn
8560 * these outputs off.
8561 */
8562 .init_verbs = { alc883_init_verbs, alc880_gpio1_init_verbs },
8563 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8564 .dac_nids = alc883_dac_nids,
8565 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8566 .channel_mode = alc883_3ST_2ch_modes,
8567 .input_mux = &alc883_capture_source,
8568 },
8569 [ALC883_ACER_ASPIRE] = {
8570 .mixers = { alc883_acer_aspire_mixer },
8571 .init_verbs = { alc883_init_verbs, alc883_acer_eapd_verbs },
8572 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8573 .dac_nids = alc883_dac_nids,
8574 .dig_out_nid = ALC883_DIGOUT_NID,
8575 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8576 .channel_mode = alc883_3ST_2ch_modes,
8577 .input_mux = &alc883_capture_source,
8578 .unsol_event = alc883_acer_aspire_unsol_event,
8579 .init_hook = alc883_acer_aspire_automute,
8580 },
8581 [ALC883_MEDION] = {
8582 .mixers = { alc883_fivestack_mixer,
8583 alc883_chmode_mixer },
8584 .init_verbs = { alc883_init_verbs,
8585 alc883_medion_eapd_verbs },
8586 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8587 .dac_nids = alc883_dac_nids,
8588 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
8589 .channel_mode = alc883_sixstack_modes,
8590 .input_mux = &alc883_capture_source,
8591 },
8592 [ALC883_MEDION_MD2] = {
8593 .mixers = { alc883_medion_md2_mixer},
8594 .init_verbs = { alc883_init_verbs, alc883_medion_md2_verbs},
8595 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8596 .dac_nids = alc883_dac_nids,
8597 .dig_out_nid = ALC883_DIGOUT_NID,
8598 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8599 .channel_mode = alc883_3ST_2ch_modes,
8600 .input_mux = &alc883_capture_source,
8601 .unsol_event = alc883_medion_md2_unsol_event,
8602 .init_hook = alc883_medion_md2_automute,
8603 },
8604 [ALC883_LAPTOP_EAPD] = {
8605 .mixers = { alc883_base_mixer },
8606 .init_verbs = { alc883_init_verbs, alc882_eapd_verbs },
8607 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8608 .dac_nids = alc883_dac_nids,
8609 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8610 .channel_mode = alc883_3ST_2ch_modes,
8611 .input_mux = &alc883_capture_source,
8612 },
8613 [ALC883_CLEVO_M720] = {
8614 .mixers = { alc883_clevo_m720_mixer },
8615 .init_verbs = { alc883_init_verbs, alc883_clevo_m720_verbs },
8616 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8617 .dac_nids = alc883_dac_nids,
8618 .dig_out_nid = ALC883_DIGOUT_NID,
8619 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8620 .channel_mode = alc883_3ST_2ch_modes,
8621 .input_mux = &alc883_capture_source,
8622 .unsol_event = alc883_clevo_m720_unsol_event,
8623 .init_hook = alc883_clevo_m720_automute,
8624 },
8625 [ALC883_LENOVO_101E_2ch] = {
8626 .mixers = { alc883_lenovo_101e_2ch_mixer},
8627 .init_verbs = { alc883_init_verbs, alc883_lenovo_101e_verbs},
8628 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8629 .dac_nids = alc883_dac_nids,
8630 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8631 .channel_mode = alc883_3ST_2ch_modes,
8632 .input_mux = &alc883_lenovo_101e_capture_source,
8633 .unsol_event = alc883_lenovo_101e_unsol_event,
8634 .init_hook = alc883_lenovo_101e_all_automute,
8635 },
8636 [ALC883_LENOVO_NB0763] = {
8637 .mixers = { alc883_lenovo_nb0763_mixer },
8638 .init_verbs = { alc883_init_verbs, alc883_lenovo_nb0763_verbs},
8639 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8640 .dac_nids = alc883_dac_nids,
8641 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8642 .channel_mode = alc883_3ST_2ch_modes,
8643 .need_dac_fix = 1,
8644 .input_mux = &alc883_lenovo_nb0763_capture_source,
8645 .unsol_event = alc883_medion_md2_unsol_event,
8646 .init_hook = alc883_medion_md2_automute,
8647 },
8648 [ALC888_LENOVO_MS7195_DIG] = {
8649 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
8650 .init_verbs = { alc883_init_verbs, alc888_lenovo_ms7195_verbs},
8651 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8652 .dac_nids = alc883_dac_nids,
8653 .dig_out_nid = ALC883_DIGOUT_NID,
8654 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
8655 .channel_mode = alc883_3ST_6ch_modes,
8656 .need_dac_fix = 1,
8657 .input_mux = &alc883_capture_source,
8658 .unsol_event = alc883_lenovo_ms7195_unsol_event,
8659 .init_hook = alc888_lenovo_ms7195_front_automute,
8660 },
8661 [ALC883_HAIER_W66] = {
8662 .mixers = { alc883_tagra_2ch_mixer},
8663 .init_verbs = { alc883_init_verbs, alc883_haier_w66_verbs},
8664 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8665 .dac_nids = alc883_dac_nids,
8666 .dig_out_nid = ALC883_DIGOUT_NID,
8667 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8668 .channel_mode = alc883_3ST_2ch_modes,
8669 .input_mux = &alc883_capture_source,
8670 .unsol_event = alc883_haier_w66_unsol_event,
8671 .init_hook = alc883_haier_w66_automute,
8672 },
8673 [ALC888_3ST_HP] = {
8674 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
8675 .init_verbs = { alc883_init_verbs, alc888_3st_hp_verbs },
8676 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8677 .dac_nids = alc883_dac_nids,
8678 .num_channel_mode = ARRAY_SIZE(alc888_3st_hp_modes),
8679 .channel_mode = alc888_3st_hp_modes,
8680 .need_dac_fix = 1,
8681 .input_mux = &alc883_capture_source,
8682 },
8683 [ALC888_6ST_DELL] = {
8684 .mixers = { alc883_base_mixer, alc883_chmode_mixer },
8685 .init_verbs = { alc883_init_verbs, alc888_6st_dell_verbs },
8686 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8687 .dac_nids = alc883_dac_nids,
8688 .dig_out_nid = ALC883_DIGOUT_NID,
8689 .dig_in_nid = ALC883_DIGIN_NID,
8690 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
8691 .channel_mode = alc883_sixstack_modes,
8692 .input_mux = &alc883_capture_source,
8693 .unsol_event = alc888_6st_dell_unsol_event,
8694 .init_hook = alc888_6st_dell_front_automute,
8695 },
8696 [ALC883_MITAC] = {
8697 .mixers = { alc883_mitac_mixer },
8698 .init_verbs = { alc883_init_verbs, alc883_mitac_verbs },
8699 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8700 .dac_nids = alc883_dac_nids,
8701 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8702 .channel_mode = alc883_3ST_2ch_modes,
8703 .input_mux = &alc883_capture_source,
8704 .unsol_event = alc883_mitac_unsol_event,
8705 .init_hook = alc883_mitac_automute,
8706 },
8707 [ALC883_FUJITSU_PI2515] = {
8708 .mixers = { alc883_2ch_fujitsu_pi2515_mixer },
8709 .init_verbs = { alc883_init_verbs,
8710 alc883_2ch_fujitsu_pi2515_verbs},
8711 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8712 .dac_nids = alc883_dac_nids,
8713 .dig_out_nid = ALC883_DIGOUT_NID,
8714 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8715 .channel_mode = alc883_3ST_2ch_modes,
8716 .input_mux = &alc883_fujitsu_pi2515_capture_source,
8717 .unsol_event = alc883_2ch_fujitsu_pi2515_unsol_event,
8718 .init_hook = alc883_2ch_fujitsu_pi2515_automute,
8719 },
8720 [ALC888_LENOVO_SKY] = {
8721 .mixers = { alc888_lenovo_sky_mixer, alc883_chmode_mixer },
8722 .init_verbs = { alc883_init_verbs, alc888_lenovo_sky_verbs},
8723 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8724 .dac_nids = alc883_dac_nids,
8725 .dig_out_nid = ALC883_DIGOUT_NID,
8726 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids),
8727 .adc_nids = alc883_adc_nids,
8728 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
8729 .channel_mode = alc883_sixstack_modes,
8730 .need_dac_fix = 1,
8731 .input_mux = &alc883_lenovo_sky_capture_source,
8732 .unsol_event = alc883_lenovo_sky_unsol_event,
8733 .init_hook = alc888_lenovo_sky_front_automute,
8734 },
8735 [ALC888_ASUS_M90V] = {
8736 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
8737 .init_verbs = { alc883_init_verbs, alc888_asus_m90v_verbs },
8738 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8739 .dac_nids = alc883_dac_nids,
8740 .dig_out_nid = ALC883_DIGOUT_NID,
8741 .dig_in_nid = ALC883_DIGIN_NID,
8742 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
8743 .channel_mode = alc883_3ST_6ch_modes,
8744 .need_dac_fix = 1,
8745 .input_mux = &alc883_fujitsu_pi2515_capture_source,
8746 .unsol_event = alc883_mode2_unsol_event,
8747 .init_hook = alc883_mode2_inithook,
8748 },
8749 [ALC888_ASUS_EEE1601] = {
8750 .mixers = { alc883_asus_eee1601_mixer },
8751 .init_verbs = { alc883_init_verbs, alc888_asus_eee1601_verbs },
8752 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8753 .dac_nids = alc883_dac_nids,
8754 .dig_out_nid = ALC883_DIGOUT_NID,
8755 .dig_in_nid = ALC883_DIGIN_NID,
8756 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8757 .channel_mode = alc883_3ST_2ch_modes,
8758 .need_dac_fix = 1,
8759 .input_mux = &alc883_asus_eee1601_capture_source,
8760 .unsol_event = alc883_eee1601_unsol_event,
8761 .init_hook = alc883_eee1601_inithook,
8762 },
8763 };
8764
8765
8766 /*
8767 * BIOS auto configuration
8768 */
8769 static void alc883_auto_set_output_and_unmute(struct hda_codec *codec,
8770 hda_nid_t nid, int pin_type,
8771 int dac_idx)
8772 {
8773 /* set as output */
8774 struct alc_spec *spec = codec->spec;
8775 int idx;
8776
8777 alc_set_pin_output(codec, nid, pin_type);
8778 if (spec->multiout.dac_nids[dac_idx] == 0x25)
8779 idx = 4;
8780 else
8781 idx = spec->multiout.dac_nids[dac_idx] - 2;
8782 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CONNECT_SEL, idx);
8783
8784 }
8785
8786 static void alc883_auto_init_multi_out(struct hda_codec *codec)
8787 {
8788 struct alc_spec *spec = codec->spec;
8789 int i;
8790
8791 alc_subsystem_id(codec, 0x15, 0x1b, 0x14);
8792 for (i = 0; i <= HDA_SIDE; i++) {
8793 hda_nid_t nid = spec->autocfg.line_out_pins[i];
8794 int pin_type = get_pin_type(spec->autocfg.line_out_type);
8795 if (nid)
8796 alc883_auto_set_output_and_unmute(codec, nid, pin_type,
8797 i);
8798 }
8799 }
8800
8801 static void alc883_auto_init_hp_out(struct hda_codec *codec)
8802 {
8803 struct alc_spec *spec = codec->spec;
8804 hda_nid_t pin;
8805
8806 pin = spec->autocfg.hp_pins[0];
8807 if (pin) /* connect to front */
8808 /* use dac 0 */
8809 alc883_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
8810 pin = spec->autocfg.speaker_pins[0];
8811 if (pin)
8812 alc883_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
8813 }
8814
8815 #define alc883_is_input_pin(nid) alc880_is_input_pin(nid)
8816 #define ALC883_PIN_CD_NID ALC880_PIN_CD_NID
8817
8818 static void alc883_auto_init_analog_input(struct hda_codec *codec)
8819 {
8820 struct alc_spec *spec = codec->spec;
8821 int i;
8822
8823 for (i = 0; i < AUTO_PIN_LAST; i++) {
8824 hda_nid_t nid = spec->autocfg.input_pins[i];
8825 if (alc883_is_input_pin(nid)) {
8826 snd_hda_codec_write(codec, nid, 0,
8827 AC_VERB_SET_PIN_WIDGET_CONTROL,
8828 (i <= AUTO_PIN_FRONT_MIC ?
8829 PIN_VREF80 : PIN_IN));
8830 if (nid != ALC883_PIN_CD_NID)
8831 snd_hda_codec_write(codec, nid, 0,
8832 AC_VERB_SET_AMP_GAIN_MUTE,
8833 AMP_OUT_MUTE);
8834 }
8835 }
8836 }
8837
8838 #define alc883_auto_init_input_src alc882_auto_init_input_src
8839
8840 /* almost identical with ALC880 parser... */
8841 static int alc883_parse_auto_config(struct hda_codec *codec)
8842 {
8843 struct alc_spec *spec = codec->spec;
8844 int err = alc880_parse_auto_config(codec);
8845
8846 if (err < 0)
8847 return err;
8848 else if (!err)
8849 return 0; /* no config found */
8850
8851 err = alc_auto_add_mic_boost(codec);
8852 if (err < 0)
8853 return err;
8854
8855 /* hack - override the init verbs */
8856 spec->init_verbs[0] = alc883_auto_init_verbs;
8857 spec->mixers[spec->num_mixers] = alc883_capture_mixer;
8858 spec->num_mixers++;
8859
8860 return 1; /* config found */
8861 }
8862
8863 /* additional initialization for auto-configuration model */
8864 static void alc883_auto_init(struct hda_codec *codec)
8865 {
8866 struct alc_spec *spec = codec->spec;
8867 alc883_auto_init_multi_out(codec);
8868 alc883_auto_init_hp_out(codec);
8869 alc883_auto_init_analog_input(codec);
8870 alc883_auto_init_input_src(codec);
8871 if (spec->unsol_event)
8872 alc_inithook(codec);
8873 }
8874
8875 static int patch_alc883(struct hda_codec *codec)
8876 {
8877 struct alc_spec *spec;
8878 int err, board_config;
8879
8880 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
8881 if (spec == NULL)
8882 return -ENOMEM;
8883
8884 codec->spec = spec;
8885
8886 alc_fix_pll_init(codec, 0x20, 0x0a, 10);
8887
8888 board_config = snd_hda_check_board_config(codec, ALC883_MODEL_LAST,
8889 alc883_models,
8890 alc883_cfg_tbl);
8891 if (board_config < 0) {
8892 printk(KERN_INFO "hda_codec: Unknown model for ALC883, "
8893 "trying auto-probe from BIOS...\n");
8894 board_config = ALC883_AUTO;
8895 }
8896
8897 if (board_config == ALC883_AUTO) {
8898 /* automatic parse from the BIOS config */
8899 err = alc883_parse_auto_config(codec);
8900 if (err < 0) {
8901 alc_free(codec);
8902 return err;
8903 } else if (!err) {
8904 printk(KERN_INFO
8905 "hda_codec: Cannot set up configuration "
8906 "from BIOS. Using base mode...\n");
8907 board_config = ALC883_3ST_2ch_DIG;
8908 }
8909 }
8910
8911 if (board_config != ALC883_AUTO)
8912 setup_preset(spec, &alc883_presets[board_config]);
8913
8914 switch (codec->vendor_id) {
8915 case 0x10ec0888:
8916 if (codec->revision_id == 0x100101) {
8917 spec->stream_name_analog = "ALC1200 Analog";
8918 spec->stream_name_digital = "ALC1200 Digital";
8919 } else {
8920 spec->stream_name_analog = "ALC888 Analog";
8921 spec->stream_name_digital = "ALC888 Digital";
8922 }
8923 break;
8924 case 0x10ec0889:
8925 spec->stream_name_analog = "ALC889 Analog";
8926 spec->stream_name_digital = "ALC889 Digital";
8927 break;
8928 default:
8929 spec->stream_name_analog = "ALC883 Analog";
8930 spec->stream_name_digital = "ALC883 Digital";
8931 break;
8932 }
8933
8934 spec->stream_analog_playback = &alc883_pcm_analog_playback;
8935 spec->stream_analog_capture = &alc883_pcm_analog_capture;
8936 spec->stream_analog_alt_capture = &alc883_pcm_analog_alt_capture;
8937
8938 spec->stream_digital_playback = &alc883_pcm_digital_playback;
8939 spec->stream_digital_capture = &alc883_pcm_digital_capture;
8940
8941 spec->num_adc_nids = ARRAY_SIZE(alc883_adc_nids);
8942 spec->adc_nids = alc883_adc_nids;
8943 spec->capsrc_nids = alc883_capsrc_nids;
8944
8945 spec->vmaster_nid = 0x0c;
8946
8947 codec->patch_ops = alc_patch_ops;
8948 if (board_config == ALC883_AUTO)
8949 spec->init_hook = alc883_auto_init;
8950
8951 #ifdef CONFIG_SND_HDA_POWER_SAVE
8952 if (!spec->loopback.amplist)
8953 spec->loopback.amplist = alc883_loopbacks;
8954 #endif
8955
8956 return 0;
8957 }
8958
8959 /*
8960 * ALC262 support
8961 */
8962
8963 #define ALC262_DIGOUT_NID ALC880_DIGOUT_NID
8964 #define ALC262_DIGIN_NID ALC880_DIGIN_NID
8965
8966 #define alc262_dac_nids alc260_dac_nids
8967 #define alc262_adc_nids alc882_adc_nids
8968 #define alc262_adc_nids_alt alc882_adc_nids_alt
8969 #define alc262_capsrc_nids alc882_capsrc_nids
8970 #define alc262_capsrc_nids_alt alc882_capsrc_nids_alt
8971
8972 #define alc262_modes alc260_modes
8973 #define alc262_capture_source alc882_capture_source
8974
8975 static hda_nid_t alc262_dmic_adc_nids[1] = {
8976 /* ADC0 */
8977 0x09
8978 };
8979
8980 static hda_nid_t alc262_dmic_capsrc_nids[1] = { 0x22 };
8981
8982 static struct snd_kcontrol_new alc262_base_mixer[] = {
8983 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8984 HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
8985 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8986 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8987 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8988 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8989 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8990 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8991 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8992 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
8993 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
8994 HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
8995 /* HDA_CODEC_VOLUME("PC Beep Playback Volume", 0x0b, 0x05, HDA_INPUT),
8996 HDA_CODEC_MUTE("PC Beep Playback Switch", 0x0b, 0x05, HDA_INPUT), */
8997 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0D, 0x0, HDA_OUTPUT),
8998 HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
8999 HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
9000 HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x16, 2, 0x0, HDA_OUTPUT),
9001 { } /* end */
9002 };
9003
9004 static struct snd_kcontrol_new alc262_hippo1_mixer[] = {
9005 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9006 HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
9007 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
9008 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
9009 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
9010 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
9011 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9012 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9013 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
9014 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
9015 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
9016 HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
9017 /* HDA_CODEC_VOLUME("PC Beep Playback Volume", 0x0b, 0x05, HDA_INPUT),
9018 HDA_CODEC_MUTE("PC Beep Playback Switch", 0x0b, 0x05, HDA_INPUT), */
9019 /*HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0D, 0x0, HDA_OUTPUT),*/
9020 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
9021 { } /* end */
9022 };
9023
9024 /* update HP, line and mono-out pins according to the master switch */
9025 static void alc262_hp_master_update(struct hda_codec *codec)
9026 {
9027 struct alc_spec *spec = codec->spec;
9028 int val = spec->master_sw;
9029
9030 /* HP & line-out */
9031 snd_hda_codec_write_cache(codec, 0x1b, 0,
9032 AC_VERB_SET_PIN_WIDGET_CONTROL,
9033 val ? PIN_HP : 0);
9034 snd_hda_codec_write_cache(codec, 0x15, 0,
9035 AC_VERB_SET_PIN_WIDGET_CONTROL,
9036 val ? PIN_HP : 0);
9037 /* mono (speaker) depending on the HP jack sense */
9038 val = val && !spec->jack_present;
9039 snd_hda_codec_write_cache(codec, 0x16, 0,
9040 AC_VERB_SET_PIN_WIDGET_CONTROL,
9041 val ? PIN_OUT : 0);
9042 }
9043
9044 static void alc262_hp_bpc_automute(struct hda_codec *codec)
9045 {
9046 struct alc_spec *spec = codec->spec;
9047 unsigned int presence;
9048 presence = snd_hda_codec_read(codec, 0x1b, 0,
9049 AC_VERB_GET_PIN_SENSE, 0);
9050 spec->jack_present = !!(presence & AC_PINSENSE_PRESENCE);
9051 alc262_hp_master_update(codec);
9052 }
9053
9054 static void alc262_hp_bpc_unsol_event(struct hda_codec *codec, unsigned int res)
9055 {
9056 if ((res >> 26) != ALC880_HP_EVENT)
9057 return;
9058 alc262_hp_bpc_automute(codec);
9059 }
9060
9061 static void alc262_hp_wildwest_automute(struct hda_codec *codec)
9062 {
9063 struct alc_spec *spec = codec->spec;
9064 unsigned int presence;
9065 presence = snd_hda_codec_read(codec, 0x15, 0,
9066 AC_VERB_GET_PIN_SENSE, 0);
9067 spec->jack_present = !!(presence & AC_PINSENSE_PRESENCE);
9068 alc262_hp_master_update(codec);
9069 }
9070
9071 static void alc262_hp_wildwest_unsol_event(struct hda_codec *codec,
9072 unsigned int res)
9073 {
9074 if ((res >> 26) != ALC880_HP_EVENT)
9075 return;
9076 alc262_hp_wildwest_automute(codec);
9077 }
9078
9079 static int alc262_hp_master_sw_get(struct snd_kcontrol *kcontrol,
9080 struct snd_ctl_elem_value *ucontrol)
9081 {
9082 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
9083 struct alc_spec *spec = codec->spec;
9084 *ucontrol->value.integer.value = spec->master_sw;
9085 return 0;
9086 }
9087
9088 static int alc262_hp_master_sw_put(struct snd_kcontrol *kcontrol,
9089 struct snd_ctl_elem_value *ucontrol)
9090 {
9091 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
9092 struct alc_spec *spec = codec->spec;
9093 int val = !!*ucontrol->value.integer.value;
9094
9095 if (val == spec->master_sw)
9096 return 0;
9097 spec->master_sw = val;
9098 alc262_hp_master_update(codec);
9099 return 1;
9100 }
9101
9102 static struct snd_kcontrol_new alc262_HP_BPC_mixer[] = {
9103 {
9104 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
9105 .name = "Master Playback Switch",
9106 .info = snd_ctl_boolean_mono_info,
9107 .get = alc262_hp_master_sw_get,
9108 .put = alc262_hp_master_sw_put,
9109 },
9110 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9111 HDA_CODEC_MUTE("Front Playback Switch", 0x15, 0x0, HDA_OUTPUT),
9112 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
9113 HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0e, 2, 0x0,
9114 HDA_OUTPUT),
9115 HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x16, 2, 0x0,
9116 HDA_OUTPUT),
9117 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9118 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9119 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
9120 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
9121 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
9122 HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
9123 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
9124 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
9125 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
9126 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
9127 HDA_CODEC_VOLUME("PC Beep Playback Volume", 0x0b, 0x05, HDA_INPUT),
9128 HDA_CODEC_MUTE("PC Beep Playback Switch", 0x0b, 0x05, HDA_INPUT),
9129 HDA_CODEC_VOLUME("AUX IN Playback Volume", 0x0b, 0x06, HDA_INPUT),
9130 HDA_CODEC_MUTE("AUX IN Playback Switch", 0x0b, 0x06, HDA_INPUT),
9131 { } /* end */
9132 };
9133
9134 static struct snd_kcontrol_new alc262_HP_BPC_WildWest_mixer[] = {
9135 {
9136 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
9137 .name = "Master Playback Switch",
9138 .info = snd_ctl_boolean_mono_info,
9139 .get = alc262_hp_master_sw_get,
9140 .put = alc262_hp_master_sw_put,
9141 },
9142 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9143 HDA_CODEC_MUTE("Front Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
9144 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
9145 HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
9146 HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0e, 2, 0x0,
9147 HDA_OUTPUT),
9148 HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x16, 2, 0x0,
9149 HDA_OUTPUT),
9150 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x02, HDA_INPUT),
9151 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x02, HDA_INPUT),
9152 HDA_CODEC_VOLUME("Front Mic Boost", 0x1a, 0, HDA_INPUT),
9153 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x01, HDA_INPUT),
9154 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x01, HDA_INPUT),
9155 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
9156 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
9157 HDA_CODEC_VOLUME("PC Beep Playback Volume", 0x0b, 0x05, HDA_INPUT),
9158 HDA_CODEC_MUTE("PC Beep Playback Switch", 0x0b, 0x05, HDA_INPUT),
9159 { } /* end */
9160 };
9161
9162 static struct snd_kcontrol_new alc262_HP_BPC_WildWest_option_mixer[] = {
9163 HDA_CODEC_VOLUME("Rear Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9164 HDA_CODEC_MUTE("Rear Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9165 HDA_CODEC_VOLUME("Rear Mic Boost", 0x18, 0, HDA_INPUT),
9166 { } /* end */
9167 };
9168
9169 /* mute/unmute internal speaker according to the hp jack and mute state */
9170 static void alc262_hp_t5735_automute(struct hda_codec *codec, int force)
9171 {
9172 struct alc_spec *spec = codec->spec;
9173
9174 if (force || !spec->sense_updated) {
9175 unsigned int present;
9176 present = snd_hda_codec_read(codec, 0x15, 0,
9177 AC_VERB_GET_PIN_SENSE, 0);
9178 spec->jack_present = (present & AC_PINSENSE_PRESENCE) != 0;
9179 spec->sense_updated = 1;
9180 }
9181 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_OUTPUT, 0, HDA_AMP_MUTE,
9182 spec->jack_present ? HDA_AMP_MUTE : 0);
9183 }
9184
9185 static void alc262_hp_t5735_unsol_event(struct hda_codec *codec,
9186 unsigned int res)
9187 {
9188 if ((res >> 26) != ALC880_HP_EVENT)
9189 return;
9190 alc262_hp_t5735_automute(codec, 1);
9191 }
9192
9193 static void alc262_hp_t5735_init_hook(struct hda_codec *codec)
9194 {
9195 alc262_hp_t5735_automute(codec, 1);
9196 }
9197
9198 static struct snd_kcontrol_new alc262_hp_t5735_mixer[] = {
9199 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9200 HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
9201 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
9202 HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
9203 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9204 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9205 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
9206 { } /* end */
9207 };
9208
9209 static struct hda_verb alc262_hp_t5735_verbs[] = {
9210 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9211 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9212
9213 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9214 { }
9215 };
9216
9217 static struct snd_kcontrol_new alc262_hp_rp5700_mixer[] = {
9218 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9219 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
9220 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0e, 0x0, HDA_OUTPUT),
9221 HDA_CODEC_MUTE("Speaker Playback Switch", 0x16, 0x0, HDA_OUTPUT),
9222 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x01, HDA_INPUT),
9223 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x01, HDA_INPUT),
9224 { } /* end */
9225 };
9226
9227 static struct hda_verb alc262_hp_rp5700_verbs[] = {
9228 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
9229 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
9230 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9231 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9232 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
9233 {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
9234 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
9235 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
9236 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x00 << 8))},
9237 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x00 << 8))},
9238 {}
9239 };
9240
9241 static struct hda_input_mux alc262_hp_rp5700_capture_source = {
9242 .num_items = 1,
9243 .items = {
9244 { "Line", 0x1 },
9245 },
9246 };
9247
9248 /* bind hp and internal speaker mute (with plug check) */
9249 static int alc262_sony_master_sw_put(struct snd_kcontrol *kcontrol,
9250 struct snd_ctl_elem_value *ucontrol)
9251 {
9252 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
9253 long *valp = ucontrol->value.integer.value;
9254 int change;
9255
9256 /* change hp mute */
9257 change = snd_hda_codec_amp_update(codec, 0x15, 0, HDA_OUTPUT, 0,
9258 HDA_AMP_MUTE,
9259 valp[0] ? 0 : HDA_AMP_MUTE);
9260 change |= snd_hda_codec_amp_update(codec, 0x15, 1, HDA_OUTPUT, 0,
9261 HDA_AMP_MUTE,
9262 valp[1] ? 0 : HDA_AMP_MUTE);
9263 if (change) {
9264 /* change speaker according to HP jack state */
9265 struct alc_spec *spec = codec->spec;
9266 unsigned int mute;
9267 if (spec->jack_present)
9268 mute = HDA_AMP_MUTE;
9269 else
9270 mute = snd_hda_codec_amp_read(codec, 0x15, 0,
9271 HDA_OUTPUT, 0);
9272 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
9273 HDA_AMP_MUTE, mute);
9274 }
9275 return change;
9276 }
9277
9278 static struct snd_kcontrol_new alc262_sony_mixer[] = {
9279 HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9280 {
9281 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
9282 .name = "Master Playback Switch",
9283 .info = snd_hda_mixer_amp_switch_info,
9284 .get = snd_hda_mixer_amp_switch_get,
9285 .put = alc262_sony_master_sw_put,
9286 .private_value = HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT),
9287 },
9288 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9289 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9290 HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
9291 HDA_CODEC_MUTE("ATAPI Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
9292 { } /* end */
9293 };
9294
9295 static struct snd_kcontrol_new alc262_benq_t31_mixer[] = {
9296 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9297 HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
9298 HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
9299 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9300 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9301 HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
9302 HDA_CODEC_MUTE("ATAPI Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
9303 { } /* end */
9304 };
9305
9306 #define alc262_capture_mixer alc882_capture_mixer
9307 #define alc262_capture_alt_mixer alc882_capture_alt_mixer
9308
9309 /*
9310 * generic initialization of ADC, input mixers and output mixers
9311 */
9312 static struct hda_verb alc262_init_verbs[] = {
9313 /*
9314 * Unmute ADC0-2 and set the default input to mic-in
9315 */
9316 {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
9317 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9318 {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
9319 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9320 {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
9321 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9322
9323 /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
9324 * mixer widget
9325 * Note: PASD motherboards uses the Line In 2 as the input for
9326 * front panel mic (mic 2)
9327 */
9328 /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
9329 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
9330 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
9331 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
9332 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
9333 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
9334
9335 /*
9336 * Set up output mixers (0x0c - 0x0e)
9337 */
9338 /* set vol=0 to output mixers */
9339 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
9340 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
9341 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
9342 /* set up input amps for analog loopback */
9343 /* Amp Indices: DAC = 0, mixer = 1 */
9344 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9345 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9346 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9347 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9348 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9349 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9350
9351 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
9352 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
9353 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
9354 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
9355 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
9356 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
9357
9358 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
9359 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
9360 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
9361 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
9362 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
9363
9364 {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
9365 {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
9366
9367 /* FIXME: use matrix-type input source selection */
9368 /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
9369 /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
9370 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
9371 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
9372 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
9373 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
9374 /* Input mixer2 */
9375 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
9376 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
9377 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
9378 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
9379 /* Input mixer3 */
9380 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
9381 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
9382 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
9383 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
9384
9385 { }
9386 };
9387
9388 static struct hda_verb alc262_eapd_verbs[] = {
9389 {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
9390 {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
9391 { }
9392 };
9393
9394 static struct hda_verb alc262_hippo_unsol_verbs[] = {
9395 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
9396 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9397 {}
9398 };
9399
9400 static struct hda_verb alc262_hippo1_unsol_verbs[] = {
9401 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
9402 {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
9403 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
9404
9405 {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
9406 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9407 {}
9408 };
9409
9410 static struct hda_verb alc262_sony_unsol_verbs[] = {
9411 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
9412 {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
9413 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24}, // Front Mic
9414
9415 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
9416 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9417 {}
9418 };
9419
9420 static struct hda_input_mux alc262_dmic_capture_source = {
9421 .num_items = 2,
9422 .items = {
9423 { "Int DMic", 0x9 },
9424 { "Mic", 0x0 },
9425 },
9426 };
9427
9428 static struct snd_kcontrol_new alc262_toshiba_s06_mixer[] = {
9429 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9430 HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
9431 HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
9432 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9433 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9434 HDA_CODEC_VOLUME("Capture Volume", 0x09, 0x0, HDA_INPUT),
9435 HDA_CODEC_MUTE("Capture Switch", 0x09, 0x0, HDA_INPUT),
9436 {
9437 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
9438 /* The multiple "Capture Source" controls confuse alsamixer
9439 * So call somewhat different..
9440 */
9441 /* .name = "Capture Source", */
9442 .name = "Input Source",
9443 .count = 1,
9444 .info = alc_mux_enum_info,
9445 .get = alc_mux_enum_get,
9446 .put = alc_mux_enum_put,
9447 },
9448 { } /* end */
9449 };
9450
9451 static struct hda_verb alc262_toshiba_s06_verbs[] = {
9452 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
9453 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9454 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9455 {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
9456 {0x22, AC_VERB_SET_CONNECT_SEL, 0x09},
9457 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
9458 {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
9459 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
9460 {}
9461 };
9462
9463 static void alc262_dmic_automute(struct hda_codec *codec)
9464 {
9465 unsigned int present;
9466
9467 present = snd_hda_codec_read(codec, 0x18, 0,
9468 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
9469 snd_hda_codec_write(codec, 0x22, 0,
9470 AC_VERB_SET_CONNECT_SEL, present ? 0x0 : 0x09);
9471 }
9472
9473 /* toggle speaker-output according to the hp-jack state */
9474 static void alc262_toshiba_s06_speaker_automute(struct hda_codec *codec)
9475 {
9476 unsigned int present;
9477 unsigned char bits;
9478
9479 present = snd_hda_codec_read(codec, 0x15, 0,
9480 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
9481 bits = present ? 0 : PIN_OUT;
9482 snd_hda_codec_write(codec, 0x14, 0,
9483 AC_VERB_SET_PIN_WIDGET_CONTROL, bits);
9484 }
9485
9486
9487
9488 /* unsolicited event for HP jack sensing */
9489 static void alc262_toshiba_s06_unsol_event(struct hda_codec *codec,
9490 unsigned int res)
9491 {
9492 if ((res >> 26) == ALC880_HP_EVENT)
9493 alc262_toshiba_s06_speaker_automute(codec);
9494 if ((res >> 26) == ALC880_MIC_EVENT)
9495 alc262_dmic_automute(codec);
9496
9497 }
9498
9499 static void alc262_toshiba_s06_init_hook(struct hda_codec *codec)
9500 {
9501 alc262_toshiba_s06_speaker_automute(codec);
9502 alc262_dmic_automute(codec);
9503 }
9504
9505 /* mute/unmute internal speaker according to the hp jack and mute state */
9506 static void alc262_hippo_automute(struct hda_codec *codec)
9507 {
9508 struct alc_spec *spec = codec->spec;
9509 unsigned int mute;
9510 unsigned int present;
9511
9512 /* need to execute and sync at first */
9513 snd_hda_codec_read(codec, 0x15, 0, AC_VERB_SET_PIN_SENSE, 0);
9514 present = snd_hda_codec_read(codec, 0x15, 0,
9515 AC_VERB_GET_PIN_SENSE, 0);
9516 spec->jack_present = (present & 0x80000000) != 0;
9517 if (spec->jack_present) {
9518 /* mute internal speaker */
9519 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
9520 HDA_AMP_MUTE, HDA_AMP_MUTE);
9521 } else {
9522 /* unmute internal speaker if necessary */
9523 mute = snd_hda_codec_amp_read(codec, 0x15, 0, HDA_OUTPUT, 0);
9524 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
9525 HDA_AMP_MUTE, mute);
9526 }
9527 }
9528
9529 /* unsolicited event for HP jack sensing */
9530 static void alc262_hippo_unsol_event(struct hda_codec *codec,
9531 unsigned int res)
9532 {
9533 if ((res >> 26) != ALC880_HP_EVENT)
9534 return;
9535 alc262_hippo_automute(codec);
9536 }
9537
9538 static void alc262_hippo1_automute(struct hda_codec *codec)
9539 {
9540 unsigned int mute;
9541 unsigned int present;
9542
9543 snd_hda_codec_read(codec, 0x1b, 0, AC_VERB_SET_PIN_SENSE, 0);
9544 present = snd_hda_codec_read(codec, 0x1b, 0,
9545 AC_VERB_GET_PIN_SENSE, 0);
9546 present = (present & 0x80000000) != 0;
9547 if (present) {
9548 /* mute internal speaker */
9549 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
9550 HDA_AMP_MUTE, HDA_AMP_MUTE);
9551 } else {
9552 /* unmute internal speaker if necessary */
9553 mute = snd_hda_codec_amp_read(codec, 0x1b, 0, HDA_OUTPUT, 0);
9554 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
9555 HDA_AMP_MUTE, mute);
9556 }
9557 }
9558
9559 /* unsolicited event for HP jack sensing */
9560 static void alc262_hippo1_unsol_event(struct hda_codec *codec,
9561 unsigned int res)
9562 {
9563 if ((res >> 26) != ALC880_HP_EVENT)
9564 return;
9565 alc262_hippo1_automute(codec);
9566 }
9567
9568 /*
9569 * nec model
9570 * 0x15 = headphone
9571 * 0x16 = internal speaker
9572 * 0x18 = external mic
9573 */
9574
9575 static struct snd_kcontrol_new alc262_nec_mixer[] = {
9576 HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
9577 HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x16, 0, 0x0, HDA_OUTPUT),
9578
9579 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9580 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9581 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
9582
9583 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
9584 HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
9585 { } /* end */
9586 };
9587
9588 static struct hda_verb alc262_nec_verbs[] = {
9589 /* Unmute Speaker */
9590 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
9591
9592 /* Headphone */
9593 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
9594 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9595
9596 /* External mic to headphone */
9597 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9598 /* External mic to speaker */
9599 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9600 {}
9601 };
9602
9603 /*
9604 * fujitsu model
9605 * 0x14 = headphone/spdif-out, 0x15 = internal speaker,
9606 * 0x1b = port replicator headphone out
9607 */
9608
9609 #define ALC_HP_EVENT 0x37
9610
9611 static struct hda_verb alc262_fujitsu_unsol_verbs[] = {
9612 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_HP_EVENT},
9613 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9614 {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_HP_EVENT},
9615 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9616 {}
9617 };
9618
9619 static struct hda_verb alc262_lenovo_3000_unsol_verbs[] = {
9620 {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_HP_EVENT},
9621 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9622 {}
9623 };
9624
9625 static struct hda_input_mux alc262_fujitsu_capture_source = {
9626 .num_items = 3,
9627 .items = {
9628 { "Mic", 0x0 },
9629 { "Int Mic", 0x1 },
9630 { "CD", 0x4 },
9631 },
9632 };
9633
9634 static struct hda_input_mux alc262_HP_capture_source = {
9635 .num_items = 5,
9636 .items = {
9637 { "Mic", 0x0 },
9638 { "Front Mic", 0x1 },
9639 { "Line", 0x2 },
9640 { "CD", 0x4 },
9641 { "AUX IN", 0x6 },
9642 },
9643 };
9644
9645 static struct hda_input_mux alc262_HP_D7000_capture_source = {
9646 .num_items = 4,
9647 .items = {
9648 { "Mic", 0x0 },
9649 { "Front Mic", 0x2 },
9650 { "Line", 0x1 },
9651 { "CD", 0x4 },
9652 },
9653 };
9654
9655 /* mute/unmute internal speaker according to the hp jacks and mute state */
9656 static void alc262_fujitsu_automute(struct hda_codec *codec, int force)
9657 {
9658 struct alc_spec *spec = codec->spec;
9659 unsigned int mute;
9660
9661 if (force || !spec->sense_updated) {
9662 unsigned int present;
9663 /* need to execute and sync at first */
9664 snd_hda_codec_read(codec, 0x14, 0, AC_VERB_SET_PIN_SENSE, 0);
9665 /* check laptop HP jack */
9666 present = snd_hda_codec_read(codec, 0x14, 0,
9667 AC_VERB_GET_PIN_SENSE, 0);
9668 /* need to execute and sync at first */
9669 snd_hda_codec_read(codec, 0x1b, 0, AC_VERB_SET_PIN_SENSE, 0);
9670 /* check docking HP jack */
9671 present |= snd_hda_codec_read(codec, 0x1b, 0,
9672 AC_VERB_GET_PIN_SENSE, 0);
9673 if (present & AC_PINSENSE_PRESENCE)
9674 spec->jack_present = 1;
9675 else
9676 spec->jack_present = 0;
9677 spec->sense_updated = 1;
9678 }
9679 /* unmute internal speaker only if both HPs are unplugged and
9680 * master switch is on
9681 */
9682 if (spec->jack_present)
9683 mute = HDA_AMP_MUTE;
9684 else
9685 mute = snd_hda_codec_amp_read(codec, 0x14, 0, HDA_OUTPUT, 0);
9686 snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
9687 HDA_AMP_MUTE, mute);
9688 }
9689
9690 /* unsolicited event for HP jack sensing */
9691 static void alc262_fujitsu_unsol_event(struct hda_codec *codec,
9692 unsigned int res)
9693 {
9694 if ((res >> 26) != ALC_HP_EVENT)
9695 return;
9696 alc262_fujitsu_automute(codec, 1);
9697 }
9698
9699 static void alc262_fujitsu_init_hook(struct hda_codec *codec)
9700 {
9701 alc262_fujitsu_automute(codec, 1);
9702 }
9703
9704 /* bind volumes of both NID 0x0c and 0x0d */
9705 static struct hda_bind_ctls alc262_fujitsu_bind_master_vol = {
9706 .ops = &snd_hda_bind_vol,
9707 .values = {
9708 HDA_COMPOSE_AMP_VAL(0x0c, 3, 0, HDA_OUTPUT),
9709 HDA_COMPOSE_AMP_VAL(0x0d, 3, 0, HDA_OUTPUT),
9710 0
9711 },
9712 };
9713
9714 /* mute/unmute internal speaker according to the hp jack and mute state */
9715 static void alc262_lenovo_3000_automute(struct hda_codec *codec, int force)
9716 {
9717 struct alc_spec *spec = codec->spec;
9718 unsigned int mute;
9719
9720 if (force || !spec->sense_updated) {
9721 unsigned int present_int_hp;
9722 /* need to execute and sync at first */
9723 snd_hda_codec_read(codec, 0x1b, 0, AC_VERB_SET_PIN_SENSE, 0);
9724 present_int_hp = snd_hda_codec_read(codec, 0x1b, 0,
9725 AC_VERB_GET_PIN_SENSE, 0);
9726 spec->jack_present = (present_int_hp & 0x80000000) != 0;
9727 spec->sense_updated = 1;
9728 }
9729 if (spec->jack_present) {
9730 /* mute internal speaker */
9731 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
9732 HDA_AMP_MUTE, HDA_AMP_MUTE);
9733 snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
9734 HDA_AMP_MUTE, HDA_AMP_MUTE);
9735 } else {
9736 /* unmute internal speaker if necessary */
9737 mute = snd_hda_codec_amp_read(codec, 0x1b, 0, HDA_OUTPUT, 0);
9738 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
9739 HDA_AMP_MUTE, mute);
9740 snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
9741 HDA_AMP_MUTE, mute);
9742 }
9743 }
9744
9745 /* unsolicited event for HP jack sensing */
9746 static void alc262_lenovo_3000_unsol_event(struct hda_codec *codec,
9747 unsigned int res)
9748 {
9749 if ((res >> 26) != ALC_HP_EVENT)
9750 return;
9751 alc262_lenovo_3000_automute(codec, 1);
9752 }
9753
9754 /* bind hp and internal speaker mute (with plug check) */
9755 static int alc262_fujitsu_master_sw_put(struct snd_kcontrol *kcontrol,
9756 struct snd_ctl_elem_value *ucontrol)
9757 {
9758 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
9759 long *valp = ucontrol->value.integer.value;
9760 int change;
9761
9762 change = snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
9763 HDA_AMP_MUTE,
9764 valp ? 0 : HDA_AMP_MUTE);
9765 change |= snd_hda_codec_amp_stereo(codec, 0x1b, HDA_OUTPUT, 0,
9766 HDA_AMP_MUTE,
9767 valp ? 0 : HDA_AMP_MUTE);
9768
9769 if (change)
9770 alc262_fujitsu_automute(codec, 0);
9771 return change;
9772 }
9773
9774 static struct snd_kcontrol_new alc262_fujitsu_mixer[] = {
9775 HDA_BIND_VOL("Master Playback Volume", &alc262_fujitsu_bind_master_vol),
9776 {
9777 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
9778 .name = "Master Playback Switch",
9779 .info = snd_hda_mixer_amp_switch_info,
9780 .get = snd_hda_mixer_amp_switch_get,
9781 .put = alc262_fujitsu_master_sw_put,
9782 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
9783 },
9784 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
9785 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
9786 HDA_CODEC_VOLUME("PC Speaker Volume", 0x0b, 0x05, HDA_INPUT),
9787 HDA_CODEC_MUTE("PC Speaker Switch", 0x0b, 0x05, HDA_INPUT),
9788 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
9789 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9790 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9791 HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
9792 HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
9793 HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
9794 { } /* end */
9795 };
9796
9797 /* bind hp and internal speaker mute (with plug check) */
9798 static int alc262_lenovo_3000_master_sw_put(struct snd_kcontrol *kcontrol,
9799 struct snd_ctl_elem_value *ucontrol)
9800 {
9801 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
9802 long *valp = ucontrol->value.integer.value;
9803 int change;
9804
9805 change = snd_hda_codec_amp_stereo(codec, 0x1b, HDA_OUTPUT, 0,
9806 HDA_AMP_MUTE,
9807 valp ? 0 : HDA_AMP_MUTE);
9808
9809 if (change)
9810 alc262_lenovo_3000_automute(codec, 0);
9811 return change;
9812 }
9813
9814 static struct snd_kcontrol_new alc262_lenovo_3000_mixer[] = {
9815 HDA_BIND_VOL("Master Playback Volume", &alc262_fujitsu_bind_master_vol),
9816 {
9817 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
9818 .name = "Master Playback Switch",
9819 .info = snd_hda_mixer_amp_switch_info,
9820 .get = snd_hda_mixer_amp_switch_get,
9821 .put = alc262_lenovo_3000_master_sw_put,
9822 .private_value = HDA_COMPOSE_AMP_VAL(0x1b, 3, 0, HDA_OUTPUT),
9823 },
9824 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
9825 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
9826 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
9827 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9828 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9829 HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
9830 HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
9831 HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
9832 { } /* end */
9833 };
9834
9835 static struct snd_kcontrol_new alc262_toshiba_rx1_mixer[] = {
9836 HDA_BIND_VOL("Master Playback Volume", &alc262_fujitsu_bind_master_vol),
9837 {
9838 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
9839 .name = "Master Playback Switch",
9840 .info = snd_hda_mixer_amp_switch_info,
9841 .get = snd_hda_mixer_amp_switch_get,
9842 .put = alc262_sony_master_sw_put,
9843 .private_value = HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT),
9844 },
9845 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9846 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9847 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
9848 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
9849 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
9850 HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
9851 { } /* end */
9852 };
9853
9854 /* additional init verbs for Benq laptops */
9855 static struct hda_verb alc262_EAPD_verbs[] = {
9856 {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
9857 {0x20, AC_VERB_SET_PROC_COEF, 0x3070},
9858 {}
9859 };
9860
9861 static struct hda_verb alc262_benq_t31_EAPD_verbs[] = {
9862 {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
9863 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
9864
9865 {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
9866 {0x20, AC_VERB_SET_PROC_COEF, 0x3050},
9867 {}
9868 };
9869
9870 /* Samsung Q1 Ultra Vista model setup */
9871 static struct snd_kcontrol_new alc262_ultra_mixer[] = {
9872 HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9873 HDA_BIND_MUTE("Master Playback Switch", 0x0c, 2, HDA_INPUT),
9874 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
9875 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
9876 HDA_CODEC_VOLUME("Mic Boost", 0x19, 0, HDA_INPUT),
9877 HDA_CODEC_VOLUME("Headphone Mic Boost", 0x15, 0, HDA_INPUT),
9878 { } /* end */
9879 };
9880
9881 static struct hda_verb alc262_ultra_verbs[] = {
9882 /* output mixer */
9883 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
9884 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
9885 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
9886 /* speaker */
9887 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9888 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
9889 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9890 {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
9891 /* HP */
9892 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9893 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
9894 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9895 {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
9896 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
9897 /* internal mic */
9898 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
9899 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
9900 /* ADC, choose mic */
9901 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
9902 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
9903 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9904 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
9905 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
9906 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
9907 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
9908 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
9909 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
9910 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(8)},
9911 {}
9912 };
9913
9914 /* mute/unmute internal speaker according to the hp jack and mute state */
9915 static void alc262_ultra_automute(struct hda_codec *codec)
9916 {
9917 struct alc_spec *spec = codec->spec;
9918 unsigned int mute;
9919
9920 mute = 0;
9921 /* auto-mute only when HP is used as HP */
9922 if (!spec->cur_mux[0]) {
9923 unsigned int present;
9924 /* need to execute and sync at first */
9925 snd_hda_codec_read(codec, 0x15, 0, AC_VERB_SET_PIN_SENSE, 0);
9926 present = snd_hda_codec_read(codec, 0x15, 0,
9927 AC_VERB_GET_PIN_SENSE, 0);
9928 spec->jack_present = (present & AC_PINSENSE_PRESENCE) != 0;
9929 if (spec->jack_present)
9930 mute = HDA_AMP_MUTE;
9931 }
9932 /* mute/unmute internal speaker */
9933 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
9934 HDA_AMP_MUTE, mute);
9935 /* mute/unmute HP */
9936 snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
9937 HDA_AMP_MUTE, mute ? 0 : HDA_AMP_MUTE);
9938 }
9939
9940 /* unsolicited event for HP jack sensing */
9941 static void alc262_ultra_unsol_event(struct hda_codec *codec,
9942 unsigned int res)
9943 {
9944 if ((res >> 26) != ALC880_HP_EVENT)
9945 return;
9946 alc262_ultra_automute(codec);
9947 }
9948
9949 static struct hda_input_mux alc262_ultra_capture_source = {
9950 .num_items = 2,
9951 .items = {
9952 { "Mic", 0x1 },
9953 { "Headphone", 0x7 },
9954 },
9955 };
9956
9957 static int alc262_ultra_mux_enum_put(struct snd_kcontrol *kcontrol,
9958 struct snd_ctl_elem_value *ucontrol)
9959 {
9960 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
9961 struct alc_spec *spec = codec->spec;
9962 int ret;
9963
9964 ret = alc882_mux_enum_put(kcontrol, ucontrol);
9965 if (!ret)
9966 return 0;
9967 /* reprogram the HP pin as mic or HP according to the input source */
9968 snd_hda_codec_write_cache(codec, 0x15, 0,
9969 AC_VERB_SET_PIN_WIDGET_CONTROL,
9970 spec->cur_mux[0] ? PIN_VREF80 : PIN_HP);
9971 alc262_ultra_automute(codec); /* mute/unmute HP */
9972 return ret;
9973 }
9974
9975 static struct snd_kcontrol_new alc262_ultra_capture_mixer[] = {
9976 HDA_CODEC_VOLUME("Capture Volume", 0x07, 0x0, HDA_INPUT),
9977 HDA_CODEC_MUTE("Capture Switch", 0x07, 0x0, HDA_INPUT),
9978 {
9979 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
9980 .name = "Capture Source",
9981 .info = alc882_mux_enum_info,
9982 .get = alc882_mux_enum_get,
9983 .put = alc262_ultra_mux_enum_put,
9984 },
9985 { } /* end */
9986 };
9987
9988 /* add playback controls from the parsed DAC table */
9989 static int alc262_auto_create_multi_out_ctls(struct alc_spec *spec,
9990 const struct auto_pin_cfg *cfg)
9991 {
9992 hda_nid_t nid;
9993 int err;
9994
9995 spec->multiout.num_dacs = 1; /* only use one dac */
9996 spec->multiout.dac_nids = spec->private_dac_nids;
9997 spec->multiout.dac_nids[0] = 2;
9998
9999 nid = cfg->line_out_pins[0];
10000 if (nid) {
10001 err = add_control(spec, ALC_CTL_WIDGET_VOL,
10002 "Front Playback Volume",
10003 HDA_COMPOSE_AMP_VAL(0x0c, 3, 0, HDA_OUTPUT));
10004 if (err < 0)
10005 return err;
10006 err = add_control(spec, ALC_CTL_WIDGET_MUTE,
10007 "Front Playback Switch",
10008 HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT));
10009 if (err < 0)
10010 return err;
10011 }
10012
10013 nid = cfg->speaker_pins[0];
10014 if (nid) {
10015 if (nid == 0x16) {
10016 err = add_control(spec, ALC_CTL_WIDGET_VOL,
10017 "Speaker Playback Volume",
10018 HDA_COMPOSE_AMP_VAL(0x0e, 2, 0,
10019 HDA_OUTPUT));
10020 if (err < 0)
10021 return err;
10022 err = add_control(spec, ALC_CTL_WIDGET_MUTE,
10023 "Speaker Playback Switch",
10024 HDA_COMPOSE_AMP_VAL(nid, 2, 0,
10025 HDA_OUTPUT));
10026 if (err < 0)
10027 return err;
10028 } else {
10029 err = add_control(spec, ALC_CTL_WIDGET_MUTE,
10030 "Speaker Playback Switch",
10031 HDA_COMPOSE_AMP_VAL(nid, 3, 0,
10032 HDA_OUTPUT));
10033 if (err < 0)
10034 return err;
10035 }
10036 }
10037 nid = cfg->hp_pins[0];
10038 if (nid) {
10039 /* spec->multiout.hp_nid = 2; */
10040 if (nid == 0x16) {
10041 err = add_control(spec, ALC_CTL_WIDGET_VOL,
10042 "Headphone Playback Volume",
10043 HDA_COMPOSE_AMP_VAL(0x0e, 2, 0,
10044 HDA_OUTPUT));
10045 if (err < 0)
10046 return err;
10047 err = add_control(spec, ALC_CTL_WIDGET_MUTE,
10048 "Headphone Playback Switch",
10049 HDA_COMPOSE_AMP_VAL(nid, 2, 0,
10050 HDA_OUTPUT));
10051 if (err < 0)
10052 return err;
10053 } else {
10054 err = add_control(spec, ALC_CTL_WIDGET_MUTE,
10055 "Headphone Playback Switch",
10056 HDA_COMPOSE_AMP_VAL(nid, 3, 0,
10057 HDA_OUTPUT));
10058 if (err < 0)
10059 return err;
10060 }
10061 }
10062 return 0;
10063 }
10064
10065 /* identical with ALC880 */
10066 #define alc262_auto_create_analog_input_ctls \
10067 alc880_auto_create_analog_input_ctls
10068
10069 /*
10070 * generic initialization of ADC, input mixers and output mixers
10071 */
10072 static struct hda_verb alc262_volume_init_verbs[] = {
10073 /*
10074 * Unmute ADC0-2 and set the default input to mic-in
10075 */
10076 {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
10077 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10078 {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
10079 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10080 {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
10081 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10082
10083 /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
10084 * mixer widget
10085 * Note: PASD motherboards uses the Line In 2 as the input for
10086 * front panel mic (mic 2)
10087 */
10088 /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
10089 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
10090 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
10091 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
10092 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
10093 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
10094
10095 /*
10096 * Set up output mixers (0x0c - 0x0f)
10097 */
10098 /* set vol=0 to output mixers */
10099 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10100 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10101 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10102
10103 /* set up input amps for analog loopback */
10104 /* Amp Indices: DAC = 0, mixer = 1 */
10105 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10106 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10107 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10108 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10109 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10110 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10111
10112 /* FIXME: use matrix-type input source selection */
10113 /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
10114 /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
10115 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
10116 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
10117 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
10118 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
10119 /* Input mixer2 */
10120 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
10121 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
10122 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
10123 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
10124 /* Input mixer3 */
10125 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
10126 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
10127 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
10128 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
10129
10130 { }
10131 };
10132
10133 static struct hda_verb alc262_HP_BPC_init_verbs[] = {
10134 /*
10135 * Unmute ADC0-2 and set the default input to mic-in
10136 */
10137 {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
10138 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10139 {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
10140 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10141 {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
10142 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10143
10144 /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
10145 * mixer widget
10146 * Note: PASD motherboards uses the Line In 2 as the input for
10147 * front panel mic (mic 2)
10148 */
10149 /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
10150 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
10151 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
10152 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
10153 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
10154 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
10155 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
10156 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
10157
10158 /*
10159 * Set up output mixers (0x0c - 0x0e)
10160 */
10161 /* set vol=0 to output mixers */
10162 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10163 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10164 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10165
10166 /* set up input amps for analog loopback */
10167 /* Amp Indices: DAC = 0, mixer = 1 */
10168 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10169 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10170 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10171 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10172 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10173 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10174
10175 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
10176 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
10177 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
10178
10179 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
10180 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
10181
10182 {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
10183 {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
10184
10185 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
10186 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
10187 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
10188 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
10189 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
10190
10191 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0x7023 },
10192 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
10193 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
10194 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0x7023 },
10195 {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
10196 {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
10197
10198
10199 /* FIXME: use matrix-type input source selection */
10200 /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
10201 /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
10202 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
10203 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))},
10204 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))},
10205 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))},
10206 /* Input mixer2 */
10207 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
10208 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))},
10209 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))},
10210 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))},
10211 /* Input mixer3 */
10212 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
10213 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))},
10214 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))},
10215 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))},
10216
10217 {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
10218
10219 { }
10220 };
10221
10222 static struct hda_verb alc262_HP_BPC_WildWest_init_verbs[] = {
10223 /*
10224 * Unmute ADC0-2 and set the default input to mic-in
10225 */
10226 {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
10227 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10228 {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
10229 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10230 {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
10231 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10232
10233 /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
10234 * mixer widget
10235 * Note: PASD motherboards uses the Line In 2 as the input for front
10236 * panel mic (mic 2)
10237 */
10238 /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
10239 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
10240 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
10241 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
10242 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
10243 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
10244 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
10245 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
10246 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
10247 /*
10248 * Set up output mixers (0x0c - 0x0e)
10249 */
10250 /* set vol=0 to output mixers */
10251 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10252 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10253 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10254
10255 /* set up input amps for analog loopback */
10256 /* Amp Indices: DAC = 0, mixer = 1 */
10257 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10258 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10259 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10260 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10261 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10262 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10263
10264
10265 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP }, /* HP */
10266 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, /* Mono */
10267 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, /* rear MIC */
10268 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN }, /* Line in */
10269 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, /* Front MIC */
10270 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, /* Line out */
10271 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN }, /* CD in */
10272
10273 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
10274 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
10275
10276 {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
10277 {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
10278
10279 /* {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0x7023 }, */
10280 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
10281 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
10282 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0x7023 },
10283 {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
10284 {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
10285
10286 /* FIXME: use matrix-type input source selection */
10287 /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
10288 /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
10289 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, /*rear MIC*/
10290 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))}, /*Line in*/
10291 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))}, /*F MIC*/
10292 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))}, /*Front*/
10293 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))}, /*CD*/
10294 /* {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x06 << 8))}, */
10295 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x07 << 8))}, /*HP*/
10296 /* Input mixer2 */
10297 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
10298 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
10299 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))},
10300 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))},
10301 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))},
10302 /* {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x06 << 8))}, */
10303 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x07 << 8))},
10304 /* Input mixer3 */
10305 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
10306 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
10307 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))},
10308 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))},
10309 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))},
10310 /* {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x06 << 8))}, */
10311 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x07 << 8))},
10312
10313 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
10314
10315 { }
10316 };
10317
10318 static struct hda_verb alc262_toshiba_rx1_unsol_verbs[] = {
10319
10320 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, /* Front Speaker */
10321 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
10322 {0x14, AC_VERB_SET_CONNECT_SEL, 0x01},
10323
10324 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, /* MIC jack */
10325 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, /* Front MIC */
10326 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0) },
10327 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0) },
10328
10329 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP }, /* HP jack */
10330 {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
10331 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
10332 {}
10333 };
10334
10335
10336 #ifdef CONFIG_SND_HDA_POWER_SAVE
10337 #define alc262_loopbacks alc880_loopbacks
10338 #endif
10339
10340 /* pcm configuration: identiacal with ALC880 */
10341 #define alc262_pcm_analog_playback alc880_pcm_analog_playback
10342 #define alc262_pcm_analog_capture alc880_pcm_analog_capture
10343 #define alc262_pcm_digital_playback alc880_pcm_digital_playback
10344 #define alc262_pcm_digital_capture alc880_pcm_digital_capture
10345
10346 /*
10347 * BIOS auto configuration
10348 */
10349 static int alc262_parse_auto_config(struct hda_codec *codec)
10350 {
10351 struct alc_spec *spec = codec->spec;
10352 int err;
10353 static hda_nid_t alc262_ignore[] = { 0x1d, 0 };
10354
10355 err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
10356 alc262_ignore);
10357 if (err < 0)
10358 return err;
10359 if (!spec->autocfg.line_outs)
10360 return 0; /* can't find valid BIOS pin config */
10361 err = alc262_auto_create_multi_out_ctls(spec, &spec->autocfg);
10362 if (err < 0)
10363 return err;
10364 err = alc262_auto_create_analog_input_ctls(spec, &spec->autocfg);
10365 if (err < 0)
10366 return err;
10367
10368 spec->multiout.max_channels = spec->multiout.num_dacs * 2;
10369
10370 if (spec->autocfg.dig_out_pin)
10371 spec->multiout.dig_out_nid = ALC262_DIGOUT_NID;
10372 if (spec->autocfg.dig_in_pin)
10373 spec->dig_in_nid = ALC262_DIGIN_NID;
10374
10375 if (spec->kctl_alloc)
10376 spec->mixers[spec->num_mixers++] = spec->kctl_alloc;
10377
10378 spec->init_verbs[spec->num_init_verbs++] = alc262_volume_init_verbs;
10379 spec->num_mux_defs = 1;
10380 spec->input_mux = &spec->private_imux;
10381
10382 err = alc_auto_add_mic_boost(codec);
10383 if (err < 0)
10384 return err;
10385
10386 store_pin_configs(codec);
10387 return 1;
10388 }
10389
10390 #define alc262_auto_init_multi_out alc882_auto_init_multi_out
10391 #define alc262_auto_init_hp_out alc882_auto_init_hp_out
10392 #define alc262_auto_init_analog_input alc882_auto_init_analog_input
10393 #define alc262_auto_init_input_src alc882_auto_init_input_src
10394
10395
10396 /* init callback for auto-configuration model -- overriding the default init */
10397 static void alc262_auto_init(struct hda_codec *codec)
10398 {
10399 struct alc_spec *spec = codec->spec;
10400 alc262_auto_init_multi_out(codec);
10401 alc262_auto_init_hp_out(codec);
10402 alc262_auto_init_analog_input(codec);
10403 alc262_auto_init_input_src(codec);
10404 if (spec->unsol_event)
10405 alc_inithook(codec);
10406 }
10407
10408 /*
10409 * configuration and preset
10410 */
10411 static const char *alc262_models[ALC262_MODEL_LAST] = {
10412 [ALC262_BASIC] = "basic",
10413 [ALC262_HIPPO] = "hippo",
10414 [ALC262_HIPPO_1] = "hippo_1",
10415 [ALC262_FUJITSU] = "fujitsu",
10416 [ALC262_HP_BPC] = "hp-bpc",
10417 [ALC262_HP_BPC_D7000_WL]= "hp-bpc-d7000",
10418 [ALC262_HP_TC_T5735] = "hp-tc-t5735",
10419 [ALC262_HP_RP5700] = "hp-rp5700",
10420 [ALC262_BENQ_ED8] = "benq",
10421 [ALC262_BENQ_T31] = "benq-t31",
10422 [ALC262_SONY_ASSAMD] = "sony-assamd",
10423 [ALC262_TOSHIBA_S06] = "toshiba-s06",
10424 [ALC262_TOSHIBA_RX1] = "toshiba-rx1",
10425 [ALC262_ULTRA] = "ultra",
10426 [ALC262_LENOVO_3000] = "lenovo-3000",
10427 [ALC262_NEC] = "nec",
10428 [ALC262_AUTO] = "auto",
10429 };
10430
10431 static struct snd_pci_quirk alc262_cfg_tbl[] = {
10432 SND_PCI_QUIRK(0x1002, 0x437b, "Hippo", ALC262_HIPPO),
10433 SND_PCI_QUIRK(0x1033, 0x8895, "NEC Versa S9100", ALC262_NEC),
10434 SND_PCI_QUIRK(0x103c, 0x12fe, "HP xw9400", ALC262_HP_BPC),
10435 SND_PCI_QUIRK(0x103c, 0x12ff, "HP xw4550", ALC262_HP_BPC),
10436 SND_PCI_QUIRK(0x103c, 0x1306, "HP xw8600", ALC262_HP_BPC),
10437 SND_PCI_QUIRK(0x103c, 0x1307, "HP xw6600", ALC262_HP_BPC),
10438 SND_PCI_QUIRK(0x103c, 0x1308, "HP xw4600", ALC262_HP_BPC),
10439 SND_PCI_QUIRK(0x103c, 0x1309, "HP xw4*00", ALC262_HP_BPC),
10440 SND_PCI_QUIRK(0x103c, 0x130a, "HP xw6*00", ALC262_HP_BPC),
10441 SND_PCI_QUIRK(0x103c, 0x130b, "HP xw8*00", ALC262_HP_BPC),
10442 SND_PCI_QUIRK(0x103c, 0x2800, "HP D7000", ALC262_HP_BPC_D7000_WL),
10443 SND_PCI_QUIRK(0x103c, 0x2801, "HP D7000", ALC262_HP_BPC_D7000_WF),
10444 SND_PCI_QUIRK(0x103c, 0x2802, "HP D7000", ALC262_HP_BPC_D7000_WL),
10445 SND_PCI_QUIRK(0x103c, 0x2803, "HP D7000", ALC262_HP_BPC_D7000_WF),
10446 SND_PCI_QUIRK(0x103c, 0x2804, "HP D7000", ALC262_HP_BPC_D7000_WL),
10447 SND_PCI_QUIRK(0x103c, 0x2805, "HP D7000", ALC262_HP_BPC_D7000_WF),
10448 SND_PCI_QUIRK(0x103c, 0x2806, "HP D7000", ALC262_HP_BPC_D7000_WL),
10449 SND_PCI_QUIRK(0x103c, 0x2807, "HP D7000", ALC262_HP_BPC_D7000_WF),
10450 SND_PCI_QUIRK(0x103c, 0x280c, "HP xw4400", ALC262_HP_BPC),
10451 SND_PCI_QUIRK(0x103c, 0x3014, "HP xw6400", ALC262_HP_BPC),
10452 SND_PCI_QUIRK(0x103c, 0x3015, "HP xw8400", ALC262_HP_BPC),
10453 SND_PCI_QUIRK(0x103c, 0x302f, "HP Thin Client T5735",
10454 ALC262_HP_TC_T5735),
10455 SND_PCI_QUIRK(0x103c, 0x2817, "HP RP5700", ALC262_HP_RP5700),
10456 SND_PCI_QUIRK(0x104d, 0x1f00, "Sony ASSAMD", ALC262_SONY_ASSAMD),
10457 SND_PCI_QUIRK(0x104d, 0x8203, "Sony UX-90", ALC262_HIPPO),
10458 SND_PCI_QUIRK(0x104d, 0x820f, "Sony ASSAMD", ALC262_SONY_ASSAMD),
10459 SND_PCI_QUIRK(0x104d, 0x900e, "Sony ASSAMD", ALC262_SONY_ASSAMD),
10460 SND_PCI_QUIRK(0x104d, 0x9015, "Sony 0x9015", ALC262_SONY_ASSAMD),
10461 SND_PCI_QUIRK(0x1179, 0x0001, "Toshiba dynabook SS RX1",
10462 ALC262_TOSHIBA_RX1),
10463 SND_PCI_QUIRK(0x1179, 0xff7b, "Toshiba S06", ALC262_TOSHIBA_S06),
10464 SND_PCI_QUIRK(0x10cf, 0x1397, "Fujitsu", ALC262_FUJITSU),
10465 SND_PCI_QUIRK(0x10cf, 0x142d, "Fujitsu Lifebook E8410", ALC262_FUJITSU),
10466 SND_PCI_QUIRK(0x144d, 0xc032, "Samsung Q1 Ultra", ALC262_ULTRA),
10467 SND_PCI_QUIRK(0x144d, 0xc039, "Samsung Q1U EL", ALC262_ULTRA),
10468 SND_PCI_QUIRK(0x17aa, 0x384e, "Lenovo 3000 y410", ALC262_LENOVO_3000),
10469 SND_PCI_QUIRK(0x17ff, 0x0560, "Benq ED8", ALC262_BENQ_ED8),
10470 SND_PCI_QUIRK(0x17ff, 0x058d, "Benq T31-16", ALC262_BENQ_T31),
10471 SND_PCI_QUIRK(0x17ff, 0x058f, "Benq Hippo", ALC262_HIPPO_1),
10472 {}
10473 };
10474
10475 static struct alc_config_preset alc262_presets[] = {
10476 [ALC262_BASIC] = {
10477 .mixers = { alc262_base_mixer },
10478 .init_verbs = { alc262_init_verbs },
10479 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
10480 .dac_nids = alc262_dac_nids,
10481 .hp_nid = 0x03,
10482 .num_channel_mode = ARRAY_SIZE(alc262_modes),
10483 .channel_mode = alc262_modes,
10484 .input_mux = &alc262_capture_source,
10485 },
10486 [ALC262_HIPPO] = {
10487 .mixers = { alc262_base_mixer },
10488 .init_verbs = { alc262_init_verbs, alc262_hippo_unsol_verbs},
10489 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
10490 .dac_nids = alc262_dac_nids,
10491 .hp_nid = 0x03,
10492 .dig_out_nid = ALC262_DIGOUT_NID,
10493 .num_channel_mode = ARRAY_SIZE(alc262_modes),
10494 .channel_mode = alc262_modes,
10495 .input_mux = &alc262_capture_source,
10496 .unsol_event = alc262_hippo_unsol_event,
10497 .init_hook = alc262_hippo_automute,
10498 },
10499 [ALC262_HIPPO_1] = {
10500 .mixers = { alc262_hippo1_mixer },
10501 .init_verbs = { alc262_init_verbs, alc262_hippo1_unsol_verbs},
10502 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
10503 .dac_nids = alc262_dac_nids,
10504 .hp_nid = 0x02,
10505 .dig_out_nid = ALC262_DIGOUT_NID,
10506 .num_channel_mode = ARRAY_SIZE(alc262_modes),
10507 .channel_mode = alc262_modes,
10508 .input_mux = &alc262_capture_source,
10509 .unsol_event = alc262_hippo1_unsol_event,
10510 .init_hook = alc262_hippo1_automute,
10511 },
10512 [ALC262_FUJITSU] = {
10513 .mixers = { alc262_fujitsu_mixer },
10514 .init_verbs = { alc262_init_verbs, alc262_EAPD_verbs,
10515 alc262_fujitsu_unsol_verbs },
10516 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
10517 .dac_nids = alc262_dac_nids,
10518 .hp_nid = 0x03,
10519 .dig_out_nid = ALC262_DIGOUT_NID,
10520 .num_channel_mode = ARRAY_SIZE(alc262_modes),
10521 .channel_mode = alc262_modes,
10522 .input_mux = &alc262_fujitsu_capture_source,
10523 .unsol_event = alc262_fujitsu_unsol_event,
10524 .init_hook = alc262_fujitsu_init_hook,
10525 },
10526 [ALC262_HP_BPC] = {
10527 .mixers = { alc262_HP_BPC_mixer },
10528 .init_verbs = { alc262_HP_BPC_init_verbs },
10529 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
10530 .dac_nids = alc262_dac_nids,
10531 .hp_nid = 0x03,
10532 .num_channel_mode = ARRAY_SIZE(alc262_modes),
10533 .channel_mode = alc262_modes,
10534 .input_mux = &alc262_HP_capture_source,
10535 .unsol_event = alc262_hp_bpc_unsol_event,
10536 .init_hook = alc262_hp_bpc_automute,
10537 },
10538 [ALC262_HP_BPC_D7000_WF] = {
10539 .mixers = { alc262_HP_BPC_WildWest_mixer },
10540 .init_verbs = { alc262_HP_BPC_WildWest_init_verbs },
10541 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
10542 .dac_nids = alc262_dac_nids,
10543 .hp_nid = 0x03,
10544 .num_channel_mode = ARRAY_SIZE(alc262_modes),
10545 .channel_mode = alc262_modes,
10546 .input_mux = &alc262_HP_D7000_capture_source,
10547 .unsol_event = alc262_hp_wildwest_unsol_event,
10548 .init_hook = alc262_hp_wildwest_automute,
10549 },
10550 [ALC262_HP_BPC_D7000_WL] = {
10551 .mixers = { alc262_HP_BPC_WildWest_mixer,
10552 alc262_HP_BPC_WildWest_option_mixer },
10553 .init_verbs = { alc262_HP_BPC_WildWest_init_verbs },
10554 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
10555 .dac_nids = alc262_dac_nids,
10556 .hp_nid = 0x03,
10557 .num_channel_mode = ARRAY_SIZE(alc262_modes),
10558 .channel_mode = alc262_modes,
10559 .input_mux = &alc262_HP_D7000_capture_source,
10560 .unsol_event = alc262_hp_wildwest_unsol_event,
10561 .init_hook = alc262_hp_wildwest_automute,
10562 },
10563 [ALC262_HP_TC_T5735] = {
10564 .mixers = { alc262_hp_t5735_mixer },
10565 .init_verbs = { alc262_init_verbs, alc262_hp_t5735_verbs },
10566 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
10567 .dac_nids = alc262_dac_nids,
10568 .hp_nid = 0x03,
10569 .num_channel_mode = ARRAY_SIZE(alc262_modes),
10570 .channel_mode = alc262_modes,
10571 .input_mux = &alc262_capture_source,
10572 .unsol_event = alc262_hp_t5735_unsol_event,
10573 .init_hook = alc262_hp_t5735_init_hook,
10574 },
10575 [ALC262_HP_RP5700] = {
10576 .mixers = { alc262_hp_rp5700_mixer },
10577 .init_verbs = { alc262_init_verbs, alc262_hp_rp5700_verbs },
10578 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
10579 .dac_nids = alc262_dac_nids,
10580 .num_channel_mode = ARRAY_SIZE(alc262_modes),
10581 .channel_mode = alc262_modes,
10582 .input_mux = &alc262_hp_rp5700_capture_source,
10583 },
10584 [ALC262_BENQ_ED8] = {
10585 .mixers = { alc262_base_mixer },
10586 .init_verbs = { alc262_init_verbs, alc262_EAPD_verbs },
10587 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
10588 .dac_nids = alc262_dac_nids,
10589 .hp_nid = 0x03,
10590 .num_channel_mode = ARRAY_SIZE(alc262_modes),
10591 .channel_mode = alc262_modes,
10592 .input_mux = &alc262_capture_source,
10593 },
10594 [ALC262_SONY_ASSAMD] = {
10595 .mixers = { alc262_sony_mixer },
10596 .init_verbs = { alc262_init_verbs, alc262_sony_unsol_verbs},
10597 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
10598 .dac_nids = alc262_dac_nids,
10599 .hp_nid = 0x02,
10600 .num_channel_mode = ARRAY_SIZE(alc262_modes),
10601 .channel_mode = alc262_modes,
10602 .input_mux = &alc262_capture_source,
10603 .unsol_event = alc262_hippo_unsol_event,
10604 .init_hook = alc262_hippo_automute,
10605 },
10606 [ALC262_BENQ_T31] = {
10607 .mixers = { alc262_benq_t31_mixer },
10608 .init_verbs = { alc262_init_verbs, alc262_benq_t31_EAPD_verbs, alc262_hippo_unsol_verbs },
10609 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
10610 .dac_nids = alc262_dac_nids,
10611 .hp_nid = 0x03,
10612 .num_channel_mode = ARRAY_SIZE(alc262_modes),
10613 .channel_mode = alc262_modes,
10614 .input_mux = &alc262_capture_source,
10615 .unsol_event = alc262_hippo_unsol_event,
10616 .init_hook = alc262_hippo_automute,
10617 },
10618 [ALC262_ULTRA] = {
10619 .mixers = { alc262_ultra_mixer, alc262_ultra_capture_mixer },
10620 .init_verbs = { alc262_ultra_verbs },
10621 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
10622 .dac_nids = alc262_dac_nids,
10623 .num_channel_mode = ARRAY_SIZE(alc262_modes),
10624 .channel_mode = alc262_modes,
10625 .input_mux = &alc262_ultra_capture_source,
10626 .adc_nids = alc262_adc_nids, /* ADC0 */
10627 .capsrc_nids = alc262_capsrc_nids,
10628 .num_adc_nids = 1, /* single ADC */
10629 .unsol_event = alc262_ultra_unsol_event,
10630 .init_hook = alc262_ultra_automute,
10631 },
10632 [ALC262_LENOVO_3000] = {
10633 .mixers = { alc262_lenovo_3000_mixer },
10634 .init_verbs = { alc262_init_verbs, alc262_EAPD_verbs,
10635 alc262_lenovo_3000_unsol_verbs },
10636 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
10637 .dac_nids = alc262_dac_nids,
10638 .hp_nid = 0x03,
10639 .dig_out_nid = ALC262_DIGOUT_NID,
10640 .num_channel_mode = ARRAY_SIZE(alc262_modes),
10641 .channel_mode = alc262_modes,
10642 .input_mux = &alc262_fujitsu_capture_source,
10643 .unsol_event = alc262_lenovo_3000_unsol_event,
10644 },
10645 [ALC262_NEC] = {
10646 .mixers = { alc262_nec_mixer },
10647 .init_verbs = { alc262_nec_verbs },
10648 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
10649 .dac_nids = alc262_dac_nids,
10650 .hp_nid = 0x03,
10651 .num_channel_mode = ARRAY_SIZE(alc262_modes),
10652 .channel_mode = alc262_modes,
10653 .input_mux = &alc262_capture_source,
10654 },
10655 [ALC262_TOSHIBA_S06] = {
10656 .mixers = { alc262_toshiba_s06_mixer },
10657 .init_verbs = { alc262_init_verbs, alc262_toshiba_s06_verbs,
10658 alc262_eapd_verbs },
10659 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
10660 .capsrc_nids = alc262_dmic_capsrc_nids,
10661 .dac_nids = alc262_dac_nids,
10662 .adc_nids = alc262_dmic_adc_nids, /* ADC0 */
10663 .dig_out_nid = ALC262_DIGOUT_NID,
10664 .num_channel_mode = ARRAY_SIZE(alc262_modes),
10665 .channel_mode = alc262_modes,
10666 .input_mux = &alc262_dmic_capture_source,
10667 .unsol_event = alc262_toshiba_s06_unsol_event,
10668 .init_hook = alc262_toshiba_s06_init_hook,
10669 },
10670 [ALC262_TOSHIBA_RX1] = {
10671 .mixers = { alc262_toshiba_rx1_mixer },
10672 .init_verbs = { alc262_init_verbs, alc262_toshiba_rx1_unsol_verbs },
10673 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
10674 .dac_nids = alc262_dac_nids,
10675 .hp_nid = 0x03,
10676 .num_channel_mode = ARRAY_SIZE(alc262_modes),
10677 .channel_mode = alc262_modes,
10678 .input_mux = &alc262_capture_source,
10679 .unsol_event = alc262_hippo_unsol_event,
10680 .init_hook = alc262_hippo_automute,
10681 },
10682 };
10683
10684 static int patch_alc262(struct hda_codec *codec)
10685 {
10686 struct alc_spec *spec;
10687 int board_config;
10688 int err;
10689
10690 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
10691 if (spec == NULL)
10692 return -ENOMEM;
10693
10694 codec->spec = spec;
10695 #if 0
10696 /* pshou 07/11/05 set a zero PCM sample to DAC when FIFO is
10697 * under-run
10698 */
10699 {
10700 int tmp;
10701 snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_COEF_INDEX, 7);
10702 tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0);
10703 snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_COEF_INDEX, 7);
10704 snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_PROC_COEF, tmp | 0x80);
10705 }
10706 #endif
10707
10708 alc_fix_pll_init(codec, 0x20, 0x0a, 10);
10709
10710 board_config = snd_hda_check_board_config(codec, ALC262_MODEL_LAST,
10711 alc262_models,
10712 alc262_cfg_tbl);
10713
10714 if (board_config < 0) {
10715 printk(KERN_INFO "hda_codec: Unknown model for ALC262, "
10716 "trying auto-probe from BIOS...\n");
10717 board_config = ALC262_AUTO;
10718 }
10719
10720 if (board_config == ALC262_AUTO) {
10721 /* automatic parse from the BIOS config */
10722 err = alc262_parse_auto_config(codec);
10723 if (err < 0) {
10724 alc_free(codec);
10725 return err;
10726 } else if (!err) {
10727 printk(KERN_INFO
10728 "hda_codec: Cannot set up configuration "
10729 "from BIOS. Using base mode...\n");
10730 board_config = ALC262_BASIC;
10731 }
10732 }
10733
10734 if (board_config != ALC262_AUTO)
10735 setup_preset(spec, &alc262_presets[board_config]);
10736
10737 spec->stream_name_analog = "ALC262 Analog";
10738 spec->stream_analog_playback = &alc262_pcm_analog_playback;
10739 spec->stream_analog_capture = &alc262_pcm_analog_capture;
10740
10741 spec->stream_name_digital = "ALC262 Digital";
10742 spec->stream_digital_playback = &alc262_pcm_digital_playback;
10743 spec->stream_digital_capture = &alc262_pcm_digital_capture;
10744
10745 if (!spec->adc_nids && spec->input_mux) {
10746 /* check whether NID 0x07 is valid */
10747 unsigned int wcap = get_wcaps(codec, 0x07);
10748
10749 /* get type */
10750 wcap = (wcap & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
10751 if (wcap != AC_WID_AUD_IN) {
10752 spec->adc_nids = alc262_adc_nids_alt;
10753 spec->num_adc_nids = ARRAY_SIZE(alc262_adc_nids_alt);
10754 spec->capsrc_nids = alc262_capsrc_nids_alt;
10755 spec->mixers[spec->num_mixers] =
10756 alc262_capture_alt_mixer;
10757 spec->num_mixers++;
10758 } else {
10759 spec->adc_nids = alc262_adc_nids;
10760 spec->num_adc_nids = ARRAY_SIZE(alc262_adc_nids);
10761 spec->capsrc_nids = alc262_capsrc_nids;
10762 spec->mixers[spec->num_mixers] = alc262_capture_mixer;
10763 spec->num_mixers++;
10764 }
10765 }
10766
10767 spec->vmaster_nid = 0x0c;
10768
10769 codec->patch_ops = alc_patch_ops;
10770 if (board_config == ALC262_AUTO)
10771 spec->init_hook = alc262_auto_init;
10772 #ifdef CONFIG_SND_HDA_POWER_SAVE
10773 if (!spec->loopback.amplist)
10774 spec->loopback.amplist = alc262_loopbacks;
10775 #endif
10776
10777 return 0;
10778 }
10779
10780 /*
10781 * ALC268 channel source setting (2 channel)
10782 */
10783 #define ALC268_DIGOUT_NID ALC880_DIGOUT_NID
10784 #define alc268_modes alc260_modes
10785
10786 static hda_nid_t alc268_dac_nids[2] = {
10787 /* front, hp */
10788 0x02, 0x03
10789 };
10790
10791 static hda_nid_t alc268_adc_nids[2] = {
10792 /* ADC0-1 */
10793 0x08, 0x07
10794 };
10795
10796 static hda_nid_t alc268_adc_nids_alt[1] = {
10797 /* ADC0 */
10798 0x08
10799 };
10800
10801 static hda_nid_t alc268_capsrc_nids[2] = { 0x23, 0x24 };
10802
10803 static struct snd_kcontrol_new alc268_base_mixer[] = {
10804 /* output mixer control */
10805 HDA_CODEC_VOLUME("Front Playback Volume", 0x2, 0x0, HDA_OUTPUT),
10806 HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
10807 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x3, 0x0, HDA_OUTPUT),
10808 HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
10809 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
10810 HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
10811 HDA_CODEC_VOLUME("Line In Boost", 0x1a, 0, HDA_INPUT),
10812 { }
10813 };
10814
10815 /* bind Beep switches of both NID 0x0f and 0x10 */
10816 static struct hda_bind_ctls alc268_bind_beep_sw = {
10817 .ops = &snd_hda_bind_sw,
10818 .values = {
10819 HDA_COMPOSE_AMP_VAL(0x0f, 3, 1, HDA_INPUT),
10820 HDA_COMPOSE_AMP_VAL(0x10, 3, 1, HDA_INPUT),
10821 0
10822 },
10823 };
10824
10825 static struct snd_kcontrol_new alc268_beep_mixer[] = {
10826 HDA_CODEC_VOLUME("Beep Playback Volume", 0x1d, 0x0, HDA_INPUT),
10827 HDA_BIND_SW("Beep Playback Switch", &alc268_bind_beep_sw),
10828 { }
10829 };
10830
10831 static struct hda_verb alc268_eapd_verbs[] = {
10832 {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
10833 {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
10834 { }
10835 };
10836
10837 /* Toshiba specific */
10838 #define alc268_toshiba_automute alc262_hippo_automute
10839
10840 static struct hda_verb alc268_toshiba_verbs[] = {
10841 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
10842 { } /* end */
10843 };
10844
10845 static struct hda_input_mux alc268_acer_lc_capture_source = {
10846 .num_items = 2,
10847 .items = {
10848 { "i-Mic", 0x6 },
10849 { "E-Mic", 0x0 },
10850 },
10851 };
10852
10853 /* Acer specific */
10854 /* bind volumes of both NID 0x02 and 0x03 */
10855 static struct hda_bind_ctls alc268_acer_bind_master_vol = {
10856 .ops = &snd_hda_bind_vol,
10857 .values = {
10858 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT),
10859 HDA_COMPOSE_AMP_VAL(0x03, 3, 0, HDA_OUTPUT),
10860 0
10861 },
10862 };
10863
10864 /* mute/unmute internal speaker according to the hp jack and mute state */
10865 static void alc268_acer_automute(struct hda_codec *codec, int force)
10866 {
10867 struct alc_spec *spec = codec->spec;
10868 unsigned int mute;
10869
10870 if (force || !spec->sense_updated) {
10871 unsigned int present;
10872 present = snd_hda_codec_read(codec, 0x14, 0,
10873 AC_VERB_GET_PIN_SENSE, 0);
10874 spec->jack_present = (present & 0x80000000) != 0;
10875 spec->sense_updated = 1;
10876 }
10877 if (spec->jack_present)
10878 mute = HDA_AMP_MUTE; /* mute internal speaker */
10879 else /* unmute internal speaker if necessary */
10880 mute = snd_hda_codec_amp_read(codec, 0x14, 0, HDA_OUTPUT, 0);
10881 snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
10882 HDA_AMP_MUTE, mute);
10883 }
10884
10885
10886 /* bind hp and internal speaker mute (with plug check) */
10887 static int alc268_acer_master_sw_put(struct snd_kcontrol *kcontrol,
10888 struct snd_ctl_elem_value *ucontrol)
10889 {
10890 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
10891 long *valp = ucontrol->value.integer.value;
10892 int change;
10893
10894 change = snd_hda_codec_amp_update(codec, 0x14, 0, HDA_OUTPUT, 0,
10895 HDA_AMP_MUTE,
10896 valp[0] ? 0 : HDA_AMP_MUTE);
10897 change |= snd_hda_codec_amp_update(codec, 0x14, 1, HDA_OUTPUT, 0,
10898 HDA_AMP_MUTE,
10899 valp[1] ? 0 : HDA_AMP_MUTE);
10900 if (change)
10901 alc268_acer_automute(codec, 0);
10902 return change;
10903 }
10904
10905 static struct snd_kcontrol_new alc268_acer_aspire_one_mixer[] = {
10906 /* output mixer control */
10907 HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
10908 {
10909 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
10910 .name = "Master Playback Switch",
10911 .info = snd_hda_mixer_amp_switch_info,
10912 .get = snd_hda_mixer_amp_switch_get,
10913 .put = alc268_acer_master_sw_put,
10914 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
10915 },
10916 HDA_CODEC_VOLUME("Mic Boost Capture Volume", 0x18, 0, HDA_INPUT),
10917 { }
10918 };
10919
10920 static struct snd_kcontrol_new alc268_acer_mixer[] = {
10921 /* output mixer control */
10922 HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
10923 {
10924 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
10925 .name = "Master Playback Switch",
10926 .info = snd_hda_mixer_amp_switch_info,
10927 .get = snd_hda_mixer_amp_switch_get,
10928 .put = alc268_acer_master_sw_put,
10929 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
10930 },
10931 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
10932 HDA_CODEC_VOLUME("Internal Mic Boost", 0x19, 0, HDA_INPUT),
10933 HDA_CODEC_VOLUME("Line In Boost", 0x1a, 0, HDA_INPUT),
10934 { }
10935 };
10936
10937 static struct hda_verb alc268_acer_aspire_one_verbs[] = {
10938 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
10939 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
10940 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
10941 {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
10942 {0x23, AC_VERB_SET_CONNECT_SEL, 0x06},
10943 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, 0xa017},
10944 { }
10945 };
10946
10947 static struct hda_verb alc268_acer_verbs[] = {
10948 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, /* internal dmic? */
10949 {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
10950 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
10951 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
10952 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
10953 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
10954 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
10955 { }
10956 };
10957
10958 /* unsolicited event for HP jack sensing */
10959 static void alc268_toshiba_unsol_event(struct hda_codec *codec,
10960 unsigned int res)
10961 {
10962 if ((res >> 26) != ALC880_HP_EVENT)
10963 return;
10964 alc268_toshiba_automute(codec);
10965 }
10966
10967 static void alc268_acer_unsol_event(struct hda_codec *codec,
10968 unsigned int res)
10969 {
10970 if ((res >> 26) != ALC880_HP_EVENT)
10971 return;
10972 alc268_acer_automute(codec, 1);
10973 }
10974
10975 static void alc268_acer_init_hook(struct hda_codec *codec)
10976 {
10977 alc268_acer_automute(codec, 1);
10978 }
10979
10980 /* toggle speaker-output according to the hp-jack state */
10981 static void alc268_aspire_one_speaker_automute(struct hda_codec *codec)
10982 {
10983 unsigned int present;
10984 unsigned char bits;
10985
10986 present = snd_hda_codec_read(codec, 0x15, 0,
10987 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
10988 bits = present ? AMP_IN_MUTE(0) : 0;
10989 snd_hda_codec_amp_stereo(codec, 0x0f, HDA_INPUT, 0,
10990 AMP_IN_MUTE(0), bits);
10991 snd_hda_codec_amp_stereo(codec, 0x0f, HDA_INPUT, 1,
10992 AMP_IN_MUTE(0), bits);
10993 }
10994
10995
10996 static void alc268_acer_mic_automute(struct hda_codec *codec)
10997 {
10998 unsigned int present;
10999
11000 present = snd_hda_codec_read(codec, 0x18, 0,
11001 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
11002 snd_hda_codec_write(codec, 0x23, 0, AC_VERB_SET_CONNECT_SEL,
11003 present ? 0x0 : 0x6);
11004 }
11005
11006 static void alc268_acer_lc_unsol_event(struct hda_codec *codec,
11007 unsigned int res)
11008 {
11009 if ((res >> 26) == ALC880_HP_EVENT)
11010 alc268_aspire_one_speaker_automute(codec);
11011 if ((res >> 26) == ALC880_MIC_EVENT)
11012 alc268_acer_mic_automute(codec);
11013 }
11014
11015 static void alc268_acer_lc_init_hook(struct hda_codec *codec)
11016 {
11017 alc268_aspire_one_speaker_automute(codec);
11018 alc268_acer_mic_automute(codec);
11019 }
11020
11021 static struct snd_kcontrol_new alc268_dell_mixer[] = {
11022 /* output mixer control */
11023 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
11024 HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
11025 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
11026 HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
11027 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
11028 HDA_CODEC_VOLUME("Internal Mic Boost", 0x19, 0, HDA_INPUT),
11029 { }
11030 };
11031
11032 static struct hda_verb alc268_dell_verbs[] = {
11033 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11034 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11035 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
11036 { }
11037 };
11038
11039 /* mute/unmute internal speaker according to the hp jack and mute state */
11040 static void alc268_dell_automute(struct hda_codec *codec)
11041 {
11042 unsigned int present;
11043 unsigned int mute;
11044
11045 present = snd_hda_codec_read(codec, 0x15, 0, AC_VERB_GET_PIN_SENSE, 0);
11046 if (present & 0x80000000)
11047 mute = HDA_AMP_MUTE;
11048 else
11049 mute = snd_hda_codec_amp_read(codec, 0x15, 0, HDA_OUTPUT, 0);
11050 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
11051 HDA_AMP_MUTE, mute);
11052 }
11053
11054 static void alc268_dell_unsol_event(struct hda_codec *codec,
11055 unsigned int res)
11056 {
11057 if ((res >> 26) != ALC880_HP_EVENT)
11058 return;
11059 alc268_dell_automute(codec);
11060 }
11061
11062 #define alc268_dell_init_hook alc268_dell_automute
11063
11064 static struct snd_kcontrol_new alc267_quanta_il1_mixer[] = {
11065 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x2, 0x0, HDA_OUTPUT),
11066 HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
11067 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x3, 0x0, HDA_OUTPUT),
11068 HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
11069 HDA_CODEC_VOLUME("Mic Capture Volume", 0x23, 0x0, HDA_OUTPUT),
11070 HDA_BIND_MUTE("Mic Capture Switch", 0x23, 2, HDA_OUTPUT),
11071 HDA_CODEC_VOLUME("Ext Mic Boost", 0x18, 0, HDA_INPUT),
11072 HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
11073 { }
11074 };
11075
11076 static struct hda_verb alc267_quanta_il1_verbs[] = {
11077 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
11078 {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN},
11079 { }
11080 };
11081
11082 static void alc267_quanta_il1_hp_automute(struct hda_codec *codec)
11083 {
11084 unsigned int present;
11085
11086 present = snd_hda_codec_read(codec, 0x15, 0, AC_VERB_GET_PIN_SENSE, 0)
11087 & AC_PINSENSE_PRESENCE;
11088 snd_hda_codec_write(codec, 0x14, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
11089 present ? 0 : PIN_OUT);
11090 }
11091
11092 static void alc267_quanta_il1_mic_automute(struct hda_codec *codec)
11093 {
11094 unsigned int present;
11095
11096 present = snd_hda_codec_read(codec, 0x18, 0,
11097 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
11098 snd_hda_codec_write(codec, 0x23, 0,
11099 AC_VERB_SET_CONNECT_SEL,
11100 present ? 0x00 : 0x01);
11101 }
11102
11103 static void alc267_quanta_il1_automute(struct hda_codec *codec)
11104 {
11105 alc267_quanta_il1_hp_automute(codec);
11106 alc267_quanta_il1_mic_automute(codec);
11107 }
11108
11109 static void alc267_quanta_il1_unsol_event(struct hda_codec *codec,
11110 unsigned int res)
11111 {
11112 switch (res >> 26) {
11113 case ALC880_HP_EVENT:
11114 alc267_quanta_il1_hp_automute(codec);
11115 break;
11116 case ALC880_MIC_EVENT:
11117 alc267_quanta_il1_mic_automute(codec);
11118 break;
11119 }
11120 }
11121
11122 /*
11123 * generic initialization of ADC, input mixers and output mixers
11124 */
11125 static struct hda_verb alc268_base_init_verbs[] = {
11126 /* Unmute DAC0-1 and set vol = 0 */
11127 {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11128 {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11129 {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11130 {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11131 {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11132 {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11133
11134 /*
11135 * Set up output mixers (0x0c - 0x0e)
11136 */
11137 /* set vol=0 to output mixers */
11138 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11139 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11140 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11141 {0x0e, AC_VERB_SET_CONNECT_SEL, 0x00},
11142
11143 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11144 {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11145
11146 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
11147 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
11148 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
11149 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
11150 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
11151 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
11152 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
11153 {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
11154
11155 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11156 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11157 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11158 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11159 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11160 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11161 {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11162
11163 /* set PCBEEP vol = 0, mute connections */
11164 {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11165 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
11166 {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
11167
11168 /* Unmute Selector 23h,24h and set the default input to mic-in */
11169
11170 {0x23, AC_VERB_SET_CONNECT_SEL, 0x00},
11171 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
11172 {0x24, AC_VERB_SET_CONNECT_SEL, 0x00},
11173 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
11174
11175 { }
11176 };
11177
11178 /*
11179 * generic initialization of ADC, input mixers and output mixers
11180 */
11181 static struct hda_verb alc268_volume_init_verbs[] = {
11182 /* set output DAC */
11183 {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11184 {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11185 {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11186 {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11187
11188 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
11189 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
11190 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
11191 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
11192 {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
11193
11194 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11195 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11196 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11197 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11198 {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11199
11200 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11201 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11202 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11203 {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11204
11205 /* set PCBEEP vol = 0, mute connections */
11206 {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11207 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
11208 {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
11209
11210 { }
11211 };
11212
11213 #define alc268_mux_enum_info alc_mux_enum_info
11214 #define alc268_mux_enum_get alc_mux_enum_get
11215 #define alc268_mux_enum_put alc_mux_enum_put
11216
11217 static struct snd_kcontrol_new alc268_capture_alt_mixer[] = {
11218 HDA_CODEC_VOLUME("Capture Volume", 0x23, 0x0, HDA_OUTPUT),
11219 HDA_CODEC_MUTE("Capture Switch", 0x23, 0x0, HDA_OUTPUT),
11220 {
11221 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
11222 /* The multiple "Capture Source" controls confuse alsamixer
11223 * So call somewhat different..
11224 */
11225 /* .name = "Capture Source", */
11226 .name = "Input Source",
11227 .count = 1,
11228 .info = alc268_mux_enum_info,
11229 .get = alc268_mux_enum_get,
11230 .put = alc268_mux_enum_put,
11231 },
11232 { } /* end */
11233 };
11234
11235 static struct snd_kcontrol_new alc268_capture_mixer[] = {
11236 HDA_CODEC_VOLUME("Capture Volume", 0x23, 0x0, HDA_OUTPUT),
11237 HDA_CODEC_MUTE("Capture Switch", 0x23, 0x0, HDA_OUTPUT),
11238 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x24, 0x0, HDA_OUTPUT),
11239 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x24, 0x0, HDA_OUTPUT),
11240 {
11241 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
11242 /* The multiple "Capture Source" controls confuse alsamixer
11243 * So call somewhat different..
11244 */
11245 /* .name = "Capture Source", */
11246 .name = "Input Source",
11247 .count = 2,
11248 .info = alc268_mux_enum_info,
11249 .get = alc268_mux_enum_get,
11250 .put = alc268_mux_enum_put,
11251 },
11252 { } /* end */
11253 };
11254
11255 static struct hda_input_mux alc268_capture_source = {
11256 .num_items = 4,
11257 .items = {
11258 { "Mic", 0x0 },
11259 { "Front Mic", 0x1 },
11260 { "Line", 0x2 },
11261 { "CD", 0x3 },
11262 },
11263 };
11264
11265 static struct hda_input_mux alc268_acer_capture_source = {
11266 .num_items = 3,
11267 .items = {
11268 { "Mic", 0x0 },
11269 { "Internal Mic", 0x6 },
11270 { "Line", 0x2 },
11271 },
11272 };
11273
11274 #ifdef CONFIG_SND_DEBUG
11275 static struct snd_kcontrol_new alc268_test_mixer[] = {
11276 /* Volume widgets */
11277 HDA_CODEC_VOLUME("LOUT1 Playback Volume", 0x02, 0x0, HDA_OUTPUT),
11278 HDA_CODEC_VOLUME("LOUT2 Playback Volume", 0x03, 0x0, HDA_OUTPUT),
11279 HDA_BIND_MUTE_MONO("Mono sum Playback Switch", 0x0e, 1, 2, HDA_INPUT),
11280 HDA_BIND_MUTE("LINE-OUT sum Playback Switch", 0x0f, 2, HDA_INPUT),
11281 HDA_BIND_MUTE("HP-OUT sum Playback Switch", 0x10, 2, HDA_INPUT),
11282 HDA_BIND_MUTE("LINE-OUT Playback Switch", 0x14, 2, HDA_OUTPUT),
11283 HDA_BIND_MUTE("HP-OUT Playback Switch", 0x15, 2, HDA_OUTPUT),
11284 HDA_BIND_MUTE("Mono Playback Switch", 0x16, 2, HDA_OUTPUT),
11285 HDA_CODEC_VOLUME("MIC1 Capture Volume", 0x18, 0x0, HDA_INPUT),
11286 HDA_BIND_MUTE("MIC1 Capture Switch", 0x18, 2, HDA_OUTPUT),
11287 HDA_CODEC_VOLUME("MIC2 Capture Volume", 0x19, 0x0, HDA_INPUT),
11288 HDA_CODEC_VOLUME("LINE1 Capture Volume", 0x1a, 0x0, HDA_INPUT),
11289 HDA_BIND_MUTE("LINE1 Capture Switch", 0x1a, 2, HDA_OUTPUT),
11290 /* The below appears problematic on some hardwares */
11291 /*HDA_CODEC_VOLUME("PCBEEP Playback Volume", 0x1d, 0x0, HDA_INPUT),*/
11292 HDA_CODEC_VOLUME("PCM-IN1 Capture Volume", 0x23, 0x0, HDA_OUTPUT),
11293 HDA_BIND_MUTE("PCM-IN1 Capture Switch", 0x23, 2, HDA_OUTPUT),
11294 HDA_CODEC_VOLUME("PCM-IN2 Capture Volume", 0x24, 0x0, HDA_OUTPUT),
11295 HDA_BIND_MUTE("PCM-IN2 Capture Switch", 0x24, 2, HDA_OUTPUT),
11296
11297 /* Modes for retasking pin widgets */
11298 ALC_PIN_MODE("LINE-OUT pin mode", 0x14, ALC_PIN_DIR_INOUT),
11299 ALC_PIN_MODE("HP-OUT pin mode", 0x15, ALC_PIN_DIR_INOUT),
11300 ALC_PIN_MODE("MIC1 pin mode", 0x18, ALC_PIN_DIR_INOUT),
11301 ALC_PIN_MODE("LINE1 pin mode", 0x1a, ALC_PIN_DIR_INOUT),
11302
11303 /* Controls for GPIO pins, assuming they are configured as outputs */
11304 ALC_GPIO_DATA_SWITCH("GPIO pin 0", 0x01, 0x01),
11305 ALC_GPIO_DATA_SWITCH("GPIO pin 1", 0x01, 0x02),
11306 ALC_GPIO_DATA_SWITCH("GPIO pin 2", 0x01, 0x04),
11307 ALC_GPIO_DATA_SWITCH("GPIO pin 3", 0x01, 0x08),
11308
11309 /* Switches to allow the digital SPDIF output pin to be enabled.
11310 * The ALC268 does not have an SPDIF input.
11311 */
11312 ALC_SPDIF_CTRL_SWITCH("SPDIF Playback Switch", 0x06, 0x01),
11313
11314 /* A switch allowing EAPD to be enabled. Some laptops seem to use
11315 * this output to turn on an external amplifier.
11316 */
11317 ALC_EAPD_CTRL_SWITCH("LINE-OUT EAPD Enable Switch", 0x0f, 0x02),
11318 ALC_EAPD_CTRL_SWITCH("HP-OUT EAPD Enable Switch", 0x10, 0x02),
11319
11320 { } /* end */
11321 };
11322 #endif
11323
11324 /* create input playback/capture controls for the given pin */
11325 static int alc268_new_analog_output(struct alc_spec *spec, hda_nid_t nid,
11326 const char *ctlname, int idx)
11327 {
11328 char name[32];
11329 int err;
11330
11331 sprintf(name, "%s Playback Volume", ctlname);
11332 if (nid == 0x14) {
11333 err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
11334 HDA_COMPOSE_AMP_VAL(0x02, 3, idx,
11335 HDA_OUTPUT));
11336 if (err < 0)
11337 return err;
11338 } else if (nid == 0x15) {
11339 err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
11340 HDA_COMPOSE_AMP_VAL(0x03, 3, idx,
11341 HDA_OUTPUT));
11342 if (err < 0)
11343 return err;
11344 } else
11345 return -1;
11346 sprintf(name, "%s Playback Switch", ctlname);
11347 err = add_control(spec, ALC_CTL_WIDGET_MUTE, name,
11348 HDA_COMPOSE_AMP_VAL(nid, 3, idx, HDA_OUTPUT));
11349 if (err < 0)
11350 return err;
11351 return 0;
11352 }
11353
11354 /* add playback controls from the parsed DAC table */
11355 static int alc268_auto_create_multi_out_ctls(struct alc_spec *spec,
11356 const struct auto_pin_cfg *cfg)
11357 {
11358 hda_nid_t nid;
11359 int err;
11360
11361 spec->multiout.num_dacs = 2; /* only use one dac */
11362 spec->multiout.dac_nids = spec->private_dac_nids;
11363 spec->multiout.dac_nids[0] = 2;
11364 spec->multiout.dac_nids[1] = 3;
11365
11366 nid = cfg->line_out_pins[0];
11367 if (nid)
11368 alc268_new_analog_output(spec, nid, "Front", 0);
11369
11370 nid = cfg->speaker_pins[0];
11371 if (nid == 0x1d) {
11372 err = add_control(spec, ALC_CTL_WIDGET_VOL,
11373 "Speaker Playback Volume",
11374 HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT));
11375 if (err < 0)
11376 return err;
11377 }
11378 nid = cfg->hp_pins[0];
11379 if (nid)
11380 alc268_new_analog_output(spec, nid, "Headphone", 0);
11381
11382 nid = cfg->line_out_pins[1] | cfg->line_out_pins[2];
11383 if (nid == 0x16) {
11384 err = add_control(spec, ALC_CTL_WIDGET_MUTE,
11385 "Mono Playback Switch",
11386 HDA_COMPOSE_AMP_VAL(nid, 2, 0, HDA_INPUT));
11387 if (err < 0)
11388 return err;
11389 }
11390 return 0;
11391 }
11392
11393 /* create playback/capture controls for input pins */
11394 static int alc268_auto_create_analog_input_ctls(struct alc_spec *spec,
11395 const struct auto_pin_cfg *cfg)
11396 {
11397 struct hda_input_mux *imux = &spec->private_imux;
11398 int i, idx1;
11399
11400 for (i = 0; i < AUTO_PIN_LAST; i++) {
11401 switch(cfg->input_pins[i]) {
11402 case 0x18:
11403 idx1 = 0; /* Mic 1 */
11404 break;
11405 case 0x19:
11406 idx1 = 1; /* Mic 2 */
11407 break;
11408 case 0x1a:
11409 idx1 = 2; /* Line In */
11410 break;
11411 case 0x1c:
11412 idx1 = 3; /* CD */
11413 break;
11414 case 0x12:
11415 case 0x13:
11416 idx1 = 6; /* digital mics */
11417 break;
11418 default:
11419 continue;
11420 }
11421 imux->items[imux->num_items].label = auto_pin_cfg_labels[i];
11422 imux->items[imux->num_items].index = idx1;
11423 imux->num_items++;
11424 }
11425 return 0;
11426 }
11427
11428 static void alc268_auto_init_mono_speaker_out(struct hda_codec *codec)
11429 {
11430 struct alc_spec *spec = codec->spec;
11431 hda_nid_t speaker_nid = spec->autocfg.speaker_pins[0];
11432 hda_nid_t hp_nid = spec->autocfg.hp_pins[0];
11433 hda_nid_t line_nid = spec->autocfg.line_out_pins[0];
11434 unsigned int dac_vol1, dac_vol2;
11435
11436 if (speaker_nid) {
11437 snd_hda_codec_write(codec, speaker_nid, 0,
11438 AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
11439 snd_hda_codec_write(codec, 0x0f, 0,
11440 AC_VERB_SET_AMP_GAIN_MUTE,
11441 AMP_IN_UNMUTE(1));
11442 snd_hda_codec_write(codec, 0x10, 0,
11443 AC_VERB_SET_AMP_GAIN_MUTE,
11444 AMP_IN_UNMUTE(1));
11445 } else {
11446 snd_hda_codec_write(codec, 0x0f, 0,
11447 AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1));
11448 snd_hda_codec_write(codec, 0x10, 0,
11449 AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1));
11450 }
11451
11452 dac_vol1 = dac_vol2 = 0xb000 | 0x40; /* set max volume */
11453 if (line_nid == 0x14)
11454 dac_vol2 = AMP_OUT_ZERO;
11455 else if (line_nid == 0x15)
11456 dac_vol1 = AMP_OUT_ZERO;
11457 if (hp_nid == 0x14)
11458 dac_vol2 = AMP_OUT_ZERO;
11459 else if (hp_nid == 0x15)
11460 dac_vol1 = AMP_OUT_ZERO;
11461 if (line_nid != 0x16 || hp_nid != 0x16 ||
11462 spec->autocfg.line_out_pins[1] != 0x16 ||
11463 spec->autocfg.line_out_pins[2] != 0x16)
11464 dac_vol1 = dac_vol2 = AMP_OUT_ZERO;
11465
11466 snd_hda_codec_write(codec, 0x02, 0,
11467 AC_VERB_SET_AMP_GAIN_MUTE, dac_vol1);
11468 snd_hda_codec_write(codec, 0x03, 0,
11469 AC_VERB_SET_AMP_GAIN_MUTE, dac_vol2);
11470 }
11471
11472 /* pcm configuration: identiacal with ALC880 */
11473 #define alc268_pcm_analog_playback alc880_pcm_analog_playback
11474 #define alc268_pcm_analog_capture alc880_pcm_analog_capture
11475 #define alc268_pcm_analog_alt_capture alc880_pcm_analog_alt_capture
11476 #define alc268_pcm_digital_playback alc880_pcm_digital_playback
11477
11478 /*
11479 * BIOS auto configuration
11480 */
11481 static int alc268_parse_auto_config(struct hda_codec *codec)
11482 {
11483 struct alc_spec *spec = codec->spec;
11484 int err;
11485 static hda_nid_t alc268_ignore[] = { 0 };
11486
11487 err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
11488 alc268_ignore);
11489 if (err < 0)
11490 return err;
11491 if (!spec->autocfg.line_outs)
11492 return 0; /* can't find valid BIOS pin config */
11493
11494 err = alc268_auto_create_multi_out_ctls(spec, &spec->autocfg);
11495 if (err < 0)
11496 return err;
11497 err = alc268_auto_create_analog_input_ctls(spec, &spec->autocfg);
11498 if (err < 0)
11499 return err;
11500
11501 spec->multiout.max_channels = 2;
11502
11503 /* digital only support output */
11504 if (spec->autocfg.dig_out_pin)
11505 spec->multiout.dig_out_nid = ALC268_DIGOUT_NID;
11506
11507 if (spec->kctl_alloc)
11508 spec->mixers[spec->num_mixers++] = spec->kctl_alloc;
11509
11510 if (spec->autocfg.speaker_pins[0] != 0x1d)
11511 spec->mixers[spec->num_mixers++] = alc268_beep_mixer;
11512
11513 spec->init_verbs[spec->num_init_verbs++] = alc268_volume_init_verbs;
11514 spec->num_mux_defs = 1;
11515 spec->input_mux = &spec->private_imux;
11516
11517 err = alc_auto_add_mic_boost(codec);
11518 if (err < 0)
11519 return err;
11520
11521 store_pin_configs(codec);
11522 return 1;
11523 }
11524
11525 #define alc268_auto_init_multi_out alc882_auto_init_multi_out
11526 #define alc268_auto_init_hp_out alc882_auto_init_hp_out
11527 #define alc268_auto_init_analog_input alc882_auto_init_analog_input
11528
11529 /* init callback for auto-configuration model -- overriding the default init */
11530 static void alc268_auto_init(struct hda_codec *codec)
11531 {
11532 struct alc_spec *spec = codec->spec;
11533 alc268_auto_init_multi_out(codec);
11534 alc268_auto_init_hp_out(codec);
11535 alc268_auto_init_mono_speaker_out(codec);
11536 alc268_auto_init_analog_input(codec);
11537 if (spec->unsol_event)
11538 alc_inithook(codec);
11539 }
11540
11541 /*
11542 * configuration and preset
11543 */
11544 static const char *alc268_models[ALC268_MODEL_LAST] = {
11545 [ALC267_QUANTA_IL1] = "quanta-il1",
11546 [ALC268_3ST] = "3stack",
11547 [ALC268_TOSHIBA] = "toshiba",
11548 [ALC268_ACER] = "acer",
11549 [ALC268_ACER_ASPIRE_ONE] = "acer-aspire",
11550 [ALC268_DELL] = "dell",
11551 [ALC268_ZEPTO] = "zepto",
11552 #ifdef CONFIG_SND_DEBUG
11553 [ALC268_TEST] = "test",
11554 #endif
11555 [ALC268_AUTO] = "auto",
11556 };
11557
11558 static struct snd_pci_quirk alc268_cfg_tbl[] = {
11559 SND_PCI_QUIRK(0x1025, 0x011e, "Acer Aspire 5720z", ALC268_ACER),
11560 SND_PCI_QUIRK(0x1025, 0x0126, "Acer", ALC268_ACER),
11561 SND_PCI_QUIRK(0x1025, 0x012e, "Acer Aspire 5310", ALC268_ACER),
11562 SND_PCI_QUIRK(0x1025, 0x0130, "Acer Extensa 5210", ALC268_ACER),
11563 SND_PCI_QUIRK(0x1025, 0x0136, "Acer Aspire 5315", ALC268_ACER),
11564 SND_PCI_QUIRK(0x1025, 0x015b, "Acer Aspire One",
11565 ALC268_ACER_ASPIRE_ONE),
11566 SND_PCI_QUIRK(0x1028, 0x0253, "Dell OEM", ALC268_DELL),
11567 SND_PCI_QUIRK(0x103c, 0x30cc, "TOSHIBA", ALC268_TOSHIBA),
11568 SND_PCI_QUIRK(0x1043, 0x1205, "ASUS W7J", ALC268_3ST),
11569 SND_PCI_QUIRK(0x1179, 0xff10, "TOSHIBA A205", ALC268_TOSHIBA),
11570 SND_PCI_QUIRK(0x1179, 0xff50, "TOSHIBA A305", ALC268_TOSHIBA),
11571 SND_PCI_QUIRK(0x1179, 0xff64, "TOSHIBA L305", ALC268_TOSHIBA),
11572 SND_PCI_QUIRK(0x14c0, 0x0025, "COMPAL IFL90/JFL-92", ALC268_TOSHIBA),
11573 SND_PCI_QUIRK(0x152d, 0x0763, "Diverse (CPR2000)", ALC268_ACER),
11574 SND_PCI_QUIRK(0x152d, 0x0771, "Quanta IL1", ALC267_QUANTA_IL1),
11575 SND_PCI_QUIRK(0x1170, 0x0040, "ZEPTO", ALC268_ZEPTO),
11576 {}
11577 };
11578
11579 static struct alc_config_preset alc268_presets[] = {
11580 [ALC267_QUANTA_IL1] = {
11581 .mixers = { alc267_quanta_il1_mixer },
11582 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
11583 alc267_quanta_il1_verbs },
11584 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
11585 .dac_nids = alc268_dac_nids,
11586 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
11587 .adc_nids = alc268_adc_nids_alt,
11588 .hp_nid = 0x03,
11589 .num_channel_mode = ARRAY_SIZE(alc268_modes),
11590 .channel_mode = alc268_modes,
11591 .input_mux = &alc268_capture_source,
11592 .unsol_event = alc267_quanta_il1_unsol_event,
11593 .init_hook = alc267_quanta_il1_automute,
11594 },
11595 [ALC268_3ST] = {
11596 .mixers = { alc268_base_mixer, alc268_capture_alt_mixer,
11597 alc268_beep_mixer },
11598 .init_verbs = { alc268_base_init_verbs },
11599 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
11600 .dac_nids = alc268_dac_nids,
11601 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
11602 .adc_nids = alc268_adc_nids_alt,
11603 .capsrc_nids = alc268_capsrc_nids,
11604 .hp_nid = 0x03,
11605 .dig_out_nid = ALC268_DIGOUT_NID,
11606 .num_channel_mode = ARRAY_SIZE(alc268_modes),
11607 .channel_mode = alc268_modes,
11608 .input_mux = &alc268_capture_source,
11609 },
11610 [ALC268_TOSHIBA] = {
11611 .mixers = { alc268_base_mixer, alc268_capture_alt_mixer,
11612 alc268_beep_mixer },
11613 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
11614 alc268_toshiba_verbs },
11615 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
11616 .dac_nids = alc268_dac_nids,
11617 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
11618 .adc_nids = alc268_adc_nids_alt,
11619 .capsrc_nids = alc268_capsrc_nids,
11620 .hp_nid = 0x03,
11621 .num_channel_mode = ARRAY_SIZE(alc268_modes),
11622 .channel_mode = alc268_modes,
11623 .input_mux = &alc268_capture_source,
11624 .unsol_event = alc268_toshiba_unsol_event,
11625 .init_hook = alc268_toshiba_automute,
11626 },
11627 [ALC268_ACER] = {
11628 .mixers = { alc268_acer_mixer, alc268_capture_alt_mixer,
11629 alc268_beep_mixer },
11630 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
11631 alc268_acer_verbs },
11632 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
11633 .dac_nids = alc268_dac_nids,
11634 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
11635 .adc_nids = alc268_adc_nids_alt,
11636 .capsrc_nids = alc268_capsrc_nids,
11637 .hp_nid = 0x02,
11638 .num_channel_mode = ARRAY_SIZE(alc268_modes),
11639 .channel_mode = alc268_modes,
11640 .input_mux = &alc268_acer_capture_source,
11641 .unsol_event = alc268_acer_unsol_event,
11642 .init_hook = alc268_acer_init_hook,
11643 },
11644 [ALC268_ACER_ASPIRE_ONE] = {
11645 .mixers = { alc268_acer_aspire_one_mixer,
11646 alc268_capture_alt_mixer },
11647 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
11648 alc268_acer_aspire_one_verbs },
11649 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
11650 .dac_nids = alc268_dac_nids,
11651 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
11652 .adc_nids = alc268_adc_nids_alt,
11653 .capsrc_nids = alc268_capsrc_nids,
11654 .hp_nid = 0x03,
11655 .num_channel_mode = ARRAY_SIZE(alc268_modes),
11656 .channel_mode = alc268_modes,
11657 .input_mux = &alc268_acer_lc_capture_source,
11658 .unsol_event = alc268_acer_lc_unsol_event,
11659 .init_hook = alc268_acer_lc_init_hook,
11660 },
11661 [ALC268_DELL] = {
11662 .mixers = { alc268_dell_mixer, alc268_beep_mixer },
11663 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
11664 alc268_dell_verbs },
11665 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
11666 .dac_nids = alc268_dac_nids,
11667 .hp_nid = 0x02,
11668 .num_channel_mode = ARRAY_SIZE(alc268_modes),
11669 .channel_mode = alc268_modes,
11670 .unsol_event = alc268_dell_unsol_event,
11671 .init_hook = alc268_dell_init_hook,
11672 .input_mux = &alc268_capture_source,
11673 },
11674 [ALC268_ZEPTO] = {
11675 .mixers = { alc268_base_mixer, alc268_capture_alt_mixer,
11676 alc268_beep_mixer },
11677 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
11678 alc268_toshiba_verbs },
11679 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
11680 .dac_nids = alc268_dac_nids,
11681 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
11682 .adc_nids = alc268_adc_nids_alt,
11683 .capsrc_nids = alc268_capsrc_nids,
11684 .hp_nid = 0x03,
11685 .dig_out_nid = ALC268_DIGOUT_NID,
11686 .num_channel_mode = ARRAY_SIZE(alc268_modes),
11687 .channel_mode = alc268_modes,
11688 .input_mux = &alc268_capture_source,
11689 .unsol_event = alc268_toshiba_unsol_event,
11690 .init_hook = alc268_toshiba_automute
11691 },
11692 #ifdef CONFIG_SND_DEBUG
11693 [ALC268_TEST] = {
11694 .mixers = { alc268_test_mixer, alc268_capture_mixer },
11695 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
11696 alc268_volume_init_verbs },
11697 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
11698 .dac_nids = alc268_dac_nids,
11699 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
11700 .adc_nids = alc268_adc_nids_alt,
11701 .capsrc_nids = alc268_capsrc_nids,
11702 .hp_nid = 0x03,
11703 .dig_out_nid = ALC268_DIGOUT_NID,
11704 .num_channel_mode = ARRAY_SIZE(alc268_modes),
11705 .channel_mode = alc268_modes,
11706 .input_mux = &alc268_capture_source,
11707 },
11708 #endif
11709 };
11710
11711 static int patch_alc268(struct hda_codec *codec)
11712 {
11713 struct alc_spec *spec;
11714 int board_config;
11715 int err;
11716
11717 spec = kcalloc(1, sizeof(*spec), GFP_KERNEL);
11718 if (spec == NULL)
11719 return -ENOMEM;
11720
11721 codec->spec = spec;
11722
11723 board_config = snd_hda_check_board_config(codec, ALC268_MODEL_LAST,
11724 alc268_models,
11725 alc268_cfg_tbl);
11726
11727 if (board_config < 0 || board_config >= ALC268_MODEL_LAST) {
11728 printk(KERN_INFO "hda_codec: Unknown model for ALC268, "
11729 "trying auto-probe from BIOS...\n");
11730 board_config = ALC268_AUTO;
11731 }
11732
11733 if (board_config == ALC268_AUTO) {
11734 /* automatic parse from the BIOS config */
11735 err = alc268_parse_auto_config(codec);
11736 if (err < 0) {
11737 alc_free(codec);
11738 return err;
11739 } else if (!err) {
11740 printk(KERN_INFO
11741 "hda_codec: Cannot set up configuration "
11742 "from BIOS. Using base mode...\n");
11743 board_config = ALC268_3ST;
11744 }
11745 }
11746
11747 if (board_config != ALC268_AUTO)
11748 setup_preset(spec, &alc268_presets[board_config]);
11749
11750 if (codec->vendor_id == 0x10ec0267) {
11751 spec->stream_name_analog = "ALC267 Analog";
11752 spec->stream_name_digital = "ALC267 Digital";
11753 } else {
11754 spec->stream_name_analog = "ALC268 Analog";
11755 spec->stream_name_digital = "ALC268 Digital";
11756 }
11757
11758 spec->stream_analog_playback = &alc268_pcm_analog_playback;
11759 spec->stream_analog_capture = &alc268_pcm_analog_capture;
11760 spec->stream_analog_alt_capture = &alc268_pcm_analog_alt_capture;
11761
11762 spec->stream_digital_playback = &alc268_pcm_digital_playback;
11763
11764 if (!query_amp_caps(codec, 0x1d, HDA_INPUT))
11765 /* override the amp caps for beep generator */
11766 snd_hda_override_amp_caps(codec, 0x1d, HDA_INPUT,
11767 (0x0c << AC_AMPCAP_OFFSET_SHIFT) |
11768 (0x0c << AC_AMPCAP_NUM_STEPS_SHIFT) |
11769 (0x07 << AC_AMPCAP_STEP_SIZE_SHIFT) |
11770 (0 << AC_AMPCAP_MUTE_SHIFT));
11771
11772 if (!spec->adc_nids && spec->input_mux) {
11773 /* check whether NID 0x07 is valid */
11774 unsigned int wcap = get_wcaps(codec, 0x07);
11775 int i;
11776
11777 /* get type */
11778 wcap = (wcap & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
11779 if (wcap != AC_WID_AUD_IN || spec->input_mux->num_items == 1) {
11780 spec->adc_nids = alc268_adc_nids_alt;
11781 spec->num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt);
11782 spec->mixers[spec->num_mixers] =
11783 alc268_capture_alt_mixer;
11784 spec->num_mixers++;
11785 } else {
11786 spec->adc_nids = alc268_adc_nids;
11787 spec->num_adc_nids = ARRAY_SIZE(alc268_adc_nids);
11788 spec->mixers[spec->num_mixers] =
11789 alc268_capture_mixer;
11790 spec->num_mixers++;
11791 }
11792 spec->capsrc_nids = alc268_capsrc_nids;
11793 /* set default input source */
11794 for (i = 0; i < spec->num_adc_nids; i++)
11795 snd_hda_codec_write_cache(codec, alc268_capsrc_nids[i],
11796 0, AC_VERB_SET_CONNECT_SEL,
11797 spec->input_mux->items[0].index);
11798 }
11799
11800 spec->vmaster_nid = 0x02;
11801
11802 codec->patch_ops = alc_patch_ops;
11803 if (board_config == ALC268_AUTO)
11804 spec->init_hook = alc268_auto_init;
11805
11806 return 0;
11807 }
11808
11809 /*
11810 * ALC269 channel source setting (2 channel)
11811 */
11812 #define ALC269_DIGOUT_NID ALC880_DIGOUT_NID
11813
11814 #define alc269_dac_nids alc260_dac_nids
11815
11816 static hda_nid_t alc269_adc_nids[1] = {
11817 /* ADC1 */
11818 0x08,
11819 };
11820
11821 static hda_nid_t alc269_capsrc_nids[1] = {
11822 0x23,
11823 };
11824
11825 /* NOTE: ADC2 (0x07) is connected from a recording *MIXER* (0x24),
11826 * not a mux!
11827 */
11828
11829 static struct hda_input_mux alc269_eeepc_dmic_capture_source = {
11830 .num_items = 2,
11831 .items = {
11832 { "i-Mic", 0x5 },
11833 { "e-Mic", 0x0 },
11834 },
11835 };
11836
11837 static struct hda_input_mux alc269_eeepc_amic_capture_source = {
11838 .num_items = 2,
11839 .items = {
11840 { "i-Mic", 0x1 },
11841 { "e-Mic", 0x0 },
11842 },
11843 };
11844
11845 #define alc269_modes alc260_modes
11846 #define alc269_capture_source alc880_lg_lw_capture_source
11847
11848 static struct snd_kcontrol_new alc269_base_mixer[] = {
11849 HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
11850 HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
11851 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
11852 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
11853 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11854 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11855 HDA_CODEC_VOLUME("Beep Playback Volume", 0x0b, 0x4, HDA_INPUT),
11856 HDA_CODEC_MUTE("Beep Playback Switch", 0x0b, 0x4, HDA_INPUT),
11857 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
11858 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
11859 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
11860 HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
11861 HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
11862 HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x16, 2, 0x0, HDA_OUTPUT),
11863 { } /* end */
11864 };
11865
11866 static struct snd_kcontrol_new alc269_quanta_fl1_mixer[] = {
11867 /* output mixer control */
11868 HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
11869 {
11870 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
11871 .name = "Master Playback Switch",
11872 .info = snd_hda_mixer_amp_switch_info,
11873 .get = snd_hda_mixer_amp_switch_get,
11874 .put = alc268_acer_master_sw_put,
11875 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
11876 },
11877 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11878 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11879 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
11880 HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
11881 HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
11882 HDA_CODEC_VOLUME("Internal Mic Boost", 0x19, 0, HDA_INPUT),
11883 HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x04, HDA_INPUT),
11884 HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x04, HDA_INPUT),
11885 { }
11886 };
11887
11888 /* bind volumes of both NID 0x0c and 0x0d */
11889 static struct hda_bind_ctls alc269_epc_bind_vol = {
11890 .ops = &snd_hda_bind_vol,
11891 .values = {
11892 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT),
11893 HDA_COMPOSE_AMP_VAL(0x03, 3, 0, HDA_OUTPUT),
11894 0
11895 },
11896 };
11897
11898 static struct snd_kcontrol_new alc269_eeepc_mixer[] = {
11899 HDA_CODEC_MUTE("iSpeaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
11900 HDA_BIND_VOL("LineOut Playback Volume", &alc269_epc_bind_vol),
11901 HDA_CODEC_MUTE("LineOut Playback Switch", 0x15, 0x0, HDA_OUTPUT),
11902 { } /* end */
11903 };
11904
11905 /* capture mixer elements */
11906 static struct snd_kcontrol_new alc269_capture_mixer[] = {
11907 HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
11908 HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
11909 {
11910 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
11911 /* The multiple "Capture Source" controls confuse alsamixer
11912 * So call somewhat different..
11913 */
11914 /* .name = "Capture Source", */
11915 .name = "Input Source",
11916 .count = 1,
11917 .info = alc_mux_enum_info,
11918 .get = alc_mux_enum_get,
11919 .put = alc_mux_enum_put,
11920 },
11921 { } /* end */
11922 };
11923
11924 /* capture mixer elements */
11925 static struct snd_kcontrol_new alc269_epc_capture_mixer[] = {
11926 HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
11927 HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
11928 { } /* end */
11929 };
11930
11931 /* beep control */
11932 static struct snd_kcontrol_new alc269_beep_mixer[] = {
11933 HDA_CODEC_VOLUME("Beep Playback Volume", 0x0b, 0x4, HDA_INPUT),
11934 HDA_CODEC_MUTE("Beep Playback Switch", 0x0b, 0x4, HDA_INPUT),
11935 { } /* end */
11936 };
11937
11938 static struct hda_verb alc269_quanta_fl1_verbs[] = {
11939 {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
11940 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
11941 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11942 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
11943 {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
11944 {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
11945 { }
11946 };
11947
11948 /* toggle speaker-output according to the hp-jack state */
11949 static void alc269_quanta_fl1_speaker_automute(struct hda_codec *codec)
11950 {
11951 unsigned int present;
11952 unsigned char bits;
11953
11954 present = snd_hda_codec_read(codec, 0x15, 0,
11955 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
11956 bits = present ? AMP_IN_MUTE(0) : 0;
11957 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
11958 AMP_IN_MUTE(0), bits);
11959 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
11960 AMP_IN_MUTE(0), bits);
11961
11962 snd_hda_codec_write(codec, 0x20, 0,
11963 AC_VERB_SET_COEF_INDEX, 0x0c);
11964 snd_hda_codec_write(codec, 0x20, 0,
11965 AC_VERB_SET_PROC_COEF, 0x680);
11966
11967 snd_hda_codec_write(codec, 0x20, 0,
11968 AC_VERB_SET_COEF_INDEX, 0x0c);
11969 snd_hda_codec_write(codec, 0x20, 0,
11970 AC_VERB_SET_PROC_COEF, 0x480);
11971 }
11972
11973 static void alc269_quanta_fl1_mic_automute(struct hda_codec *codec)
11974 {
11975 unsigned int present;
11976
11977 present = snd_hda_codec_read(codec, 0x18, 0,
11978 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
11979 snd_hda_codec_write(codec, 0x23, 0,
11980 AC_VERB_SET_CONNECT_SEL, present ? 0x0 : 0x1);
11981 }
11982
11983 static void alc269_quanta_fl1_unsol_event(struct hda_codec *codec,
11984 unsigned int res)
11985 {
11986 if ((res >> 26) == ALC880_HP_EVENT)
11987 alc269_quanta_fl1_speaker_automute(codec);
11988 if ((res >> 26) == ALC880_MIC_EVENT)
11989 alc269_quanta_fl1_mic_automute(codec);
11990 }
11991
11992 static void alc269_quanta_fl1_init_hook(struct hda_codec *codec)
11993 {
11994 alc269_quanta_fl1_speaker_automute(codec);
11995 alc269_quanta_fl1_mic_automute(codec);
11996 }
11997
11998 static struct hda_verb alc269_eeepc_dmic_init_verbs[] = {
11999 {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
12000 {0x23, AC_VERB_SET_CONNECT_SEL, 0x05},
12001 {0x02, AC_VERB_SET_AMP_GAIN_MUTE, 0xb026 },
12002 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7019 | (0x00 << 8))},
12003 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
12004 {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
12005 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
12006 {}
12007 };
12008
12009 static struct hda_verb alc269_eeepc_amic_init_verbs[] = {
12010 {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
12011 {0x23, AC_VERB_SET_CONNECT_SEL, 0x01},
12012 {0x02, AC_VERB_SET_AMP_GAIN_MUTE, 0xb026 },
12013 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x701b | (0x00 << 8))},
12014 {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
12015 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
12016 {}
12017 };
12018
12019 /* toggle speaker-output according to the hp-jack state */
12020 static void alc269_speaker_automute(struct hda_codec *codec)
12021 {
12022 unsigned int present;
12023 unsigned char bits;
12024
12025 present = snd_hda_codec_read(codec, 0x15, 0,
12026 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
12027 bits = present ? AMP_IN_MUTE(0) : 0;
12028 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
12029 AMP_IN_MUTE(0), bits);
12030 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
12031 AMP_IN_MUTE(0), bits);
12032 }
12033
12034 static void alc269_eeepc_dmic_automute(struct hda_codec *codec)
12035 {
12036 unsigned int present;
12037
12038 present = snd_hda_codec_read(codec, 0x18, 0,
12039 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
12040 snd_hda_codec_write(codec, 0x23, 0,
12041 AC_VERB_SET_CONNECT_SEL, (present ? 0 : 5));
12042 }
12043
12044 static void alc269_eeepc_amic_automute(struct hda_codec *codec)
12045 {
12046 unsigned int present;
12047
12048 present = snd_hda_codec_read(codec, 0x18, 0,
12049 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
12050 snd_hda_codec_write(codec, 0x24, 0, AC_VERB_SET_AMP_GAIN_MUTE,
12051 0x7000 | (0x00 << 8) | (present ? 0 : 0x80));
12052 snd_hda_codec_write(codec, 0x24, 0, AC_VERB_SET_AMP_GAIN_MUTE,
12053 0x7000 | (0x01 << 8) | (present ? 0x80 : 0));
12054 }
12055
12056 /* unsolicited event for HP jack sensing */
12057 static void alc269_eeepc_dmic_unsol_event(struct hda_codec *codec,
12058 unsigned int res)
12059 {
12060 if ((res >> 26) == ALC880_HP_EVENT)
12061 alc269_speaker_automute(codec);
12062
12063 if ((res >> 26) == ALC880_MIC_EVENT)
12064 alc269_eeepc_dmic_automute(codec);
12065 }
12066
12067 static void alc269_eeepc_dmic_inithook(struct hda_codec *codec)
12068 {
12069 alc269_speaker_automute(codec);
12070 alc269_eeepc_dmic_automute(codec);
12071 }
12072
12073 /* unsolicited event for HP jack sensing */
12074 static void alc269_eeepc_amic_unsol_event(struct hda_codec *codec,
12075 unsigned int res)
12076 {
12077 if ((res >> 26) == ALC880_HP_EVENT)
12078 alc269_speaker_automute(codec);
12079
12080 if ((res >> 26) == ALC880_MIC_EVENT)
12081 alc269_eeepc_amic_automute(codec);
12082 }
12083
12084 static void alc269_eeepc_amic_inithook(struct hda_codec *codec)
12085 {
12086 alc269_speaker_automute(codec);
12087 alc269_eeepc_amic_automute(codec);
12088 }
12089
12090 /*
12091 * generic initialization of ADC, input mixers and output mixers
12092 */
12093 static struct hda_verb alc269_init_verbs[] = {
12094 /*
12095 * Unmute ADC0 and set the default input to mic-in
12096 */
12097 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12098
12099 /* Mute input amps (PCBeep, Line In, Mic 1 & Mic 2) of the
12100 * analog-loopback mixer widget
12101 * Note: PASD motherboards uses the Line In 2 as the input for
12102 * front panel mic (mic 2)
12103 */
12104 /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
12105 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
12106 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
12107 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
12108 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
12109 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
12110
12111 /*
12112 * Set up output mixers (0x0c - 0x0e)
12113 */
12114 /* set vol=0 to output mixers */
12115 {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12116 {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12117
12118 /* set up input amps for analog loopback */
12119 /* Amp Indices: DAC = 0, mixer = 1 */
12120 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12121 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12122 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12123 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12124 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12125 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12126
12127 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
12128 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
12129 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
12130 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
12131 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
12132 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
12133 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
12134
12135 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12136 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12137 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12138 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12139 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12140 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12141 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12142
12143 {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
12144 {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
12145
12146 /* FIXME: use matrix-type input source selection */
12147 /* Mixer elements: 0x18, 19, 1a, 1b, 1d, 0b */
12148 /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
12149 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
12150 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12151 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
12152 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
12153
12154 /* set EAPD */
12155 {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
12156 {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
12157 { }
12158 };
12159
12160 /* add playback controls from the parsed DAC table */
12161 static int alc269_auto_create_multi_out_ctls(struct alc_spec *spec,
12162 const struct auto_pin_cfg *cfg)
12163 {
12164 hda_nid_t nid;
12165 int err;
12166
12167 spec->multiout.num_dacs = 1; /* only use one dac */
12168 spec->multiout.dac_nids = spec->private_dac_nids;
12169 spec->multiout.dac_nids[0] = 2;
12170
12171 nid = cfg->line_out_pins[0];
12172 if (nid) {
12173 err = add_control(spec, ALC_CTL_WIDGET_VOL,
12174 "Front Playback Volume",
12175 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT));
12176 if (err < 0)
12177 return err;
12178 err = add_control(spec, ALC_CTL_WIDGET_MUTE,
12179 "Front Playback Switch",
12180 HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT));
12181 if (err < 0)
12182 return err;
12183 }
12184
12185 nid = cfg->speaker_pins[0];
12186 if (nid) {
12187 if (!cfg->line_out_pins[0]) {
12188 err = add_control(spec, ALC_CTL_WIDGET_VOL,
12189 "Speaker Playback Volume",
12190 HDA_COMPOSE_AMP_VAL(0x02, 3, 0,
12191 HDA_OUTPUT));
12192 if (err < 0)
12193 return err;
12194 }
12195 if (nid == 0x16) {
12196 err = add_control(spec, ALC_CTL_WIDGET_MUTE,
12197 "Speaker Playback Switch",
12198 HDA_COMPOSE_AMP_VAL(nid, 2, 0,
12199 HDA_OUTPUT));
12200 if (err < 0)
12201 return err;
12202 } else {
12203 err = add_control(spec, ALC_CTL_WIDGET_MUTE,
12204 "Speaker Playback Switch",
12205 HDA_COMPOSE_AMP_VAL(nid, 3, 0,
12206 HDA_OUTPUT));
12207 if (err < 0)
12208 return err;
12209 }
12210 }
12211 nid = cfg->hp_pins[0];
12212 if (nid) {
12213 /* spec->multiout.hp_nid = 2; */
12214 if (!cfg->line_out_pins[0] && !cfg->speaker_pins[0]) {
12215 err = add_control(spec, ALC_CTL_WIDGET_VOL,
12216 "Headphone Playback Volume",
12217 HDA_COMPOSE_AMP_VAL(0x02, 3, 0,
12218 HDA_OUTPUT));
12219 if (err < 0)
12220 return err;
12221 }
12222 if (nid == 0x16) {
12223 err = add_control(spec, ALC_CTL_WIDGET_MUTE,
12224 "Headphone Playback Switch",
12225 HDA_COMPOSE_AMP_VAL(nid, 2, 0,
12226 HDA_OUTPUT));
12227 if (err < 0)
12228 return err;
12229 } else {
12230 err = add_control(spec, ALC_CTL_WIDGET_MUTE,
12231 "Headphone Playback Switch",
12232 HDA_COMPOSE_AMP_VAL(nid, 3, 0,
12233 HDA_OUTPUT));
12234 if (err < 0)
12235 return err;
12236 }
12237 }
12238 return 0;
12239 }
12240
12241 #define alc269_auto_create_analog_input_ctls \
12242 alc880_auto_create_analog_input_ctls
12243
12244 #ifdef CONFIG_SND_HDA_POWER_SAVE
12245 #define alc269_loopbacks alc880_loopbacks
12246 #endif
12247
12248 /* pcm configuration: identiacal with ALC880 */
12249 #define alc269_pcm_analog_playback alc880_pcm_analog_playback
12250 #define alc269_pcm_analog_capture alc880_pcm_analog_capture
12251 #define alc269_pcm_digital_playback alc880_pcm_digital_playback
12252 #define alc269_pcm_digital_capture alc880_pcm_digital_capture
12253
12254 /*
12255 * BIOS auto configuration
12256 */
12257 static int alc269_parse_auto_config(struct hda_codec *codec)
12258 {
12259 struct alc_spec *spec = codec->spec;
12260 int i, err;
12261 static hda_nid_t alc269_ignore[] = { 0x1d, 0 };
12262
12263 err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
12264 alc269_ignore);
12265 if (err < 0)
12266 return err;
12267
12268 err = alc269_auto_create_multi_out_ctls(spec, &spec->autocfg);
12269 if (err < 0)
12270 return err;
12271 err = alc269_auto_create_analog_input_ctls(spec, &spec->autocfg);
12272 if (err < 0)
12273 return err;
12274
12275 spec->multiout.max_channels = spec->multiout.num_dacs * 2;
12276
12277 if (spec->autocfg.dig_out_pin)
12278 spec->multiout.dig_out_nid = ALC269_DIGOUT_NID;
12279
12280 if (spec->kctl_alloc)
12281 spec->mixers[spec->num_mixers++] = spec->kctl_alloc;
12282
12283 /* create a beep mixer control if the pin 0x1d isn't assigned */
12284 for (i = 0; i < ARRAY_SIZE(spec->autocfg.input_pins); i++)
12285 if (spec->autocfg.input_pins[i] == 0x1d)
12286 break;
12287 if (i >= ARRAY_SIZE(spec->autocfg.input_pins))
12288 spec->mixers[spec->num_mixers++] = alc269_beep_mixer;
12289
12290 spec->init_verbs[spec->num_init_verbs++] = alc269_init_verbs;
12291 spec->num_mux_defs = 1;
12292 spec->input_mux = &spec->private_imux;
12293 /* set default input source */
12294 snd_hda_codec_write_cache(codec, alc269_capsrc_nids[0],
12295 0, AC_VERB_SET_CONNECT_SEL,
12296 spec->input_mux->items[0].index);
12297
12298 err = alc_auto_add_mic_boost(codec);
12299 if (err < 0)
12300 return err;
12301
12302 spec->mixers[spec->num_mixers] = alc269_capture_mixer;
12303 spec->num_mixers++;
12304
12305 store_pin_configs(codec);
12306 return 1;
12307 }
12308
12309 #define alc269_auto_init_multi_out alc882_auto_init_multi_out
12310 #define alc269_auto_init_hp_out alc882_auto_init_hp_out
12311 #define alc269_auto_init_analog_input alc882_auto_init_analog_input
12312
12313
12314 /* init callback for auto-configuration model -- overriding the default init */
12315 static void alc269_auto_init(struct hda_codec *codec)
12316 {
12317 struct alc_spec *spec = codec->spec;
12318 alc269_auto_init_multi_out(codec);
12319 alc269_auto_init_hp_out(codec);
12320 alc269_auto_init_analog_input(codec);
12321 if (spec->unsol_event)
12322 alc_inithook(codec);
12323 }
12324
12325 /*
12326 * configuration and preset
12327 */
12328 static const char *alc269_models[ALC269_MODEL_LAST] = {
12329 [ALC269_BASIC] = "basic",
12330 [ALC269_QUANTA_FL1] = "quanta",
12331 [ALC269_ASUS_EEEPC_P703] = "eeepc-p703",
12332 [ALC269_ASUS_EEEPC_P901] = "eeepc-p901"
12333 };
12334
12335 static struct snd_pci_quirk alc269_cfg_tbl[] = {
12336 SND_PCI_QUIRK(0x17aa, 0x3bf8, "Quanta FL1", ALC269_QUANTA_FL1),
12337 SND_PCI_QUIRK(0x1043, 0x8330, "ASUS Eeepc P703 P900A",
12338 ALC269_ASUS_EEEPC_P703),
12339 SND_PCI_QUIRK(0x1043, 0x831a, "ASUS Eeepc P901",
12340 ALC269_ASUS_EEEPC_P901),
12341 SND_PCI_QUIRK(0x1043, 0x834a, "ASUS Eeepc S101",
12342 ALC269_ASUS_EEEPC_P901),
12343 {}
12344 };
12345
12346 static struct alc_config_preset alc269_presets[] = {
12347 [ALC269_BASIC] = {
12348 .mixers = { alc269_base_mixer, alc269_capture_mixer },
12349 .init_verbs = { alc269_init_verbs },
12350 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
12351 .dac_nids = alc269_dac_nids,
12352 .hp_nid = 0x03,
12353 .num_channel_mode = ARRAY_SIZE(alc269_modes),
12354 .channel_mode = alc269_modes,
12355 .input_mux = &alc269_capture_source,
12356 },
12357 [ALC269_QUANTA_FL1] = {
12358 .mixers = { alc269_quanta_fl1_mixer },
12359 .init_verbs = { alc269_init_verbs, alc269_quanta_fl1_verbs },
12360 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
12361 .dac_nids = alc269_dac_nids,
12362 .hp_nid = 0x03,
12363 .num_channel_mode = ARRAY_SIZE(alc269_modes),
12364 .channel_mode = alc269_modes,
12365 .input_mux = &alc269_capture_source,
12366 .unsol_event = alc269_quanta_fl1_unsol_event,
12367 .init_hook = alc269_quanta_fl1_init_hook,
12368 },
12369 [ALC269_ASUS_EEEPC_P703] = {
12370 .mixers = { alc269_eeepc_mixer, alc269_epc_capture_mixer },
12371 .init_verbs = { alc269_init_verbs,
12372 alc269_eeepc_amic_init_verbs },
12373 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
12374 .dac_nids = alc269_dac_nids,
12375 .hp_nid = 0x03,
12376 .num_channel_mode = ARRAY_SIZE(alc269_modes),
12377 .channel_mode = alc269_modes,
12378 .input_mux = &alc269_eeepc_amic_capture_source,
12379 .unsol_event = alc269_eeepc_amic_unsol_event,
12380 .init_hook = alc269_eeepc_amic_inithook,
12381 },
12382 [ALC269_ASUS_EEEPC_P901] = {
12383 .mixers = { alc269_eeepc_mixer, alc269_epc_capture_mixer},
12384 .init_verbs = { alc269_init_verbs,
12385 alc269_eeepc_dmic_init_verbs },
12386 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
12387 .dac_nids = alc269_dac_nids,
12388 .hp_nid = 0x03,
12389 .num_channel_mode = ARRAY_SIZE(alc269_modes),
12390 .channel_mode = alc269_modes,
12391 .input_mux = &alc269_eeepc_dmic_capture_source,
12392 .unsol_event = alc269_eeepc_dmic_unsol_event,
12393 .init_hook = alc269_eeepc_dmic_inithook,
12394 },
12395 };
12396
12397 static int patch_alc269(struct hda_codec *codec)
12398 {
12399 struct alc_spec *spec;
12400 int board_config;
12401 int err;
12402
12403 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
12404 if (spec == NULL)
12405 return -ENOMEM;
12406
12407 codec->spec = spec;
12408
12409 alc_fix_pll_init(codec, 0x20, 0x04, 15);
12410
12411 board_config = snd_hda_check_board_config(codec, ALC269_MODEL_LAST,
12412 alc269_models,
12413 alc269_cfg_tbl);
12414
12415 if (board_config < 0) {
12416 printk(KERN_INFO "hda_codec: Unknown model for ALC269, "
12417 "trying auto-probe from BIOS...\n");
12418 board_config = ALC269_AUTO;
12419 }
12420
12421 if (board_config == ALC269_AUTO) {
12422 /* automatic parse from the BIOS config */
12423 err = alc269_parse_auto_config(codec);
12424 if (err < 0) {
12425 alc_free(codec);
12426 return err;
12427 } else if (!err) {
12428 printk(KERN_INFO
12429 "hda_codec: Cannot set up configuration "
12430 "from BIOS. Using base mode...\n");
12431 board_config = ALC269_BASIC;
12432 }
12433 }
12434
12435 if (board_config != ALC269_AUTO)
12436 setup_preset(spec, &alc269_presets[board_config]);
12437
12438 spec->stream_name_analog = "ALC269 Analog";
12439 spec->stream_analog_playback = &alc269_pcm_analog_playback;
12440 spec->stream_analog_capture = &alc269_pcm_analog_capture;
12441
12442 spec->stream_name_digital = "ALC269 Digital";
12443 spec->stream_digital_playback = &alc269_pcm_digital_playback;
12444 spec->stream_digital_capture = &alc269_pcm_digital_capture;
12445
12446 spec->adc_nids = alc269_adc_nids;
12447 spec->num_adc_nids = ARRAY_SIZE(alc269_adc_nids);
12448 spec->capsrc_nids = alc269_capsrc_nids;
12449
12450 codec->patch_ops = alc_patch_ops;
12451 if (board_config == ALC269_AUTO)
12452 spec->init_hook = alc269_auto_init;
12453 #ifdef CONFIG_SND_HDA_POWER_SAVE
12454 if (!spec->loopback.amplist)
12455 spec->loopback.amplist = alc269_loopbacks;
12456 #endif
12457
12458 return 0;
12459 }
12460
12461 /*
12462 * ALC861 channel source setting (2/6 channel selection for 3-stack)
12463 */
12464
12465 /*
12466 * set the path ways for 2 channel output
12467 * need to set the codec line out and mic 1 pin widgets to inputs
12468 */
12469 static struct hda_verb alc861_threestack_ch2_init[] = {
12470 /* set pin widget 1Ah (line in) for input */
12471 { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
12472 /* set pin widget 18h (mic1/2) for input, for mic also enable
12473 * the vref
12474 */
12475 { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
12476
12477 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c },
12478 #if 0
12479 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8)) }, /*mic*/
12480 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8)) }, /*line-in*/
12481 #endif
12482 { } /* end */
12483 };
12484 /*
12485 * 6ch mode
12486 * need to set the codec line out and mic 1 pin widgets to outputs
12487 */
12488 static struct hda_verb alc861_threestack_ch6_init[] = {
12489 /* set pin widget 1Ah (line in) for output (Back Surround)*/
12490 { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
12491 /* set pin widget 18h (mic1) for output (CLFE)*/
12492 { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
12493
12494 { 0x0c, AC_VERB_SET_CONNECT_SEL, 0x00 },
12495 { 0x0d, AC_VERB_SET_CONNECT_SEL, 0x00 },
12496
12497 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080 },
12498 #if 0
12499 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8)) }, /*mic*/
12500 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8)) }, /*line in*/
12501 #endif
12502 { } /* end */
12503 };
12504
12505 static struct hda_channel_mode alc861_threestack_modes[2] = {
12506 { 2, alc861_threestack_ch2_init },
12507 { 6, alc861_threestack_ch6_init },
12508 };
12509 /* Set mic1 as input and unmute the mixer */
12510 static struct hda_verb alc861_uniwill_m31_ch2_init[] = {
12511 { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
12512 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8)) }, /*mic*/
12513 { } /* end */
12514 };
12515 /* Set mic1 as output and mute mixer */
12516 static struct hda_verb alc861_uniwill_m31_ch4_init[] = {
12517 { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
12518 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8)) }, /*mic*/
12519 { } /* end */
12520 };
12521
12522 static struct hda_channel_mode alc861_uniwill_m31_modes[2] = {
12523 { 2, alc861_uniwill_m31_ch2_init },
12524 { 4, alc861_uniwill_m31_ch4_init },
12525 };
12526
12527 /* Set mic1 and line-in as input and unmute the mixer */
12528 static struct hda_verb alc861_asus_ch2_init[] = {
12529 /* set pin widget 1Ah (line in) for input */
12530 { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
12531 /* set pin widget 18h (mic1/2) for input, for mic also enable
12532 * the vref
12533 */
12534 { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
12535
12536 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c },
12537 #if 0
12538 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8)) }, /*mic*/
12539 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8)) }, /*line-in*/
12540 #endif
12541 { } /* end */
12542 };
12543 /* Set mic1 nad line-in as output and mute mixer */
12544 static struct hda_verb alc861_asus_ch6_init[] = {
12545 /* set pin widget 1Ah (line in) for output (Back Surround)*/
12546 { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
12547 /* { 0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, */
12548 /* set pin widget 18h (mic1) for output (CLFE)*/
12549 { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
12550 /* { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, */
12551 { 0x0c, AC_VERB_SET_CONNECT_SEL, 0x00 },
12552 { 0x0d, AC_VERB_SET_CONNECT_SEL, 0x00 },
12553
12554 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080 },
12555 #if 0
12556 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8)) }, /*mic*/
12557 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8)) }, /*line in*/
12558 #endif
12559 { } /* end */
12560 };
12561
12562 static struct hda_channel_mode alc861_asus_modes[2] = {
12563 { 2, alc861_asus_ch2_init },
12564 { 6, alc861_asus_ch6_init },
12565 };
12566
12567 /* patch-ALC861 */
12568
12569 static struct snd_kcontrol_new alc861_base_mixer[] = {
12570 /* output mixer control */
12571 HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
12572 HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
12573 HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
12574 HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
12575 HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT),
12576
12577 /*Input mixer control */
12578 /* HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
12579 HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT), */
12580 HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
12581 HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
12582 HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
12583 HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
12584 HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
12585 HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
12586 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
12587 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_INPUT),
12588
12589 /* Capture mixer control */
12590 HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
12591 HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
12592 {
12593 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
12594 .name = "Capture Source",
12595 .count = 1,
12596 .info = alc_mux_enum_info,
12597 .get = alc_mux_enum_get,
12598 .put = alc_mux_enum_put,
12599 },
12600 { } /* end */
12601 };
12602
12603 static struct snd_kcontrol_new alc861_3ST_mixer[] = {
12604 /* output mixer control */
12605 HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
12606 HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
12607 HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
12608 HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
12609 /*HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT), */
12610
12611 /* Input mixer control */
12612 /* HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
12613 HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT), */
12614 HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
12615 HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
12616 HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
12617 HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
12618 HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
12619 HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
12620 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
12621 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_INPUT),
12622
12623 /* Capture mixer control */
12624 HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
12625 HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
12626 {
12627 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
12628 .name = "Capture Source",
12629 .count = 1,
12630 .info = alc_mux_enum_info,
12631 .get = alc_mux_enum_get,
12632 .put = alc_mux_enum_put,
12633 },
12634 {
12635 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
12636 .name = "Channel Mode",
12637 .info = alc_ch_mode_info,
12638 .get = alc_ch_mode_get,
12639 .put = alc_ch_mode_put,
12640 .private_value = ARRAY_SIZE(alc861_threestack_modes),
12641 },
12642 { } /* end */
12643 };
12644
12645 static struct snd_kcontrol_new alc861_toshiba_mixer[] = {
12646 /* output mixer control */
12647 HDA_CODEC_MUTE("Master Playback Switch", 0x03, 0x0, HDA_OUTPUT),
12648 HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
12649 HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
12650
12651 /*Capture mixer control */
12652 HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
12653 HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
12654 {
12655 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
12656 .name = "Capture Source",
12657 .count = 1,
12658 .info = alc_mux_enum_info,
12659 .get = alc_mux_enum_get,
12660 .put = alc_mux_enum_put,
12661 },
12662
12663 { } /* end */
12664 };
12665
12666 static struct snd_kcontrol_new alc861_uniwill_m31_mixer[] = {
12667 /* output mixer control */
12668 HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
12669 HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
12670 HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
12671 HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
12672 /*HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT), */
12673
12674 /* Input mixer control */
12675 /* HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
12676 HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT), */
12677 HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
12678 HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
12679 HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
12680 HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
12681 HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
12682 HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
12683 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
12684 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_INPUT),
12685
12686 /* Capture mixer control */
12687 HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
12688 HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
12689 {
12690 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
12691 .name = "Capture Source",
12692 .count = 1,
12693 .info = alc_mux_enum_info,
12694 .get = alc_mux_enum_get,
12695 .put = alc_mux_enum_put,
12696 },
12697 {
12698 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
12699 .name = "Channel Mode",
12700 .info = alc_ch_mode_info,
12701 .get = alc_ch_mode_get,
12702 .put = alc_ch_mode_put,
12703 .private_value = ARRAY_SIZE(alc861_uniwill_m31_modes),
12704 },
12705 { } /* end */
12706 };
12707
12708 static struct snd_kcontrol_new alc861_asus_mixer[] = {
12709 /* output mixer control */
12710 HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
12711 HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
12712 HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
12713 HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
12714 HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT),
12715
12716 /* Input mixer control */
12717 HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
12718 HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT),
12719 HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
12720 HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
12721 HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
12722 HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
12723 HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
12724 HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
12725 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
12726 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_OUTPUT),
12727
12728 /* Capture mixer control */
12729 HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
12730 HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
12731 {
12732 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
12733 .name = "Capture Source",
12734 .count = 1,
12735 .info = alc_mux_enum_info,
12736 .get = alc_mux_enum_get,
12737 .put = alc_mux_enum_put,
12738 },
12739 {
12740 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
12741 .name = "Channel Mode",
12742 .info = alc_ch_mode_info,
12743 .get = alc_ch_mode_get,
12744 .put = alc_ch_mode_put,
12745 .private_value = ARRAY_SIZE(alc861_asus_modes),
12746 },
12747 { }
12748 };
12749
12750 /* additional mixer */
12751 static struct snd_kcontrol_new alc861_asus_laptop_mixer[] = {
12752 HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
12753 HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
12754 HDA_CODEC_VOLUME("PC Beep Playback Volume", 0x23, 0x0, HDA_OUTPUT),
12755 HDA_CODEC_MUTE("PC Beep Playback Switch", 0x23, 0x0, HDA_OUTPUT),
12756 { }
12757 };
12758
12759 /*
12760 * generic initialization of ADC, input mixers and output mixers
12761 */
12762 static struct hda_verb alc861_base_init_verbs[] = {
12763 /*
12764 * Unmute ADC0 and set the default input to mic-in
12765 */
12766 /* port-A for surround (rear panel) */
12767 { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
12768 { 0x0e, AC_VERB_SET_CONNECT_SEL, 0x00 },
12769 /* port-B for mic-in (rear panel) with vref */
12770 { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
12771 /* port-C for line-in (rear panel) */
12772 { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
12773 /* port-D for Front */
12774 { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
12775 { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
12776 /* port-E for HP out (front panel) */
12777 { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 },
12778 /* route front PCM to HP */
12779 { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
12780 /* port-F for mic-in (front panel) with vref */
12781 { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
12782 /* port-G for CLFE (rear panel) */
12783 { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
12784 { 0x1f, AC_VERB_SET_CONNECT_SEL, 0x00 },
12785 /* port-H for side (rear panel) */
12786 { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
12787 { 0x20, AC_VERB_SET_CONNECT_SEL, 0x00 },
12788 /* CD-in */
12789 { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
12790 /* route front mic to ADC1*/
12791 {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
12792 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12793
12794 /* Unmute DAC0~3 & spdif out*/
12795 {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12796 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12797 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12798 {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12799 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12800
12801 /* Unmute Mixer 14 (mic) 1c (Line in)*/
12802 {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12803 {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12804 {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12805 {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12806
12807 /* Unmute Stereo Mixer 15 */
12808 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12809 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12810 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
12811 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */
12812
12813 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12814 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12815 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12816 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12817 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12818 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12819 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12820 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12821 /* hp used DAC 3 (Front) */
12822 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
12823 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
12824
12825 { }
12826 };
12827
12828 static struct hda_verb alc861_threestack_init_verbs[] = {
12829 /*
12830 * Unmute ADC0 and set the default input to mic-in
12831 */
12832 /* port-A for surround (rear panel) */
12833 { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
12834 /* port-B for mic-in (rear panel) with vref */
12835 { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
12836 /* port-C for line-in (rear panel) */
12837 { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
12838 /* port-D for Front */
12839 { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
12840 { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
12841 /* port-E for HP out (front panel) */
12842 { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 },
12843 /* route front PCM to HP */
12844 { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
12845 /* port-F for mic-in (front panel) with vref */
12846 { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
12847 /* port-G for CLFE (rear panel) */
12848 { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
12849 /* port-H for side (rear panel) */
12850 { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
12851 /* CD-in */
12852 { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
12853 /* route front mic to ADC1*/
12854 {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
12855 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12856 /* Unmute DAC0~3 & spdif out*/
12857 {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12858 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12859 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12860 {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12861 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12862
12863 /* Unmute Mixer 14 (mic) 1c (Line in)*/
12864 {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12865 {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12866 {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12867 {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12868
12869 /* Unmute Stereo Mixer 15 */
12870 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12871 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12872 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
12873 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */
12874
12875 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12876 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12877 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12878 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12879 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12880 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12881 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12882 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12883 /* hp used DAC 3 (Front) */
12884 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
12885 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
12886 { }
12887 };
12888
12889 static struct hda_verb alc861_uniwill_m31_init_verbs[] = {
12890 /*
12891 * Unmute ADC0 and set the default input to mic-in
12892 */
12893 /* port-A for surround (rear panel) */
12894 { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
12895 /* port-B for mic-in (rear panel) with vref */
12896 { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
12897 /* port-C for line-in (rear panel) */
12898 { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
12899 /* port-D for Front */
12900 { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
12901 { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
12902 /* port-E for HP out (front panel) */
12903 /* this has to be set to VREF80 */
12904 { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
12905 /* route front PCM to HP */
12906 { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
12907 /* port-F for mic-in (front panel) with vref */
12908 { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
12909 /* port-G for CLFE (rear panel) */
12910 { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
12911 /* port-H for side (rear panel) */
12912 { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
12913 /* CD-in */
12914 { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
12915 /* route front mic to ADC1*/
12916 {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
12917 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12918 /* Unmute DAC0~3 & spdif out*/
12919 {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12920 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12921 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12922 {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12923 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12924
12925 /* Unmute Mixer 14 (mic) 1c (Line in)*/
12926 {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12927 {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12928 {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12929 {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12930
12931 /* Unmute Stereo Mixer 15 */
12932 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12933 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12934 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
12935 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */
12936
12937 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12938 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12939 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12940 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12941 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12942 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12943 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12944 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12945 /* hp used DAC 3 (Front) */
12946 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
12947 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
12948 { }
12949 };
12950
12951 static struct hda_verb alc861_asus_init_verbs[] = {
12952 /*
12953 * Unmute ADC0 and set the default input to mic-in
12954 */
12955 /* port-A for surround (rear panel)
12956 * according to codec#0 this is the HP jack
12957 */
12958 { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 }, /* was 0x00 */
12959 /* route front PCM to HP */
12960 { 0x0e, AC_VERB_SET_CONNECT_SEL, 0x01 },
12961 /* port-B for mic-in (rear panel) with vref */
12962 { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
12963 /* port-C for line-in (rear panel) */
12964 { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
12965 /* port-D for Front */
12966 { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
12967 { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
12968 /* port-E for HP out (front panel) */
12969 /* this has to be set to VREF80 */
12970 { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
12971 /* route front PCM to HP */
12972 { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
12973 /* port-F for mic-in (front panel) with vref */
12974 { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
12975 /* port-G for CLFE (rear panel) */
12976 { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
12977 /* port-H for side (rear panel) */
12978 { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
12979 /* CD-in */
12980 { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
12981 /* route front mic to ADC1*/
12982 {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
12983 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12984 /* Unmute DAC0~3 & spdif out*/
12985 {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12986 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12987 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12988 {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12989 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12990 /* Unmute Mixer 14 (mic) 1c (Line in)*/
12991 {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12992 {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12993 {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12994 {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12995
12996 /* Unmute Stereo Mixer 15 */
12997 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12998 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12999 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
13000 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */
13001
13002 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13003 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13004 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13005 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13006 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13007 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13008 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13009 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13010 /* hp used DAC 3 (Front) */
13011 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
13012 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
13013 { }
13014 };
13015
13016 /* additional init verbs for ASUS laptops */
13017 static struct hda_verb alc861_asus_laptop_init_verbs[] = {
13018 { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x45 }, /* HP-out */
13019 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2) }, /* mute line-in */
13020 { }
13021 };
13022
13023 /*
13024 * generic initialization of ADC, input mixers and output mixers
13025 */
13026 static struct hda_verb alc861_auto_init_verbs[] = {
13027 /*
13028 * Unmute ADC0 and set the default input to mic-in
13029 */
13030 /* {0x08, AC_VERB_SET_CONNECT_SEL, 0x00}, */
13031 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13032
13033 /* Unmute DAC0~3 & spdif out*/
13034 {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13035 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13036 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13037 {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13038 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13039
13040 /* Unmute Mixer 14 (mic) 1c (Line in)*/
13041 {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13042 {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13043 {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13044 {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13045
13046 /* Unmute Stereo Mixer 15 */
13047 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13048 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13049 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
13050 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c},
13051
13052 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13053 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13054 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13055 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13056 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13057 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13058 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13059 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13060
13061 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
13062 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
13063 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
13064 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
13065 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
13066 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
13067 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
13068 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
13069
13070 {0x08, AC_VERB_SET_CONNECT_SEL, 0x00}, /* set Mic 1 */
13071
13072 { }
13073 };
13074
13075 static struct hda_verb alc861_toshiba_init_verbs[] = {
13076 {0x0f, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
13077
13078 { }
13079 };
13080
13081 /* toggle speaker-output according to the hp-jack state */
13082 static void alc861_toshiba_automute(struct hda_codec *codec)
13083 {
13084 unsigned int present;
13085
13086 present = snd_hda_codec_read(codec, 0x0f, 0,
13087 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
13088 snd_hda_codec_amp_stereo(codec, 0x16, HDA_INPUT, 0,
13089 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
13090 snd_hda_codec_amp_stereo(codec, 0x1a, HDA_INPUT, 3,
13091 HDA_AMP_MUTE, present ? 0 : HDA_AMP_MUTE);
13092 }
13093
13094 static void alc861_toshiba_unsol_event(struct hda_codec *codec,
13095 unsigned int res)
13096 {
13097 if ((res >> 26) == ALC880_HP_EVENT)
13098 alc861_toshiba_automute(codec);
13099 }
13100
13101 /* pcm configuration: identiacal with ALC880 */
13102 #define alc861_pcm_analog_playback alc880_pcm_analog_playback
13103 #define alc861_pcm_analog_capture alc880_pcm_analog_capture
13104 #define alc861_pcm_digital_playback alc880_pcm_digital_playback
13105 #define alc861_pcm_digital_capture alc880_pcm_digital_capture
13106
13107
13108 #define ALC861_DIGOUT_NID 0x07
13109
13110 static struct hda_channel_mode alc861_8ch_modes[1] = {
13111 { 8, NULL }
13112 };
13113
13114 static hda_nid_t alc861_dac_nids[4] = {
13115 /* front, surround, clfe, side */
13116 0x03, 0x06, 0x05, 0x04
13117 };
13118
13119 static hda_nid_t alc660_dac_nids[3] = {
13120 /* front, clfe, surround */
13121 0x03, 0x05, 0x06
13122 };
13123
13124 static hda_nid_t alc861_adc_nids[1] = {
13125 /* ADC0-2 */
13126 0x08,
13127 };
13128
13129 static struct hda_input_mux alc861_capture_source = {
13130 .num_items = 5,
13131 .items = {
13132 { "Mic", 0x0 },
13133 { "Front Mic", 0x3 },
13134 { "Line", 0x1 },
13135 { "CD", 0x4 },
13136 { "Mixer", 0x5 },
13137 },
13138 };
13139
13140 /* fill in the dac_nids table from the parsed pin configuration */
13141 static int alc861_auto_fill_dac_nids(struct alc_spec *spec,
13142 const struct auto_pin_cfg *cfg)
13143 {
13144 int i;
13145 hda_nid_t nid;
13146
13147 spec->multiout.dac_nids = spec->private_dac_nids;
13148 for (i = 0; i < cfg->line_outs; i++) {
13149 nid = cfg->line_out_pins[i];
13150 if (nid) {
13151 if (i >= ARRAY_SIZE(alc861_dac_nids))
13152 continue;
13153 spec->multiout.dac_nids[i] = alc861_dac_nids[i];
13154 }
13155 }
13156 spec->multiout.num_dacs = cfg->line_outs;
13157 return 0;
13158 }
13159
13160 /* add playback controls from the parsed DAC table */
13161 static int alc861_auto_create_multi_out_ctls(struct alc_spec *spec,
13162 const struct auto_pin_cfg *cfg)
13163 {
13164 char name[32];
13165 static const char *chname[4] = {
13166 "Front", "Surround", NULL /*CLFE*/, "Side"
13167 };
13168 hda_nid_t nid;
13169 int i, idx, err;
13170
13171 for (i = 0; i < cfg->line_outs; i++) {
13172 nid = spec->multiout.dac_nids[i];
13173 if (!nid)
13174 continue;
13175 if (nid == 0x05) {
13176 /* Center/LFE */
13177 err = add_control(spec, ALC_CTL_BIND_MUTE,
13178 "Center Playback Switch",
13179 HDA_COMPOSE_AMP_VAL(nid, 1, 0,
13180 HDA_OUTPUT));
13181 if (err < 0)
13182 return err;
13183 err = add_control(spec, ALC_CTL_BIND_MUTE,
13184 "LFE Playback Switch",
13185 HDA_COMPOSE_AMP_VAL(nid, 2, 0,
13186 HDA_OUTPUT));
13187 if (err < 0)
13188 return err;
13189 } else {
13190 for (idx = 0; idx < ARRAY_SIZE(alc861_dac_nids) - 1;
13191 idx++)
13192 if (nid == alc861_dac_nids[idx])
13193 break;
13194 sprintf(name, "%s Playback Switch", chname[idx]);
13195 err = add_control(spec, ALC_CTL_BIND_MUTE, name,
13196 HDA_COMPOSE_AMP_VAL(nid, 3, 0,
13197 HDA_OUTPUT));
13198 if (err < 0)
13199 return err;
13200 }
13201 }
13202 return 0;
13203 }
13204
13205 static int alc861_auto_create_hp_ctls(struct alc_spec *spec, hda_nid_t pin)
13206 {
13207 int err;
13208 hda_nid_t nid;
13209
13210 if (!pin)
13211 return 0;
13212
13213 if ((pin >= 0x0b && pin <= 0x10) || pin == 0x1f || pin == 0x20) {
13214 nid = 0x03;
13215 err = add_control(spec, ALC_CTL_WIDGET_MUTE,
13216 "Headphone Playback Switch",
13217 HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT));
13218 if (err < 0)
13219 return err;
13220 spec->multiout.hp_nid = nid;
13221 }
13222 return 0;
13223 }
13224
13225 /* create playback/capture controls for input pins */
13226 static int alc861_auto_create_analog_input_ctls(struct alc_spec *spec,
13227 const struct auto_pin_cfg *cfg)
13228 {
13229 struct hda_input_mux *imux = &spec->private_imux;
13230 int i, err, idx, idx1;
13231
13232 for (i = 0; i < AUTO_PIN_LAST; i++) {
13233 switch (cfg->input_pins[i]) {
13234 case 0x0c:
13235 idx1 = 1;
13236 idx = 2; /* Line In */
13237 break;
13238 case 0x0f:
13239 idx1 = 2;
13240 idx = 2; /* Line In */
13241 break;
13242 case 0x0d:
13243 idx1 = 0;
13244 idx = 1; /* Mic In */
13245 break;
13246 case 0x10:
13247 idx1 = 3;
13248 idx = 1; /* Mic In */
13249 break;
13250 case 0x11:
13251 idx1 = 4;
13252 idx = 0; /* CD */
13253 break;
13254 default:
13255 continue;
13256 }
13257
13258 err = new_analog_input(spec, cfg->input_pins[i],
13259 auto_pin_cfg_labels[i], idx, 0x15);
13260 if (err < 0)
13261 return err;
13262
13263 imux->items[imux->num_items].label = auto_pin_cfg_labels[i];
13264 imux->items[imux->num_items].index = idx1;
13265 imux->num_items++;
13266 }
13267 return 0;
13268 }
13269
13270 static struct snd_kcontrol_new alc861_capture_mixer[] = {
13271 HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
13272 HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
13273
13274 {
13275 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
13276 /* The multiple "Capture Source" controls confuse alsamixer
13277 * So call somewhat different..
13278 */
13279 /* .name = "Capture Source", */
13280 .name = "Input Source",
13281 .count = 1,
13282 .info = alc_mux_enum_info,
13283 .get = alc_mux_enum_get,
13284 .put = alc_mux_enum_put,
13285 },
13286 { } /* end */
13287 };
13288
13289 static void alc861_auto_set_output_and_unmute(struct hda_codec *codec,
13290 hda_nid_t nid,
13291 int pin_type, int dac_idx)
13292 {
13293 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
13294 pin_type);
13295 snd_hda_codec_write(codec, dac_idx, 0, AC_VERB_SET_AMP_GAIN_MUTE,
13296 AMP_OUT_UNMUTE);
13297 }
13298
13299 static void alc861_auto_init_multi_out(struct hda_codec *codec)
13300 {
13301 struct alc_spec *spec = codec->spec;
13302 int i;
13303
13304 alc_subsystem_id(codec, 0x0e, 0x0f, 0x0b);
13305 for (i = 0; i < spec->autocfg.line_outs; i++) {
13306 hda_nid_t nid = spec->autocfg.line_out_pins[i];
13307 int pin_type = get_pin_type(spec->autocfg.line_out_type);
13308 if (nid)
13309 alc861_auto_set_output_and_unmute(codec, nid, pin_type,
13310 spec->multiout.dac_nids[i]);
13311 }
13312 }
13313
13314 static void alc861_auto_init_hp_out(struct hda_codec *codec)
13315 {
13316 struct alc_spec *spec = codec->spec;
13317 hda_nid_t pin;
13318
13319 pin = spec->autocfg.hp_pins[0];
13320 if (pin) /* connect to front */
13321 alc861_auto_set_output_and_unmute(codec, pin, PIN_HP,
13322 spec->multiout.dac_nids[0]);
13323 pin = spec->autocfg.speaker_pins[0];
13324 if (pin)
13325 alc861_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
13326 }
13327
13328 static void alc861_auto_init_analog_input(struct hda_codec *codec)
13329 {
13330 struct alc_spec *spec = codec->spec;
13331 int i;
13332
13333 for (i = 0; i < AUTO_PIN_LAST; i++) {
13334 hda_nid_t nid = spec->autocfg.input_pins[i];
13335 if (nid >= 0x0c && nid <= 0x11) {
13336 snd_hda_codec_write(codec, nid, 0,
13337 AC_VERB_SET_PIN_WIDGET_CONTROL,
13338 i <= AUTO_PIN_FRONT_MIC ?
13339 PIN_VREF80 : PIN_IN);
13340 }
13341 }
13342 }
13343
13344 /* parse the BIOS configuration and set up the alc_spec */
13345 /* return 1 if successful, 0 if the proper config is not found,
13346 * or a negative error code
13347 */
13348 static int alc861_parse_auto_config(struct hda_codec *codec)
13349 {
13350 struct alc_spec *spec = codec->spec;
13351 int err;
13352 static hda_nid_t alc861_ignore[] = { 0x1d, 0 };
13353
13354 err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
13355 alc861_ignore);
13356 if (err < 0)
13357 return err;
13358 if (!spec->autocfg.line_outs)
13359 return 0; /* can't find valid BIOS pin config */
13360
13361 err = alc861_auto_fill_dac_nids(spec, &spec->autocfg);
13362 if (err < 0)
13363 return err;
13364 err = alc861_auto_create_multi_out_ctls(spec, &spec->autocfg);
13365 if (err < 0)
13366 return err;
13367 err = alc861_auto_create_hp_ctls(spec, spec->autocfg.hp_pins[0]);
13368 if (err < 0)
13369 return err;
13370 err = alc861_auto_create_analog_input_ctls(spec, &spec->autocfg);
13371 if (err < 0)
13372 return err;
13373
13374 spec->multiout.max_channels = spec->multiout.num_dacs * 2;
13375
13376 if (spec->autocfg.dig_out_pin)
13377 spec->multiout.dig_out_nid = ALC861_DIGOUT_NID;
13378
13379 if (spec->kctl_alloc)
13380 spec->mixers[spec->num_mixers++] = spec->kctl_alloc;
13381
13382 spec->init_verbs[spec->num_init_verbs++] = alc861_auto_init_verbs;
13383
13384 spec->num_mux_defs = 1;
13385 spec->input_mux = &spec->private_imux;
13386
13387 spec->adc_nids = alc861_adc_nids;
13388 spec->num_adc_nids = ARRAY_SIZE(alc861_adc_nids);
13389 spec->mixers[spec->num_mixers] = alc861_capture_mixer;
13390 spec->num_mixers++;
13391
13392 store_pin_configs(codec);
13393 return 1;
13394 }
13395
13396 /* additional initialization for auto-configuration model */
13397 static void alc861_auto_init(struct hda_codec *codec)
13398 {
13399 struct alc_spec *spec = codec->spec;
13400 alc861_auto_init_multi_out(codec);
13401 alc861_auto_init_hp_out(codec);
13402 alc861_auto_init_analog_input(codec);
13403 if (spec->unsol_event)
13404 alc_inithook(codec);
13405 }
13406
13407 #ifdef CONFIG_SND_HDA_POWER_SAVE
13408 static struct hda_amp_list alc861_loopbacks[] = {
13409 { 0x15, HDA_INPUT, 0 },
13410 { 0x15, HDA_INPUT, 1 },
13411 { 0x15, HDA_INPUT, 2 },
13412 { 0x15, HDA_INPUT, 3 },
13413 { } /* end */
13414 };
13415 #endif
13416
13417
13418 /*
13419 * configuration and preset
13420 */
13421 static const char *alc861_models[ALC861_MODEL_LAST] = {
13422 [ALC861_3ST] = "3stack",
13423 [ALC660_3ST] = "3stack-660",
13424 [ALC861_3ST_DIG] = "3stack-dig",
13425 [ALC861_6ST_DIG] = "6stack-dig",
13426 [ALC861_UNIWILL_M31] = "uniwill-m31",
13427 [ALC861_TOSHIBA] = "toshiba",
13428 [ALC861_ASUS] = "asus",
13429 [ALC861_ASUS_LAPTOP] = "asus-laptop",
13430 [ALC861_AUTO] = "auto",
13431 };
13432
13433 static struct snd_pci_quirk alc861_cfg_tbl[] = {
13434 SND_PCI_QUIRK(0x1043, 0x1205, "ASUS W7J", ALC861_3ST),
13435 SND_PCI_QUIRK(0x1043, 0x1335, "ASUS F2/3", ALC861_ASUS_LAPTOP),
13436 SND_PCI_QUIRK(0x1043, 0x1338, "ASUS F2/3", ALC861_ASUS_LAPTOP),
13437 SND_PCI_QUIRK(0x1043, 0x1393, "ASUS", ALC861_ASUS),
13438 SND_PCI_QUIRK(0x1043, 0x13d7, "ASUS A9rp", ALC861_ASUS_LAPTOP),
13439 SND_PCI_QUIRK(0x1043, 0x81cb, "ASUS P1-AH2", ALC861_3ST_DIG),
13440 SND_PCI_QUIRK(0x1179, 0xff00, "Toshiba", ALC861_TOSHIBA),
13441 /* FIXME: the entry below breaks Toshiba A100 (model=auto works!)
13442 * Any other models that need this preset?
13443 */
13444 /* SND_PCI_QUIRK(0x1179, 0xff10, "Toshiba", ALC861_TOSHIBA), */
13445 SND_PCI_QUIRK(0x1462, 0x7254, "HP dx2200 (MSI MS-7254)", ALC861_3ST),
13446 SND_PCI_QUIRK(0x1462, 0x7297, "HP dx2250 (MSI MS-7297)", ALC861_3ST),
13447 SND_PCI_QUIRK(0x1584, 0x2b01, "Uniwill X40AIx", ALC861_UNIWILL_M31),
13448 SND_PCI_QUIRK(0x1584, 0x9072, "Uniwill m31", ALC861_UNIWILL_M31),
13449 SND_PCI_QUIRK(0x1584, 0x9075, "Airis Praxis N1212", ALC861_ASUS_LAPTOP),
13450 /* FIXME: the below seems conflict */
13451 /* SND_PCI_QUIRK(0x1584, 0x9075, "Uniwill", ALC861_UNIWILL_M31), */
13452 SND_PCI_QUIRK(0x1849, 0x0660, "Asrock 939SLI32", ALC660_3ST),
13453 SND_PCI_QUIRK(0x8086, 0xd600, "Intel", ALC861_3ST),
13454 {}
13455 };
13456
13457 static struct alc_config_preset alc861_presets[] = {
13458 [ALC861_3ST] = {
13459 .mixers = { alc861_3ST_mixer },
13460 .init_verbs = { alc861_threestack_init_verbs },
13461 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
13462 .dac_nids = alc861_dac_nids,
13463 .num_channel_mode = ARRAY_SIZE(alc861_threestack_modes),
13464 .channel_mode = alc861_threestack_modes,
13465 .need_dac_fix = 1,
13466 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
13467 .adc_nids = alc861_adc_nids,
13468 .input_mux = &alc861_capture_source,
13469 },
13470 [ALC861_3ST_DIG] = {
13471 .mixers = { alc861_base_mixer },
13472 .init_verbs = { alc861_threestack_init_verbs },
13473 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
13474 .dac_nids = alc861_dac_nids,
13475 .dig_out_nid = ALC861_DIGOUT_NID,
13476 .num_channel_mode = ARRAY_SIZE(alc861_threestack_modes),
13477 .channel_mode = alc861_threestack_modes,
13478 .need_dac_fix = 1,
13479 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
13480 .adc_nids = alc861_adc_nids,
13481 .input_mux = &alc861_capture_source,
13482 },
13483 [ALC861_6ST_DIG] = {
13484 .mixers = { alc861_base_mixer },
13485 .init_verbs = { alc861_base_init_verbs },
13486 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
13487 .dac_nids = alc861_dac_nids,
13488 .dig_out_nid = ALC861_DIGOUT_NID,
13489 .num_channel_mode = ARRAY_SIZE(alc861_8ch_modes),
13490 .channel_mode = alc861_8ch_modes,
13491 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
13492 .adc_nids = alc861_adc_nids,
13493 .input_mux = &alc861_capture_source,
13494 },
13495 [ALC660_3ST] = {
13496 .mixers = { alc861_3ST_mixer },
13497 .init_verbs = { alc861_threestack_init_verbs },
13498 .num_dacs = ARRAY_SIZE(alc660_dac_nids),
13499 .dac_nids = alc660_dac_nids,
13500 .num_channel_mode = ARRAY_SIZE(alc861_threestack_modes),
13501 .channel_mode = alc861_threestack_modes,
13502 .need_dac_fix = 1,
13503 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
13504 .adc_nids = alc861_adc_nids,
13505 .input_mux = &alc861_capture_source,
13506 },
13507 [ALC861_UNIWILL_M31] = {
13508 .mixers = { alc861_uniwill_m31_mixer },
13509 .init_verbs = { alc861_uniwill_m31_init_verbs },
13510 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
13511 .dac_nids = alc861_dac_nids,
13512 .dig_out_nid = ALC861_DIGOUT_NID,
13513 .num_channel_mode = ARRAY_SIZE(alc861_uniwill_m31_modes),
13514 .channel_mode = alc861_uniwill_m31_modes,
13515 .need_dac_fix = 1,
13516 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
13517 .adc_nids = alc861_adc_nids,
13518 .input_mux = &alc861_capture_source,
13519 },
13520 [ALC861_TOSHIBA] = {
13521 .mixers = { alc861_toshiba_mixer },
13522 .init_verbs = { alc861_base_init_verbs,
13523 alc861_toshiba_init_verbs },
13524 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
13525 .dac_nids = alc861_dac_nids,
13526 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
13527 .channel_mode = alc883_3ST_2ch_modes,
13528 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
13529 .adc_nids = alc861_adc_nids,
13530 .input_mux = &alc861_capture_source,
13531 .unsol_event = alc861_toshiba_unsol_event,
13532 .init_hook = alc861_toshiba_automute,
13533 },
13534 [ALC861_ASUS] = {
13535 .mixers = { alc861_asus_mixer },
13536 .init_verbs = { alc861_asus_init_verbs },
13537 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
13538 .dac_nids = alc861_dac_nids,
13539 .dig_out_nid = ALC861_DIGOUT_NID,
13540 .num_channel_mode = ARRAY_SIZE(alc861_asus_modes),
13541 .channel_mode = alc861_asus_modes,
13542 .need_dac_fix = 1,
13543 .hp_nid = 0x06,
13544 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
13545 .adc_nids = alc861_adc_nids,
13546 .input_mux = &alc861_capture_source,
13547 },
13548 [ALC861_ASUS_LAPTOP] = {
13549 .mixers = { alc861_toshiba_mixer, alc861_asus_laptop_mixer },
13550 .init_verbs = { alc861_asus_init_verbs,
13551 alc861_asus_laptop_init_verbs },
13552 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
13553 .dac_nids = alc861_dac_nids,
13554 .dig_out_nid = ALC861_DIGOUT_NID,
13555 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
13556 .channel_mode = alc883_3ST_2ch_modes,
13557 .need_dac_fix = 1,
13558 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
13559 .adc_nids = alc861_adc_nids,
13560 .input_mux = &alc861_capture_source,
13561 },
13562 };
13563
13564
13565 static int patch_alc861(struct hda_codec *codec)
13566 {
13567 struct alc_spec *spec;
13568 int board_config;
13569 int err;
13570
13571 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
13572 if (spec == NULL)
13573 return -ENOMEM;
13574
13575 codec->spec = spec;
13576
13577 board_config = snd_hda_check_board_config(codec, ALC861_MODEL_LAST,
13578 alc861_models,
13579 alc861_cfg_tbl);
13580
13581 if (board_config < 0) {
13582 printk(KERN_INFO "hda_codec: Unknown model for ALC861, "
13583 "trying auto-probe from BIOS...\n");
13584 board_config = ALC861_AUTO;
13585 }
13586
13587 if (board_config == ALC861_AUTO) {
13588 /* automatic parse from the BIOS config */
13589 err = alc861_parse_auto_config(codec);
13590 if (err < 0) {
13591 alc_free(codec);
13592 return err;
13593 } else if (!err) {
13594 printk(KERN_INFO
13595 "hda_codec: Cannot set up configuration "
13596 "from BIOS. Using base mode...\n");
13597 board_config = ALC861_3ST_DIG;
13598 }
13599 }
13600
13601 if (board_config != ALC861_AUTO)
13602 setup_preset(spec, &alc861_presets[board_config]);
13603
13604 spec->stream_name_analog = "ALC861 Analog";
13605 spec->stream_analog_playback = &alc861_pcm_analog_playback;
13606 spec->stream_analog_capture = &alc861_pcm_analog_capture;
13607
13608 spec->stream_name_digital = "ALC861 Digital";
13609 spec->stream_digital_playback = &alc861_pcm_digital_playback;
13610 spec->stream_digital_capture = &alc861_pcm_digital_capture;
13611
13612 spec->vmaster_nid = 0x03;
13613
13614 codec->patch_ops = alc_patch_ops;
13615 if (board_config == ALC861_AUTO)
13616 spec->init_hook = alc861_auto_init;
13617 #ifdef CONFIG_SND_HDA_POWER_SAVE
13618 if (!spec->loopback.amplist)
13619 spec->loopback.amplist = alc861_loopbacks;
13620 #endif
13621
13622 return 0;
13623 }
13624
13625 /*
13626 * ALC861-VD support
13627 *
13628 * Based on ALC882
13629 *
13630 * In addition, an independent DAC
13631 */
13632 #define ALC861VD_DIGOUT_NID 0x06
13633
13634 static hda_nid_t alc861vd_dac_nids[4] = {
13635 /* front, surr, clfe, side surr */
13636 0x02, 0x03, 0x04, 0x05
13637 };
13638
13639 /* dac_nids for ALC660vd are in a different order - according to
13640 * Realtek's driver.
13641 * This should probably tesult in a different mixer for 6stack models
13642 * of ALC660vd codecs, but for now there is only 3stack mixer
13643 * - and it is the same as in 861vd.
13644 * adc_nids in ALC660vd are (is) the same as in 861vd
13645 */
13646 static hda_nid_t alc660vd_dac_nids[3] = {
13647 /* front, rear, clfe, rear_surr */
13648 0x02, 0x04, 0x03
13649 };
13650
13651 static hda_nid_t alc861vd_adc_nids[1] = {
13652 /* ADC0 */
13653 0x09,
13654 };
13655
13656 static hda_nid_t alc861vd_capsrc_nids[1] = { 0x22 };
13657
13658 /* input MUX */
13659 /* FIXME: should be a matrix-type input source selection */
13660 static struct hda_input_mux alc861vd_capture_source = {
13661 .num_items = 4,
13662 .items = {
13663 { "Mic", 0x0 },
13664 { "Front Mic", 0x1 },
13665 { "Line", 0x2 },
13666 { "CD", 0x4 },
13667 },
13668 };
13669
13670 static struct hda_input_mux alc861vd_dallas_capture_source = {
13671 .num_items = 2,
13672 .items = {
13673 { "Ext Mic", 0x0 },
13674 { "Int Mic", 0x1 },
13675 },
13676 };
13677
13678 static struct hda_input_mux alc861vd_hp_capture_source = {
13679 .num_items = 2,
13680 .items = {
13681 { "Front Mic", 0x0 },
13682 { "ATAPI Mic", 0x1 },
13683 },
13684 };
13685
13686 #define alc861vd_mux_enum_info alc_mux_enum_info
13687 #define alc861vd_mux_enum_get alc_mux_enum_get
13688 /* ALC861VD has the ALC882-type input selection (but has only one ADC) */
13689 #define alc861vd_mux_enum_put alc882_mux_enum_put
13690
13691 /*
13692 * 2ch mode
13693 */
13694 static struct hda_channel_mode alc861vd_3stack_2ch_modes[1] = {
13695 { 2, NULL }
13696 };
13697
13698 /*
13699 * 6ch mode
13700 */
13701 static struct hda_verb alc861vd_6stack_ch6_init[] = {
13702 { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
13703 { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
13704 { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
13705 { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
13706 { } /* end */
13707 };
13708
13709 /*
13710 * 8ch mode
13711 */
13712 static struct hda_verb alc861vd_6stack_ch8_init[] = {
13713 { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
13714 { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
13715 { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
13716 { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
13717 { } /* end */
13718 };
13719
13720 static struct hda_channel_mode alc861vd_6stack_modes[2] = {
13721 { 6, alc861vd_6stack_ch6_init },
13722 { 8, alc861vd_6stack_ch8_init },
13723 };
13724
13725 static struct snd_kcontrol_new alc861vd_chmode_mixer[] = {
13726 {
13727 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
13728 .name = "Channel Mode",
13729 .info = alc_ch_mode_info,
13730 .get = alc_ch_mode_get,
13731 .put = alc_ch_mode_put,
13732 },
13733 { } /* end */
13734 };
13735
13736 static struct snd_kcontrol_new alc861vd_capture_mixer[] = {
13737 HDA_CODEC_VOLUME("Capture Volume", 0x09, 0x0, HDA_INPUT),
13738 HDA_CODEC_MUTE("Capture Switch", 0x09, 0x0, HDA_INPUT),
13739
13740 {
13741 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
13742 /* The multiple "Capture Source" controls confuse alsamixer
13743 * So call somewhat different..
13744 */
13745 /* .name = "Capture Source", */
13746 .name = "Input Source",
13747 .count = 1,
13748 .info = alc861vd_mux_enum_info,
13749 .get = alc861vd_mux_enum_get,
13750 .put = alc861vd_mux_enum_put,
13751 },
13752 { } /* end */
13753 };
13754
13755 /* Pin assignment: Front=0x14, Rear=0x15, CLFE=0x16, Side=0x17
13756 * Mic=0x18, Front Mic=0x19, Line-In=0x1a, HP=0x1b
13757 */
13758 static struct snd_kcontrol_new alc861vd_6st_mixer[] = {
13759 HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
13760 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
13761
13762 HDA_CODEC_VOLUME("Surround Playback Volume", 0x03, 0x0, HDA_OUTPUT),
13763 HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
13764
13765 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0,
13766 HDA_OUTPUT),
13767 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0,
13768 HDA_OUTPUT),
13769 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
13770 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
13771
13772 HDA_CODEC_VOLUME("Side Playback Volume", 0x05, 0x0, HDA_OUTPUT),
13773 HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
13774
13775 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
13776
13777 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
13778 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
13779 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
13780
13781 HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
13782 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
13783 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
13784
13785 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
13786 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
13787
13788 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
13789 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
13790
13791 HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
13792 HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
13793
13794 { } /* end */
13795 };
13796
13797 static struct snd_kcontrol_new alc861vd_3st_mixer[] = {
13798 HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
13799 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
13800
13801 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
13802
13803 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
13804 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
13805 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
13806
13807 HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
13808 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
13809 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
13810
13811 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
13812 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
13813
13814 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
13815 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
13816
13817 HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
13818 HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
13819
13820 { } /* end */
13821 };
13822
13823 static struct snd_kcontrol_new alc861vd_lenovo_mixer[] = {
13824 HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
13825 /*HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),*/
13826 HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
13827
13828 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
13829
13830 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
13831 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
13832 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
13833
13834 HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
13835 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
13836 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
13837
13838 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
13839 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
13840
13841 { } /* end */
13842 };
13843
13844 /* Pin assignment: Speaker=0x14, HP = 0x15,
13845 * Ext Mic=0x18, Int Mic = 0x19, CD = 0x1c, PC Beep = 0x1d
13846 */
13847 static struct snd_kcontrol_new alc861vd_dallas_mixer[] = {
13848 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
13849 HDA_BIND_MUTE("Speaker Playback Switch", 0x0c, 2, HDA_INPUT),
13850 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
13851 HDA_BIND_MUTE("Headphone Playback Switch", 0x0d, 2, HDA_INPUT),
13852 HDA_CODEC_VOLUME("Ext Mic Boost", 0x18, 0, HDA_INPUT),
13853 HDA_CODEC_VOLUME("Ext Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
13854 HDA_CODEC_MUTE("Ext Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
13855 HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
13856 HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
13857 HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
13858 HDA_CODEC_VOLUME("PC Beep Volume", 0x0b, 0x05, HDA_INPUT),
13859 HDA_CODEC_MUTE("PC Beep Switch", 0x0b, 0x05, HDA_INPUT),
13860 { } /* end */
13861 };
13862
13863 /* Pin assignment: Speaker=0x14, Line-out = 0x15,
13864 * Front Mic=0x18, ATAPI Mic = 0x19,
13865 */
13866 static struct snd_kcontrol_new alc861vd_hp_mixer[] = {
13867 HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
13868 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
13869 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
13870 HDA_BIND_MUTE("Headphone Playback Switch", 0x0d, 2, HDA_INPUT),
13871 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
13872 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
13873 HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
13874 HDA_CODEC_MUTE("ATAPI Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
13875
13876 { } /* end */
13877 };
13878
13879 /*
13880 * generic initialization of ADC, input mixers and output mixers
13881 */
13882 static struct hda_verb alc861vd_volume_init_verbs[] = {
13883 /*
13884 * Unmute ADC0 and set the default input to mic-in
13885 */
13886 {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
13887 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13888
13889 /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of
13890 * the analog-loopback mixer widget
13891 */
13892 /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
13893 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
13894 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
13895 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
13896 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
13897 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
13898
13899 /* Capture mixer: unmute Mic, F-Mic, Line, CD inputs */
13900 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13901 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13902 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
13903 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
13904
13905 /*
13906 * Set up output mixers (0x02 - 0x05)
13907 */
13908 /* set vol=0 to output mixers */
13909 {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
13910 {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
13911 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
13912 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
13913
13914 /* set up input amps for analog loopback */
13915 /* Amp Indices: DAC = 0, mixer = 1 */
13916 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
13917 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
13918 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
13919 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
13920 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
13921 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
13922 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
13923 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
13924
13925 { }
13926 };
13927
13928 /*
13929 * 3-stack pin configuration:
13930 * front = 0x14, mic/clfe = 0x18, HP = 0x19, line/surr = 0x1a, f-mic = 0x1b
13931 */
13932 static struct hda_verb alc861vd_3stack_init_verbs[] = {
13933 /*
13934 * Set pin mode and muting
13935 */
13936 /* set front pin widgets 0x14 for output */
13937 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
13938 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13939 {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
13940
13941 /* Mic (rear) pin: input vref at 80% */
13942 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
13943 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13944 /* Front Mic pin: input vref at 80% */
13945 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
13946 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13947 /* Line In pin: input */
13948 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
13949 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13950 /* Line-2 In: Headphone output (output 0 - 0x0c) */
13951 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
13952 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13953 {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
13954 /* CD pin widget for input */
13955 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
13956
13957 { }
13958 };
13959
13960 /*
13961 * 6-stack pin configuration:
13962 */
13963 static struct hda_verb alc861vd_6stack_init_verbs[] = {
13964 /*
13965 * Set pin mode and muting
13966 */
13967 /* set front pin widgets 0x14 for output */
13968 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
13969 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13970 {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
13971
13972 /* Rear Pin: output 1 (0x0d) */
13973 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
13974 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13975 {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
13976 /* CLFE Pin: output 2 (0x0e) */
13977 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
13978 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13979 {0x16, AC_VERB_SET_CONNECT_SEL, 0x02},
13980 /* Side Pin: output 3 (0x0f) */
13981 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
13982 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13983 {0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
13984
13985 /* Mic (rear) pin: input vref at 80% */
13986 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
13987 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13988 /* Front Mic pin: input vref at 80% */
13989 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
13990 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13991 /* Line In pin: input */
13992 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
13993 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13994 /* Line-2 In: Headphone output (output 0 - 0x0c) */
13995 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
13996 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13997 {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
13998 /* CD pin widget for input */
13999 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14000
14001 { }
14002 };
14003
14004 static struct hda_verb alc861vd_eapd_verbs[] = {
14005 {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
14006 { }
14007 };
14008
14009 static struct hda_verb alc660vd_eapd_verbs[] = {
14010 {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
14011 {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
14012 { }
14013 };
14014
14015 static struct hda_verb alc861vd_lenovo_unsol_verbs[] = {
14016 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14017 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14018 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
14019 {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
14020 {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
14021 {}
14022 };
14023
14024 /* toggle speaker-output according to the hp-jack state */
14025 static void alc861vd_lenovo_hp_automute(struct hda_codec *codec)
14026 {
14027 unsigned int present;
14028 unsigned char bits;
14029
14030 present = snd_hda_codec_read(codec, 0x1b, 0,
14031 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
14032 bits = present ? HDA_AMP_MUTE : 0;
14033 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
14034 HDA_AMP_MUTE, bits);
14035 }
14036
14037 static void alc861vd_lenovo_mic_automute(struct hda_codec *codec)
14038 {
14039 unsigned int present;
14040 unsigned char bits;
14041
14042 present = snd_hda_codec_read(codec, 0x18, 0,
14043 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
14044 bits = present ? HDA_AMP_MUTE : 0;
14045 snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1,
14046 HDA_AMP_MUTE, bits);
14047 }
14048
14049 static void alc861vd_lenovo_automute(struct hda_codec *codec)
14050 {
14051 alc861vd_lenovo_hp_automute(codec);
14052 alc861vd_lenovo_mic_automute(codec);
14053 }
14054
14055 static void alc861vd_lenovo_unsol_event(struct hda_codec *codec,
14056 unsigned int res)
14057 {
14058 switch (res >> 26) {
14059 case ALC880_HP_EVENT:
14060 alc861vd_lenovo_hp_automute(codec);
14061 break;
14062 case ALC880_MIC_EVENT:
14063 alc861vd_lenovo_mic_automute(codec);
14064 break;
14065 }
14066 }
14067
14068 static struct hda_verb alc861vd_dallas_verbs[] = {
14069 {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
14070 {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
14071 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
14072 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
14073
14074 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14075 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14076 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14077 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14078 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14079 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14080 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14081 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14082
14083 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14084 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14085 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14086 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14087 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14088 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14089 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14090 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14091
14092 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
14093 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
14094 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
14095 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
14096 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14097 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14098 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14099 {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14100
14101 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14102 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
14103 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
14104 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
14105
14106 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14107 {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
14108 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
14109
14110 { } /* end */
14111 };
14112
14113 /* toggle speaker-output according to the hp-jack state */
14114 static void alc861vd_dallas_automute(struct hda_codec *codec)
14115 {
14116 unsigned int present;
14117
14118 present = snd_hda_codec_read(codec, 0x15, 0,
14119 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
14120 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
14121 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
14122 }
14123
14124 static void alc861vd_dallas_unsol_event(struct hda_codec *codec, unsigned int res)
14125 {
14126 if ((res >> 26) == ALC880_HP_EVENT)
14127 alc861vd_dallas_automute(codec);
14128 }
14129
14130 #ifdef CONFIG_SND_HDA_POWER_SAVE
14131 #define alc861vd_loopbacks alc880_loopbacks
14132 #endif
14133
14134 /* pcm configuration: identiacal with ALC880 */
14135 #define alc861vd_pcm_analog_playback alc880_pcm_analog_playback
14136 #define alc861vd_pcm_analog_capture alc880_pcm_analog_capture
14137 #define alc861vd_pcm_digital_playback alc880_pcm_digital_playback
14138 #define alc861vd_pcm_digital_capture alc880_pcm_digital_capture
14139
14140 /*
14141 * configuration and preset
14142 */
14143 static const char *alc861vd_models[ALC861VD_MODEL_LAST] = {
14144 [ALC660VD_3ST] = "3stack-660",
14145 [ALC660VD_3ST_DIG] = "3stack-660-digout",
14146 [ALC861VD_3ST] = "3stack",
14147 [ALC861VD_3ST_DIG] = "3stack-digout",
14148 [ALC861VD_6ST_DIG] = "6stack-digout",
14149 [ALC861VD_LENOVO] = "lenovo",
14150 [ALC861VD_DALLAS] = "dallas",
14151 [ALC861VD_HP] = "hp",
14152 [ALC861VD_AUTO] = "auto",
14153 };
14154
14155 static struct snd_pci_quirk alc861vd_cfg_tbl[] = {
14156 SND_PCI_QUIRK(0x1019, 0xa88d, "Realtek ALC660 demo", ALC660VD_3ST),
14157 SND_PCI_QUIRK(0x103c, 0x30bf, "HP TX1000", ALC861VD_HP),
14158 SND_PCI_QUIRK(0x1043, 0x12e2, "Asus z35m", ALC660VD_3ST),
14159 SND_PCI_QUIRK(0x1043, 0x1339, "Asus G1", ALC660VD_3ST),
14160 SND_PCI_QUIRK(0x1043, 0x1633, "Asus V1Sn", ALC861VD_LENOVO),
14161 SND_PCI_QUIRK(0x1043, 0x81e7, "ASUS", ALC660VD_3ST_DIG),
14162 SND_PCI_QUIRK(0x10de, 0x03f0, "Realtek ALC660 demo", ALC660VD_3ST),
14163 SND_PCI_QUIRK(0x1179, 0xff00, "Toshiba A135", ALC861VD_LENOVO),
14164 /*SND_PCI_QUIRK(0x1179, 0xff00, "DALLAS", ALC861VD_DALLAS),*/ /*lenovo*/
14165 SND_PCI_QUIRK(0x1179, 0xff01, "DALLAS", ALC861VD_DALLAS),
14166 SND_PCI_QUIRK(0x1179, 0xff03, "Toshiba P205", ALC861VD_LENOVO),
14167 SND_PCI_QUIRK(0x1179, 0xff31, "Toshiba L30-149", ALC861VD_DALLAS),
14168 SND_PCI_QUIRK(0x1565, 0x820d, "Biostar NF61S SE", ALC861VD_6ST_DIG),
14169 SND_PCI_QUIRK(0x17aa, 0x2066, "Lenovo", ALC861VD_LENOVO),
14170 SND_PCI_QUIRK(0x17aa, 0x3802, "Lenovo 3000 C200", ALC861VD_LENOVO),
14171 SND_PCI_QUIRK(0x17aa, 0x384e, "Lenovo 3000 N200", ALC861VD_LENOVO),
14172 SND_PCI_QUIRK(0x1849, 0x0862, "ASRock K8NF6G-VSTA", ALC861VD_6ST_DIG),
14173 {}
14174 };
14175
14176 static struct alc_config_preset alc861vd_presets[] = {
14177 [ALC660VD_3ST] = {
14178 .mixers = { alc861vd_3st_mixer },
14179 .init_verbs = { alc861vd_volume_init_verbs,
14180 alc861vd_3stack_init_verbs },
14181 .num_dacs = ARRAY_SIZE(alc660vd_dac_nids),
14182 .dac_nids = alc660vd_dac_nids,
14183 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
14184 .channel_mode = alc861vd_3stack_2ch_modes,
14185 .input_mux = &alc861vd_capture_source,
14186 },
14187 [ALC660VD_3ST_DIG] = {
14188 .mixers = { alc861vd_3st_mixer },
14189 .init_verbs = { alc861vd_volume_init_verbs,
14190 alc861vd_3stack_init_verbs },
14191 .num_dacs = ARRAY_SIZE(alc660vd_dac_nids),
14192 .dac_nids = alc660vd_dac_nids,
14193 .dig_out_nid = ALC861VD_DIGOUT_NID,
14194 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
14195 .channel_mode = alc861vd_3stack_2ch_modes,
14196 .input_mux = &alc861vd_capture_source,
14197 },
14198 [ALC861VD_3ST] = {
14199 .mixers = { alc861vd_3st_mixer },
14200 .init_verbs = { alc861vd_volume_init_verbs,
14201 alc861vd_3stack_init_verbs },
14202 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
14203 .dac_nids = alc861vd_dac_nids,
14204 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
14205 .channel_mode = alc861vd_3stack_2ch_modes,
14206 .input_mux = &alc861vd_capture_source,
14207 },
14208 [ALC861VD_3ST_DIG] = {
14209 .mixers = { alc861vd_3st_mixer },
14210 .init_verbs = { alc861vd_volume_init_verbs,
14211 alc861vd_3stack_init_verbs },
14212 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
14213 .dac_nids = alc861vd_dac_nids,
14214 .dig_out_nid = ALC861VD_DIGOUT_NID,
14215 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
14216 .channel_mode = alc861vd_3stack_2ch_modes,
14217 .input_mux = &alc861vd_capture_source,
14218 },
14219 [ALC861VD_6ST_DIG] = {
14220 .mixers = { alc861vd_6st_mixer, alc861vd_chmode_mixer },
14221 .init_verbs = { alc861vd_volume_init_verbs,
14222 alc861vd_6stack_init_verbs },
14223 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
14224 .dac_nids = alc861vd_dac_nids,
14225 .dig_out_nid = ALC861VD_DIGOUT_NID,
14226 .num_channel_mode = ARRAY_SIZE(alc861vd_6stack_modes),
14227 .channel_mode = alc861vd_6stack_modes,
14228 .input_mux = &alc861vd_capture_source,
14229 },
14230 [ALC861VD_LENOVO] = {
14231 .mixers = { alc861vd_lenovo_mixer },
14232 .init_verbs = { alc861vd_volume_init_verbs,
14233 alc861vd_3stack_init_verbs,
14234 alc861vd_eapd_verbs,
14235 alc861vd_lenovo_unsol_verbs },
14236 .num_dacs = ARRAY_SIZE(alc660vd_dac_nids),
14237 .dac_nids = alc660vd_dac_nids,
14238 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
14239 .channel_mode = alc861vd_3stack_2ch_modes,
14240 .input_mux = &alc861vd_capture_source,
14241 .unsol_event = alc861vd_lenovo_unsol_event,
14242 .init_hook = alc861vd_lenovo_automute,
14243 },
14244 [ALC861VD_DALLAS] = {
14245 .mixers = { alc861vd_dallas_mixer },
14246 .init_verbs = { alc861vd_dallas_verbs },
14247 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
14248 .dac_nids = alc861vd_dac_nids,
14249 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
14250 .channel_mode = alc861vd_3stack_2ch_modes,
14251 .input_mux = &alc861vd_dallas_capture_source,
14252 .unsol_event = alc861vd_dallas_unsol_event,
14253 .init_hook = alc861vd_dallas_automute,
14254 },
14255 [ALC861VD_HP] = {
14256 .mixers = { alc861vd_hp_mixer },
14257 .init_verbs = { alc861vd_dallas_verbs, alc861vd_eapd_verbs },
14258 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
14259 .dac_nids = alc861vd_dac_nids,
14260 .dig_out_nid = ALC861VD_DIGOUT_NID,
14261 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
14262 .channel_mode = alc861vd_3stack_2ch_modes,
14263 .input_mux = &alc861vd_hp_capture_source,
14264 .unsol_event = alc861vd_dallas_unsol_event,
14265 .init_hook = alc861vd_dallas_automute,
14266 },
14267 };
14268
14269 /*
14270 * BIOS auto configuration
14271 */
14272 static void alc861vd_auto_set_output_and_unmute(struct hda_codec *codec,
14273 hda_nid_t nid, int pin_type, int dac_idx)
14274 {
14275 alc_set_pin_output(codec, nid, pin_type);
14276 }
14277
14278 static void alc861vd_auto_init_multi_out(struct hda_codec *codec)
14279 {
14280 struct alc_spec *spec = codec->spec;
14281 int i;
14282
14283 alc_subsystem_id(codec, 0x15, 0x1b, 0x14);
14284 for (i = 0; i <= HDA_SIDE; i++) {
14285 hda_nid_t nid = spec->autocfg.line_out_pins[i];
14286 int pin_type = get_pin_type(spec->autocfg.line_out_type);
14287 if (nid)
14288 alc861vd_auto_set_output_and_unmute(codec, nid,
14289 pin_type, i);
14290 }
14291 }
14292
14293
14294 static void alc861vd_auto_init_hp_out(struct hda_codec *codec)
14295 {
14296 struct alc_spec *spec = codec->spec;
14297 hda_nid_t pin;
14298
14299 pin = spec->autocfg.hp_pins[0];
14300 if (pin) /* connect to front and use dac 0 */
14301 alc861vd_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
14302 pin = spec->autocfg.speaker_pins[0];
14303 if (pin)
14304 alc861vd_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
14305 }
14306
14307 #define alc861vd_is_input_pin(nid) alc880_is_input_pin(nid)
14308 #define ALC861VD_PIN_CD_NID ALC880_PIN_CD_NID
14309
14310 static void alc861vd_auto_init_analog_input(struct hda_codec *codec)
14311 {
14312 struct alc_spec *spec = codec->spec;
14313 int i;
14314
14315 for (i = 0; i < AUTO_PIN_LAST; i++) {
14316 hda_nid_t nid = spec->autocfg.input_pins[i];
14317 if (alc861vd_is_input_pin(nid)) {
14318 snd_hda_codec_write(codec, nid, 0,
14319 AC_VERB_SET_PIN_WIDGET_CONTROL,
14320 i <= AUTO_PIN_FRONT_MIC ?
14321 PIN_VREF80 : PIN_IN);
14322 if (nid != ALC861VD_PIN_CD_NID)
14323 snd_hda_codec_write(codec, nid, 0,
14324 AC_VERB_SET_AMP_GAIN_MUTE,
14325 AMP_OUT_MUTE);
14326 }
14327 }
14328 }
14329
14330 #define alc861vd_auto_init_input_src alc882_auto_init_input_src
14331
14332 #define alc861vd_idx_to_mixer_vol(nid) ((nid) + 0x02)
14333 #define alc861vd_idx_to_mixer_switch(nid) ((nid) + 0x0c)
14334
14335 /* add playback controls from the parsed DAC table */
14336 /* Based on ALC880 version. But ALC861VD has separate,
14337 * different NIDs for mute/unmute switch and volume control */
14338 static int alc861vd_auto_create_multi_out_ctls(struct alc_spec *spec,
14339 const struct auto_pin_cfg *cfg)
14340 {
14341 char name[32];
14342 static const char *chname[4] = {"Front", "Surround", "CLFE", "Side"};
14343 hda_nid_t nid_v, nid_s;
14344 int i, err;
14345
14346 for (i = 0; i < cfg->line_outs; i++) {
14347 if (!spec->multiout.dac_nids[i])
14348 continue;
14349 nid_v = alc861vd_idx_to_mixer_vol(
14350 alc880_dac_to_idx(
14351 spec->multiout.dac_nids[i]));
14352 nid_s = alc861vd_idx_to_mixer_switch(
14353 alc880_dac_to_idx(
14354 spec->multiout.dac_nids[i]));
14355
14356 if (i == 2) {
14357 /* Center/LFE */
14358 err = add_control(spec, ALC_CTL_WIDGET_VOL,
14359 "Center Playback Volume",
14360 HDA_COMPOSE_AMP_VAL(nid_v, 1, 0,
14361 HDA_OUTPUT));
14362 if (err < 0)
14363 return err;
14364 err = add_control(spec, ALC_CTL_WIDGET_VOL,
14365 "LFE Playback Volume",
14366 HDA_COMPOSE_AMP_VAL(nid_v, 2, 0,
14367 HDA_OUTPUT));
14368 if (err < 0)
14369 return err;
14370 err = add_control(spec, ALC_CTL_BIND_MUTE,
14371 "Center Playback Switch",
14372 HDA_COMPOSE_AMP_VAL(nid_s, 1, 2,
14373 HDA_INPUT));
14374 if (err < 0)
14375 return err;
14376 err = add_control(spec, ALC_CTL_BIND_MUTE,
14377 "LFE Playback Switch",
14378 HDA_COMPOSE_AMP_VAL(nid_s, 2, 2,
14379 HDA_INPUT));
14380 if (err < 0)
14381 return err;
14382 } else {
14383 sprintf(name, "%s Playback Volume", chname[i]);
14384 err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
14385 HDA_COMPOSE_AMP_VAL(nid_v, 3, 0,
14386 HDA_OUTPUT));
14387 if (err < 0)
14388 return err;
14389 sprintf(name, "%s Playback Switch", chname[i]);
14390 err = add_control(spec, ALC_CTL_BIND_MUTE, name,
14391 HDA_COMPOSE_AMP_VAL(nid_s, 3, 2,
14392 HDA_INPUT));
14393 if (err < 0)
14394 return err;
14395 }
14396 }
14397 return 0;
14398 }
14399
14400 /* add playback controls for speaker and HP outputs */
14401 /* Based on ALC880 version. But ALC861VD has separate,
14402 * different NIDs for mute/unmute switch and volume control */
14403 static int alc861vd_auto_create_extra_out(struct alc_spec *spec,
14404 hda_nid_t pin, const char *pfx)
14405 {
14406 hda_nid_t nid_v, nid_s;
14407 int err;
14408 char name[32];
14409
14410 if (!pin)
14411 return 0;
14412
14413 if (alc880_is_fixed_pin(pin)) {
14414 nid_v = alc880_idx_to_dac(alc880_fixed_pin_idx(pin));
14415 /* specify the DAC as the extra output */
14416 if (!spec->multiout.hp_nid)
14417 spec->multiout.hp_nid = nid_v;
14418 else
14419 spec->multiout.extra_out_nid[0] = nid_v;
14420 /* control HP volume/switch on the output mixer amp */
14421 nid_v = alc861vd_idx_to_mixer_vol(
14422 alc880_fixed_pin_idx(pin));
14423 nid_s = alc861vd_idx_to_mixer_switch(
14424 alc880_fixed_pin_idx(pin));
14425
14426 sprintf(name, "%s Playback Volume", pfx);
14427 err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
14428 HDA_COMPOSE_AMP_VAL(nid_v, 3, 0, HDA_OUTPUT));
14429 if (err < 0)
14430 return err;
14431 sprintf(name, "%s Playback Switch", pfx);
14432 err = add_control(spec, ALC_CTL_BIND_MUTE, name,
14433 HDA_COMPOSE_AMP_VAL(nid_s, 3, 2, HDA_INPUT));
14434 if (err < 0)
14435 return err;
14436 } else if (alc880_is_multi_pin(pin)) {
14437 /* set manual connection */
14438 /* we have only a switch on HP-out PIN */
14439 sprintf(name, "%s Playback Switch", pfx);
14440 err = add_control(spec, ALC_CTL_WIDGET_MUTE, name,
14441 HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
14442 if (err < 0)
14443 return err;
14444 }
14445 return 0;
14446 }
14447
14448 /* parse the BIOS configuration and set up the alc_spec
14449 * return 1 if successful, 0 if the proper config is not found,
14450 * or a negative error code
14451 * Based on ALC880 version - had to change it to override
14452 * alc880_auto_create_extra_out and alc880_auto_create_multi_out_ctls */
14453 static int alc861vd_parse_auto_config(struct hda_codec *codec)
14454 {
14455 struct alc_spec *spec = codec->spec;
14456 int err;
14457 static hda_nid_t alc861vd_ignore[] = { 0x1d, 0 };
14458
14459 err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
14460 alc861vd_ignore);
14461 if (err < 0)
14462 return err;
14463 if (!spec->autocfg.line_outs)
14464 return 0; /* can't find valid BIOS pin config */
14465
14466 err = alc880_auto_fill_dac_nids(spec, &spec->autocfg);
14467 if (err < 0)
14468 return err;
14469 err = alc861vd_auto_create_multi_out_ctls(spec, &spec->autocfg);
14470 if (err < 0)
14471 return err;
14472 err = alc861vd_auto_create_extra_out(spec,
14473 spec->autocfg.speaker_pins[0],
14474 "Speaker");
14475 if (err < 0)
14476 return err;
14477 err = alc861vd_auto_create_extra_out(spec,
14478 spec->autocfg.hp_pins[0],
14479 "Headphone");
14480 if (err < 0)
14481 return err;
14482 err = alc880_auto_create_analog_input_ctls(spec, &spec->autocfg);
14483 if (err < 0)
14484 return err;
14485
14486 spec->multiout.max_channels = spec->multiout.num_dacs * 2;
14487
14488 if (spec->autocfg.dig_out_pin)
14489 spec->multiout.dig_out_nid = ALC861VD_DIGOUT_NID;
14490
14491 if (spec->kctl_alloc)
14492 spec->mixers[spec->num_mixers++] = spec->kctl_alloc;
14493
14494 spec->init_verbs[spec->num_init_verbs++]
14495 = alc861vd_volume_init_verbs;
14496
14497 spec->num_mux_defs = 1;
14498 spec->input_mux = &spec->private_imux;
14499
14500 err = alc_auto_add_mic_boost(codec);
14501 if (err < 0)
14502 return err;
14503
14504 store_pin_configs(codec);
14505 return 1;
14506 }
14507
14508 /* additional initialization for auto-configuration model */
14509 static void alc861vd_auto_init(struct hda_codec *codec)
14510 {
14511 struct alc_spec *spec = codec->spec;
14512 alc861vd_auto_init_multi_out(codec);
14513 alc861vd_auto_init_hp_out(codec);
14514 alc861vd_auto_init_analog_input(codec);
14515 alc861vd_auto_init_input_src(codec);
14516 if (spec->unsol_event)
14517 alc_inithook(codec);
14518 }
14519
14520 static int patch_alc861vd(struct hda_codec *codec)
14521 {
14522 struct alc_spec *spec;
14523 int err, board_config;
14524
14525 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
14526 if (spec == NULL)
14527 return -ENOMEM;
14528
14529 codec->spec = spec;
14530
14531 board_config = snd_hda_check_board_config(codec, ALC861VD_MODEL_LAST,
14532 alc861vd_models,
14533 alc861vd_cfg_tbl);
14534
14535 if (board_config < 0 || board_config >= ALC861VD_MODEL_LAST) {
14536 printk(KERN_INFO "hda_codec: Unknown model for ALC660VD/"
14537 "ALC861VD, trying auto-probe from BIOS...\n");
14538 board_config = ALC861VD_AUTO;
14539 }
14540
14541 if (board_config == ALC861VD_AUTO) {
14542 /* automatic parse from the BIOS config */
14543 err = alc861vd_parse_auto_config(codec);
14544 if (err < 0) {
14545 alc_free(codec);
14546 return err;
14547 } else if (!err) {
14548 printk(KERN_INFO
14549 "hda_codec: Cannot set up configuration "
14550 "from BIOS. Using base mode...\n");
14551 board_config = ALC861VD_3ST;
14552 }
14553 }
14554
14555 if (board_config != ALC861VD_AUTO)
14556 setup_preset(spec, &alc861vd_presets[board_config]);
14557
14558 if (codec->vendor_id == 0x10ec0660) {
14559 spec->stream_name_analog = "ALC660-VD Analog";
14560 spec->stream_name_digital = "ALC660-VD Digital";
14561 /* always turn on EAPD */
14562 spec->init_verbs[spec->num_init_verbs++] = alc660vd_eapd_verbs;
14563 } else {
14564 spec->stream_name_analog = "ALC861VD Analog";
14565 spec->stream_name_digital = "ALC861VD Digital";
14566 }
14567
14568 spec->stream_analog_playback = &alc861vd_pcm_analog_playback;
14569 spec->stream_analog_capture = &alc861vd_pcm_analog_capture;
14570
14571 spec->stream_digital_playback = &alc861vd_pcm_digital_playback;
14572 spec->stream_digital_capture = &alc861vd_pcm_digital_capture;
14573
14574 spec->adc_nids = alc861vd_adc_nids;
14575 spec->num_adc_nids = ARRAY_SIZE(alc861vd_adc_nids);
14576 spec->capsrc_nids = alc861vd_capsrc_nids;
14577
14578 spec->mixers[spec->num_mixers] = alc861vd_capture_mixer;
14579 spec->num_mixers++;
14580
14581 spec->vmaster_nid = 0x02;
14582
14583 codec->patch_ops = alc_patch_ops;
14584
14585 if (board_config == ALC861VD_AUTO)
14586 spec->init_hook = alc861vd_auto_init;
14587 #ifdef CONFIG_SND_HDA_POWER_SAVE
14588 if (!spec->loopback.amplist)
14589 spec->loopback.amplist = alc861vd_loopbacks;
14590 #endif
14591
14592 return 0;
14593 }
14594
14595 /*
14596 * ALC662 support
14597 *
14598 * ALC662 is almost identical with ALC880 but has cleaner and more flexible
14599 * configuration. Each pin widget can choose any input DACs and a mixer.
14600 * Each ADC is connected from a mixer of all inputs. This makes possible
14601 * 6-channel independent captures.
14602 *
14603 * In addition, an independent DAC for the multi-playback (not used in this
14604 * driver yet).
14605 */
14606 #define ALC662_DIGOUT_NID 0x06
14607 #define ALC662_DIGIN_NID 0x0a
14608
14609 static hda_nid_t alc662_dac_nids[4] = {
14610 /* front, rear, clfe, rear_surr */
14611 0x02, 0x03, 0x04
14612 };
14613
14614 static hda_nid_t alc662_adc_nids[1] = {
14615 /* ADC1-2 */
14616 0x09,
14617 };
14618
14619 static hda_nid_t alc662_capsrc_nids[1] = { 0x22 };
14620
14621 /* input MUX */
14622 /* FIXME: should be a matrix-type input source selection */
14623 static struct hda_input_mux alc662_capture_source = {
14624 .num_items = 4,
14625 .items = {
14626 { "Mic", 0x0 },
14627 { "Front Mic", 0x1 },
14628 { "Line", 0x2 },
14629 { "CD", 0x4 },
14630 },
14631 };
14632
14633 static struct hda_input_mux alc662_lenovo_101e_capture_source = {
14634 .num_items = 2,
14635 .items = {
14636 { "Mic", 0x1 },
14637 { "Line", 0x2 },
14638 },
14639 };
14640
14641 static struct hda_input_mux alc662_eeepc_capture_source = {
14642 .num_items = 2,
14643 .items = {
14644 { "i-Mic", 0x1 },
14645 { "e-Mic", 0x0 },
14646 },
14647 };
14648
14649 static struct hda_input_mux alc663_capture_source = {
14650 .num_items = 3,
14651 .items = {
14652 { "Mic", 0x0 },
14653 { "Front Mic", 0x1 },
14654 { "Line", 0x2 },
14655 },
14656 };
14657
14658 static struct hda_input_mux alc663_m51va_capture_source = {
14659 .num_items = 2,
14660 .items = {
14661 { "Ext-Mic", 0x0 },
14662 { "D-Mic", 0x9 },
14663 },
14664 };
14665
14666 #define alc662_mux_enum_info alc_mux_enum_info
14667 #define alc662_mux_enum_get alc_mux_enum_get
14668 #define alc662_mux_enum_put alc882_mux_enum_put
14669
14670 /*
14671 * 2ch mode
14672 */
14673 static struct hda_channel_mode alc662_3ST_2ch_modes[1] = {
14674 { 2, NULL }
14675 };
14676
14677 /*
14678 * 2ch mode
14679 */
14680 static struct hda_verb alc662_3ST_ch2_init[] = {
14681 { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
14682 { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
14683 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
14684 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
14685 { } /* end */
14686 };
14687
14688 /*
14689 * 6ch mode
14690 */
14691 static struct hda_verb alc662_3ST_ch6_init[] = {
14692 { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
14693 { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
14694 { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
14695 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
14696 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
14697 { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
14698 { } /* end */
14699 };
14700
14701 static struct hda_channel_mode alc662_3ST_6ch_modes[2] = {
14702 { 2, alc662_3ST_ch2_init },
14703 { 6, alc662_3ST_ch6_init },
14704 };
14705
14706 /*
14707 * 2ch mode
14708 */
14709 static struct hda_verb alc662_sixstack_ch6_init[] = {
14710 { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
14711 { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
14712 { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
14713 { } /* end */
14714 };
14715
14716 /*
14717 * 6ch mode
14718 */
14719 static struct hda_verb alc662_sixstack_ch8_init[] = {
14720 { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
14721 { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
14722 { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
14723 { } /* end */
14724 };
14725
14726 static struct hda_channel_mode alc662_5stack_modes[2] = {
14727 { 2, alc662_sixstack_ch6_init },
14728 { 6, alc662_sixstack_ch8_init },
14729 };
14730
14731 /* Pin assignment: Front=0x14, Rear=0x15, CLFE=0x16, Side=0x17
14732 * Mic=0x18, Front Mic=0x19, Line-In=0x1a, HP=0x1b
14733 */
14734
14735 static struct snd_kcontrol_new alc662_base_mixer[] = {
14736 /* output mixer control */
14737 HDA_CODEC_VOLUME("Front Playback Volume", 0x2, 0x0, HDA_OUTPUT),
14738 HDA_CODEC_MUTE("Front Playback Switch", 0x0c, 0x0, HDA_INPUT),
14739 HDA_CODEC_VOLUME("Surround Playback Volume", 0x3, 0x0, HDA_OUTPUT),
14740 HDA_CODEC_MUTE("Surround Playback Switch", 0x0d, 0x0, HDA_INPUT),
14741 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0, HDA_OUTPUT),
14742 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0, HDA_OUTPUT),
14743 HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x0e, 1, 0x0, HDA_INPUT),
14744 HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 0x0, HDA_INPUT),
14745 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
14746
14747 /*Input mixer control */
14748 HDA_CODEC_VOLUME("CD Playback Volume", 0xb, 0x4, HDA_INPUT),
14749 HDA_CODEC_MUTE("CD Playback Switch", 0xb, 0x4, HDA_INPUT),
14750 HDA_CODEC_VOLUME("Line Playback Volume", 0xb, 0x02, HDA_INPUT),
14751 HDA_CODEC_MUTE("Line Playback Switch", 0xb, 0x02, HDA_INPUT),
14752 HDA_CODEC_VOLUME("Mic Playback Volume", 0xb, 0x0, HDA_INPUT),
14753 HDA_CODEC_MUTE("Mic Playback Switch", 0xb, 0x0, HDA_INPUT),
14754 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0xb, 0x01, HDA_INPUT),
14755 HDA_CODEC_MUTE("Front Mic Playback Switch", 0xb, 0x01, HDA_INPUT),
14756 { } /* end */
14757 };
14758
14759 static struct snd_kcontrol_new alc662_3ST_2ch_mixer[] = {
14760 HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
14761 HDA_CODEC_MUTE("Front Playback Switch", 0x0c, 0x0, HDA_INPUT),
14762 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
14763 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
14764 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
14765 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
14766 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
14767 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
14768 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
14769 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
14770 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
14771 HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
14772 HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
14773 { } /* end */
14774 };
14775
14776 static struct snd_kcontrol_new alc662_3ST_6ch_mixer[] = {
14777 HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
14778 HDA_CODEC_MUTE("Front Playback Switch", 0x0c, 0x0, HDA_INPUT),
14779 HDA_CODEC_VOLUME("Surround Playback Volume", 0x03, 0x0, HDA_OUTPUT),
14780 HDA_CODEC_MUTE("Surround Playback Switch", 0x0d, 0x0, HDA_INPUT),
14781 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0, HDA_OUTPUT),
14782 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0, HDA_OUTPUT),
14783 HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x0e, 1, 0x0, HDA_INPUT),
14784 HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 0x0, HDA_INPUT),
14785 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
14786 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
14787 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
14788 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
14789 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
14790 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
14791 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
14792 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
14793 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
14794 HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
14795 HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
14796 { } /* end */
14797 };
14798
14799 static struct snd_kcontrol_new alc662_lenovo_101e_mixer[] = {
14800 HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
14801 HDA_BIND_MUTE("Front Playback Switch", 0x02, 2, HDA_INPUT),
14802 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x03, 0x0, HDA_OUTPUT),
14803 HDA_BIND_MUTE("Speaker Playback Switch", 0x03, 2, HDA_INPUT),
14804 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
14805 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
14806 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
14807 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
14808 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
14809 { } /* end */
14810 };
14811
14812 static struct snd_kcontrol_new alc662_eeepc_p701_mixer[] = {
14813 HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
14814
14815 HDA_CODEC_VOLUME("Line-Out Playback Volume", 0x02, 0x0, HDA_OUTPUT),
14816 HDA_CODEC_MUTE("Line-Out Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
14817
14818 HDA_CODEC_VOLUME("e-Mic Boost", 0x18, 0, HDA_INPUT),
14819 HDA_CODEC_VOLUME("e-Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
14820 HDA_CODEC_MUTE("e-Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
14821
14822 HDA_CODEC_VOLUME("i-Mic Boost", 0x19, 0, HDA_INPUT),
14823 HDA_CODEC_VOLUME("i-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
14824 HDA_CODEC_MUTE("i-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
14825 { } /* end */
14826 };
14827
14828 static struct snd_kcontrol_new alc662_eeepc_ep20_mixer[] = {
14829 HDA_CODEC_VOLUME("Line-Out Playback Volume", 0x02, 0x0, HDA_OUTPUT),
14830 HDA_CODEC_MUTE("Line-Out Playback Switch", 0x14, 0x0, HDA_OUTPUT),
14831 HDA_CODEC_VOLUME("Surround Playback Volume", 0x03, 0x0, HDA_OUTPUT),
14832 HDA_BIND_MUTE("Surround Playback Switch", 0x03, 2, HDA_INPUT),
14833 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0, HDA_OUTPUT),
14834 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0, HDA_OUTPUT),
14835 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x04, 1, 2, HDA_INPUT),
14836 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x04, 2, 2, HDA_INPUT),
14837 HDA_CODEC_MUTE("Speaker Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
14838 HDA_BIND_MUTE("MuteCtrl Playback Switch", 0x0c, 2, HDA_INPUT),
14839 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
14840 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
14841 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
14842 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
14843 { } /* end */
14844 };
14845
14846 static struct hda_bind_ctls alc663_asus_bind_master_vol = {
14847 .ops = &snd_hda_bind_vol,
14848 .values = {
14849 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT),
14850 HDA_COMPOSE_AMP_VAL(0x03, 3, 0, HDA_OUTPUT),
14851 0
14852 },
14853 };
14854
14855 static struct hda_bind_ctls alc663_asus_one_bind_switch = {
14856 .ops = &snd_hda_bind_sw,
14857 .values = {
14858 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
14859 HDA_COMPOSE_AMP_VAL(0x21, 3, 0, HDA_OUTPUT),
14860 0
14861 },
14862 };
14863
14864 static struct snd_kcontrol_new alc663_m51va_mixer[] = {
14865 HDA_BIND_VOL("Master Playback Volume", &alc663_asus_bind_master_vol),
14866 HDA_BIND_SW("Master Playback Switch", &alc663_asus_one_bind_switch),
14867 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
14868 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
14869 { } /* end */
14870 };
14871
14872 static struct hda_bind_ctls alc663_asus_tree_bind_switch = {
14873 .ops = &snd_hda_bind_sw,
14874 .values = {
14875 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
14876 HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT),
14877 HDA_COMPOSE_AMP_VAL(0x21, 3, 0, HDA_OUTPUT),
14878 0
14879 },
14880 };
14881
14882 static struct snd_kcontrol_new alc663_two_hp_m1_mixer[] = {
14883 HDA_BIND_VOL("Master Playback Volume", &alc663_asus_bind_master_vol),
14884 HDA_BIND_SW("Master Playback Switch", &alc663_asus_tree_bind_switch),
14885 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
14886 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
14887 HDA_CODEC_VOLUME("F-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
14888 HDA_CODEC_MUTE("F-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
14889
14890 { } /* end */
14891 };
14892
14893 static struct hda_bind_ctls alc663_asus_four_bind_switch = {
14894 .ops = &snd_hda_bind_sw,
14895 .values = {
14896 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
14897 HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT),
14898 HDA_COMPOSE_AMP_VAL(0x1b, 3, 0, HDA_OUTPUT),
14899 0
14900 },
14901 };
14902
14903 static struct snd_kcontrol_new alc663_two_hp_m2_mixer[] = {
14904 HDA_BIND_VOL("Master Playback Volume", &alc663_asus_bind_master_vol),
14905 HDA_BIND_SW("Master Playback Switch", &alc663_asus_four_bind_switch),
14906 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
14907 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
14908 HDA_CODEC_VOLUME("F-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
14909 HDA_CODEC_MUTE("F-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
14910 { } /* end */
14911 };
14912
14913 static struct snd_kcontrol_new alc662_1bjd_mixer[] = {
14914 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
14915 HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
14916 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
14917 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
14918 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
14919 HDA_CODEC_VOLUME("F-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
14920 HDA_CODEC_MUTE("F-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
14921 { } /* end */
14922 };
14923
14924 static struct hda_bind_ctls alc663_asus_two_bind_master_vol = {
14925 .ops = &snd_hda_bind_vol,
14926 .values = {
14927 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT),
14928 HDA_COMPOSE_AMP_VAL(0x04, 3, 0, HDA_OUTPUT),
14929 0
14930 },
14931 };
14932
14933 static struct hda_bind_ctls alc663_asus_two_bind_switch = {
14934 .ops = &snd_hda_bind_sw,
14935 .values = {
14936 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
14937 HDA_COMPOSE_AMP_VAL(0x16, 3, 0, HDA_OUTPUT),
14938 0
14939 },
14940 };
14941
14942 static struct snd_kcontrol_new alc663_asus_21jd_clfe_mixer[] = {
14943 HDA_BIND_VOL("Master Playback Volume",
14944 &alc663_asus_two_bind_master_vol),
14945 HDA_BIND_SW("Master Playback Switch", &alc663_asus_two_bind_switch),
14946 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
14947 HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT),
14948 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
14949 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
14950 { } /* end */
14951 };
14952
14953 static struct snd_kcontrol_new alc663_asus_15jd_clfe_mixer[] = {
14954 HDA_BIND_VOL("Master Playback Volume", &alc663_asus_bind_master_vol),
14955 HDA_BIND_SW("Master Playback Switch", &alc663_asus_two_bind_switch),
14956 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
14957 HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
14958 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
14959 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
14960 { } /* end */
14961 };
14962
14963 static struct snd_kcontrol_new alc663_g71v_mixer[] = {
14964 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
14965 HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
14966 HDA_CODEC_VOLUME("Front Playback Volume", 0x03, 0x0, HDA_OUTPUT),
14967 HDA_CODEC_MUTE("Front Playback Switch", 0x15, 0x0, HDA_OUTPUT),
14968 HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT),
14969
14970 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
14971 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
14972 HDA_CODEC_VOLUME("i-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
14973 HDA_CODEC_MUTE("i-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
14974 { } /* end */
14975 };
14976
14977 static struct snd_kcontrol_new alc663_g50v_mixer[] = {
14978 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
14979 HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
14980 HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT),
14981
14982 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
14983 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
14984 HDA_CODEC_VOLUME("i-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
14985 HDA_CODEC_MUTE("i-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
14986 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
14987 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
14988 { } /* end */
14989 };
14990
14991 static struct snd_kcontrol_new alc662_chmode_mixer[] = {
14992 {
14993 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
14994 .name = "Channel Mode",
14995 .info = alc_ch_mode_info,
14996 .get = alc_ch_mode_get,
14997 .put = alc_ch_mode_put,
14998 },
14999 { } /* end */
15000 };
15001
15002 static struct hda_verb alc662_init_verbs[] = {
15003 /* ADC: mute amp left and right */
15004 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15005 {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
15006 /* Front mixer: unmute input/output amp left and right (volume = 0) */
15007
15008 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15009 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
15010 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
15011 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
15012 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
15013
15014 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15015 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15016 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15017 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15018 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15019 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15020
15021 /* Front Pin: output 0 (0x0c) */
15022 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
15023 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15024
15025 /* Rear Pin: output 1 (0x0d) */
15026 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
15027 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15028
15029 /* CLFE Pin: output 2 (0x0e) */
15030 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
15031 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15032
15033 /* Mic (rear) pin: input vref at 80% */
15034 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
15035 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
15036 /* Front Mic pin: input vref at 80% */
15037 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
15038 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
15039 /* Line In pin: input */
15040 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15041 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
15042 /* Line-2 In: Headphone output (output 0 - 0x0c) */
15043 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15044 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15045 {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
15046 /* CD pin widget for input */
15047 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15048
15049 /* FIXME: use matrix-type input source selection */
15050 /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
15051 /* Input mixer */
15052 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15053 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15054 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
15055 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
15056
15057 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15058 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15059 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
15060 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
15061
15062 /* always trun on EAPD */
15063 {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
15064 {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
15065
15066 { }
15067 };
15068
15069 static struct hda_verb alc662_sue_init_verbs[] = {
15070 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_FRONT_EVENT},
15071 {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_HP_EVENT},
15072 {}
15073 };
15074
15075 static struct hda_verb alc662_eeepc_sue_init_verbs[] = {
15076 {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
15077 {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15078 {}
15079 };
15080
15081 /* Set Unsolicited Event*/
15082 static struct hda_verb alc662_eeepc_ep20_sue_init_verbs[] = {
15083 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
15084 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15085 {}
15086 };
15087
15088 /*
15089 * generic initialization of ADC, input mixers and output mixers
15090 */
15091 static struct hda_verb alc662_auto_init_verbs[] = {
15092 /*
15093 * Unmute ADC and set the default input to mic-in
15094 */
15095 {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
15096 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15097
15098 /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
15099 * mixer widget
15100 * Note: PASD motherboards uses the Line In 2 as the input for front
15101 * panel mic (mic 2)
15102 */
15103 /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
15104 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15105 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
15106 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
15107 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
15108 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
15109
15110 /*
15111 * Set up output mixers (0x0c - 0x0f)
15112 */
15113 /* set vol=0 to output mixers */
15114 {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
15115 {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
15116 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
15117
15118 /* set up input amps for analog loopback */
15119 /* Amp Indices: DAC = 0, mixer = 1 */
15120 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15121 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15122 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15123 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15124 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15125 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15126
15127
15128 /* FIXME: use matrix-type input source selection */
15129 /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
15130 /* Input mixer */
15131 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15132 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15133 { }
15134 };
15135
15136 /* additional verbs for ALC663 */
15137 static struct hda_verb alc663_auto_init_verbs[] = {
15138 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15139 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15140 { }
15141 };
15142
15143 static struct hda_verb alc663_m51va_init_verbs[] = {
15144 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15145 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15146 {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15147 {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15148 {0x21, AC_VERB_SET_CONNECT_SEL, 0x01}, /* Headphone */
15149 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15150 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(9)},
15151 {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
15152 {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15153 {}
15154 };
15155
15156 static struct hda_verb alc663_21jd_amic_init_verbs[] = {
15157 {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15158 {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15159 {0x21, AC_VERB_SET_CONNECT_SEL, 0x01}, /* Headphone */
15160 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15161 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15162 {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
15163 {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15164 {}
15165 };
15166
15167 static struct hda_verb alc662_1bjd_amic_init_verbs[] = {
15168 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15169 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15170 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15171 {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Headphone */
15172 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15173 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15174 {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
15175 {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15176 {}
15177 };
15178
15179 static struct hda_verb alc663_15jd_amic_init_verbs[] = {
15180 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15181 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15182 {0x15, AC_VERB_SET_CONNECT_SEL, 0x01}, /* Headphone */
15183 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15184 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15185 {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
15186 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15187 {}
15188 };
15189
15190 static struct hda_verb alc663_two_hp_amic_m1_init_verbs[] = {
15191 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15192 {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15193 {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15194 {0x21, AC_VERB_SET_CONNECT_SEL, 0x0}, /* Headphone */
15195 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15196 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15197 {0x15, AC_VERB_SET_CONNECT_SEL, 0x0}, /* Headphone */
15198 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15199 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15200 {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
15201 {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15202 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15203 {}
15204 };
15205
15206 static struct hda_verb alc663_two_hp_amic_m2_init_verbs[] = {
15207 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15208 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15209 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15210 {0x1b, AC_VERB_SET_CONNECT_SEL, 0x01}, /* Headphone */
15211 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15212 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15213 {0x15, AC_VERB_SET_CONNECT_SEL, 0x01}, /* Headphone */
15214 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15215 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15216 {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
15217 {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15218 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15219 {}
15220 };
15221
15222 static struct hda_verb alc663_g71v_init_verbs[] = {
15223 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15224 /* {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, */
15225 /* {0x15, AC_VERB_SET_CONNECT_SEL, 0x01}, */ /* Headphone */
15226
15227 {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15228 {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15229 {0x21, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Headphone */
15230
15231 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_FRONT_EVENT},
15232 {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_MIC_EVENT},
15233 {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_HP_EVENT},
15234 {}
15235 };
15236
15237 static struct hda_verb alc663_g50v_init_verbs[] = {
15238 {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15239 {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15240 {0x21, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Headphone */
15241
15242 {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
15243 {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15244 {}
15245 };
15246
15247 static struct hda_verb alc662_ecs_init_verbs[] = {
15248 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, 0x701f},
15249 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15250 {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
15251 {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15252 {}
15253 };
15254
15255 /* capture mixer elements */
15256 static struct snd_kcontrol_new alc662_capture_mixer[] = {
15257 HDA_CODEC_VOLUME("Capture Volume", 0x09, 0x0, HDA_INPUT),
15258 HDA_CODEC_MUTE("Capture Switch", 0x09, 0x0, HDA_INPUT),
15259 {
15260 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
15261 /* The multiple "Capture Source" controls confuse alsamixer
15262 * So call somewhat different..
15263 */
15264 /* .name = "Capture Source", */
15265 .name = "Input Source",
15266 .count = 1,
15267 .info = alc662_mux_enum_info,
15268 .get = alc662_mux_enum_get,
15269 .put = alc662_mux_enum_put,
15270 },
15271 { } /* end */
15272 };
15273
15274 static struct snd_kcontrol_new alc662_auto_capture_mixer[] = {
15275 HDA_CODEC_VOLUME("Capture Volume", 0x09, 0x0, HDA_INPUT),
15276 HDA_CODEC_MUTE("Capture Switch", 0x09, 0x0, HDA_INPUT),
15277 { } /* end */
15278 };
15279
15280 static void alc662_lenovo_101e_ispeaker_automute(struct hda_codec *codec)
15281 {
15282 unsigned int present;
15283 unsigned char bits;
15284
15285 present = snd_hda_codec_read(codec, 0x14, 0,
15286 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
15287 bits = present ? HDA_AMP_MUTE : 0;
15288 snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
15289 HDA_AMP_MUTE, bits);
15290 }
15291
15292 static void alc662_lenovo_101e_all_automute(struct hda_codec *codec)
15293 {
15294 unsigned int present;
15295 unsigned char bits;
15296
15297 present = snd_hda_codec_read(codec, 0x1b, 0,
15298 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
15299 bits = present ? HDA_AMP_MUTE : 0;
15300 snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
15301 HDA_AMP_MUTE, bits);
15302 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
15303 HDA_AMP_MUTE, bits);
15304 }
15305
15306 static void alc662_lenovo_101e_unsol_event(struct hda_codec *codec,
15307 unsigned int res)
15308 {
15309 if ((res >> 26) == ALC880_HP_EVENT)
15310 alc662_lenovo_101e_all_automute(codec);
15311 if ((res >> 26) == ALC880_FRONT_EVENT)
15312 alc662_lenovo_101e_ispeaker_automute(codec);
15313 }
15314
15315 static void alc662_eeepc_mic_automute(struct hda_codec *codec)
15316 {
15317 unsigned int present;
15318
15319 present = snd_hda_codec_read(codec, 0x18, 0,
15320 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
15321 snd_hda_codec_write(codec, 0x22, 0, AC_VERB_SET_AMP_GAIN_MUTE,
15322 0x7000 | (0x00 << 8) | (present ? 0 : 0x80));
15323 snd_hda_codec_write(codec, 0x23, 0, AC_VERB_SET_AMP_GAIN_MUTE,
15324 0x7000 | (0x00 << 8) | (present ? 0 : 0x80));
15325 snd_hda_codec_write(codec, 0x22, 0, AC_VERB_SET_AMP_GAIN_MUTE,
15326 0x7000 | (0x01 << 8) | (present ? 0x80 : 0));
15327 snd_hda_codec_write(codec, 0x23, 0, AC_VERB_SET_AMP_GAIN_MUTE,
15328 0x7000 | (0x01 << 8) | (present ? 0x80 : 0));
15329 }
15330
15331 /* unsolicited event for HP jack sensing */
15332 static void alc662_eeepc_unsol_event(struct hda_codec *codec,
15333 unsigned int res)
15334 {
15335 if ((res >> 26) == ALC880_HP_EVENT)
15336 alc262_hippo1_automute( codec );
15337
15338 if ((res >> 26) == ALC880_MIC_EVENT)
15339 alc662_eeepc_mic_automute(codec);
15340 }
15341
15342 static void alc662_eeepc_inithook(struct hda_codec *codec)
15343 {
15344 alc262_hippo1_automute( codec );
15345 alc662_eeepc_mic_automute(codec);
15346 }
15347
15348 static void alc662_eeepc_ep20_automute(struct hda_codec *codec)
15349 {
15350 unsigned int mute;
15351 unsigned int present;
15352
15353 snd_hda_codec_read(codec, 0x14, 0, AC_VERB_SET_PIN_SENSE, 0);
15354 present = snd_hda_codec_read(codec, 0x14, 0,
15355 AC_VERB_GET_PIN_SENSE, 0);
15356 present = (present & 0x80000000) != 0;
15357 if (present) {
15358 /* mute internal speaker */
15359 snd_hda_codec_amp_stereo(codec, 0x1b, HDA_OUTPUT, 0,
15360 HDA_AMP_MUTE, HDA_AMP_MUTE);
15361 } else {
15362 /* unmute internal speaker if necessary */
15363 mute = snd_hda_codec_amp_read(codec, 0x14, 0, HDA_OUTPUT, 0);
15364 snd_hda_codec_amp_stereo(codec, 0x1b, HDA_OUTPUT, 0,
15365 HDA_AMP_MUTE, mute);
15366 }
15367 }
15368
15369 /* unsolicited event for HP jack sensing */
15370 static void alc662_eeepc_ep20_unsol_event(struct hda_codec *codec,
15371 unsigned int res)
15372 {
15373 if ((res >> 26) == ALC880_HP_EVENT)
15374 alc662_eeepc_ep20_automute(codec);
15375 }
15376
15377 static void alc662_eeepc_ep20_inithook(struct hda_codec *codec)
15378 {
15379 alc662_eeepc_ep20_automute(codec);
15380 }
15381
15382 static void alc663_m51va_speaker_automute(struct hda_codec *codec)
15383 {
15384 unsigned int present;
15385 unsigned char bits;
15386
15387 present = snd_hda_codec_read(codec, 0x21, 0,
15388 AC_VERB_GET_PIN_SENSE, 0)
15389 & AC_PINSENSE_PRESENCE;
15390 bits = present ? HDA_AMP_MUTE : 0;
15391 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
15392 AMP_IN_MUTE(0), bits);
15393 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
15394 AMP_IN_MUTE(0), bits);
15395 }
15396
15397 static void alc663_21jd_two_speaker_automute(struct hda_codec *codec)
15398 {
15399 unsigned int present;
15400 unsigned char bits;
15401
15402 present = snd_hda_codec_read(codec, 0x21, 0,
15403 AC_VERB_GET_PIN_SENSE, 0)
15404 & AC_PINSENSE_PRESENCE;
15405 bits = present ? HDA_AMP_MUTE : 0;
15406 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
15407 AMP_IN_MUTE(0), bits);
15408 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
15409 AMP_IN_MUTE(0), bits);
15410 snd_hda_codec_amp_stereo(codec, 0x0e, HDA_INPUT, 0,
15411 AMP_IN_MUTE(0), bits);
15412 snd_hda_codec_amp_stereo(codec, 0x0e, HDA_INPUT, 1,
15413 AMP_IN_MUTE(0), bits);
15414 }
15415
15416 static void alc663_15jd_two_speaker_automute(struct hda_codec *codec)
15417 {
15418 unsigned int present;
15419 unsigned char bits;
15420
15421 present = snd_hda_codec_read(codec, 0x15, 0,
15422 AC_VERB_GET_PIN_SENSE, 0)
15423 & AC_PINSENSE_PRESENCE;
15424 bits = present ? HDA_AMP_MUTE : 0;
15425 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
15426 AMP_IN_MUTE(0), bits);
15427 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
15428 AMP_IN_MUTE(0), bits);
15429 snd_hda_codec_amp_stereo(codec, 0x0e, HDA_INPUT, 0,
15430 AMP_IN_MUTE(0), bits);
15431 snd_hda_codec_amp_stereo(codec, 0x0e, HDA_INPUT, 1,
15432 AMP_IN_MUTE(0), bits);
15433 }
15434
15435 static void alc662_f5z_speaker_automute(struct hda_codec *codec)
15436 {
15437 unsigned int present;
15438 unsigned char bits;
15439
15440 present = snd_hda_codec_read(codec, 0x1b, 0,
15441 AC_VERB_GET_PIN_SENSE, 0)
15442 & AC_PINSENSE_PRESENCE;
15443 bits = present ? 0 : PIN_OUT;
15444 snd_hda_codec_write(codec, 0x14, 0,
15445 AC_VERB_SET_PIN_WIDGET_CONTROL, bits);
15446 }
15447
15448 static void alc663_two_hp_m1_speaker_automute(struct hda_codec *codec)
15449 {
15450 unsigned int present1, present2;
15451
15452 present1 = snd_hda_codec_read(codec, 0x21, 0,
15453 AC_VERB_GET_PIN_SENSE, 0)
15454 & AC_PINSENSE_PRESENCE;
15455 present2 = snd_hda_codec_read(codec, 0x15, 0,
15456 AC_VERB_GET_PIN_SENSE, 0)
15457 & AC_PINSENSE_PRESENCE;
15458
15459 if (present1 || present2) {
15460 snd_hda_codec_write_cache(codec, 0x14, 0,
15461 AC_VERB_SET_PIN_WIDGET_CONTROL, 0);
15462 } else {
15463 snd_hda_codec_write_cache(codec, 0x14, 0,
15464 AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
15465 }
15466 }
15467
15468 static void alc663_two_hp_m2_speaker_automute(struct hda_codec *codec)
15469 {
15470 unsigned int present1, present2;
15471
15472 present1 = snd_hda_codec_read(codec, 0x1b, 0,
15473 AC_VERB_GET_PIN_SENSE, 0)
15474 & AC_PINSENSE_PRESENCE;
15475 present2 = snd_hda_codec_read(codec, 0x15, 0,
15476 AC_VERB_GET_PIN_SENSE, 0)
15477 & AC_PINSENSE_PRESENCE;
15478
15479 if (present1 || present2) {
15480 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
15481 AMP_IN_MUTE(0), AMP_IN_MUTE(0));
15482 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
15483 AMP_IN_MUTE(0), AMP_IN_MUTE(0));
15484 } else {
15485 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
15486 AMP_IN_MUTE(0), 0);
15487 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
15488 AMP_IN_MUTE(0), 0);
15489 }
15490 }
15491
15492 static void alc663_m51va_mic_automute(struct hda_codec *codec)
15493 {
15494 unsigned int present;
15495
15496 present = snd_hda_codec_read(codec, 0x18, 0,
15497 AC_VERB_GET_PIN_SENSE, 0)
15498 & AC_PINSENSE_PRESENCE;
15499 snd_hda_codec_write_cache(codec, 0x22, 0, AC_VERB_SET_AMP_GAIN_MUTE,
15500 0x7000 | (0x00 << 8) | (present ? 0 : 0x80));
15501 snd_hda_codec_write_cache(codec, 0x23, 0, AC_VERB_SET_AMP_GAIN_MUTE,
15502 0x7000 | (0x00 << 8) | (present ? 0 : 0x80));
15503 snd_hda_codec_write_cache(codec, 0x22, 0, AC_VERB_SET_AMP_GAIN_MUTE,
15504 0x7000 | (0x09 << 8) | (present ? 0x80 : 0));
15505 snd_hda_codec_write_cache(codec, 0x23, 0, AC_VERB_SET_AMP_GAIN_MUTE,
15506 0x7000 | (0x09 << 8) | (present ? 0x80 : 0));
15507 }
15508
15509 static void alc663_m51va_unsol_event(struct hda_codec *codec,
15510 unsigned int res)
15511 {
15512 switch (res >> 26) {
15513 case ALC880_HP_EVENT:
15514 alc663_m51va_speaker_automute(codec);
15515 break;
15516 case ALC880_MIC_EVENT:
15517 alc663_m51va_mic_automute(codec);
15518 break;
15519 }
15520 }
15521
15522 static void alc663_m51va_inithook(struct hda_codec *codec)
15523 {
15524 alc663_m51va_speaker_automute(codec);
15525 alc663_m51va_mic_automute(codec);
15526 }
15527
15528 /* ***************** Mode1 ******************************/
15529 static void alc663_mode1_unsol_event(struct hda_codec *codec,
15530 unsigned int res)
15531 {
15532 switch (res >> 26) {
15533 case ALC880_HP_EVENT:
15534 alc663_m51va_speaker_automute(codec);
15535 break;
15536 case ALC880_MIC_EVENT:
15537 alc662_eeepc_mic_automute(codec);
15538 break;
15539 }
15540 }
15541
15542 static void alc663_mode1_inithook(struct hda_codec *codec)
15543 {
15544 alc663_m51va_speaker_automute(codec);
15545 alc662_eeepc_mic_automute(codec);
15546 }
15547 /* ***************** Mode2 ******************************/
15548 static void alc662_mode2_unsol_event(struct hda_codec *codec,
15549 unsigned int res)
15550 {
15551 switch (res >> 26) {
15552 case ALC880_HP_EVENT:
15553 alc662_f5z_speaker_automute(codec);
15554 break;
15555 case ALC880_MIC_EVENT:
15556 alc662_eeepc_mic_automute(codec);
15557 break;
15558 }
15559 }
15560
15561 static void alc662_mode2_inithook(struct hda_codec *codec)
15562 {
15563 alc662_f5z_speaker_automute(codec);
15564 alc662_eeepc_mic_automute(codec);
15565 }
15566 /* ***************** Mode3 ******************************/
15567 static void alc663_mode3_unsol_event(struct hda_codec *codec,
15568 unsigned int res)
15569 {
15570 switch (res >> 26) {
15571 case ALC880_HP_EVENT:
15572 alc663_two_hp_m1_speaker_automute(codec);
15573 break;
15574 case ALC880_MIC_EVENT:
15575 alc662_eeepc_mic_automute(codec);
15576 break;
15577 }
15578 }
15579
15580 static void alc663_mode3_inithook(struct hda_codec *codec)
15581 {
15582 alc663_two_hp_m1_speaker_automute(codec);
15583 alc662_eeepc_mic_automute(codec);
15584 }
15585 /* ***************** Mode4 ******************************/
15586 static void alc663_mode4_unsol_event(struct hda_codec *codec,
15587 unsigned int res)
15588 {
15589 switch (res >> 26) {
15590 case ALC880_HP_EVENT:
15591 alc663_21jd_two_speaker_automute(codec);
15592 break;
15593 case ALC880_MIC_EVENT:
15594 alc662_eeepc_mic_automute(codec);
15595 break;
15596 }
15597 }
15598
15599 static void alc663_mode4_inithook(struct hda_codec *codec)
15600 {
15601 alc663_21jd_two_speaker_automute(codec);
15602 alc662_eeepc_mic_automute(codec);
15603 }
15604 /* ***************** Mode5 ******************************/
15605 static void alc663_mode5_unsol_event(struct hda_codec *codec,
15606 unsigned int res)
15607 {
15608 switch (res >> 26) {
15609 case ALC880_HP_EVENT:
15610 alc663_15jd_two_speaker_automute(codec);
15611 break;
15612 case ALC880_MIC_EVENT:
15613 alc662_eeepc_mic_automute(codec);
15614 break;
15615 }
15616 }
15617
15618 static void alc663_mode5_inithook(struct hda_codec *codec)
15619 {
15620 alc663_15jd_two_speaker_automute(codec);
15621 alc662_eeepc_mic_automute(codec);
15622 }
15623 /* ***************** Mode6 ******************************/
15624 static void alc663_mode6_unsol_event(struct hda_codec *codec,
15625 unsigned int res)
15626 {
15627 switch (res >> 26) {
15628 case ALC880_HP_EVENT:
15629 alc663_two_hp_m2_speaker_automute(codec);
15630 break;
15631 case ALC880_MIC_EVENT:
15632 alc662_eeepc_mic_automute(codec);
15633 break;
15634 }
15635 }
15636
15637 static void alc663_mode6_inithook(struct hda_codec *codec)
15638 {
15639 alc663_two_hp_m2_speaker_automute(codec);
15640 alc662_eeepc_mic_automute(codec);
15641 }
15642
15643 static void alc663_g71v_hp_automute(struct hda_codec *codec)
15644 {
15645 unsigned int present;
15646 unsigned char bits;
15647
15648 present = snd_hda_codec_read(codec, 0x21, 0,
15649 AC_VERB_GET_PIN_SENSE, 0)
15650 & AC_PINSENSE_PRESENCE;
15651 bits = present ? HDA_AMP_MUTE : 0;
15652 snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
15653 HDA_AMP_MUTE, bits);
15654 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
15655 HDA_AMP_MUTE, bits);
15656 }
15657
15658 static void alc663_g71v_front_automute(struct hda_codec *codec)
15659 {
15660 unsigned int present;
15661 unsigned char bits;
15662
15663 present = snd_hda_codec_read(codec, 0x15, 0,
15664 AC_VERB_GET_PIN_SENSE, 0)
15665 & AC_PINSENSE_PRESENCE;
15666 bits = present ? HDA_AMP_MUTE : 0;
15667 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
15668 HDA_AMP_MUTE, bits);
15669 }
15670
15671 static void alc663_g71v_unsol_event(struct hda_codec *codec,
15672 unsigned int res)
15673 {
15674 switch (res >> 26) {
15675 case ALC880_HP_EVENT:
15676 alc663_g71v_hp_automute(codec);
15677 break;
15678 case ALC880_FRONT_EVENT:
15679 alc663_g71v_front_automute(codec);
15680 break;
15681 case ALC880_MIC_EVENT:
15682 alc662_eeepc_mic_automute(codec);
15683 break;
15684 }
15685 }
15686
15687 static void alc663_g71v_inithook(struct hda_codec *codec)
15688 {
15689 alc663_g71v_front_automute(codec);
15690 alc663_g71v_hp_automute(codec);
15691 alc662_eeepc_mic_automute(codec);
15692 }
15693
15694 static void alc663_g50v_unsol_event(struct hda_codec *codec,
15695 unsigned int res)
15696 {
15697 switch (res >> 26) {
15698 case ALC880_HP_EVENT:
15699 alc663_m51va_speaker_automute(codec);
15700 break;
15701 case ALC880_MIC_EVENT:
15702 alc662_eeepc_mic_automute(codec);
15703 break;
15704 }
15705 }
15706
15707 static void alc663_g50v_inithook(struct hda_codec *codec)
15708 {
15709 alc663_m51va_speaker_automute(codec);
15710 alc662_eeepc_mic_automute(codec);
15711 }
15712
15713 /* bind hp and internal speaker mute (with plug check) */
15714 static int alc662_ecs_master_sw_put(struct snd_kcontrol *kcontrol,
15715 struct snd_ctl_elem_value *ucontrol)
15716 {
15717 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
15718 long *valp = ucontrol->value.integer.value;
15719 int change;
15720
15721 change = snd_hda_codec_amp_update(codec, 0x1b, 0, HDA_OUTPUT, 0,
15722 HDA_AMP_MUTE,
15723 valp[0] ? 0 : HDA_AMP_MUTE);
15724 change |= snd_hda_codec_amp_update(codec, 0x1b, 1, HDA_OUTPUT, 0,
15725 HDA_AMP_MUTE,
15726 valp[1] ? 0 : HDA_AMP_MUTE);
15727 if (change)
15728 alc262_hippo1_automute(codec);
15729 return change;
15730 }
15731
15732 static struct snd_kcontrol_new alc662_ecs_mixer[] = {
15733 HDA_CODEC_VOLUME("Master Playback Volume", 0x02, 0x0, HDA_OUTPUT),
15734 {
15735 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
15736 .name = "Master Playback Switch",
15737 .info = snd_hda_mixer_amp_switch_info,
15738 .get = snd_hda_mixer_amp_switch_get,
15739 .put = alc662_ecs_master_sw_put,
15740 .private_value = HDA_COMPOSE_AMP_VAL(0x1b, 3, 0, HDA_OUTPUT),
15741 },
15742
15743 HDA_CODEC_VOLUME("e-Mic/LineIn Boost", 0x18, 0, HDA_INPUT),
15744 HDA_CODEC_VOLUME("e-Mic/LineIn Playback Volume", 0x0b, 0x0, HDA_INPUT),
15745 HDA_CODEC_MUTE("e-Mic/LineIn Playback Switch", 0x0b, 0x0, HDA_INPUT),
15746
15747 HDA_CODEC_VOLUME("i-Mic Boost", 0x19, 0, HDA_INPUT),
15748 HDA_CODEC_VOLUME("i-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
15749 HDA_CODEC_MUTE("i-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
15750 { } /* end */
15751 };
15752
15753 #ifdef CONFIG_SND_HDA_POWER_SAVE
15754 #define alc662_loopbacks alc880_loopbacks
15755 #endif
15756
15757
15758 /* pcm configuration: identiacal with ALC880 */
15759 #define alc662_pcm_analog_playback alc880_pcm_analog_playback
15760 #define alc662_pcm_analog_capture alc880_pcm_analog_capture
15761 #define alc662_pcm_digital_playback alc880_pcm_digital_playback
15762 #define alc662_pcm_digital_capture alc880_pcm_digital_capture
15763
15764 /*
15765 * configuration and preset
15766 */
15767 static const char *alc662_models[ALC662_MODEL_LAST] = {
15768 [ALC662_3ST_2ch_DIG] = "3stack-dig",
15769 [ALC662_3ST_6ch_DIG] = "3stack-6ch-dig",
15770 [ALC662_3ST_6ch] = "3stack-6ch",
15771 [ALC662_5ST_DIG] = "6stack-dig",
15772 [ALC662_LENOVO_101E] = "lenovo-101e",
15773 [ALC662_ASUS_EEEPC_P701] = "eeepc-p701",
15774 [ALC662_ASUS_EEEPC_EP20] = "eeepc-ep20",
15775 [ALC662_ECS] = "ecs",
15776 [ALC663_ASUS_M51VA] = "m51va",
15777 [ALC663_ASUS_G71V] = "g71v",
15778 [ALC663_ASUS_H13] = "h13",
15779 [ALC663_ASUS_G50V] = "g50v",
15780 [ALC663_ASUS_MODE1] = "asus-mode1",
15781 [ALC662_ASUS_MODE2] = "asus-mode2",
15782 [ALC663_ASUS_MODE3] = "asus-mode3",
15783 [ALC663_ASUS_MODE4] = "asus-mode4",
15784 [ALC663_ASUS_MODE5] = "asus-mode5",
15785 [ALC663_ASUS_MODE6] = "asus-mode6",
15786 [ALC662_AUTO] = "auto",
15787 };
15788
15789 static struct snd_pci_quirk alc662_cfg_tbl[] = {
15790 SND_PCI_QUIRK(0x1043, 0x1878, "ASUS M51VA", ALC663_ASUS_M51VA),
15791 SND_PCI_QUIRK(0x1043, 0x19a3, "ASUS G50V", ALC663_ASUS_G50V),
15792 SND_PCI_QUIRK(0x1043, 0x8290, "ASUS P5GC-MX", ALC662_3ST_6ch_DIG),
15793 SND_PCI_QUIRK(0x1043, 0x82a1, "ASUS Eeepc", ALC662_ASUS_EEEPC_P701),
15794 SND_PCI_QUIRK(0x1043, 0x82d1, "ASUS Eeepc EP20", ALC662_ASUS_EEEPC_EP20),
15795 SND_PCI_QUIRK(0x1043, 0x1903, "ASUS F5GL", ALC663_ASUS_MODE1),
15796 SND_PCI_QUIRK(0x1043, 0x1878, "ASUS M50Vr", ALC663_ASUS_MODE1),
15797 SND_PCI_QUIRK(0x1043, 0x1000, "ASUS N50Vm", ALC663_ASUS_MODE1),
15798 SND_PCI_QUIRK(0x1043, 0x19b3, "ASUS F7Z", ALC663_ASUS_MODE1),
15799 SND_PCI_QUIRK(0x1043, 0x1953, "ASUS NB", ALC663_ASUS_MODE1),
15800 SND_PCI_QUIRK(0x1043, 0x19a3, "ASUS NB", ALC663_ASUS_MODE1),
15801 SND_PCI_QUIRK(0x1043, 0x11d3, "ASUS NB", ALC663_ASUS_MODE1),
15802 SND_PCI_QUIRK(0x1043, 0x1203, "ASUS NB", ALC663_ASUS_MODE1),
15803 SND_PCI_QUIRK(0x1043, 0x19e3, "ASUS NB", ALC663_ASUS_MODE1),
15804 SND_PCI_QUIRK(0x1043, 0x1993, "ASUS N20", ALC663_ASUS_MODE1),
15805 SND_PCI_QUIRK(0x1043, 0x19c3, "ASUS F5Z/F6x", ALC662_ASUS_MODE2),
15806 SND_PCI_QUIRK(0x1043, 0x1339, "ASUS NB", ALC662_ASUS_MODE2),
15807 SND_PCI_QUIRK(0x1043, 0x1913, "ASUS NB", ALC662_ASUS_MODE2),
15808 SND_PCI_QUIRK(0x1043, 0x1843, "ASUS NB", ALC662_ASUS_MODE2),
15809 SND_PCI_QUIRK(0x1043, 0x1813, "ASUS NB", ALC662_ASUS_MODE2),
15810 SND_PCI_QUIRK(0x1043, 0x11f3, "ASUS NB", ALC662_ASUS_MODE2),
15811 SND_PCI_QUIRK(0x1043, 0x1876, "ASUS NB", ALC662_ASUS_MODE2),
15812 SND_PCI_QUIRK(0x1043, 0x1864, "ASUS NB", ALC662_ASUS_MODE2),
15813 SND_PCI_QUIRK(0x1043, 0x1783, "ASUS NB", ALC662_ASUS_MODE2),
15814 SND_PCI_QUIRK(0x1043, 0x1753, "ASUS NB", ALC662_ASUS_MODE2),
15815 SND_PCI_QUIRK(0x1043, 0x16c3, "ASUS NB", ALC662_ASUS_MODE2),
15816 SND_PCI_QUIRK(0x1043, 0x1933, "ASUS F80Q", ALC662_ASUS_MODE2),
15817 SND_PCI_QUIRK(0x1043, 0x1893, "ASUS M50Vm", ALC663_ASUS_MODE3),
15818 SND_PCI_QUIRK(0x1043, 0x11c3, "ASUS M70V", ALC663_ASUS_MODE3),
15819 SND_PCI_QUIRK(0x1043, 0x1963, "ASUS X71C", ALC663_ASUS_MODE3),
15820 SND_PCI_QUIRK(0x1043, 0x1894, "ASUS X55", ALC663_ASUS_MODE3),
15821 SND_PCI_QUIRK(0x1043, 0x1092, "ASUS NB", ALC663_ASUS_MODE3),
15822 SND_PCI_QUIRK(0x1043, 0x19f3, "ASUS NB", ALC663_ASUS_MODE4),
15823 SND_PCI_QUIRK(0x1043, 0x1823, "ASUS NB", ALC663_ASUS_MODE5),
15824 SND_PCI_QUIRK(0x1043, 0x1833, "ASUS NB", ALC663_ASUS_MODE6),
15825 SND_PCI_QUIRK(0x1043, 0x1763, "ASUS NB", ALC663_ASUS_MODE6),
15826 SND_PCI_QUIRK(0x1043, 0x1765, "ASUS NB", ALC663_ASUS_MODE6),
15827 SND_PCI_QUIRK(0x105b, 0x0d47, "Foxconn 45CMX/45GMX/45CMX-K",
15828 ALC662_3ST_6ch_DIG),
15829 SND_PCI_QUIRK(0x17aa, 0x101e, "Lenovo", ALC662_LENOVO_101E),
15830 SND_PCI_QUIRK(0x1019, 0x9087, "ECS", ALC662_ECS),
15831 SND_PCI_QUIRK(0x105b, 0x0cd6, "Foxconn", ALC662_ECS),
15832 SND_PCI_QUIRK(0x1458, 0xa002, "Gigabyte 945GCM-S2L",
15833 ALC662_3ST_6ch_DIG),
15834 SND_PCI_QUIRK(0x1565, 0x820f, "Biostar TA780G M2+", ALC662_3ST_6ch_DIG),
15835 SND_PCI_QUIRK(0x1849, 0x3662, "ASROCK K10N78FullHD-hSLI R3.0",
15836 ALC662_3ST_6ch_DIG),
15837 SND_PCI_QUIRK(0x1854, 0x2000, "ASUS H13-2000", ALC663_ASUS_H13),
15838 SND_PCI_QUIRK(0x1854, 0x2001, "ASUS H13-2001", ALC663_ASUS_H13),
15839 SND_PCI_QUIRK(0x1854, 0x2002, "ASUS H13-2002", ALC663_ASUS_H13),
15840 {}
15841 };
15842
15843 static struct alc_config_preset alc662_presets[] = {
15844 [ALC662_3ST_2ch_DIG] = {
15845 .mixers = { alc662_3ST_2ch_mixer, alc662_capture_mixer },
15846 .init_verbs = { alc662_init_verbs },
15847 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
15848 .dac_nids = alc662_dac_nids,
15849 .dig_out_nid = ALC662_DIGOUT_NID,
15850 .dig_in_nid = ALC662_DIGIN_NID,
15851 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
15852 .channel_mode = alc662_3ST_2ch_modes,
15853 .input_mux = &alc662_capture_source,
15854 },
15855 [ALC662_3ST_6ch_DIG] = {
15856 .mixers = { alc662_3ST_6ch_mixer, alc662_chmode_mixer,
15857 alc662_capture_mixer },
15858 .init_verbs = { alc662_init_verbs },
15859 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
15860 .dac_nids = alc662_dac_nids,
15861 .dig_out_nid = ALC662_DIGOUT_NID,
15862 .dig_in_nid = ALC662_DIGIN_NID,
15863 .num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes),
15864 .channel_mode = alc662_3ST_6ch_modes,
15865 .need_dac_fix = 1,
15866 .input_mux = &alc662_capture_source,
15867 },
15868 [ALC662_3ST_6ch] = {
15869 .mixers = { alc662_3ST_6ch_mixer, alc662_chmode_mixer,
15870 alc662_capture_mixer },
15871 .init_verbs = { alc662_init_verbs },
15872 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
15873 .dac_nids = alc662_dac_nids,
15874 .num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes),
15875 .channel_mode = alc662_3ST_6ch_modes,
15876 .need_dac_fix = 1,
15877 .input_mux = &alc662_capture_source,
15878 },
15879 [ALC662_5ST_DIG] = {
15880 .mixers = { alc662_base_mixer, alc662_chmode_mixer,
15881 alc662_capture_mixer },
15882 .init_verbs = { alc662_init_verbs },
15883 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
15884 .dac_nids = alc662_dac_nids,
15885 .dig_out_nid = ALC662_DIGOUT_NID,
15886 .dig_in_nid = ALC662_DIGIN_NID,
15887 .num_channel_mode = ARRAY_SIZE(alc662_5stack_modes),
15888 .channel_mode = alc662_5stack_modes,
15889 .input_mux = &alc662_capture_source,
15890 },
15891 [ALC662_LENOVO_101E] = {
15892 .mixers = { alc662_lenovo_101e_mixer, alc662_capture_mixer },
15893 .init_verbs = { alc662_init_verbs, alc662_sue_init_verbs },
15894 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
15895 .dac_nids = alc662_dac_nids,
15896 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
15897 .channel_mode = alc662_3ST_2ch_modes,
15898 .input_mux = &alc662_lenovo_101e_capture_source,
15899 .unsol_event = alc662_lenovo_101e_unsol_event,
15900 .init_hook = alc662_lenovo_101e_all_automute,
15901 },
15902 [ALC662_ASUS_EEEPC_P701] = {
15903 .mixers = { alc662_eeepc_p701_mixer, alc662_capture_mixer },
15904 .init_verbs = { alc662_init_verbs,
15905 alc662_eeepc_sue_init_verbs },
15906 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
15907 .dac_nids = alc662_dac_nids,
15908 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
15909 .channel_mode = alc662_3ST_2ch_modes,
15910 .input_mux = &alc662_eeepc_capture_source,
15911 .unsol_event = alc662_eeepc_unsol_event,
15912 .init_hook = alc662_eeepc_inithook,
15913 },
15914 [ALC662_ASUS_EEEPC_EP20] = {
15915 .mixers = { alc662_eeepc_ep20_mixer, alc662_capture_mixer,
15916 alc662_chmode_mixer },
15917 .init_verbs = { alc662_init_verbs,
15918 alc662_eeepc_ep20_sue_init_verbs },
15919 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
15920 .dac_nids = alc662_dac_nids,
15921 .num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes),
15922 .channel_mode = alc662_3ST_6ch_modes,
15923 .input_mux = &alc662_lenovo_101e_capture_source,
15924 .unsol_event = alc662_eeepc_ep20_unsol_event,
15925 .init_hook = alc662_eeepc_ep20_inithook,
15926 },
15927 [ALC662_ECS] = {
15928 .mixers = { alc662_ecs_mixer, alc662_capture_mixer },
15929 .init_verbs = { alc662_init_verbs,
15930 alc662_ecs_init_verbs },
15931 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
15932 .dac_nids = alc662_dac_nids,
15933 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
15934 .channel_mode = alc662_3ST_2ch_modes,
15935 .input_mux = &alc662_eeepc_capture_source,
15936 .unsol_event = alc662_eeepc_unsol_event,
15937 .init_hook = alc662_eeepc_inithook,
15938 },
15939 [ALC663_ASUS_M51VA] = {
15940 .mixers = { alc663_m51va_mixer, alc662_capture_mixer},
15941 .init_verbs = { alc662_init_verbs, alc663_m51va_init_verbs },
15942 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
15943 .dac_nids = alc662_dac_nids,
15944 .dig_out_nid = ALC662_DIGOUT_NID,
15945 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
15946 .channel_mode = alc662_3ST_2ch_modes,
15947 .input_mux = &alc663_m51va_capture_source,
15948 .unsol_event = alc663_m51va_unsol_event,
15949 .init_hook = alc663_m51va_inithook,
15950 },
15951 [ALC663_ASUS_G71V] = {
15952 .mixers = { alc663_g71v_mixer, alc662_capture_mixer},
15953 .init_verbs = { alc662_init_verbs, alc663_g71v_init_verbs },
15954 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
15955 .dac_nids = alc662_dac_nids,
15956 .dig_out_nid = ALC662_DIGOUT_NID,
15957 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
15958 .channel_mode = alc662_3ST_2ch_modes,
15959 .input_mux = &alc662_eeepc_capture_source,
15960 .unsol_event = alc663_g71v_unsol_event,
15961 .init_hook = alc663_g71v_inithook,
15962 },
15963 [ALC663_ASUS_H13] = {
15964 .mixers = { alc663_m51va_mixer, alc662_capture_mixer},
15965 .init_verbs = { alc662_init_verbs, alc663_m51va_init_verbs },
15966 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
15967 .dac_nids = alc662_dac_nids,
15968 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
15969 .channel_mode = alc662_3ST_2ch_modes,
15970 .input_mux = &alc663_m51va_capture_source,
15971 .unsol_event = alc663_m51va_unsol_event,
15972 .init_hook = alc663_m51va_inithook,
15973 },
15974 [ALC663_ASUS_G50V] = {
15975 .mixers = { alc663_g50v_mixer, alc662_capture_mixer},
15976 .init_verbs = { alc662_init_verbs, alc663_g50v_init_verbs },
15977 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
15978 .dac_nids = alc662_dac_nids,
15979 .dig_out_nid = ALC662_DIGOUT_NID,
15980 .num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes),
15981 .channel_mode = alc662_3ST_6ch_modes,
15982 .input_mux = &alc663_capture_source,
15983 .unsol_event = alc663_g50v_unsol_event,
15984 .init_hook = alc663_g50v_inithook,
15985 },
15986 [ALC663_ASUS_MODE1] = {
15987 .mixers = { alc663_m51va_mixer, alc662_auto_capture_mixer },
15988 .init_verbs = { alc662_init_verbs,
15989 alc663_21jd_amic_init_verbs },
15990 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
15991 .hp_nid = 0x03,
15992 .dac_nids = alc662_dac_nids,
15993 .dig_out_nid = ALC662_DIGOUT_NID,
15994 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
15995 .channel_mode = alc662_3ST_2ch_modes,
15996 .input_mux = &alc662_eeepc_capture_source,
15997 .unsol_event = alc663_mode1_unsol_event,
15998 .init_hook = alc663_mode1_inithook,
15999 },
16000 [ALC662_ASUS_MODE2] = {
16001 .mixers = { alc662_1bjd_mixer, alc662_auto_capture_mixer },
16002 .init_verbs = { alc662_init_verbs,
16003 alc662_1bjd_amic_init_verbs },
16004 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16005 .dac_nids = alc662_dac_nids,
16006 .dig_out_nid = ALC662_DIGOUT_NID,
16007 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
16008 .channel_mode = alc662_3ST_2ch_modes,
16009 .input_mux = &alc662_eeepc_capture_source,
16010 .unsol_event = alc662_mode2_unsol_event,
16011 .init_hook = alc662_mode2_inithook,
16012 },
16013 [ALC663_ASUS_MODE3] = {
16014 .mixers = { alc663_two_hp_m1_mixer, alc662_auto_capture_mixer },
16015 .init_verbs = { alc662_init_verbs,
16016 alc663_two_hp_amic_m1_init_verbs },
16017 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16018 .hp_nid = 0x03,
16019 .dac_nids = alc662_dac_nids,
16020 .dig_out_nid = ALC662_DIGOUT_NID,
16021 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
16022 .channel_mode = alc662_3ST_2ch_modes,
16023 .input_mux = &alc662_eeepc_capture_source,
16024 .unsol_event = alc663_mode3_unsol_event,
16025 .init_hook = alc663_mode3_inithook,
16026 },
16027 [ALC663_ASUS_MODE4] = {
16028 .mixers = { alc663_asus_21jd_clfe_mixer,
16029 alc662_auto_capture_mixer},
16030 .init_verbs = { alc662_init_verbs,
16031 alc663_21jd_amic_init_verbs},
16032 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16033 .hp_nid = 0x03,
16034 .dac_nids = alc662_dac_nids,
16035 .dig_out_nid = ALC662_DIGOUT_NID,
16036 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
16037 .channel_mode = alc662_3ST_2ch_modes,
16038 .input_mux = &alc662_eeepc_capture_source,
16039 .unsol_event = alc663_mode4_unsol_event,
16040 .init_hook = alc663_mode4_inithook,
16041 },
16042 [ALC663_ASUS_MODE5] = {
16043 .mixers = { alc663_asus_15jd_clfe_mixer,
16044 alc662_auto_capture_mixer },
16045 .init_verbs = { alc662_init_verbs,
16046 alc663_15jd_amic_init_verbs },
16047 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16048 .hp_nid = 0x03,
16049 .dac_nids = alc662_dac_nids,
16050 .dig_out_nid = ALC662_DIGOUT_NID,
16051 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
16052 .channel_mode = alc662_3ST_2ch_modes,
16053 .input_mux = &alc662_eeepc_capture_source,
16054 .unsol_event = alc663_mode5_unsol_event,
16055 .init_hook = alc663_mode5_inithook,
16056 },
16057 [ALC663_ASUS_MODE6] = {
16058 .mixers = { alc663_two_hp_m2_mixer, alc662_auto_capture_mixer },
16059 .init_verbs = { alc662_init_verbs,
16060 alc663_two_hp_amic_m2_init_verbs },
16061 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16062 .hp_nid = 0x03,
16063 .dac_nids = alc662_dac_nids,
16064 .dig_out_nid = ALC662_DIGOUT_NID,
16065 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
16066 .channel_mode = alc662_3ST_2ch_modes,
16067 .input_mux = &alc662_eeepc_capture_source,
16068 .unsol_event = alc663_mode6_unsol_event,
16069 .init_hook = alc663_mode6_inithook,
16070 },
16071 };
16072
16073
16074 /*
16075 * BIOS auto configuration
16076 */
16077
16078 /* add playback controls from the parsed DAC table */
16079 static int alc662_auto_create_multi_out_ctls(struct alc_spec *spec,
16080 const struct auto_pin_cfg *cfg)
16081 {
16082 char name[32];
16083 static const char *chname[4] = {
16084 "Front", "Surround", NULL /*CLFE*/, "Side"
16085 };
16086 hda_nid_t nid;
16087 int i, err;
16088
16089 for (i = 0; i < cfg->line_outs; i++) {
16090 if (!spec->multiout.dac_nids[i])
16091 continue;
16092 nid = alc880_idx_to_dac(i);
16093 if (i == 2) {
16094 /* Center/LFE */
16095 err = add_control(spec, ALC_CTL_WIDGET_VOL,
16096 "Center Playback Volume",
16097 HDA_COMPOSE_AMP_VAL(nid, 1, 0,
16098 HDA_OUTPUT));
16099 if (err < 0)
16100 return err;
16101 err = add_control(spec, ALC_CTL_WIDGET_VOL,
16102 "LFE Playback Volume",
16103 HDA_COMPOSE_AMP_VAL(nid, 2, 0,
16104 HDA_OUTPUT));
16105 if (err < 0)
16106 return err;
16107 err = add_control(spec, ALC_CTL_WIDGET_MUTE,
16108 "Center Playback Switch",
16109 HDA_COMPOSE_AMP_VAL(0x0e, 1, 0,
16110 HDA_INPUT));
16111 if (err < 0)
16112 return err;
16113 err = add_control(spec, ALC_CTL_WIDGET_MUTE,
16114 "LFE Playback Switch",
16115 HDA_COMPOSE_AMP_VAL(0x0e, 2, 0,
16116 HDA_INPUT));
16117 if (err < 0)
16118 return err;
16119 } else {
16120 sprintf(name, "%s Playback Volume", chname[i]);
16121 err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
16122 HDA_COMPOSE_AMP_VAL(nid, 3, 0,
16123 HDA_OUTPUT));
16124 if (err < 0)
16125 return err;
16126 sprintf(name, "%s Playback Switch", chname[i]);
16127 err = add_control(spec, ALC_CTL_WIDGET_MUTE, name,
16128 HDA_COMPOSE_AMP_VAL(alc880_idx_to_mixer(i),
16129 3, 0, HDA_INPUT));
16130 if (err < 0)
16131 return err;
16132 }
16133 }
16134 return 0;
16135 }
16136
16137 /* add playback controls for speaker and HP outputs */
16138 static int alc662_auto_create_extra_out(struct alc_spec *spec, hda_nid_t pin,
16139 const char *pfx)
16140 {
16141 hda_nid_t nid;
16142 int err;
16143 char name[32];
16144
16145 if (!pin)
16146 return 0;
16147
16148 if (pin == 0x17) {
16149 /* ALC663 has a mono output pin on 0x17 */
16150 sprintf(name, "%s Playback Switch", pfx);
16151 err = add_control(spec, ALC_CTL_WIDGET_MUTE, name,
16152 HDA_COMPOSE_AMP_VAL(pin, 2, 0, HDA_OUTPUT));
16153 return err;
16154 }
16155
16156 if (alc880_is_fixed_pin(pin)) {
16157 nid = alc880_idx_to_dac(alc880_fixed_pin_idx(pin));
16158 /* printk("DAC nid=%x\n",nid); */
16159 /* specify the DAC as the extra output */
16160 if (!spec->multiout.hp_nid)
16161 spec->multiout.hp_nid = nid;
16162 else
16163 spec->multiout.extra_out_nid[0] = nid;
16164 /* control HP volume/switch on the output mixer amp */
16165 nid = alc880_idx_to_dac(alc880_fixed_pin_idx(pin));
16166 sprintf(name, "%s Playback Volume", pfx);
16167 err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
16168 HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT));
16169 if (err < 0)
16170 return err;
16171 sprintf(name, "%s Playback Switch", pfx);
16172 err = add_control(spec, ALC_CTL_BIND_MUTE, name,
16173 HDA_COMPOSE_AMP_VAL(nid, 3, 2, HDA_INPUT));
16174 if (err < 0)
16175 return err;
16176 } else if (alc880_is_multi_pin(pin)) {
16177 /* set manual connection */
16178 /* we have only a switch on HP-out PIN */
16179 sprintf(name, "%s Playback Switch", pfx);
16180 err = add_control(spec, ALC_CTL_WIDGET_MUTE, name,
16181 HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
16182 if (err < 0)
16183 return err;
16184 }
16185 return 0;
16186 }
16187
16188 /* create playback/capture controls for input pins */
16189 static int alc662_auto_create_analog_input_ctls(struct alc_spec *spec,
16190 const struct auto_pin_cfg *cfg)
16191 {
16192 struct hda_input_mux *imux = &spec->private_imux;
16193 int i, err, idx;
16194
16195 for (i = 0; i < AUTO_PIN_LAST; i++) {
16196 if (alc880_is_input_pin(cfg->input_pins[i])) {
16197 idx = alc880_input_pin_idx(cfg->input_pins[i]);
16198 err = new_analog_input(spec, cfg->input_pins[i],
16199 auto_pin_cfg_labels[i],
16200 idx, 0x0b);
16201 if (err < 0)
16202 return err;
16203 imux->items[imux->num_items].label =
16204 auto_pin_cfg_labels[i];
16205 imux->items[imux->num_items].index =
16206 alc880_input_pin_idx(cfg->input_pins[i]);
16207 imux->num_items++;
16208 }
16209 }
16210 return 0;
16211 }
16212
16213 static void alc662_auto_set_output_and_unmute(struct hda_codec *codec,
16214 hda_nid_t nid, int pin_type,
16215 int dac_idx)
16216 {
16217 alc_set_pin_output(codec, nid, pin_type);
16218 /* need the manual connection? */
16219 if (alc880_is_multi_pin(nid)) {
16220 struct alc_spec *spec = codec->spec;
16221 int idx = alc880_multi_pin_idx(nid);
16222 snd_hda_codec_write(codec, alc880_idx_to_selector(idx), 0,
16223 AC_VERB_SET_CONNECT_SEL,
16224 alc880_dac_to_idx(spec->multiout.dac_nids[dac_idx]));
16225 }
16226 }
16227
16228 static void alc662_auto_init_multi_out(struct hda_codec *codec)
16229 {
16230 struct alc_spec *spec = codec->spec;
16231 int i;
16232
16233 alc_subsystem_id(codec, 0x15, 0x1b, 0x14);
16234 for (i = 0; i <= HDA_SIDE; i++) {
16235 hda_nid_t nid = spec->autocfg.line_out_pins[i];
16236 int pin_type = get_pin_type(spec->autocfg.line_out_type);
16237 if (nid)
16238 alc662_auto_set_output_and_unmute(codec, nid, pin_type,
16239 i);
16240 }
16241 }
16242
16243 static void alc662_auto_init_hp_out(struct hda_codec *codec)
16244 {
16245 struct alc_spec *spec = codec->spec;
16246 hda_nid_t pin;
16247
16248 pin = spec->autocfg.hp_pins[0];
16249 if (pin) /* connect to front */
16250 /* use dac 0 */
16251 alc662_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
16252 pin = spec->autocfg.speaker_pins[0];
16253 if (pin)
16254 alc662_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
16255 }
16256
16257 #define alc662_is_input_pin(nid) alc880_is_input_pin(nid)
16258 #define ALC662_PIN_CD_NID ALC880_PIN_CD_NID
16259
16260 static void alc662_auto_init_analog_input(struct hda_codec *codec)
16261 {
16262 struct alc_spec *spec = codec->spec;
16263 int i;
16264
16265 for (i = 0; i < AUTO_PIN_LAST; i++) {
16266 hda_nid_t nid = spec->autocfg.input_pins[i];
16267 if (alc662_is_input_pin(nid)) {
16268 snd_hda_codec_write(codec, nid, 0,
16269 AC_VERB_SET_PIN_WIDGET_CONTROL,
16270 (i <= AUTO_PIN_FRONT_MIC ?
16271 PIN_VREF80 : PIN_IN));
16272 if (nid != ALC662_PIN_CD_NID)
16273 snd_hda_codec_write(codec, nid, 0,
16274 AC_VERB_SET_AMP_GAIN_MUTE,
16275 AMP_OUT_MUTE);
16276 }
16277 }
16278 }
16279
16280 #define alc662_auto_init_input_src alc882_auto_init_input_src
16281
16282 static int alc662_parse_auto_config(struct hda_codec *codec)
16283 {
16284 struct alc_spec *spec = codec->spec;
16285 int err;
16286 static hda_nid_t alc662_ignore[] = { 0x1d, 0 };
16287
16288 err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
16289 alc662_ignore);
16290 if (err < 0)
16291 return err;
16292 if (!spec->autocfg.line_outs)
16293 return 0; /* can't find valid BIOS pin config */
16294
16295 err = alc880_auto_fill_dac_nids(spec, &spec->autocfg);
16296 if (err < 0)
16297 return err;
16298 err = alc662_auto_create_multi_out_ctls(spec, &spec->autocfg);
16299 if (err < 0)
16300 return err;
16301 err = alc662_auto_create_extra_out(spec,
16302 spec->autocfg.speaker_pins[0],
16303 "Speaker");
16304 if (err < 0)
16305 return err;
16306 err = alc662_auto_create_extra_out(spec, spec->autocfg.hp_pins[0],
16307 "Headphone");
16308 if (err < 0)
16309 return err;
16310 err = alc662_auto_create_analog_input_ctls(spec, &spec->autocfg);
16311 if (err < 0)
16312 return err;
16313
16314 spec->multiout.max_channels = spec->multiout.num_dacs * 2;
16315
16316 if (spec->autocfg.dig_out_pin)
16317 spec->multiout.dig_out_nid = ALC880_DIGOUT_NID;
16318
16319 if (spec->kctl_alloc)
16320 spec->mixers[spec->num_mixers++] = spec->kctl_alloc;
16321
16322 spec->num_mux_defs = 1;
16323 spec->input_mux = &spec->private_imux;
16324
16325 spec->init_verbs[spec->num_init_verbs++] = alc662_auto_init_verbs;
16326 if (codec->vendor_id == 0x10ec0663)
16327 spec->init_verbs[spec->num_init_verbs++] =
16328 alc663_auto_init_verbs;
16329
16330 err = alc_auto_add_mic_boost(codec);
16331 if (err < 0)
16332 return err;
16333
16334 spec->mixers[spec->num_mixers] = alc662_capture_mixer;
16335 spec->num_mixers++;
16336
16337 store_pin_configs(codec);
16338 return 1;
16339 }
16340
16341 /* additional initialization for auto-configuration model */
16342 static void alc662_auto_init(struct hda_codec *codec)
16343 {
16344 struct alc_spec *spec = codec->spec;
16345 alc662_auto_init_multi_out(codec);
16346 alc662_auto_init_hp_out(codec);
16347 alc662_auto_init_analog_input(codec);
16348 alc662_auto_init_input_src(codec);
16349 if (spec->unsol_event)
16350 alc_inithook(codec);
16351 }
16352
16353 static int patch_alc662(struct hda_codec *codec)
16354 {
16355 struct alc_spec *spec;
16356 int err, board_config;
16357
16358 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
16359 if (!spec)
16360 return -ENOMEM;
16361
16362 codec->spec = spec;
16363
16364 alc_fix_pll_init(codec, 0x20, 0x04, 15);
16365
16366 board_config = snd_hda_check_board_config(codec, ALC662_MODEL_LAST,
16367 alc662_models,
16368 alc662_cfg_tbl);
16369 if (board_config < 0) {
16370 printk(KERN_INFO "hda_codec: Unknown model for ALC662, "
16371 "trying auto-probe from BIOS...\n");
16372 board_config = ALC662_AUTO;
16373 }
16374
16375 if (board_config == ALC662_AUTO) {
16376 /* automatic parse from the BIOS config */
16377 err = alc662_parse_auto_config(codec);
16378 if (err < 0) {
16379 alc_free(codec);
16380 return err;
16381 } else if (!err) {
16382 printk(KERN_INFO
16383 "hda_codec: Cannot set up configuration "
16384 "from BIOS. Using base mode...\n");
16385 board_config = ALC662_3ST_2ch_DIG;
16386 }
16387 }
16388
16389 if (board_config != ALC662_AUTO)
16390 setup_preset(spec, &alc662_presets[board_config]);
16391
16392 if (codec->vendor_id == 0x10ec0663) {
16393 spec->stream_name_analog = "ALC663 Analog";
16394 spec->stream_name_digital = "ALC663 Digital";
16395 } else if (codec->vendor_id == 0x10ec0272) {
16396 spec->stream_name_analog = "ALC272 Analog";
16397 spec->stream_name_digital = "ALC272 Digital";
16398 } else {
16399 spec->stream_name_analog = "ALC662 Analog";
16400 spec->stream_name_digital = "ALC662 Digital";
16401 }
16402
16403 spec->stream_analog_playback = &alc662_pcm_analog_playback;
16404 spec->stream_analog_capture = &alc662_pcm_analog_capture;
16405
16406 spec->stream_digital_playback = &alc662_pcm_digital_playback;
16407 spec->stream_digital_capture = &alc662_pcm_digital_capture;
16408
16409 spec->adc_nids = alc662_adc_nids;
16410 spec->num_adc_nids = ARRAY_SIZE(alc662_adc_nids);
16411 spec->capsrc_nids = alc662_capsrc_nids;
16412
16413 spec->vmaster_nid = 0x02;
16414
16415 codec->patch_ops = alc_patch_ops;
16416 if (board_config == ALC662_AUTO)
16417 spec->init_hook = alc662_auto_init;
16418 #ifdef CONFIG_SND_HDA_POWER_SAVE
16419 if (!spec->loopback.amplist)
16420 spec->loopback.amplist = alc662_loopbacks;
16421 #endif
16422
16423 return 0;
16424 }
16425
16426 /*
16427 * patch entries
16428 */
16429 struct hda_codec_preset snd_hda_preset_realtek[] = {
16430 { .id = 0x10ec0260, .name = "ALC260", .patch = patch_alc260 },
16431 { .id = 0x10ec0262, .name = "ALC262", .patch = patch_alc262 },
16432 { .id = 0x10ec0267, .name = "ALC267", .patch = patch_alc268 },
16433 { .id = 0x10ec0268, .name = "ALC268", .patch = patch_alc268 },
16434 { .id = 0x10ec0269, .name = "ALC269", .patch = patch_alc269 },
16435 { .id = 0x10ec0272, .name = "ALC272", .patch = patch_alc662 },
16436 { .id = 0x10ec0861, .rev = 0x100340, .name = "ALC660",
16437 .patch = patch_alc861 },
16438 { .id = 0x10ec0660, .name = "ALC660-VD", .patch = patch_alc861vd },
16439 { .id = 0x10ec0861, .name = "ALC861", .patch = patch_alc861 },
16440 { .id = 0x10ec0862, .name = "ALC861-VD", .patch = patch_alc861vd },
16441 { .id = 0x10ec0662, .rev = 0x100002, .name = "ALC662 rev2",
16442 .patch = patch_alc883 },
16443 { .id = 0x10ec0662, .rev = 0x100101, .name = "ALC662 rev1",
16444 .patch = patch_alc662 },
16445 { .id = 0x10ec0663, .name = "ALC663", .patch = patch_alc662 },
16446 { .id = 0x10ec0880, .name = "ALC880", .patch = patch_alc880 },
16447 { .id = 0x10ec0882, .name = "ALC882", .patch = patch_alc882 },
16448 { .id = 0x10ec0883, .name = "ALC883", .patch = patch_alc883 },
16449 { .id = 0x10ec0885, .rev = 0x100101, .name = "ALC889A",
16450 .patch = patch_alc882 }, /* should be patch_alc883() in future */
16451 { .id = 0x10ec0885, .rev = 0x100103, .name = "ALC889A",
16452 .patch = patch_alc882 }, /* should be patch_alc883() in future */
16453 { .id = 0x10ec0885, .name = "ALC885", .patch = patch_alc882 },
16454 { .id = 0x10ec0887, .name = "ALC887", .patch = patch_alc883 },
16455 { .id = 0x10ec0888, .name = "ALC888", .patch = patch_alc883 },
16456 { .id = 0x10ec0888, .rev = 0x100101, .name = "ALC1200",
16457 .patch = patch_alc883 },
16458 { .id = 0x10ec0889, .name = "ALC889", .patch = patch_alc883 },
16459 {} /* terminator */
16460 };
ubuntu-bionic-kernel mirror