2 * Universal Interface for Intel High Definition Audio Codec
4 * HD audio interface patch for ALC 260/880/882 codecs
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>
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.
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.
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
26 #include <sound/driver.h>
27 #include <linux/init.h>
28 #include <linux/delay.h>
29 #include <linux/slab.h>
30 #include <linux/pci.h>
31 #include <sound/core.h>
32 #include "hda_codec.h"
33 #include "hda_local.h"
36 /* ALC880 board config type */
56 #ifdef CONFIG_SND_DEBUG
60 ALC880_MODEL_LAST
/* last tag */
70 #ifdef CONFIG_SND_DEBUG
74 ALC260_MODEL_LAST
/* last tag */
84 ALC262_MODEL_LAST
/* last tag */
120 #define GPIO_MASK 0x03
123 /* codec parameterization */
124 struct snd_kcontrol_new
*mixers
[5]; /* mixer arrays */
125 unsigned int num_mixers
;
127 const struct hda_verb
*init_verbs
[5]; /* initialization verbs
131 unsigned int num_init_verbs
;
133 char *stream_name_analog
; /* analog PCM stream */
134 struct hda_pcm_stream
*stream_analog_playback
;
135 struct hda_pcm_stream
*stream_analog_capture
;
137 char *stream_name_digital
; /* digital PCM stream */
138 struct hda_pcm_stream
*stream_digital_playback
;
139 struct hda_pcm_stream
*stream_digital_capture
;
142 struct hda_multi_out multiout
; /* playback set-up
143 * max_channels, dacs must be set
144 * dig_out_nid and hp_nid are optional
148 unsigned int num_adc_nids
;
150 hda_nid_t dig_in_nid
; /* digital-in NID; optional */
153 unsigned int num_mux_defs
;
154 const struct hda_input_mux
*input_mux
;
155 unsigned int cur_mux
[3];
158 const struct hda_channel_mode
*channel_mode
;
159 int num_channel_mode
;
162 /* PCM information */
163 struct hda_pcm pcm_rec
[3]; /* used in alc_build_pcms() */
165 /* dynamic controls, init_verbs and input_mux */
166 struct auto_pin_cfg autocfg
;
167 unsigned int num_kctl_alloc
, num_kctl_used
;
168 struct snd_kcontrol_new
*kctl_alloc
;
169 struct hda_input_mux private_imux
;
170 hda_nid_t private_dac_nids
[5];
173 void (*init_hook
)(struct hda_codec
*codec
);
174 void (*unsol_event
)(struct hda_codec
*codec
, unsigned int res
);
176 /* for pin sensing */
177 unsigned int sense_updated
: 1;
178 unsigned int jack_present
: 1;
182 * configuration template - to be copied to the spec instance
184 struct alc_config_preset
{
185 struct snd_kcontrol_new
*mixers
[5]; /* should be identical size
188 const struct hda_verb
*init_verbs
[5];
189 unsigned int num_dacs
;
191 hda_nid_t dig_out_nid
; /* optional */
192 hda_nid_t hp_nid
; /* optional */
193 unsigned int num_adc_nids
;
195 hda_nid_t dig_in_nid
;
196 unsigned int num_channel_mode
;
197 const struct hda_channel_mode
*channel_mode
;
199 unsigned int num_mux_defs
;
200 const struct hda_input_mux
*input_mux
;
201 void (*unsol_event
)(struct hda_codec
*, unsigned int);
202 void (*init_hook
)(struct hda_codec
*);
209 static int alc_mux_enum_info(struct snd_kcontrol
*kcontrol
,
210 struct snd_ctl_elem_info
*uinfo
)
212 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
213 struct alc_spec
*spec
= codec
->spec
;
214 unsigned int mux_idx
= snd_ctl_get_ioffidx(kcontrol
, &uinfo
->id
);
215 if (mux_idx
>= spec
->num_mux_defs
)
217 return snd_hda_input_mux_info(&spec
->input_mux
[mux_idx
], uinfo
);
220 static int alc_mux_enum_get(struct snd_kcontrol
*kcontrol
,
221 struct snd_ctl_elem_value
*ucontrol
)
223 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
224 struct alc_spec
*spec
= codec
->spec
;
225 unsigned int adc_idx
= snd_ctl_get_ioffidx(kcontrol
, &ucontrol
->id
);
227 ucontrol
->value
.enumerated
.item
[0] = spec
->cur_mux
[adc_idx
];
231 static int alc_mux_enum_put(struct snd_kcontrol
*kcontrol
,
232 struct snd_ctl_elem_value
*ucontrol
)
234 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
235 struct alc_spec
*spec
= codec
->spec
;
236 unsigned int adc_idx
= snd_ctl_get_ioffidx(kcontrol
, &ucontrol
->id
);
237 unsigned int mux_idx
= adc_idx
>= spec
->num_mux_defs
? 0 : adc_idx
;
238 return snd_hda_input_mux_put(codec
, &spec
->input_mux
[mux_idx
], ucontrol
,
239 spec
->adc_nids
[adc_idx
],
240 &spec
->cur_mux
[adc_idx
]);
245 * channel mode setting
247 static int alc_ch_mode_info(struct snd_kcontrol
*kcontrol
,
248 struct snd_ctl_elem_info
*uinfo
)
250 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
251 struct alc_spec
*spec
= codec
->spec
;
252 return snd_hda_ch_mode_info(codec
, uinfo
, spec
->channel_mode
,
253 spec
->num_channel_mode
);
256 static int alc_ch_mode_get(struct snd_kcontrol
*kcontrol
,
257 struct snd_ctl_elem_value
*ucontrol
)
259 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
260 struct alc_spec
*spec
= codec
->spec
;
261 return snd_hda_ch_mode_get(codec
, ucontrol
, spec
->channel_mode
,
262 spec
->num_channel_mode
,
263 spec
->multiout
.max_channels
);
266 static int alc_ch_mode_put(struct snd_kcontrol
*kcontrol
,
267 struct snd_ctl_elem_value
*ucontrol
)
269 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
270 struct alc_spec
*spec
= codec
->spec
;
271 int err
= snd_hda_ch_mode_put(codec
, ucontrol
, spec
->channel_mode
,
272 spec
->num_channel_mode
,
273 &spec
->multiout
.max_channels
);
274 if (err
>= 0 && spec
->need_dac_fix
)
275 spec
->multiout
.num_dacs
= spec
->multiout
.max_channels
/ 2;
280 * Control the mode of pin widget settings via the mixer. "pc" is used
281 * instead of "%" to avoid consequences of accidently treating the % as
282 * being part of a format specifier. Maximum allowed length of a value is
283 * 63 characters plus NULL terminator.
285 * Note: some retasking pin complexes seem to ignore requests for input
286 * states other than HiZ (eg: PIN_VREFxx) and revert to HiZ if any of these
287 * are requested. Therefore order this list so that this behaviour will not
288 * cause problems when mixer clients move through the enum sequentially.
289 * NIDs 0x0f and 0x10 have been observed to have this behaviour as of
292 static char *alc_pin_mode_names
[] = {
293 "Mic 50pc bias", "Mic 80pc bias",
294 "Line in", "Line out", "Headphone out",
296 static unsigned char alc_pin_mode_values
[] = {
297 PIN_VREF50
, PIN_VREF80
, PIN_IN
, PIN_OUT
, PIN_HP
,
299 /* The control can present all 5 options, or it can limit the options based
300 * in the pin being assumed to be exclusively an input or an output pin. In
301 * addition, "input" pins may or may not process the mic bias option
302 * depending on actual widget capability (NIDs 0x0f and 0x10 don't seem to
303 * accept requests for bias as of chip versions up to March 2006) and/or
304 * wiring in the computer.
306 #define ALC_PIN_DIR_IN 0x00
307 #define ALC_PIN_DIR_OUT 0x01
308 #define ALC_PIN_DIR_INOUT 0x02
309 #define ALC_PIN_DIR_IN_NOMICBIAS 0x03
310 #define ALC_PIN_DIR_INOUT_NOMICBIAS 0x04
312 /* Info about the pin modes supported by the different pin direction modes.
313 * For each direction the minimum and maximum values are given.
315 static signed char alc_pin_mode_dir_info
[5][2] = {
316 { 0, 2 }, /* ALC_PIN_DIR_IN */
317 { 3, 4 }, /* ALC_PIN_DIR_OUT */
318 { 0, 4 }, /* ALC_PIN_DIR_INOUT */
319 { 2, 2 }, /* ALC_PIN_DIR_IN_NOMICBIAS */
320 { 2, 4 }, /* ALC_PIN_DIR_INOUT_NOMICBIAS */
322 #define alc_pin_mode_min(_dir) (alc_pin_mode_dir_info[_dir][0])
323 #define alc_pin_mode_max(_dir) (alc_pin_mode_dir_info[_dir][1])
324 #define alc_pin_mode_n_items(_dir) \
325 (alc_pin_mode_max(_dir)-alc_pin_mode_min(_dir)+1)
327 static int alc_pin_mode_info(struct snd_kcontrol
*kcontrol
,
328 struct snd_ctl_elem_info
*uinfo
)
330 unsigned int item_num
= uinfo
->value
.enumerated
.item
;
331 unsigned char dir
= (kcontrol
->private_value
>> 16) & 0xff;
333 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_ENUMERATED
;
335 uinfo
->value
.enumerated
.items
= alc_pin_mode_n_items(dir
);
337 if (item_num
<alc_pin_mode_min(dir
) || item_num
>alc_pin_mode_max(dir
))
338 item_num
= alc_pin_mode_min(dir
);
339 strcpy(uinfo
->value
.enumerated
.name
, alc_pin_mode_names
[item_num
]);
343 static int alc_pin_mode_get(struct snd_kcontrol
*kcontrol
,
344 struct snd_ctl_elem_value
*ucontrol
)
347 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
348 hda_nid_t nid
= kcontrol
->private_value
& 0xffff;
349 unsigned char dir
= (kcontrol
->private_value
>> 16) & 0xff;
350 long *valp
= ucontrol
->value
.integer
.value
;
351 unsigned int pinctl
= snd_hda_codec_read(codec
, nid
, 0,
352 AC_VERB_GET_PIN_WIDGET_CONTROL
,
355 /* Find enumerated value for current pinctl setting */
356 i
= alc_pin_mode_min(dir
);
357 while (alc_pin_mode_values
[i
] != pinctl
&& i
<= alc_pin_mode_max(dir
))
359 *valp
= i
<= alc_pin_mode_max(dir
) ? i
: alc_pin_mode_min(dir
);
363 static int alc_pin_mode_put(struct snd_kcontrol
*kcontrol
,
364 struct snd_ctl_elem_value
*ucontrol
)
367 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
368 hda_nid_t nid
= kcontrol
->private_value
& 0xffff;
369 unsigned char dir
= (kcontrol
->private_value
>> 16) & 0xff;
370 long val
= *ucontrol
->value
.integer
.value
;
371 unsigned int pinctl
= snd_hda_codec_read(codec
, nid
, 0,
372 AC_VERB_GET_PIN_WIDGET_CONTROL
,
375 if (val
< alc_pin_mode_min(dir
) || val
> alc_pin_mode_max(dir
))
376 val
= alc_pin_mode_min(dir
);
378 change
= pinctl
!= alc_pin_mode_values
[val
];
380 /* Set pin mode to that requested */
381 snd_hda_codec_write(codec
,nid
,0,AC_VERB_SET_PIN_WIDGET_CONTROL
,
382 alc_pin_mode_values
[val
]);
384 /* Also enable the retasking pin's input/output as required
385 * for the requested pin mode. Enum values of 2 or less are
388 * Dynamically switching the input/output buffers probably
389 * reduces noise slightly (particularly on input) so we'll
390 * do it. However, having both input and output buffers
391 * enabled simultaneously doesn't seem to be problematic if
392 * this turns out to be necessary in the future.
395 snd_hda_codec_write(codec
, nid
, 0,
396 AC_VERB_SET_AMP_GAIN_MUTE
,
398 snd_hda_codec_write(codec
, nid
, 0,
399 AC_VERB_SET_AMP_GAIN_MUTE
,
402 snd_hda_codec_write(codec
, nid
, 0,
403 AC_VERB_SET_AMP_GAIN_MUTE
,
405 snd_hda_codec_write(codec
, nid
, 0,
406 AC_VERB_SET_AMP_GAIN_MUTE
,
413 #define ALC_PIN_MODE(xname, nid, dir) \
414 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0, \
415 .info = alc_pin_mode_info, \
416 .get = alc_pin_mode_get, \
417 .put = alc_pin_mode_put, \
418 .private_value = nid | (dir<<16) }
420 /* A switch control for ALC260 GPIO pins. Multiple GPIOs can be ganged
421 * together using a mask with more than one bit set. This control is
422 * currently used only by the ALC260 test model. At this stage they are not
423 * needed for any "production" models.
425 #ifdef CONFIG_SND_DEBUG
426 static int alc_gpio_data_info(struct snd_kcontrol
*kcontrol
,
427 struct snd_ctl_elem_info
*uinfo
)
429 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_BOOLEAN
;
431 uinfo
->value
.integer
.min
= 0;
432 uinfo
->value
.integer
.max
= 1;
435 static int alc_gpio_data_get(struct snd_kcontrol
*kcontrol
,
436 struct snd_ctl_elem_value
*ucontrol
)
438 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
439 hda_nid_t nid
= kcontrol
->private_value
& 0xffff;
440 unsigned char mask
= (kcontrol
->private_value
>> 16) & 0xff;
441 long *valp
= ucontrol
->value
.integer
.value
;
442 unsigned int val
= snd_hda_codec_read(codec
, nid
, 0,
443 AC_VERB_GET_GPIO_DATA
, 0x00);
445 *valp
= (val
& mask
) != 0;
448 static int alc_gpio_data_put(struct snd_kcontrol
*kcontrol
,
449 struct snd_ctl_elem_value
*ucontrol
)
452 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
453 hda_nid_t nid
= kcontrol
->private_value
& 0xffff;
454 unsigned char mask
= (kcontrol
->private_value
>> 16) & 0xff;
455 long val
= *ucontrol
->value
.integer
.value
;
456 unsigned int gpio_data
= snd_hda_codec_read(codec
, nid
, 0,
457 AC_VERB_GET_GPIO_DATA
,
460 /* Set/unset the masked GPIO bit(s) as needed */
461 change
= (val
== 0 ? 0 : mask
) != (gpio_data
& mask
);
466 snd_hda_codec_write(codec
, nid
, 0, AC_VERB_SET_GPIO_DATA
, gpio_data
);
470 #define ALC_GPIO_DATA_SWITCH(xname, nid, mask) \
471 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0, \
472 .info = alc_gpio_data_info, \
473 .get = alc_gpio_data_get, \
474 .put = alc_gpio_data_put, \
475 .private_value = nid | (mask<<16) }
476 #endif /* CONFIG_SND_DEBUG */
478 /* A switch control to allow the enabling of the digital IO pins on the
479 * ALC260. This is incredibly simplistic; the intention of this control is
480 * to provide something in the test model allowing digital outputs to be
481 * identified if present. If models are found which can utilise these
482 * outputs a more complete mixer control can be devised for those models if
485 #ifdef CONFIG_SND_DEBUG
486 static int alc_spdif_ctrl_info(struct snd_kcontrol
*kcontrol
,
487 struct snd_ctl_elem_info
*uinfo
)
489 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_BOOLEAN
;
491 uinfo
->value
.integer
.min
= 0;
492 uinfo
->value
.integer
.max
= 1;
495 static int alc_spdif_ctrl_get(struct snd_kcontrol
*kcontrol
,
496 struct snd_ctl_elem_value
*ucontrol
)
498 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
499 hda_nid_t nid
= kcontrol
->private_value
& 0xffff;
500 unsigned char mask
= (kcontrol
->private_value
>> 16) & 0xff;
501 long *valp
= ucontrol
->value
.integer
.value
;
502 unsigned int val
= snd_hda_codec_read(codec
, nid
, 0,
503 AC_VERB_GET_DIGI_CONVERT
, 0x00);
505 *valp
= (val
& mask
) != 0;
508 static int alc_spdif_ctrl_put(struct snd_kcontrol
*kcontrol
,
509 struct snd_ctl_elem_value
*ucontrol
)
512 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
513 hda_nid_t nid
= kcontrol
->private_value
& 0xffff;
514 unsigned char mask
= (kcontrol
->private_value
>> 16) & 0xff;
515 long val
= *ucontrol
->value
.integer
.value
;
516 unsigned int ctrl_data
= snd_hda_codec_read(codec
, nid
, 0,
517 AC_VERB_GET_DIGI_CONVERT
,
520 /* Set/unset the masked control bit(s) as needed */
521 change
= (val
== 0 ? 0 : mask
) != (ctrl_data
& mask
);
526 snd_hda_codec_write(codec
, nid
, 0, AC_VERB_SET_DIGI_CONVERT_1
,
531 #define ALC_SPDIF_CTRL_SWITCH(xname, nid, mask) \
532 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0, \
533 .info = alc_spdif_ctrl_info, \
534 .get = alc_spdif_ctrl_get, \
535 .put = alc_spdif_ctrl_put, \
536 .private_value = nid | (mask<<16) }
537 #endif /* CONFIG_SND_DEBUG */
540 * set up from the preset table
542 static void setup_preset(struct alc_spec
*spec
,
543 const struct alc_config_preset
*preset
)
547 for (i
= 0; i
< ARRAY_SIZE(preset
->mixers
) && preset
->mixers
[i
]; i
++)
548 spec
->mixers
[spec
->num_mixers
++] = preset
->mixers
[i
];
549 for (i
= 0; i
< ARRAY_SIZE(preset
->init_verbs
) && preset
->init_verbs
[i
];
551 spec
->init_verbs
[spec
->num_init_verbs
++] =
552 preset
->init_verbs
[i
];
554 spec
->channel_mode
= preset
->channel_mode
;
555 spec
->num_channel_mode
= preset
->num_channel_mode
;
556 spec
->need_dac_fix
= preset
->need_dac_fix
;
558 spec
->multiout
.max_channels
= spec
->channel_mode
[0].channels
;
560 spec
->multiout
.num_dacs
= preset
->num_dacs
;
561 spec
->multiout
.dac_nids
= preset
->dac_nids
;
562 spec
->multiout
.dig_out_nid
= preset
->dig_out_nid
;
563 spec
->multiout
.hp_nid
= preset
->hp_nid
;
565 spec
->num_mux_defs
= preset
->num_mux_defs
;
566 if (! spec
->num_mux_defs
)
567 spec
->num_mux_defs
= 1;
568 spec
->input_mux
= preset
->input_mux
;
570 spec
->num_adc_nids
= preset
->num_adc_nids
;
571 spec
->adc_nids
= preset
->adc_nids
;
572 spec
->dig_in_nid
= preset
->dig_in_nid
;
574 spec
->unsol_event
= preset
->unsol_event
;
575 spec
->init_hook
= preset
->init_hook
;
579 * ALC880 3-stack model
581 * DAC: Front = 0x02 (0x0c), Surr = 0x05 (0x0f), CLFE = 0x04 (0x0e)
582 * Pin assignment: Front = 0x14, Line-In/Surr = 0x1a, Mic/CLFE = 0x18,
583 * F-Mic = 0x1b, HP = 0x19
586 static hda_nid_t alc880_dac_nids
[4] = {
587 /* front, rear, clfe, rear_surr */
588 0x02, 0x05, 0x04, 0x03
591 static hda_nid_t alc880_adc_nids
[3] = {
596 /* The datasheet says the node 0x07 is connected from inputs,
597 * but it shows zero connection in the real implementation on some devices.
598 * Note: this is a 915GAV bug, fixed on 915GLV
600 static hda_nid_t alc880_adc_nids_alt
[2] = {
605 #define ALC880_DIGOUT_NID 0x06
606 #define ALC880_DIGIN_NID 0x0a
608 static struct hda_input_mux alc880_capture_source
= {
612 { "Front Mic", 0x3 },
618 /* channel source setting (2/6 channel selection for 3-stack) */
620 static struct hda_verb alc880_threestack_ch2_init
[] = {
621 /* set line-in to input, mute it */
622 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_IN
},
623 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_MUTE
},
624 /* set mic-in to input vref 80%, mute it */
625 { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_VREF80
},
626 { 0x18, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_MUTE
},
631 static struct hda_verb alc880_threestack_ch6_init
[] = {
632 /* set line-in to output, unmute it */
633 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_OUT
},
634 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_UNMUTE
},
635 /* set mic-in to output, unmute it */
636 { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_OUT
},
637 { 0x18, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_UNMUTE
},
641 static struct hda_channel_mode alc880_threestack_modes
[2] = {
642 { 2, alc880_threestack_ch2_init
},
643 { 6, alc880_threestack_ch6_init
},
646 static struct snd_kcontrol_new alc880_three_stack_mixer
[] = {
647 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT
),
648 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT
),
649 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0f, 0x0, HDA_OUTPUT
),
650 HDA_BIND_MUTE("Surround Playback Switch", 0x0f, 2, HDA_INPUT
),
651 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT
),
652 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT
),
653 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT
),
654 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT
),
655 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT
),
656 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT
),
657 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT
),
658 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT
),
659 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT
),
660 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT
),
661 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x3, HDA_INPUT
),
662 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x3, HDA_INPUT
),
663 HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT
),
664 HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT
),
665 HDA_CODEC_MUTE("Headphone Playback Switch", 0x19, 0x0, HDA_OUTPUT
),
667 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
668 .name
= "Channel Mode",
669 .info
= alc_ch_mode_info
,
670 .get
= alc_ch_mode_get
,
671 .put
= alc_ch_mode_put
,
676 /* capture mixer elements */
677 static struct snd_kcontrol_new alc880_capture_mixer
[] = {
678 HDA_CODEC_VOLUME("Capture Volume", 0x07, 0x0, HDA_INPUT
),
679 HDA_CODEC_MUTE("Capture Switch", 0x07, 0x0, HDA_INPUT
),
680 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x08, 0x0, HDA_INPUT
),
681 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x08, 0x0, HDA_INPUT
),
682 HDA_CODEC_VOLUME_IDX("Capture Volume", 2, 0x09, 0x0, HDA_INPUT
),
683 HDA_CODEC_MUTE_IDX("Capture Switch", 2, 0x09, 0x0, HDA_INPUT
),
685 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
686 /* The multiple "Capture Source" controls confuse alsamixer
687 * So call somewhat different..
688 * FIXME: the controls appear in the "playback" view!
690 /* .name = "Capture Source", */
691 .name
= "Input Source",
693 .info
= alc_mux_enum_info
,
694 .get
= alc_mux_enum_get
,
695 .put
= alc_mux_enum_put
,
700 /* capture mixer elements (in case NID 0x07 not available) */
701 static struct snd_kcontrol_new alc880_capture_alt_mixer
[] = {
702 HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT
),
703 HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT
),
704 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT
),
705 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT
),
707 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
708 /* The multiple "Capture Source" controls confuse alsamixer
709 * So call somewhat different..
710 * FIXME: the controls appear in the "playback" view!
712 /* .name = "Capture Source", */
713 .name
= "Input Source",
715 .info
= alc_mux_enum_info
,
716 .get
= alc_mux_enum_get
,
717 .put
= alc_mux_enum_put
,
725 * ALC880 5-stack model
727 * DAC: Front = 0x02 (0x0c), Surr = 0x05 (0x0f), CLFE = 0x04 (0x0d),
729 * Pin assignment: Front = 0x14, Surr = 0x17, CLFE = 0x16
730 * Line-In/Side = 0x1a, Mic = 0x18, F-Mic = 0x1b, HP = 0x19
733 /* additional mixers to alc880_three_stack_mixer */
734 static struct snd_kcontrol_new alc880_five_stack_mixer
[] = {
735 HDA_CODEC_VOLUME("Side Playback Volume", 0x0d, 0x0, HDA_OUTPUT
),
736 HDA_BIND_MUTE("Side Playback Switch", 0x0d, 2, HDA_INPUT
),
740 /* channel source setting (6/8 channel selection for 5-stack) */
742 static struct hda_verb alc880_fivestack_ch6_init
[] = {
743 /* set line-in to input, mute it */
744 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_IN
},
745 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_MUTE
},
750 static struct hda_verb alc880_fivestack_ch8_init
[] = {
751 /* set line-in to output, unmute it */
752 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_OUT
},
753 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_UNMUTE
},
757 static struct hda_channel_mode alc880_fivestack_modes
[2] = {
758 { 6, alc880_fivestack_ch6_init
},
759 { 8, alc880_fivestack_ch8_init
},
764 * ALC880 6-stack model
766 * DAC: Front = 0x02 (0x0c), Surr = 0x03 (0x0d), CLFE = 0x04 (0x0e),
768 * Pin assignment: Front = 0x14, Surr = 0x15, CLFE = 0x16, Side = 0x17,
769 * Mic = 0x18, F-Mic = 0x19, Line = 0x1a, HP = 0x1b
772 static hda_nid_t alc880_6st_dac_nids
[4] = {
773 /* front, rear, clfe, rear_surr */
774 0x02, 0x03, 0x04, 0x05
777 static struct hda_input_mux alc880_6stack_capture_source
= {
781 { "Front Mic", 0x1 },
787 /* fixed 8-channels */
788 static struct hda_channel_mode alc880_sixstack_modes
[1] = {
792 static struct snd_kcontrol_new alc880_six_stack_mixer
[] = {
793 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT
),
794 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT
),
795 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT
),
796 HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT
),
797 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT
),
798 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT
),
799 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT
),
800 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT
),
801 HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT
),
802 HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT
),
803 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT
),
804 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT
),
805 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT
),
806 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT
),
807 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT
),
808 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT
),
809 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT
),
810 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT
),
811 HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT
),
812 HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT
),
814 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
815 .name
= "Channel Mode",
816 .info
= alc_ch_mode_info
,
817 .get
= alc_ch_mode_get
,
818 .put
= alc_ch_mode_put
,
827 * W810 has rear IO for:
830 * Center/LFE (DAC 04)
833 * The system also has a pair of internal speakers, and a headphone jack.
834 * These are both connected to Line2 on the codec, hence to DAC 02.
836 * There is a variable resistor to control the speaker or headphone
837 * volume. This is a hardware-only device without a software API.
839 * Plugging headphones in will disable the internal speakers. This is
840 * implemented in hardware, not via the driver using jack sense. In
841 * a similar fashion, plugging into the rear socket marked "front" will
842 * disable both the speakers and headphones.
844 * For input, there's a microphone jack, and an "audio in" jack.
845 * These may not do anything useful with this driver yet, because I
846 * haven't setup any initialization verbs for these yet...
849 static hda_nid_t alc880_w810_dac_nids
[3] = {
850 /* front, rear/surround, clfe */
854 /* fixed 6 channels */
855 static struct hda_channel_mode alc880_w810_modes
[1] = {
859 /* Pin assignment: Front = 0x14, Surr = 0x15, CLFE = 0x16, HP = 0x1b */
860 static struct snd_kcontrol_new alc880_w810_base_mixer
[] = {
861 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT
),
862 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT
),
863 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT
),
864 HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT
),
865 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT
),
866 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT
),
867 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT
),
868 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT
),
869 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT
),
877 * DAC: Front = 0x02 (0x0c), HP = 0x03 (0x0d)
878 * Pin assignment: Front = 0x14, HP = 0x15, Mic = 0x18, Mic2 = 0x19(?),
882 static hda_nid_t alc880_z71v_dac_nids
[1] = {
885 #define ALC880_Z71V_HP_DAC 0x03
887 /* fixed 2 channels */
888 static struct hda_channel_mode alc880_2_jack_modes
[1] = {
892 static struct snd_kcontrol_new alc880_z71v_mixer
[] = {
893 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT
),
894 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT
),
895 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT
),
896 HDA_BIND_MUTE("Headphone Playback Switch", 0x0d, 2, HDA_INPUT
),
897 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT
),
898 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT
),
899 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT
),
900 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT
),
909 * DAC: HP = 0x02 (0x0c), Front = 0x03 (0x0d)
910 * Pin assignment: HP = 0x14, Front = 0x15, Mic = 0x18
913 static hda_nid_t alc880_f1734_dac_nids
[1] = {
916 #define ALC880_F1734_HP_DAC 0x02
918 static struct snd_kcontrol_new alc880_f1734_mixer
[] = {
919 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT
),
920 HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT
),
921 HDA_CODEC_VOLUME("Internal Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT
),
922 HDA_BIND_MUTE("Internal Speaker Playback Switch", 0x0d, 2, HDA_INPUT
),
923 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT
),
924 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT
),
925 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT
),
926 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT
),
935 * DAC: HP/Front = 0x02 (0x0c), Surr = 0x03 (0x0d), CLFE = 0x04 (0x0e)
936 * Pin assignment: HP/Front = 0x14, Surr = 0x15, CLFE = 0x16,
937 * Mic = 0x18, Line = 0x1a
940 #define alc880_asus_dac_nids alc880_w810_dac_nids /* identical with w810 */
941 #define alc880_asus_modes alc880_threestack_modes /* 2/6 channel mode */
943 static struct snd_kcontrol_new alc880_asus_mixer
[] = {
944 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT
),
945 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT
),
946 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT
),
947 HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT
),
948 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT
),
949 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT
),
950 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT
),
951 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT
),
952 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT
),
953 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT
),
954 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT
),
955 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT
),
956 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT
),
957 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT
),
959 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
960 .name
= "Channel Mode",
961 .info
= alc_ch_mode_info
,
962 .get
= alc_ch_mode_get
,
963 .put
= alc_ch_mode_put
,
970 * ALC880 ASUS W1V model
972 * DAC: HP/Front = 0x02 (0x0c), Surr = 0x03 (0x0d), CLFE = 0x04 (0x0e)
973 * Pin assignment: HP/Front = 0x14, Surr = 0x15, CLFE = 0x16,
974 * Mic = 0x18, Line = 0x1a, Line2 = 0x1b
977 /* additional mixers to alc880_asus_mixer */
978 static struct snd_kcontrol_new alc880_asus_w1v_mixer
[] = {
979 HDA_CODEC_VOLUME("Line2 Playback Volume", 0x0b, 0x03, HDA_INPUT
),
980 HDA_CODEC_MUTE("Line2 Playback Switch", 0x0b, 0x03, HDA_INPUT
),
984 /* additional mixers to alc880_asus_mixer */
985 static struct snd_kcontrol_new alc880_pcbeep_mixer
[] = {
986 HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT
),
987 HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT
),
992 static struct snd_kcontrol_new alc880_tcl_s700_mixer
[] = {
993 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT
),
994 HDA_CODEC_MUTE("Front Playback Switch", 0x1b, 0x0, HDA_OUTPUT
),
995 HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT
),
996 HDA_CODEC_VOLUME("CD Playback Volume", 0x0B, 0x04, HDA_INPUT
),
997 HDA_CODEC_MUTE("CD Playback Switch", 0x0B, 0x04, HDA_INPUT
),
998 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0B, 0x0, HDA_INPUT
),
999 HDA_CODEC_MUTE("Mic Playback Switch", 0x0B, 0x0, HDA_INPUT
),
1000 HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT
),
1001 HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT
),
1003 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
1004 /* The multiple "Capture Source" controls confuse alsamixer
1005 * So call somewhat different..
1006 * FIXME: the controls appear in the "playback" view!
1008 /* .name = "Capture Source", */
1009 .name
= "Input Source",
1011 .info
= alc_mux_enum_info
,
1012 .get
= alc_mux_enum_get
,
1013 .put
= alc_mux_enum_put
,
1019 * build control elements
1021 static int alc_build_controls(struct hda_codec
*codec
)
1023 struct alc_spec
*spec
= codec
->spec
;
1027 for (i
= 0; i
< spec
->num_mixers
; i
++) {
1028 err
= snd_hda_add_new_ctls(codec
, spec
->mixers
[i
]);
1033 if (spec
->multiout
.dig_out_nid
) {
1034 err
= snd_hda_create_spdif_out_ctls(codec
,
1035 spec
->multiout
.dig_out_nid
);
1039 if (spec
->dig_in_nid
) {
1040 err
= snd_hda_create_spdif_in_ctls(codec
, spec
->dig_in_nid
);
1049 * initialize the codec volumes, etc
1053 * generic initialization of ADC, input mixers and output mixers
1055 static struct hda_verb alc880_volume_init_verbs
[] = {
1057 * Unmute ADC0-2 and set the default input to mic-in
1059 {0x07, AC_VERB_SET_CONNECT_SEL
, 0x00},
1060 {0x07, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(0)},
1061 {0x08, AC_VERB_SET_CONNECT_SEL
, 0x00},
1062 {0x08, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(0)},
1063 {0x09, AC_VERB_SET_CONNECT_SEL
, 0x00},
1064 {0x09, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(0)},
1066 /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
1068 * Note: PASD motherboards uses the Line In 2 as the input for front
1071 /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
1072 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(0)},
1073 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(1)},
1074 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(2)},
1075 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(3)},
1076 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(4)},
1079 * Set up output mixers (0x0c - 0x0f)
1081 /* set vol=0 to output mixers */
1082 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_ZERO
},
1083 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_ZERO
},
1084 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_ZERO
},
1085 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_ZERO
},
1086 /* set up input amps for analog loopback */
1087 /* Amp Indices: DAC = 0, mixer = 1 */
1088 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_MUTE(0)},
1089 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_MUTE(1)},
1090 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_MUTE(0)},
1091 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_MUTE(1)},
1092 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_MUTE(0)},
1093 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_MUTE(1)},
1094 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_MUTE(0)},
1095 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_MUTE(1)},
1101 * 3-stack pin configuration:
1102 * front = 0x14, mic/clfe = 0x18, HP = 0x19, line/surr = 0x1a, f-mic = 0x1b
1104 static struct hda_verb alc880_pin_3stack_init_verbs
[] = {
1106 * preset connection lists of input pins
1107 * 0 = front, 1 = rear_surr, 2 = CLFE, 3 = surround
1109 {0x10, AC_VERB_SET_CONNECT_SEL
, 0x02}, /* mic/clfe */
1110 {0x11, AC_VERB_SET_CONNECT_SEL
, 0x00}, /* HP */
1111 {0x12, AC_VERB_SET_CONNECT_SEL
, 0x03}, /* line/surround */
1114 * Set pin mode and muting
1116 /* set front pin widgets 0x14 for output */
1117 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_OUT
},
1118 {0x14, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_UNMUTE
},
1119 /* Mic1 (rear panel) pin widget for input and vref at 80% */
1120 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_VREF80
},
1121 {0x18, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_MUTE
},
1122 /* Mic2 (as headphone out) for HP output */
1123 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_HP
},
1124 {0x19, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_UNMUTE
},
1125 /* Line In pin widget for input */
1126 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_IN
},
1127 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_MUTE
},
1128 /* Line2 (as front mic) pin widget for input and vref at 80% */
1129 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_VREF80
},
1130 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_MUTE
},
1131 /* CD pin widget for input */
1132 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_IN
},
1138 * 5-stack pin configuration:
1139 * front = 0x14, surround = 0x17, clfe = 0x16, mic = 0x18, HP = 0x19,
1140 * line-in/side = 0x1a, f-mic = 0x1b
1142 static struct hda_verb alc880_pin_5stack_init_verbs
[] = {
1144 * preset connection lists of input pins
1145 * 0 = front, 1 = rear_surr, 2 = CLFE, 3 = surround
1147 {0x11, AC_VERB_SET_CONNECT_SEL
, 0x00}, /* HP */
1148 {0x12, AC_VERB_SET_CONNECT_SEL
, 0x01}, /* line/side */
1151 * Set pin mode and muting
1153 /* set pin widgets 0x14-0x17 for output */
1154 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_OUT
},
1155 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_OUT
},
1156 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_OUT
},
1157 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_OUT
},
1158 /* unmute pins for output (no gain on this amp) */
1159 {0x14, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_UNMUTE
},
1160 {0x15, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_UNMUTE
},
1161 {0x16, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_UNMUTE
},
1162 {0x17, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_UNMUTE
},
1164 /* Mic1 (rear panel) pin widget for input and vref at 80% */
1165 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_VREF80
},
1166 {0x18, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_MUTE
},
1167 /* Mic2 (as headphone out) for HP output */
1168 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_HP
},
1169 {0x19, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_UNMUTE
},
1170 /* Line In pin widget for input */
1171 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_IN
},
1172 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_MUTE
},
1173 /* Line2 (as front mic) pin widget for input and vref at 80% */
1174 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_VREF80
},
1175 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_MUTE
},
1176 /* CD pin widget for input */
1177 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_IN
},
1183 * W810 pin configuration:
1184 * front = 0x14, surround = 0x15, clfe = 0x16, HP = 0x1b
1186 static struct hda_verb alc880_pin_w810_init_verbs
[] = {
1187 /* hphone/speaker input selector: front DAC */
1188 {0x13, AC_VERB_SET_CONNECT_SEL
, 0x0},
1190 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_OUT
},
1191 {0x14, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_UNMUTE
},
1192 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_OUT
},
1193 {0x15, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_UNMUTE
},
1194 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_OUT
},
1195 {0x16, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_UNMUTE
},
1197 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_HP
},
1198 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_MUTE
},
1204 * Z71V pin configuration:
1205 * Speaker-out = 0x14, HP = 0x15, Mic = 0x18, Line-in = 0x1a, Mic2 = 0x1b (?)
1207 static struct hda_verb alc880_pin_z71v_init_verbs
[] = {
1208 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_OUT
},
1209 {0x14, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_UNMUTE
},
1210 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_HP
},
1211 {0x15, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_UNMUTE
},
1213 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_VREF80
},
1214 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_IN
},
1215 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_VREF80
},
1216 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_IN
},
1222 * 6-stack pin configuration:
1223 * front = 0x14, surr = 0x15, clfe = 0x16, side = 0x17, mic = 0x18,
1224 * f-mic = 0x19, line = 0x1a, HP = 0x1b
1226 static struct hda_verb alc880_pin_6stack_init_verbs
[] = {
1227 {0x13, AC_VERB_SET_CONNECT_SEL
, 0x00}, /* HP */
1229 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_OUT
},
1230 {0x14, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_UNMUTE
},
1231 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_OUT
},
1232 {0x15, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_UNMUTE
},
1233 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_OUT
},
1234 {0x16, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_UNMUTE
},
1235 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_OUT
},
1236 {0x17, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_UNMUTE
},
1238 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_VREF80
},
1239 {0x18, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_MUTE
},
1240 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_VREF80
},
1241 {0x19, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_MUTE
},
1242 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_IN
},
1243 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_MUTE
},
1244 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_HP
},
1245 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_UNMUTE
},
1246 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_IN
},
1253 * F1734 pin configuration:
1254 * HP = 0x14, speaker-out = 0x15, mic = 0x18
1256 static struct hda_verb alc880_pin_f1734_init_verbs
[] = {
1257 {0x10, AC_VERB_SET_CONNECT_SEL
, 0x02},
1258 {0x11, AC_VERB_SET_CONNECT_SEL
, 0x00},
1259 {0x12, AC_VERB_SET_CONNECT_SEL
, 0x01},
1260 {0x13, AC_VERB_SET_CONNECT_SEL
, 0x00},
1262 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_HP
},
1263 {0x14, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_UNMUTE
},
1264 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_OUT
},
1265 {0x15, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_UNMUTE
},
1267 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_VREF80
},
1268 {0x18, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_MUTE
},
1269 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_VREF80
},
1270 {0x19, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_MUTE
},
1271 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_OUT
},
1272 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_UNMUTE
},
1273 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_OUT
},
1274 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_UNMUTE
},
1275 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_IN
},
1282 * ASUS pin configuration:
1283 * HP/front = 0x14, surr = 0x15, clfe = 0x16, mic = 0x18, line = 0x1a
1285 static struct hda_verb alc880_pin_asus_init_verbs
[] = {
1286 {0x10, AC_VERB_SET_CONNECT_SEL
, 0x02},
1287 {0x11, AC_VERB_SET_CONNECT_SEL
, 0x00},
1288 {0x12, AC_VERB_SET_CONNECT_SEL
, 0x01},
1289 {0x13, AC_VERB_SET_CONNECT_SEL
, 0x00},
1291 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_HP
},
1292 {0x14, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_UNMUTE
},
1293 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_OUT
},
1294 {0x14, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_UNMUTE
},
1295 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_OUT
},
1296 {0x14, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_UNMUTE
},
1297 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_OUT
},
1298 {0x14, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_UNMUTE
},
1300 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_VREF80
},
1301 {0x14, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_MUTE
},
1302 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_VREF80
},
1303 {0x14, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_MUTE
},
1304 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_IN
},
1305 {0x14, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_MUTE
},
1306 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_OUT
},
1307 {0x14, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_UNMUTE
},
1308 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_IN
},
1313 /* Enable GPIO mask and set output */
1314 static struct hda_verb alc880_gpio1_init_verbs
[] = {
1315 {0x01, AC_VERB_SET_GPIO_MASK
, 0x01},
1316 {0x01, AC_VERB_SET_GPIO_DIRECTION
, 0x01},
1317 {0x01, AC_VERB_SET_GPIO_DATA
, 0x01},
1322 /* Enable GPIO mask and set output */
1323 static struct hda_verb alc880_gpio2_init_verbs
[] = {
1324 {0x01, AC_VERB_SET_GPIO_MASK
, 0x02},
1325 {0x01, AC_VERB_SET_GPIO_DIRECTION
, 0x02},
1326 {0x01, AC_VERB_SET_GPIO_DATA
, 0x02},
1331 /* Clevo m520g init */
1332 static struct hda_verb alc880_pin_clevo_init_verbs
[] = {
1333 /* headphone output */
1334 {0x11, AC_VERB_SET_CONNECT_SEL
, 0x01},
1336 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_OUT
},
1337 {0x14, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_UNMUTE
},
1339 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_IN
},
1340 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_UNMUTE
},
1342 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_IN
},
1343 {0x1c, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_UNMUTE
},
1344 /* Mic1 (rear panel) */
1345 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_VREF80
},
1346 {0x18, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_UNMUTE
},
1347 /* Mic2 (front panel) */
1348 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_VREF80
},
1349 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_UNMUTE
},
1351 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_HP
},
1352 {0x19, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_UNMUTE
},
1353 /* change to EAPD mode */
1354 {0x20, AC_VERB_SET_COEF_INDEX
, 0x07},
1355 {0x20, AC_VERB_SET_PROC_COEF
, 0x3060},
1360 static struct hda_verb alc880_pin_tcl_S700_init_verbs
[] = {
1361 /* change to EAPD mode */
1362 {0x20, AC_VERB_SET_COEF_INDEX
, 0x07},
1363 {0x20, AC_VERB_SET_PROC_COEF
, 0x3060},
1365 /* Headphone output */
1366 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_HP
},
1368 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_OUT
},
1369 {0x1b, AC_VERB_SET_CONNECT_SEL
, 0x00},
1371 /* Line In pin widget for input */
1372 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_IN
},
1373 /* CD pin widget for input */
1374 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_IN
},
1375 /* Mic1 (rear panel) pin widget for input and vref at 80% */
1376 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_VREF80
},
1378 /* change to EAPD mode */
1379 {0x20, AC_VERB_SET_COEF_INDEX
, 0x07},
1380 {0x20, AC_VERB_SET_PROC_COEF
, 0x3070},
1386 * LG m1 express dual
1389 * Rear Line-In/Out (blue): 0x14
1390 * Build-in Mic-In: 0x15
1392 * HP-Out (green): 0x1b
1393 * Mic-In/Out (red): 0x19
1397 /* To make 5.1 output working (green=Front, blue=Surr, red=CLFE) */
1398 static hda_nid_t alc880_lg_dac_nids
[3] = {
1402 /* seems analog CD is not working */
1403 static struct hda_input_mux alc880_lg_capture_source
= {
1408 { "Internal Mic", 0x6 },
1412 /* 2,4,6 channel modes */
1413 static struct hda_verb alc880_lg_ch2_init
[] = {
1414 /* set line-in and mic-in to input */
1415 { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_IN
},
1416 { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_VREF80
},
1420 static struct hda_verb alc880_lg_ch4_init
[] = {
1421 /* set line-in to out and mic-in to input */
1422 { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_HP
},
1423 { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_VREF80
},
1427 static struct hda_verb alc880_lg_ch6_init
[] = {
1428 /* set line-in and mic-in to output */
1429 { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_HP
},
1430 { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_HP
},
1434 static struct hda_channel_mode alc880_lg_ch_modes
[3] = {
1435 { 2, alc880_lg_ch2_init
},
1436 { 4, alc880_lg_ch4_init
},
1437 { 6, alc880_lg_ch6_init
},
1440 static struct snd_kcontrol_new alc880_lg_mixer
[] = {
1441 /* FIXME: it's not really "master" but front channels */
1442 HDA_CODEC_VOLUME("Master Playback Volume", 0x0f, 0x0, HDA_OUTPUT
),
1443 HDA_BIND_MUTE("Master Playback Switch", 0x0f, 2, HDA_INPUT
),
1444 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0c, 0x0, HDA_OUTPUT
),
1445 HDA_BIND_MUTE("Surround Playback Switch", 0x0c, 2, HDA_INPUT
),
1446 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0d, 1, 0x0, HDA_OUTPUT
),
1447 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0d, 2, 0x0, HDA_OUTPUT
),
1448 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0d, 1, 2, HDA_INPUT
),
1449 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0d, 2, 2, HDA_INPUT
),
1450 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT
),
1451 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT
),
1452 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x06, HDA_INPUT
),
1453 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x06, HDA_INPUT
),
1454 HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x07, HDA_INPUT
),
1455 HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x07, HDA_INPUT
),
1457 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
1458 .name
= "Channel Mode",
1459 .info
= alc_ch_mode_info
,
1460 .get
= alc_ch_mode_get
,
1461 .put
= alc_ch_mode_put
,
1466 static struct hda_verb alc880_lg_init_verbs
[] = {
1467 /* set capture source to mic-in */
1468 {0x07, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(1)},
1469 {0x08, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(1)},
1470 {0x09, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(1)},
1471 /* mute all amp mixer inputs */
1472 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(5)},
1473 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(6)},
1474 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(7)},
1475 /* line-in to input */
1476 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_IN
},
1477 {0x14, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_UNMUTE
},
1479 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_VREF80
},
1480 {0x15, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_UNMUTE
},
1482 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_HP
},
1483 {0x17, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_UNMUTE
},
1484 /* mic-in to input */
1485 {0x11, AC_VERB_SET_CONNECT_SEL
, 0x01},
1486 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_VREF80
},
1487 {0x19, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_UNMUTE
},
1489 {0x13, AC_VERB_SET_CONNECT_SEL
, 0x03},
1490 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_HP
},
1491 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_UNMUTE
},
1493 {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE
, AC_USRSP_EN
| 0x1},
1497 /* toggle speaker-output according to the hp-jack state */
1498 static void alc880_lg_automute(struct hda_codec
*codec
)
1500 unsigned int present
;
1502 present
= snd_hda_codec_read(codec
, 0x1b, 0,
1503 AC_VERB_GET_PIN_SENSE
, 0) & 0x80000000;
1504 snd_hda_codec_amp_update(codec
, 0x17, 0, HDA_OUTPUT
, 0,
1505 0x80, present
? 0x80 : 0);
1506 snd_hda_codec_amp_update(codec
, 0x17, 1, HDA_OUTPUT
, 0,
1507 0x80, present
? 0x80 : 0);
1510 static void alc880_lg_unsol_event(struct hda_codec
*codec
, unsigned int res
)
1512 /* Looks like the unsol event is incompatible with the standard
1513 * definition. 4bit tag is placed at 28 bit!
1515 if ((res
>> 28) == 0x01)
1516 alc880_lg_automute(codec
);
1525 * Built-in Mic-In: 0x19 (?)
1530 /* seems analog CD is not working */
1531 static struct hda_input_mux alc880_lg_lw_capture_source
= {
1535 { "Internal Mic", 0x1 },
1539 static struct snd_kcontrol_new alc880_lg_lw_mixer
[] = {
1540 HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT
),
1541 HDA_BIND_MUTE("Master Playback Switch", 0x0c, 2, HDA_INPUT
),
1542 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT
),
1543 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT
),
1544 HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x01, HDA_INPUT
),
1545 HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x01, HDA_INPUT
),
1549 static struct hda_verb alc880_lg_lw_init_verbs
[] = {
1550 /* set capture source to mic-in */
1551 {0x07, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(0)},
1552 {0x08, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(0)},
1553 {0x09, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(0)},
1554 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(7)},
1556 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_HP
},
1557 {0x14, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_UNMUTE
},
1559 {0x13, AC_VERB_SET_CONNECT_SEL
, 0x00},
1560 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_HP
},
1561 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_UNMUTE
},
1562 /* mic-in to input */
1563 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_VREF80
},
1564 {0x18, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_UNMUTE
},
1566 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_VREF80
},
1567 {0x19, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_UNMUTE
},
1569 {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE
, AC_USRSP_EN
| 0x1},
1573 /* toggle speaker-output according to the hp-jack state */
1574 static void alc880_lg_lw_automute(struct hda_codec
*codec
)
1576 unsigned int present
;
1578 present
= snd_hda_codec_read(codec
, 0x1b, 0,
1579 AC_VERB_GET_PIN_SENSE
, 0) & 0x80000000;
1580 snd_hda_codec_amp_update(codec
, 0x14, 0, HDA_OUTPUT
, 0,
1581 0x80, present
? 0x80 : 0);
1582 snd_hda_codec_amp_update(codec
, 0x14, 1, HDA_OUTPUT
, 0,
1583 0x80, present
? 0x80 : 0);
1586 static void alc880_lg_lw_unsol_event(struct hda_codec
*codec
, unsigned int res
)
1588 /* Looks like the unsol event is incompatible with the standard
1589 * definition. 4bit tag is placed at 28 bit!
1591 if ((res
>> 28) == 0x01)
1592 alc880_lg_lw_automute(codec
);
1599 static int alc_init(struct hda_codec
*codec
)
1601 struct alc_spec
*spec
= codec
->spec
;
1604 for (i
= 0; i
< spec
->num_init_verbs
; i
++)
1605 snd_hda_sequence_write(codec
, spec
->init_verbs
[i
]);
1607 if (spec
->init_hook
)
1608 spec
->init_hook(codec
);
1613 static void alc_unsol_event(struct hda_codec
*codec
, unsigned int res
)
1615 struct alc_spec
*spec
= codec
->spec
;
1617 if (spec
->unsol_event
)
1618 spec
->unsol_event(codec
, res
);
1625 static int alc_resume(struct hda_codec
*codec
)
1627 struct alc_spec
*spec
= codec
->spec
;
1631 for (i
= 0; i
< spec
->num_mixers
; i
++)
1632 snd_hda_resume_ctls(codec
, spec
->mixers
[i
]);
1633 if (spec
->multiout
.dig_out_nid
)
1634 snd_hda_resume_spdif_out(codec
);
1635 if (spec
->dig_in_nid
)
1636 snd_hda_resume_spdif_in(codec
);
1643 * Analog playback callbacks
1645 static int alc880_playback_pcm_open(struct hda_pcm_stream
*hinfo
,
1646 struct hda_codec
*codec
,
1647 struct snd_pcm_substream
*substream
)
1649 struct alc_spec
*spec
= codec
->spec
;
1650 return snd_hda_multi_out_analog_open(codec
, &spec
->multiout
, substream
);
1653 static int alc880_playback_pcm_prepare(struct hda_pcm_stream
*hinfo
,
1654 struct hda_codec
*codec
,
1655 unsigned int stream_tag
,
1656 unsigned int format
,
1657 struct snd_pcm_substream
*substream
)
1659 struct alc_spec
*spec
= codec
->spec
;
1660 return snd_hda_multi_out_analog_prepare(codec
, &spec
->multiout
,
1661 stream_tag
, format
, substream
);
1664 static int alc880_playback_pcm_cleanup(struct hda_pcm_stream
*hinfo
,
1665 struct hda_codec
*codec
,
1666 struct snd_pcm_substream
*substream
)
1668 struct alc_spec
*spec
= codec
->spec
;
1669 return snd_hda_multi_out_analog_cleanup(codec
, &spec
->multiout
);
1675 static int alc880_dig_playback_pcm_open(struct hda_pcm_stream
*hinfo
,
1676 struct hda_codec
*codec
,
1677 struct snd_pcm_substream
*substream
)
1679 struct alc_spec
*spec
= codec
->spec
;
1680 return snd_hda_multi_out_dig_open(codec
, &spec
->multiout
);
1683 static int alc880_dig_playback_pcm_close(struct hda_pcm_stream
*hinfo
,
1684 struct hda_codec
*codec
,
1685 struct snd_pcm_substream
*substream
)
1687 struct alc_spec
*spec
= codec
->spec
;
1688 return snd_hda_multi_out_dig_close(codec
, &spec
->multiout
);
1694 static int alc880_capture_pcm_prepare(struct hda_pcm_stream
*hinfo
,
1695 struct hda_codec
*codec
,
1696 unsigned int stream_tag
,
1697 unsigned int format
,
1698 struct snd_pcm_substream
*substream
)
1700 struct alc_spec
*spec
= codec
->spec
;
1702 snd_hda_codec_setup_stream(codec
, spec
->adc_nids
[substream
->number
],
1703 stream_tag
, 0, format
);
1707 static int alc880_capture_pcm_cleanup(struct hda_pcm_stream
*hinfo
,
1708 struct hda_codec
*codec
,
1709 struct snd_pcm_substream
*substream
)
1711 struct alc_spec
*spec
= codec
->spec
;
1713 snd_hda_codec_setup_stream(codec
, spec
->adc_nids
[substream
->number
],
1721 static struct hda_pcm_stream alc880_pcm_analog_playback
= {
1725 /* NID is set in alc_build_pcms */
1727 .open
= alc880_playback_pcm_open
,
1728 .prepare
= alc880_playback_pcm_prepare
,
1729 .cleanup
= alc880_playback_pcm_cleanup
1733 static struct hda_pcm_stream alc880_pcm_analog_capture
= {
1737 /* NID is set in alc_build_pcms */
1739 .prepare
= alc880_capture_pcm_prepare
,
1740 .cleanup
= alc880_capture_pcm_cleanup
1744 static struct hda_pcm_stream alc880_pcm_digital_playback
= {
1748 /* NID is set in alc_build_pcms */
1750 .open
= alc880_dig_playback_pcm_open
,
1751 .close
= alc880_dig_playback_pcm_close
1755 static struct hda_pcm_stream alc880_pcm_digital_capture
= {
1759 /* NID is set in alc_build_pcms */
1762 /* Used by alc_build_pcms to flag that a PCM has no playback stream */
1763 static struct hda_pcm_stream alc_pcm_null_playback
= {
1769 static int alc_build_pcms(struct hda_codec
*codec
)
1771 struct alc_spec
*spec
= codec
->spec
;
1772 struct hda_pcm
*info
= spec
->pcm_rec
;
1775 codec
->num_pcms
= 1;
1776 codec
->pcm_info
= info
;
1778 info
->name
= spec
->stream_name_analog
;
1779 if (spec
->stream_analog_playback
) {
1780 snd_assert(spec
->multiout
.dac_nids
, return -EINVAL
);
1781 info
->stream
[SNDRV_PCM_STREAM_PLAYBACK
] = *(spec
->stream_analog_playback
);
1782 info
->stream
[SNDRV_PCM_STREAM_PLAYBACK
].nid
= spec
->multiout
.dac_nids
[0];
1784 if (spec
->stream_analog_capture
) {
1785 snd_assert(spec
->adc_nids
, return -EINVAL
);
1786 info
->stream
[SNDRV_PCM_STREAM_CAPTURE
] = *(spec
->stream_analog_capture
);
1787 info
->stream
[SNDRV_PCM_STREAM_CAPTURE
].nid
= spec
->adc_nids
[0];
1790 if (spec
->channel_mode
) {
1791 info
->stream
[SNDRV_PCM_STREAM_PLAYBACK
].channels_max
= 0;
1792 for (i
= 0; i
< spec
->num_channel_mode
; i
++) {
1793 if (spec
->channel_mode
[i
].channels
> info
->stream
[SNDRV_PCM_STREAM_PLAYBACK
].channels_max
) {
1794 info
->stream
[SNDRV_PCM_STREAM_PLAYBACK
].channels_max
= spec
->channel_mode
[i
].channels
;
1799 /* SPDIF for stream index #1 */
1800 if (spec
->multiout
.dig_out_nid
|| spec
->dig_in_nid
) {
1801 codec
->num_pcms
= 2;
1802 info
= spec
->pcm_rec
+ 1;
1803 info
->name
= spec
->stream_name_digital
;
1804 if (spec
->multiout
.dig_out_nid
&&
1805 spec
->stream_digital_playback
) {
1806 info
->stream
[SNDRV_PCM_STREAM_PLAYBACK
] = *(spec
->stream_digital_playback
);
1807 info
->stream
[SNDRV_PCM_STREAM_PLAYBACK
].nid
= spec
->multiout
.dig_out_nid
;
1809 if (spec
->dig_in_nid
&&
1810 spec
->stream_digital_capture
) {
1811 info
->stream
[SNDRV_PCM_STREAM_CAPTURE
] = *(spec
->stream_digital_capture
);
1812 info
->stream
[SNDRV_PCM_STREAM_CAPTURE
].nid
= spec
->dig_in_nid
;
1816 /* If the use of more than one ADC is requested for the current
1817 * model, configure a second analog capture-only PCM.
1819 /* Additional Analaog capture for index #2 */
1820 if (spec
->num_adc_nids
> 1 && spec
->stream_analog_capture
&&
1822 codec
->num_pcms
= 3;
1823 info
= spec
->pcm_rec
+ 2;
1824 info
->name
= spec
->stream_name_analog
;
1825 /* No playback stream for second PCM */
1826 info
->stream
[SNDRV_PCM_STREAM_PLAYBACK
] = alc_pcm_null_playback
;
1827 info
->stream
[SNDRV_PCM_STREAM_PLAYBACK
].nid
= 0;
1828 if (spec
->stream_analog_capture
) {
1829 info
->stream
[SNDRV_PCM_STREAM_CAPTURE
] = *(spec
->stream_analog_capture
);
1830 info
->stream
[SNDRV_PCM_STREAM_CAPTURE
].nid
= spec
->adc_nids
[1];
1837 static void alc_free(struct hda_codec
*codec
)
1839 struct alc_spec
*spec
= codec
->spec
;
1845 if (spec
->kctl_alloc
) {
1846 for (i
= 0; i
< spec
->num_kctl_used
; i
++)
1847 kfree(spec
->kctl_alloc
[i
].name
);
1848 kfree(spec
->kctl_alloc
);
1855 static struct hda_codec_ops alc_patch_ops
= {
1856 .build_controls
= alc_build_controls
,
1857 .build_pcms
= alc_build_pcms
,
1860 .unsol_event
= alc_unsol_event
,
1862 .resume
= alc_resume
,
1868 * Test configuration for debugging
1870 * Almost all inputs/outputs are enabled. I/O pins can be configured via
1873 #ifdef CONFIG_SND_DEBUG
1874 static hda_nid_t alc880_test_dac_nids
[4] = {
1875 0x02, 0x03, 0x04, 0x05
1878 static struct hda_input_mux alc880_test_capture_source
= {
1887 { "Surround", 0x6 },
1891 static struct hda_channel_mode alc880_test_modes
[4] = {
1898 static int alc_test_pin_ctl_info(struct snd_kcontrol
*kcontrol
,
1899 struct snd_ctl_elem_info
*uinfo
)
1901 static char *texts
[] = {
1902 "N/A", "Line Out", "HP Out",
1903 "In Hi-Z", "In 50%", "In Grd", "In 80%", "In 100%"
1905 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_ENUMERATED
;
1907 uinfo
->value
.enumerated
.items
= 8;
1908 if (uinfo
->value
.enumerated
.item
>= 8)
1909 uinfo
->value
.enumerated
.item
= 7;
1910 strcpy(uinfo
->value
.enumerated
.name
, texts
[uinfo
->value
.enumerated
.item
]);
1914 static int alc_test_pin_ctl_get(struct snd_kcontrol
*kcontrol
,
1915 struct snd_ctl_elem_value
*ucontrol
)
1917 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
1918 hda_nid_t nid
= (hda_nid_t
)kcontrol
->private_value
;
1919 unsigned int pin_ctl
, item
= 0;
1921 pin_ctl
= snd_hda_codec_read(codec
, nid
, 0,
1922 AC_VERB_GET_PIN_WIDGET_CONTROL
, 0);
1923 if (pin_ctl
& AC_PINCTL_OUT_EN
) {
1924 if (pin_ctl
& AC_PINCTL_HP_EN
)
1928 } else if (pin_ctl
& AC_PINCTL_IN_EN
) {
1929 switch (pin_ctl
& AC_PINCTL_VREFEN
) {
1930 case AC_PINCTL_VREF_HIZ
: item
= 3; break;
1931 case AC_PINCTL_VREF_50
: item
= 4; break;
1932 case AC_PINCTL_VREF_GRD
: item
= 5; break;
1933 case AC_PINCTL_VREF_80
: item
= 6; break;
1934 case AC_PINCTL_VREF_100
: item
= 7; break;
1937 ucontrol
->value
.enumerated
.item
[0] = item
;
1941 static int alc_test_pin_ctl_put(struct snd_kcontrol
*kcontrol
,
1942 struct snd_ctl_elem_value
*ucontrol
)
1944 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
1945 hda_nid_t nid
= (hda_nid_t
)kcontrol
->private_value
;
1946 static unsigned int ctls
[] = {
1947 0, AC_PINCTL_OUT_EN
, AC_PINCTL_OUT_EN
| AC_PINCTL_HP_EN
,
1948 AC_PINCTL_IN_EN
| AC_PINCTL_VREF_HIZ
,
1949 AC_PINCTL_IN_EN
| AC_PINCTL_VREF_50
,
1950 AC_PINCTL_IN_EN
| AC_PINCTL_VREF_GRD
,
1951 AC_PINCTL_IN_EN
| AC_PINCTL_VREF_80
,
1952 AC_PINCTL_IN_EN
| AC_PINCTL_VREF_100
,
1954 unsigned int old_ctl
, new_ctl
;
1956 old_ctl
= snd_hda_codec_read(codec
, nid
, 0,
1957 AC_VERB_GET_PIN_WIDGET_CONTROL
, 0);
1958 new_ctl
= ctls
[ucontrol
->value
.enumerated
.item
[0]];
1959 if (old_ctl
!= new_ctl
) {
1960 snd_hda_codec_write(codec
, nid
, 0,
1961 AC_VERB_SET_PIN_WIDGET_CONTROL
, new_ctl
);
1962 snd_hda_codec_write(codec
, nid
, 0, AC_VERB_SET_AMP_GAIN_MUTE
,
1963 (ucontrol
->value
.enumerated
.item
[0] >= 3 ?
1970 static int alc_test_pin_src_info(struct snd_kcontrol
*kcontrol
,
1971 struct snd_ctl_elem_info
*uinfo
)
1973 static char *texts
[] = {
1974 "Front", "Surround", "CLFE", "Side"
1976 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_ENUMERATED
;
1978 uinfo
->value
.enumerated
.items
= 4;
1979 if (uinfo
->value
.enumerated
.item
>= 4)
1980 uinfo
->value
.enumerated
.item
= 3;
1981 strcpy(uinfo
->value
.enumerated
.name
, texts
[uinfo
->value
.enumerated
.item
]);
1985 static int alc_test_pin_src_get(struct snd_kcontrol
*kcontrol
,
1986 struct snd_ctl_elem_value
*ucontrol
)
1988 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
1989 hda_nid_t nid
= (hda_nid_t
)kcontrol
->private_value
;
1992 sel
= snd_hda_codec_read(codec
, nid
, 0, AC_VERB_GET_CONNECT_SEL
, 0);
1993 ucontrol
->value
.enumerated
.item
[0] = sel
& 3;
1997 static int alc_test_pin_src_put(struct snd_kcontrol
*kcontrol
,
1998 struct snd_ctl_elem_value
*ucontrol
)
2000 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
2001 hda_nid_t nid
= (hda_nid_t
)kcontrol
->private_value
;
2004 sel
= snd_hda_codec_read(codec
, nid
, 0, AC_VERB_GET_CONNECT_SEL
, 0) & 3;
2005 if (ucontrol
->value
.enumerated
.item
[0] != sel
) {
2006 sel
= ucontrol
->value
.enumerated
.item
[0] & 3;
2007 snd_hda_codec_write(codec
, nid
, 0, AC_VERB_SET_CONNECT_SEL
, sel
);
2013 #define PIN_CTL_TEST(xname,nid) { \
2014 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
2016 .info = alc_test_pin_ctl_info, \
2017 .get = alc_test_pin_ctl_get, \
2018 .put = alc_test_pin_ctl_put, \
2019 .private_value = nid \
2022 #define PIN_SRC_TEST(xname,nid) { \
2023 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
2025 .info = alc_test_pin_src_info, \
2026 .get = alc_test_pin_src_get, \
2027 .put = alc_test_pin_src_put, \
2028 .private_value = nid \
2031 static struct snd_kcontrol_new alc880_test_mixer
[] = {
2032 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT
),
2033 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT
),
2034 HDA_CODEC_VOLUME("CLFE Playback Volume", 0x0e, 0x0, HDA_OUTPUT
),
2035 HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT
),
2036 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT
),
2037 HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT
),
2038 HDA_BIND_MUTE("CLFE Playback Switch", 0x0e, 2, HDA_INPUT
),
2039 HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT
),
2040 PIN_CTL_TEST("Front Pin Mode", 0x14),
2041 PIN_CTL_TEST("Surround Pin Mode", 0x15),
2042 PIN_CTL_TEST("CLFE Pin Mode", 0x16),
2043 PIN_CTL_TEST("Side Pin Mode", 0x17),
2044 PIN_CTL_TEST("In-1 Pin Mode", 0x18),
2045 PIN_CTL_TEST("In-2 Pin Mode", 0x19),
2046 PIN_CTL_TEST("In-3 Pin Mode", 0x1a),
2047 PIN_CTL_TEST("In-4 Pin Mode", 0x1b),
2048 PIN_SRC_TEST("In-1 Pin Source", 0x18),
2049 PIN_SRC_TEST("In-2 Pin Source", 0x19),
2050 PIN_SRC_TEST("In-3 Pin Source", 0x1a),
2051 PIN_SRC_TEST("In-4 Pin Source", 0x1b),
2052 HDA_CODEC_VOLUME("In-1 Playback Volume", 0x0b, 0x0, HDA_INPUT
),
2053 HDA_CODEC_MUTE("In-1 Playback Switch", 0x0b, 0x0, HDA_INPUT
),
2054 HDA_CODEC_VOLUME("In-2 Playback Volume", 0x0b, 0x1, HDA_INPUT
),
2055 HDA_CODEC_MUTE("In-2 Playback Switch", 0x0b, 0x1, HDA_INPUT
),
2056 HDA_CODEC_VOLUME("In-3 Playback Volume", 0x0b, 0x2, HDA_INPUT
),
2057 HDA_CODEC_MUTE("In-3 Playback Switch", 0x0b, 0x2, HDA_INPUT
),
2058 HDA_CODEC_VOLUME("In-4 Playback Volume", 0x0b, 0x3, HDA_INPUT
),
2059 HDA_CODEC_MUTE("In-4 Playback Switch", 0x0b, 0x3, HDA_INPUT
),
2060 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x4, HDA_INPUT
),
2061 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x4, HDA_INPUT
),
2063 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
2064 .name
= "Channel Mode",
2065 .info
= alc_ch_mode_info
,
2066 .get
= alc_ch_mode_get
,
2067 .put
= alc_ch_mode_put
,
2072 static struct hda_verb alc880_test_init_verbs
[] = {
2073 /* Unmute inputs of 0x0c - 0x0f */
2074 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(0)},
2075 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(1)},
2076 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(0)},
2077 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(1)},
2078 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(0)},
2079 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(1)},
2080 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(0)},
2081 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(1)},
2082 /* Vol output for 0x0c-0x0f */
2083 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_ZERO
},
2084 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_ZERO
},
2085 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_ZERO
},
2086 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_ZERO
},
2087 /* Set output pins 0x14-0x17 */
2088 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_OUT
},
2089 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_OUT
},
2090 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_OUT
},
2091 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_OUT
},
2092 /* Unmute output pins 0x14-0x17 */
2093 {0x14, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_UNMUTE
},
2094 {0x15, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_UNMUTE
},
2095 {0x16, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_UNMUTE
},
2096 {0x17, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_UNMUTE
},
2097 /* Set input pins 0x18-0x1c */
2098 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_VREF80
},
2099 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_VREF80
},
2100 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_IN
},
2101 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_IN
},
2102 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_IN
},
2103 /* Mute input pins 0x18-0x1b */
2104 {0x18, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_MUTE
},
2105 {0x19, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_MUTE
},
2106 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_MUTE
},
2107 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_MUTE
},
2109 {0x07, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_MUTE(0)},
2110 {0x07, AC_VERB_SET_CONNECT_SEL
, 0x00},
2111 {0x08, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_MUTE(0)},
2112 {0x08, AC_VERB_SET_CONNECT_SEL
, 0x00},
2113 {0x09, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_MUTE(0)},
2114 {0x09, AC_VERB_SET_CONNECT_SEL
, 0x00},
2115 /* Analog input/passthru */
2116 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_MUTE(0)},
2117 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_MUTE(1)},
2118 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_MUTE(2)},
2119 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_MUTE(3)},
2120 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_MUTE(4)},
2128 static struct hda_board_config alc880_cfg_tbl
[] = {
2129 /* Back 3 jack, front 2 jack */
2130 { .modelname
= "3stack", .config
= ALC880_3ST
},
2131 { .pci_subvendor
= 0x8086, .pci_subdevice
= 0xe200, .config
= ALC880_3ST
},
2132 { .pci_subvendor
= 0x8086, .pci_subdevice
= 0xe201, .config
= ALC880_3ST
},
2133 { .pci_subvendor
= 0x8086, .pci_subdevice
= 0xe202, .config
= ALC880_3ST
},
2134 { .pci_subvendor
= 0x8086, .pci_subdevice
= 0xe203, .config
= ALC880_3ST
},
2135 { .pci_subvendor
= 0x8086, .pci_subdevice
= 0xe204, .config
= ALC880_3ST
},
2136 { .pci_subvendor
= 0x8086, .pci_subdevice
= 0xe205, .config
= ALC880_3ST
},
2137 { .pci_subvendor
= 0x8086, .pci_subdevice
= 0xe206, .config
= ALC880_3ST
},
2138 { .pci_subvendor
= 0x8086, .pci_subdevice
= 0xe207, .config
= ALC880_3ST
},
2139 { .pci_subvendor
= 0x8086, .pci_subdevice
= 0xe208, .config
= ALC880_3ST
},
2140 { .pci_subvendor
= 0x8086, .pci_subdevice
= 0xe209, .config
= ALC880_3ST
},
2141 { .pci_subvendor
= 0x8086, .pci_subdevice
= 0xe20a, .config
= ALC880_3ST
},
2142 { .pci_subvendor
= 0x8086, .pci_subdevice
= 0xe20b, .config
= ALC880_3ST
},
2143 { .pci_subvendor
= 0x8086, .pci_subdevice
= 0xe20c, .config
= ALC880_3ST
},
2144 { .pci_subvendor
= 0x8086, .pci_subdevice
= 0xe20d, .config
= ALC880_3ST
},
2145 { .pci_subvendor
= 0x8086, .pci_subdevice
= 0xe20e, .config
= ALC880_3ST
},
2146 { .pci_subvendor
= 0x8086, .pci_subdevice
= 0xe20f, .config
= ALC880_3ST
},
2147 { .pci_subvendor
= 0x8086, .pci_subdevice
= 0xe210, .config
= ALC880_3ST
},
2148 { .pci_subvendor
= 0x8086, .pci_subdevice
= 0xe211, .config
= ALC880_3ST
},
2149 { .pci_subvendor
= 0x8086, .pci_subdevice
= 0xe212, .config
= ALC880_3ST
},
2150 { .pci_subvendor
= 0x8086, .pci_subdevice
= 0xe213, .config
= ALC880_3ST
},
2151 { .pci_subvendor
= 0x8086, .pci_subdevice
= 0xe214, .config
= ALC880_3ST
},
2152 { .pci_subvendor
= 0x8086, .pci_subdevice
= 0xe234, .config
= ALC880_3ST
},
2153 { .pci_subvendor
= 0x8086, .pci_subdevice
= 0xe302, .config
= ALC880_3ST
},
2154 { .pci_subvendor
= 0x8086, .pci_subdevice
= 0xe303, .config
= ALC880_3ST
},
2155 { .pci_subvendor
= 0x8086, .pci_subdevice
= 0xe304, .config
= ALC880_3ST
},
2156 { .pci_subvendor
= 0x8086, .pci_subdevice
= 0xe306, .config
= ALC880_3ST
},
2157 { .pci_subvendor
= 0x8086, .pci_subdevice
= 0xe307, .config
= ALC880_3ST
},
2158 { .pci_subvendor
= 0x8086, .pci_subdevice
= 0xe404, .config
= ALC880_3ST
},
2159 { .pci_subvendor
= 0x8086, .pci_subdevice
= 0xa101, .config
= ALC880_3ST
},
2160 { .pci_subvendor
= 0x107b, .pci_subdevice
= 0x3031, .config
= ALC880_3ST
},
2161 { .pci_subvendor
= 0x107b, .pci_subdevice
= 0x4036, .config
= ALC880_3ST
},
2162 { .pci_subvendor
= 0x107b, .pci_subdevice
= 0x4037, .config
= ALC880_3ST
},
2163 { .pci_subvendor
= 0x107b, .pci_subdevice
= 0x4038, .config
= ALC880_3ST
},
2164 { .pci_subvendor
= 0x107b, .pci_subdevice
= 0x4040, .config
= ALC880_3ST
},
2165 { .pci_subvendor
= 0x107b, .pci_subdevice
= 0x4041, .config
= ALC880_3ST
},
2167 { .modelname
= "tcl", .config
= ALC880_TCL_S700
},
2168 { .pci_subvendor
= 0x19db, .pci_subdevice
= 0x4188, .config
= ALC880_TCL_S700
},
2170 /* Back 3 jack, front 2 jack (Internal add Aux-In) */
2171 { .pci_subvendor
= 0x1025, .pci_subdevice
= 0xe310, .config
= ALC880_3ST
},
2172 { .pci_subvendor
= 0x104d, .pci_subdevice
= 0x81d6, .config
= ALC880_3ST
},
2173 { .pci_subvendor
= 0x104d, .pci_subdevice
= 0x81a0, .config
= ALC880_3ST
},
2175 /* Back 3 jack plus 1 SPDIF out jack, front 2 jack */
2176 { .modelname
= "3stack-digout", .config
= ALC880_3ST_DIG
},
2177 { .pci_subvendor
= 0x8086, .pci_subdevice
= 0xe308, .config
= ALC880_3ST_DIG
},
2178 { .pci_subvendor
= 0x1025, .pci_subdevice
= 0x0070, .config
= ALC880_3ST_DIG
},
2181 { .modelname
= "clevo", .config
= ALC880_CLEVO
},
2182 { .pci_subvendor
= 0x1558, .pci_subdevice
= 0x0520,
2183 .config
= ALC880_CLEVO
}, /* Clevo m520G NB */
2184 { .pci_subvendor
= 0x1558, .pci_subdevice
= 0x0660,
2185 .config
= ALC880_CLEVO
}, /* Clevo m665n */
2187 /* Back 3 jack plus 1 SPDIF out jack, front 2 jack (Internal add Aux-In)*/
2188 { .pci_subvendor
= 0x8086, .pci_subdevice
= 0xe305, .config
= ALC880_3ST_DIG
},
2189 { .pci_subvendor
= 0x8086, .pci_subdevice
= 0xd402, .config
= ALC880_3ST_DIG
},
2190 { .pci_subvendor
= 0x1025, .pci_subdevice
= 0xe309, .config
= ALC880_3ST_DIG
},
2192 /* Back 5 jack, front 2 jack */
2193 { .modelname
= "5stack", .config
= ALC880_5ST
},
2194 { .pci_subvendor
= 0x107b, .pci_subdevice
= 0x3033, .config
= ALC880_5ST
},
2195 { .pci_subvendor
= 0x107b, .pci_subdevice
= 0x4039, .config
= ALC880_5ST
},
2196 { .pci_subvendor
= 0x107b, .pci_subdevice
= 0x3032, .config
= ALC880_5ST
},
2197 { .pci_subvendor
= 0x103c, .pci_subdevice
= 0x2a09, .config
= ALC880_5ST
},
2198 { .pci_subvendor
= 0x1043, .pci_subdevice
= 0x814e, .config
= ALC880_5ST
},
2200 /* Back 5 jack plus 1 SPDIF out jack, front 2 jack */
2201 { .modelname
= "5stack-digout", .config
= ALC880_5ST_DIG
},
2202 { .pci_subvendor
= 0x8086, .pci_subdevice
= 0xe224, .config
= ALC880_5ST_DIG
},
2203 { .pci_subvendor
= 0x8086, .pci_subdevice
= 0xe400, .config
= ALC880_5ST_DIG
},
2204 { .pci_subvendor
= 0x8086, .pci_subdevice
= 0xe401, .config
= ALC880_5ST_DIG
},
2205 { .pci_subvendor
= 0x8086, .pci_subdevice
= 0xe402, .config
= ALC880_5ST_DIG
},
2206 { .pci_subvendor
= 0x8086, .pci_subdevice
= 0xd400, .config
= ALC880_5ST_DIG
},
2207 { .pci_subvendor
= 0x8086, .pci_subdevice
= 0xd401, .config
= ALC880_5ST_DIG
},
2208 { .pci_subvendor
= 0x8086, .pci_subdevice
= 0xa100, .config
= ALC880_5ST_DIG
},
2209 { .pci_subvendor
= 0x1565, .pci_subdevice
= 0x8202, .config
= ALC880_5ST_DIG
},
2210 { .pci_subvendor
= 0x1019, .pci_subdevice
= 0xa880, .config
= ALC880_5ST_DIG
},
2211 { .pci_subvendor
= 0xa0a0, .pci_subdevice
= 0x0560,
2212 .config
= ALC880_5ST_DIG
}, /* Aopen i915GMm-HFS */
2213 /* { .pci_subvendor = 0x1019, .pci_subdevice = 0xa884, .config = ALC880_5ST_DIG }, */ /* conflict with 6stack */
2214 { .pci_subvendor
= 0x1695, .pci_subdevice
= 0x400d, .config
= ALC880_5ST_DIG
},
2215 /* note subvendor = 0 below */
2216 /* { .pci_subvendor = 0x0000, .pci_subdevice = 0x8086, .config = ALC880_5ST_DIG }, */
2218 { .modelname
= "w810", .config
= ALC880_W810
},
2219 { .pci_subvendor
= 0x161f, .pci_subdevice
= 0x203d, .config
= ALC880_W810
},
2221 { .modelname
= "z71v", .config
= ALC880_Z71V
},
2222 { .pci_subvendor
= 0x1043, .pci_subdevice
= 0x1964, .config
= ALC880_Z71V
},
2224 { .modelname
= "6stack", .config
= ALC880_6ST
},
2225 { .pci_subvendor
= 0x1043, .pci_subdevice
= 0x8196, .config
= ALC880_6ST
}, /* ASUS P5GD1-HVM */
2226 { .pci_subvendor
= 0x1043, .pci_subdevice
= 0x81b4, .config
= ALC880_6ST
},
2227 { .pci_subvendor
= 0x1019, .pci_subdevice
= 0xa884, .config
= ALC880_6ST
}, /* Acer APFV */
2228 { .pci_subvendor
= 0x1458, .pci_subdevice
= 0xa102, .config
= ALC880_6ST
}, /* Gigabyte K8N51 */
2230 { .modelname
= "6stack-digout", .config
= ALC880_6ST_DIG
},
2231 { .pci_subvendor
= 0x2668, .pci_subdevice
= 0x8086, .config
= ALC880_6ST_DIG
},
2232 { .pci_subvendor
= 0x8086, .pci_subdevice
= 0x2668, .config
= ALC880_6ST_DIG
},
2233 { .pci_subvendor
= 0x1462, .pci_subdevice
= 0x1150, .config
= ALC880_6ST_DIG
},
2234 { .pci_subvendor
= 0xe803, .pci_subdevice
= 0x1019, .config
= ALC880_6ST_DIG
},
2235 { .pci_subvendor
= 0x1039, .pci_subdevice
= 0x1234, .config
= ALC880_6ST_DIG
},
2236 { .pci_subvendor
= 0x1025, .pci_subdevice
= 0x0077, .config
= ALC880_6ST_DIG
},
2237 { .pci_subvendor
= 0x1025, .pci_subdevice
= 0x0078, .config
= ALC880_6ST_DIG
},
2238 { .pci_subvendor
= 0x1025, .pci_subdevice
= 0x0087, .config
= ALC880_6ST_DIG
},
2239 { .pci_subvendor
= 0x1297, .pci_subdevice
= 0xc790, .config
= ALC880_6ST_DIG
}, /* Shuttle ST20G5 */
2240 { .pci_subvendor
= 0x1509, .pci_subdevice
= 0x925d, .config
= ALC880_6ST_DIG
}, /* FIC P4M-915GD1 */
2241 { .pci_subvendor
= 0x1695, .pci_subdevice
= 0x4012, .config
= ALC880_5ST_DIG
}, /* Epox EP-5LDA+ GLi */
2243 { .modelname
= "asus", .config
= ALC880_ASUS
},
2244 { .pci_subvendor
= 0x1043, .pci_subdevice
= 0x1964, .config
= ALC880_ASUS_DIG
},
2245 { .pci_subvendor
= 0x1043, .pci_subdevice
= 0x1973, .config
= ALC880_ASUS_DIG
},
2246 { .pci_subvendor
= 0x1043, .pci_subdevice
= 0x19b3, .config
= ALC880_ASUS_DIG
},
2247 { .pci_subvendor
= 0x1043, .pci_subdevice
= 0x1113, .config
= ALC880_ASUS_DIG
},
2248 { .pci_subvendor
= 0x1043, .pci_subdevice
= 0x1173, .config
= ALC880_ASUS_DIG
},
2249 { .pci_subvendor
= 0x1043, .pci_subdevice
= 0x1993, .config
= ALC880_ASUS
},
2250 { .pci_subvendor
= 0x1043, .pci_subdevice
= 0x10c2, .config
= ALC880_ASUS_DIG
}, /* Asus W6A */
2251 { .pci_subvendor
= 0x1043, .pci_subdevice
= 0x10c3, .config
= ALC880_ASUS_DIG
},
2252 { .pci_subvendor
= 0x1043, .pci_subdevice
= 0x1133, .config
= ALC880_ASUS
},
2253 { .pci_subvendor
= 0x1043, .pci_subdevice
= 0x1123, .config
= ALC880_ASUS_DIG
},
2254 { .pci_subvendor
= 0x1043, .pci_subdevice
= 0x1143, .config
= ALC880_ASUS
},
2255 { .modelname
= "asus-w1v", .config
= ALC880_ASUS_W1V
},
2256 { .pci_subvendor
= 0x1043, .pci_subdevice
= 0x10b3, .config
= ALC880_ASUS_W1V
},
2257 { .modelname
= "asus-dig", .config
= ALC880_ASUS_DIG
},
2258 { .pci_subvendor
= 0x1043, .pci_subdevice
= 0x8181, .config
= ALC880_ASUS_DIG
}, /* ASUS P4GPL-X */
2259 { .modelname
= "asus-dig2", .config
= ALC880_ASUS_DIG2
},
2260 { .pci_subvendor
= 0x1558, .pci_subdevice
= 0x5401, .config
= ALC880_ASUS_DIG2
},
2262 { .modelname
= "uniwill", .config
= ALC880_UNIWILL_DIG
},
2263 { .pci_subvendor
= 0x1584, .pci_subdevice
= 0x9050, .config
= ALC880_UNIWILL_DIG
},
2265 { .modelname
= "F1734", .config
= ALC880_F1734
},
2266 { .pci_subvendor
= 0x1734, .pci_subdevice
= 0x107c, .config
= ALC880_F1734
},
2267 { .pci_subvendor
= 0x1584, .pci_subdevice
= 0x9054, .config
= ALC880_F1734
},
2269 { .modelname
= "lg", .config
= ALC880_LG
},
2270 { .pci_subvendor
= 0x1854, .pci_subdevice
= 0x003b, .config
= ALC880_LG
},
2271 { .pci_subvendor
= 0x1854, .pci_subdevice
= 0x0068, .config
= ALC880_LG
},
2273 { .modelname
= "lg-lw", .config
= ALC880_LG_LW
},
2274 { .pci_subvendor
= 0x1854, .pci_subdevice
= 0x0018, .config
= ALC880_LG_LW
},
2275 { .pci_subvendor
= 0x1854, .pci_subdevice
= 0x0077, .config
= ALC880_LG_LW
},
2277 #ifdef CONFIG_SND_DEBUG
2278 { .modelname
= "test", .config
= ALC880_TEST
},
2280 { .modelname
= "auto", .config
= ALC880_AUTO
},
2286 * ALC880 codec presets
2288 static struct alc_config_preset alc880_presets
[] = {
2290 .mixers
= { alc880_three_stack_mixer
},
2291 .init_verbs
= { alc880_volume_init_verbs
, alc880_pin_3stack_init_verbs
},
2292 .num_dacs
= ARRAY_SIZE(alc880_dac_nids
),
2293 .dac_nids
= alc880_dac_nids
,
2294 .num_channel_mode
= ARRAY_SIZE(alc880_threestack_modes
),
2295 .channel_mode
= alc880_threestack_modes
,
2297 .input_mux
= &alc880_capture_source
,
2299 [ALC880_3ST_DIG
] = {
2300 .mixers
= { alc880_three_stack_mixer
},
2301 .init_verbs
= { alc880_volume_init_verbs
, alc880_pin_3stack_init_verbs
},
2302 .num_dacs
= ARRAY_SIZE(alc880_dac_nids
),
2303 .dac_nids
= alc880_dac_nids
,
2304 .dig_out_nid
= ALC880_DIGOUT_NID
,
2305 .num_channel_mode
= ARRAY_SIZE(alc880_threestack_modes
),
2306 .channel_mode
= alc880_threestack_modes
,
2308 .input_mux
= &alc880_capture_source
,
2310 [ALC880_TCL_S700
] = {
2311 .mixers
= { alc880_tcl_s700_mixer
},
2312 .init_verbs
= { alc880_volume_init_verbs
,
2313 alc880_pin_tcl_S700_init_verbs
,
2314 alc880_gpio2_init_verbs
},
2315 .num_dacs
= ARRAY_SIZE(alc880_dac_nids
),
2316 .dac_nids
= alc880_dac_nids
,
2318 .num_channel_mode
= ARRAY_SIZE(alc880_2_jack_modes
),
2319 .channel_mode
= alc880_2_jack_modes
,
2320 .input_mux
= &alc880_capture_source
,
2323 .mixers
= { alc880_three_stack_mixer
, alc880_five_stack_mixer
},
2324 .init_verbs
= { alc880_volume_init_verbs
, alc880_pin_5stack_init_verbs
},
2325 .num_dacs
= ARRAY_SIZE(alc880_dac_nids
),
2326 .dac_nids
= alc880_dac_nids
,
2327 .num_channel_mode
= ARRAY_SIZE(alc880_fivestack_modes
),
2328 .channel_mode
= alc880_fivestack_modes
,
2329 .input_mux
= &alc880_capture_source
,
2331 [ALC880_5ST_DIG
] = {
2332 .mixers
= { alc880_three_stack_mixer
, alc880_five_stack_mixer
},
2333 .init_verbs
= { alc880_volume_init_verbs
, alc880_pin_5stack_init_verbs
},
2334 .num_dacs
= ARRAY_SIZE(alc880_dac_nids
),
2335 .dac_nids
= alc880_dac_nids
,
2336 .dig_out_nid
= ALC880_DIGOUT_NID
,
2337 .num_channel_mode
= ARRAY_SIZE(alc880_fivestack_modes
),
2338 .channel_mode
= alc880_fivestack_modes
,
2339 .input_mux
= &alc880_capture_source
,
2342 .mixers
= { alc880_six_stack_mixer
},
2343 .init_verbs
= { alc880_volume_init_verbs
, alc880_pin_6stack_init_verbs
},
2344 .num_dacs
= ARRAY_SIZE(alc880_6st_dac_nids
),
2345 .dac_nids
= alc880_6st_dac_nids
,
2346 .num_channel_mode
= ARRAY_SIZE(alc880_sixstack_modes
),
2347 .channel_mode
= alc880_sixstack_modes
,
2348 .input_mux
= &alc880_6stack_capture_source
,
2350 [ALC880_6ST_DIG
] = {
2351 .mixers
= { alc880_six_stack_mixer
},
2352 .init_verbs
= { alc880_volume_init_verbs
, alc880_pin_6stack_init_verbs
},
2353 .num_dacs
= ARRAY_SIZE(alc880_6st_dac_nids
),
2354 .dac_nids
= alc880_6st_dac_nids
,
2355 .dig_out_nid
= ALC880_DIGOUT_NID
,
2356 .num_channel_mode
= ARRAY_SIZE(alc880_sixstack_modes
),
2357 .channel_mode
= alc880_sixstack_modes
,
2358 .input_mux
= &alc880_6stack_capture_source
,
2361 .mixers
= { alc880_w810_base_mixer
},
2362 .init_verbs
= { alc880_volume_init_verbs
, alc880_pin_w810_init_verbs
,
2363 alc880_gpio2_init_verbs
},
2364 .num_dacs
= ARRAY_SIZE(alc880_w810_dac_nids
),
2365 .dac_nids
= alc880_w810_dac_nids
,
2366 .dig_out_nid
= ALC880_DIGOUT_NID
,
2367 .num_channel_mode
= ARRAY_SIZE(alc880_w810_modes
),
2368 .channel_mode
= alc880_w810_modes
,
2369 .input_mux
= &alc880_capture_source
,
2372 .mixers
= { alc880_z71v_mixer
},
2373 .init_verbs
= { alc880_volume_init_verbs
, alc880_pin_z71v_init_verbs
},
2374 .num_dacs
= ARRAY_SIZE(alc880_z71v_dac_nids
),
2375 .dac_nids
= alc880_z71v_dac_nids
,
2376 .dig_out_nid
= ALC880_DIGOUT_NID
,
2378 .num_channel_mode
= ARRAY_SIZE(alc880_2_jack_modes
),
2379 .channel_mode
= alc880_2_jack_modes
,
2380 .input_mux
= &alc880_capture_source
,
2383 .mixers
= { alc880_f1734_mixer
},
2384 .init_verbs
= { alc880_volume_init_verbs
, alc880_pin_f1734_init_verbs
},
2385 .num_dacs
= ARRAY_SIZE(alc880_f1734_dac_nids
),
2386 .dac_nids
= alc880_f1734_dac_nids
,
2388 .num_channel_mode
= ARRAY_SIZE(alc880_2_jack_modes
),
2389 .channel_mode
= alc880_2_jack_modes
,
2390 .input_mux
= &alc880_capture_source
,
2393 .mixers
= { alc880_asus_mixer
},
2394 .init_verbs
= { alc880_volume_init_verbs
, alc880_pin_asus_init_verbs
,
2395 alc880_gpio1_init_verbs
},
2396 .num_dacs
= ARRAY_SIZE(alc880_asus_dac_nids
),
2397 .dac_nids
= alc880_asus_dac_nids
,
2398 .num_channel_mode
= ARRAY_SIZE(alc880_asus_modes
),
2399 .channel_mode
= alc880_asus_modes
,
2401 .input_mux
= &alc880_capture_source
,
2403 [ALC880_ASUS_DIG
] = {
2404 .mixers
= { alc880_asus_mixer
},
2405 .init_verbs
= { alc880_volume_init_verbs
, alc880_pin_asus_init_verbs
,
2406 alc880_gpio1_init_verbs
},
2407 .num_dacs
= ARRAY_SIZE(alc880_asus_dac_nids
),
2408 .dac_nids
= alc880_asus_dac_nids
,
2409 .dig_out_nid
= ALC880_DIGOUT_NID
,
2410 .num_channel_mode
= ARRAY_SIZE(alc880_asus_modes
),
2411 .channel_mode
= alc880_asus_modes
,
2413 .input_mux
= &alc880_capture_source
,
2415 [ALC880_ASUS_DIG2
] = {
2416 .mixers
= { alc880_asus_mixer
},
2417 .init_verbs
= { alc880_volume_init_verbs
, alc880_pin_asus_init_verbs
,
2418 alc880_gpio2_init_verbs
}, /* use GPIO2 */
2419 .num_dacs
= ARRAY_SIZE(alc880_asus_dac_nids
),
2420 .dac_nids
= alc880_asus_dac_nids
,
2421 .dig_out_nid
= ALC880_DIGOUT_NID
,
2422 .num_channel_mode
= ARRAY_SIZE(alc880_asus_modes
),
2423 .channel_mode
= alc880_asus_modes
,
2425 .input_mux
= &alc880_capture_source
,
2427 [ALC880_ASUS_W1V
] = {
2428 .mixers
= { alc880_asus_mixer
, alc880_asus_w1v_mixer
},
2429 .init_verbs
= { alc880_volume_init_verbs
, alc880_pin_asus_init_verbs
,
2430 alc880_gpio1_init_verbs
},
2431 .num_dacs
= ARRAY_SIZE(alc880_asus_dac_nids
),
2432 .dac_nids
= alc880_asus_dac_nids
,
2433 .dig_out_nid
= ALC880_DIGOUT_NID
,
2434 .num_channel_mode
= ARRAY_SIZE(alc880_asus_modes
),
2435 .channel_mode
= alc880_asus_modes
,
2437 .input_mux
= &alc880_capture_source
,
2439 [ALC880_UNIWILL_DIG
] = {
2440 .mixers
= { alc880_asus_mixer
, alc880_pcbeep_mixer
},
2441 .init_verbs
= { alc880_volume_init_verbs
, alc880_pin_asus_init_verbs
},
2442 .num_dacs
= ARRAY_SIZE(alc880_asus_dac_nids
),
2443 .dac_nids
= alc880_asus_dac_nids
,
2444 .dig_out_nid
= ALC880_DIGOUT_NID
,
2445 .num_channel_mode
= ARRAY_SIZE(alc880_asus_modes
),
2446 .channel_mode
= alc880_asus_modes
,
2448 .input_mux
= &alc880_capture_source
,
2451 .mixers
= { alc880_three_stack_mixer
},
2452 .init_verbs
= { alc880_volume_init_verbs
,
2453 alc880_pin_clevo_init_verbs
},
2454 .num_dacs
= ARRAY_SIZE(alc880_dac_nids
),
2455 .dac_nids
= alc880_dac_nids
,
2457 .num_channel_mode
= ARRAY_SIZE(alc880_threestack_modes
),
2458 .channel_mode
= alc880_threestack_modes
,
2460 .input_mux
= &alc880_capture_source
,
2463 .mixers
= { alc880_lg_mixer
},
2464 .init_verbs
= { alc880_volume_init_verbs
,
2465 alc880_lg_init_verbs
},
2466 .num_dacs
= ARRAY_SIZE(alc880_lg_dac_nids
),
2467 .dac_nids
= alc880_lg_dac_nids
,
2468 .dig_out_nid
= ALC880_DIGOUT_NID
,
2469 .num_channel_mode
= ARRAY_SIZE(alc880_lg_ch_modes
),
2470 .channel_mode
= alc880_lg_ch_modes
,
2472 .input_mux
= &alc880_lg_capture_source
,
2473 .unsol_event
= alc880_lg_unsol_event
,
2474 .init_hook
= alc880_lg_automute
,
2477 .mixers
= { alc880_lg_lw_mixer
},
2478 .init_verbs
= { alc880_volume_init_verbs
,
2479 alc880_lg_lw_init_verbs
},
2481 .dac_nids
= alc880_dac_nids
,
2482 .dig_out_nid
= ALC880_DIGOUT_NID
,
2483 .num_channel_mode
= ARRAY_SIZE(alc880_2_jack_modes
),
2484 .channel_mode
= alc880_2_jack_modes
,
2485 .input_mux
= &alc880_lg_lw_capture_source
,
2486 .unsol_event
= alc880_lg_lw_unsol_event
,
2487 .init_hook
= alc880_lg_lw_automute
,
2489 #ifdef CONFIG_SND_DEBUG
2491 .mixers
= { alc880_test_mixer
},
2492 .init_verbs
= { alc880_test_init_verbs
},
2493 .num_dacs
= ARRAY_SIZE(alc880_test_dac_nids
),
2494 .dac_nids
= alc880_test_dac_nids
,
2495 .dig_out_nid
= ALC880_DIGOUT_NID
,
2496 .num_channel_mode
= ARRAY_SIZE(alc880_test_modes
),
2497 .channel_mode
= alc880_test_modes
,
2498 .input_mux
= &alc880_test_capture_source
,
2504 * Automatic parse of I/O pins from the BIOS configuration
2507 #define NUM_CONTROL_ALLOC 32
2508 #define NUM_VERB_ALLOC 32
2512 ALC_CTL_WIDGET_MUTE
,
2515 static struct snd_kcontrol_new alc880_control_templates
[] = {
2516 HDA_CODEC_VOLUME(NULL
, 0, 0, 0),
2517 HDA_CODEC_MUTE(NULL
, 0, 0, 0),
2518 HDA_BIND_MUTE(NULL
, 0, 0, 0),
2521 /* add dynamic controls */
2522 static int add_control(struct alc_spec
*spec
, int type
, const char *name
, unsigned long val
)
2524 struct snd_kcontrol_new
*knew
;
2526 if (spec
->num_kctl_used
>= spec
->num_kctl_alloc
) {
2527 int num
= spec
->num_kctl_alloc
+ NUM_CONTROL_ALLOC
;
2529 knew
= kcalloc(num
+ 1, sizeof(*knew
), GFP_KERNEL
); /* array + terminator */
2532 if (spec
->kctl_alloc
) {
2533 memcpy(knew
, spec
->kctl_alloc
, sizeof(*knew
) * spec
->num_kctl_alloc
);
2534 kfree(spec
->kctl_alloc
);
2536 spec
->kctl_alloc
= knew
;
2537 spec
->num_kctl_alloc
= num
;
2540 knew
= &spec
->kctl_alloc
[spec
->num_kctl_used
];
2541 *knew
= alc880_control_templates
[type
];
2542 knew
->name
= kstrdup(name
, GFP_KERNEL
);
2545 knew
->private_value
= val
;
2546 spec
->num_kctl_used
++;
2550 #define alc880_is_fixed_pin(nid) ((nid) >= 0x14 && (nid) <= 0x17)
2551 #define alc880_fixed_pin_idx(nid) ((nid) - 0x14)
2552 #define alc880_is_multi_pin(nid) ((nid) >= 0x18)
2553 #define alc880_multi_pin_idx(nid) ((nid) - 0x18)
2554 #define alc880_is_input_pin(nid) ((nid) >= 0x18)
2555 #define alc880_input_pin_idx(nid) ((nid) - 0x18)
2556 #define alc880_idx_to_dac(nid) ((nid) + 0x02)
2557 #define alc880_dac_to_idx(nid) ((nid) - 0x02)
2558 #define alc880_idx_to_mixer(nid) ((nid) + 0x0c)
2559 #define alc880_idx_to_selector(nid) ((nid) + 0x10)
2560 #define ALC880_PIN_CD_NID 0x1c
2562 /* fill in the dac_nids table from the parsed pin configuration */
2563 static int alc880_auto_fill_dac_nids(struct alc_spec
*spec
, const struct auto_pin_cfg
*cfg
)
2569 memset(assigned
, 0, sizeof(assigned
));
2570 spec
->multiout
.dac_nids
= spec
->private_dac_nids
;
2572 /* check the pins hardwired to audio widget */
2573 for (i
= 0; i
< cfg
->line_outs
; i
++) {
2574 nid
= cfg
->line_out_pins
[i
];
2575 if (alc880_is_fixed_pin(nid
)) {
2576 int idx
= alc880_fixed_pin_idx(nid
);
2577 spec
->multiout
.dac_nids
[i
] = alc880_idx_to_dac(idx
);
2581 /* left pins can be connect to any audio widget */
2582 for (i
= 0; i
< cfg
->line_outs
; i
++) {
2583 nid
= cfg
->line_out_pins
[i
];
2584 if (alc880_is_fixed_pin(nid
))
2586 /* search for an empty channel */
2587 for (j
= 0; j
< cfg
->line_outs
; j
++) {
2588 if (! assigned
[j
]) {
2589 spec
->multiout
.dac_nids
[i
] = alc880_idx_to_dac(j
);
2595 spec
->multiout
.num_dacs
= cfg
->line_outs
;
2599 /* add playback controls from the parsed DAC table */
2600 static int alc880_auto_create_multi_out_ctls(struct alc_spec
*spec
,
2601 const struct auto_pin_cfg
*cfg
)
2604 static const char *chname
[4] = { "Front", "Surround", NULL
/*CLFE*/, "Side" };
2608 for (i
= 0; i
< cfg
->line_outs
; i
++) {
2609 if (! spec
->multiout
.dac_nids
[i
])
2611 nid
= alc880_idx_to_mixer(alc880_dac_to_idx(spec
->multiout
.dac_nids
[i
]));
2614 if ((err
= add_control(spec
, ALC_CTL_WIDGET_VOL
, "Center Playback Volume",
2615 HDA_COMPOSE_AMP_VAL(nid
, 1, 0, HDA_OUTPUT
))) < 0)
2617 if ((err
= add_control(spec
, ALC_CTL_WIDGET_VOL
, "LFE Playback Volume",
2618 HDA_COMPOSE_AMP_VAL(nid
, 2, 0, HDA_OUTPUT
))) < 0)
2620 if ((err
= add_control(spec
, ALC_CTL_BIND_MUTE
, "Center Playback Switch",
2621 HDA_COMPOSE_AMP_VAL(nid
, 1, 2, HDA_INPUT
))) < 0)
2623 if ((err
= add_control(spec
, ALC_CTL_BIND_MUTE
, "LFE Playback Switch",
2624 HDA_COMPOSE_AMP_VAL(nid
, 2, 2, HDA_INPUT
))) < 0)
2627 sprintf(name
, "%s Playback Volume", chname
[i
]);
2628 if ((err
= add_control(spec
, ALC_CTL_WIDGET_VOL
, name
,
2629 HDA_COMPOSE_AMP_VAL(nid
, 3, 0, HDA_OUTPUT
))) < 0)
2631 sprintf(name
, "%s Playback Switch", chname
[i
]);
2632 if ((err
= add_control(spec
, ALC_CTL_BIND_MUTE
, name
,
2633 HDA_COMPOSE_AMP_VAL(nid
, 3, 2, HDA_INPUT
))) < 0)
2640 /* add playback controls for speaker and HP outputs */
2641 static int alc880_auto_create_extra_out(struct alc_spec
*spec
, hda_nid_t pin
,
2651 if (alc880_is_fixed_pin(pin
)) {
2652 nid
= alc880_idx_to_dac(alc880_fixed_pin_idx(pin
));
2653 /* specify the DAC as the extra output */
2654 if (! spec
->multiout
.hp_nid
)
2655 spec
->multiout
.hp_nid
= nid
;
2657 spec
->multiout
.extra_out_nid
[0] = nid
;
2658 /* control HP volume/switch on the output mixer amp */
2659 nid
= alc880_idx_to_mixer(alc880_fixed_pin_idx(pin
));
2660 sprintf(name
, "%s Playback Volume", pfx
);
2661 if ((err
= add_control(spec
, ALC_CTL_WIDGET_VOL
, name
,
2662 HDA_COMPOSE_AMP_VAL(nid
, 3, 0, HDA_OUTPUT
))) < 0)
2664 sprintf(name
, "%s Playback Switch", pfx
);
2665 if ((err
= add_control(spec
, ALC_CTL_BIND_MUTE
, name
,
2666 HDA_COMPOSE_AMP_VAL(nid
, 3, 2, HDA_INPUT
))) < 0)
2668 } else if (alc880_is_multi_pin(pin
)) {
2669 /* set manual connection */
2670 /* we have only a switch on HP-out PIN */
2671 sprintf(name
, "%s Playback Switch", pfx
);
2672 if ((err
= add_control(spec
, ALC_CTL_WIDGET_MUTE
, name
,
2673 HDA_COMPOSE_AMP_VAL(pin
, 3, 0, HDA_OUTPUT
))) < 0)
2679 /* create input playback/capture controls for the given pin */
2680 static int new_analog_input(struct alc_spec
*spec
, hda_nid_t pin
, const char *ctlname
,
2681 int idx
, hda_nid_t mix_nid
)
2686 sprintf(name
, "%s Playback Volume", ctlname
);
2687 if ((err
= add_control(spec
, ALC_CTL_WIDGET_VOL
, name
,
2688 HDA_COMPOSE_AMP_VAL(mix_nid
, 3, idx
, HDA_INPUT
))) < 0)
2690 sprintf(name
, "%s Playback Switch", ctlname
);
2691 if ((err
= add_control(spec
, ALC_CTL_WIDGET_MUTE
, name
,
2692 HDA_COMPOSE_AMP_VAL(mix_nid
, 3, idx
, HDA_INPUT
))) < 0)
2697 /* create playback/capture controls for input pins */
2698 static int alc880_auto_create_analog_input_ctls(struct alc_spec
*spec
,
2699 const struct auto_pin_cfg
*cfg
)
2701 struct hda_input_mux
*imux
= &spec
->private_imux
;
2704 for (i
= 0; i
< AUTO_PIN_LAST
; i
++) {
2705 if (alc880_is_input_pin(cfg
->input_pins
[i
])) {
2706 idx
= alc880_input_pin_idx(cfg
->input_pins
[i
]);
2707 err
= new_analog_input(spec
, cfg
->input_pins
[i
],
2708 auto_pin_cfg_labels
[i
],
2712 imux
->items
[imux
->num_items
].label
= auto_pin_cfg_labels
[i
];
2713 imux
->items
[imux
->num_items
].index
= alc880_input_pin_idx(cfg
->input_pins
[i
]);
2720 static void alc880_auto_set_output_and_unmute(struct hda_codec
*codec
,
2721 hda_nid_t nid
, int pin_type
,
2725 snd_hda_codec_write(codec
, nid
, 0, AC_VERB_SET_PIN_WIDGET_CONTROL
, pin_type
);
2726 snd_hda_codec_write(codec
, nid
, 0, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_UNMUTE
);
2727 /* need the manual connection? */
2728 if (alc880_is_multi_pin(nid
)) {
2729 struct alc_spec
*spec
= codec
->spec
;
2730 int idx
= alc880_multi_pin_idx(nid
);
2731 snd_hda_codec_write(codec
, alc880_idx_to_selector(idx
), 0,
2732 AC_VERB_SET_CONNECT_SEL
,
2733 alc880_dac_to_idx(spec
->multiout
.dac_nids
[dac_idx
]));
2737 static void alc880_auto_init_multi_out(struct hda_codec
*codec
)
2739 struct alc_spec
*spec
= codec
->spec
;
2742 for (i
= 0; i
< spec
->autocfg
.line_outs
; i
++) {
2743 hda_nid_t nid
= spec
->autocfg
.line_out_pins
[i
];
2744 alc880_auto_set_output_and_unmute(codec
, nid
, PIN_OUT
, i
);
2748 static void alc880_auto_init_extra_out(struct hda_codec
*codec
)
2750 struct alc_spec
*spec
= codec
->spec
;
2753 pin
= spec
->autocfg
.speaker_pins
[0];
2754 if (pin
) /* connect to front */
2755 alc880_auto_set_output_and_unmute(codec
, pin
, PIN_OUT
, 0);
2756 pin
= spec
->autocfg
.hp_pins
[0];
2757 if (pin
) /* connect to front */
2758 alc880_auto_set_output_and_unmute(codec
, pin
, PIN_HP
, 0);
2761 static void alc880_auto_init_analog_input(struct hda_codec
*codec
)
2763 struct alc_spec
*spec
= codec
->spec
;
2766 for (i
= 0; i
< AUTO_PIN_LAST
; i
++) {
2767 hda_nid_t nid
= spec
->autocfg
.input_pins
[i
];
2768 if (alc880_is_input_pin(nid
)) {
2769 snd_hda_codec_write(codec
, nid
, 0, AC_VERB_SET_PIN_WIDGET_CONTROL
,
2770 i
<= AUTO_PIN_FRONT_MIC
? PIN_VREF80
: PIN_IN
);
2771 if (nid
!= ALC880_PIN_CD_NID
)
2772 snd_hda_codec_write(codec
, nid
, 0, AC_VERB_SET_AMP_GAIN_MUTE
,
2778 /* parse the BIOS configuration and set up the alc_spec */
2779 /* return 1 if successful, 0 if the proper config is not found, or a negative error code */
2780 static int alc880_parse_auto_config(struct hda_codec
*codec
)
2782 struct alc_spec
*spec
= codec
->spec
;
2784 static hda_nid_t alc880_ignore
[] = { 0x1d, 0 };
2786 if ((err
= snd_hda_parse_pin_def_config(codec
, &spec
->autocfg
,
2787 alc880_ignore
)) < 0)
2789 if (! spec
->autocfg
.line_outs
)
2790 return 0; /* can't find valid BIOS pin config */
2792 if ((err
= alc880_auto_fill_dac_nids(spec
, &spec
->autocfg
)) < 0 ||
2793 (err
= alc880_auto_create_multi_out_ctls(spec
, &spec
->autocfg
)) < 0 ||
2794 (err
= alc880_auto_create_extra_out(spec
,
2795 spec
->autocfg
.speaker_pins
[0],
2797 (err
= alc880_auto_create_extra_out(spec
, spec
->autocfg
.hp_pins
[0],
2798 "Headphone")) < 0 ||
2799 (err
= alc880_auto_create_analog_input_ctls(spec
, &spec
->autocfg
)) < 0)
2802 spec
->multiout
.max_channels
= spec
->multiout
.num_dacs
* 2;
2804 if (spec
->autocfg
.dig_out_pin
)
2805 spec
->multiout
.dig_out_nid
= ALC880_DIGOUT_NID
;
2806 if (spec
->autocfg
.dig_in_pin
)
2807 spec
->dig_in_nid
= ALC880_DIGIN_NID
;
2809 if (spec
->kctl_alloc
)
2810 spec
->mixers
[spec
->num_mixers
++] = spec
->kctl_alloc
;
2812 spec
->init_verbs
[spec
->num_init_verbs
++] = alc880_volume_init_verbs
;
2814 spec
->num_mux_defs
= 1;
2815 spec
->input_mux
= &spec
->private_imux
;
2820 /* additional initialization for auto-configuration model */
2821 static void alc880_auto_init(struct hda_codec
*codec
)
2823 alc880_auto_init_multi_out(codec
);
2824 alc880_auto_init_extra_out(codec
);
2825 alc880_auto_init_analog_input(codec
);
2829 * OK, here we have finally the patch for ALC880
2832 static int patch_alc880(struct hda_codec
*codec
)
2834 struct alc_spec
*spec
;
2838 spec
= kzalloc(sizeof(*spec
), GFP_KERNEL
);
2844 board_config
= snd_hda_check_board_config(codec
, alc880_cfg_tbl
);
2845 if (board_config
< 0 || board_config
>= ALC880_MODEL_LAST
) {
2846 printk(KERN_INFO
"hda_codec: Unknown model for ALC880, "
2847 "trying auto-probe from BIOS...\n");
2848 board_config
= ALC880_AUTO
;
2851 if (board_config
== ALC880_AUTO
) {
2852 /* automatic parse from the BIOS config */
2853 err
= alc880_parse_auto_config(codec
);
2859 "hda_codec: Cannot set up configuration "
2860 "from BIOS. Using 3-stack mode...\n");
2861 board_config
= ALC880_3ST
;
2865 if (board_config
!= ALC880_AUTO
)
2866 setup_preset(spec
, &alc880_presets
[board_config
]);
2868 spec
->stream_name_analog
= "ALC880 Analog";
2869 spec
->stream_analog_playback
= &alc880_pcm_analog_playback
;
2870 spec
->stream_analog_capture
= &alc880_pcm_analog_capture
;
2872 spec
->stream_name_digital
= "ALC880 Digital";
2873 spec
->stream_digital_playback
= &alc880_pcm_digital_playback
;
2874 spec
->stream_digital_capture
= &alc880_pcm_digital_capture
;
2876 if (! spec
->adc_nids
&& spec
->input_mux
) {
2877 /* check whether NID 0x07 is valid */
2878 unsigned int wcap
= get_wcaps(codec
, alc880_adc_nids
[0]);
2879 wcap
= (wcap
& AC_WCAP_TYPE
) >> AC_WCAP_TYPE_SHIFT
; /* get type */
2880 if (wcap
!= AC_WID_AUD_IN
) {
2881 spec
->adc_nids
= alc880_adc_nids_alt
;
2882 spec
->num_adc_nids
= ARRAY_SIZE(alc880_adc_nids_alt
);
2883 spec
->mixers
[spec
->num_mixers
] = alc880_capture_alt_mixer
;
2886 spec
->adc_nids
= alc880_adc_nids
;
2887 spec
->num_adc_nids
= ARRAY_SIZE(alc880_adc_nids
);
2888 spec
->mixers
[spec
->num_mixers
] = alc880_capture_mixer
;
2893 codec
->patch_ops
= alc_patch_ops
;
2894 if (board_config
== ALC880_AUTO
)
2895 spec
->init_hook
= alc880_auto_init
;
2905 static hda_nid_t alc260_dac_nids
[1] = {
2910 static hda_nid_t alc260_adc_nids
[1] = {
2915 static hda_nid_t alc260_adc_nids_alt
[1] = {
2920 static hda_nid_t alc260_hp_adc_nids
[2] = {
2925 /* NIDs used when simultaneous access to both ADCs makes sense. Note that
2926 * alc260_capture_mixer assumes ADC0 (nid 0x04) is the first ADC.
2928 static hda_nid_t alc260_dual_adc_nids
[2] = {
2933 #define ALC260_DIGOUT_NID 0x03
2934 #define ALC260_DIGIN_NID 0x06
2936 static struct hda_input_mux alc260_capture_source
= {
2940 { "Front Mic", 0x1 },
2946 /* On Fujitsu S702x laptops capture only makes sense from Mic/LineIn jack,
2947 * headphone jack and the internal CD lines since these are the only pins at
2948 * which audio can appear. For flexibility, also allow the option of
2949 * recording the mixer output on the second ADC (ADC0 doesn't have a
2950 * connection to the mixer output).
2952 static struct hda_input_mux alc260_fujitsu_capture_sources
[2] = {
2956 { "Mic/Line", 0x0 },
2958 { "Headphone", 0x2 },
2964 { "Mic/Line", 0x0 },
2966 { "Headphone", 0x2 },
2973 /* Acer TravelMate(/Extensa/Aspire) notebooks have similar configuration to
2974 * the Fujitsu S702x, but jacks are marked differently.
2976 static struct hda_input_mux alc260_acer_capture_sources
[2] = {
2983 { "Headphone", 0x5 },
2992 { "Headphone", 0x6 },
2998 * This is just place-holder, so there's something for alc_build_pcms to look
2999 * at when it calculates the maximum number of channels. ALC260 has no mixer
3000 * element which allows changing the channel mode, so the verb list is
3003 static struct hda_channel_mode alc260_modes
[1] = {
3008 /* Mixer combinations
3010 * basic: base_output + input + pc_beep + capture
3011 * HP: base_output + input + capture_alt
3012 * HP_3013: hp_3013 + input + capture
3013 * fujitsu: fujitsu + capture
3014 * acer: acer + capture
3017 static struct snd_kcontrol_new alc260_base_output_mixer
[] = {
3018 HDA_CODEC_VOLUME("Front Playback Volume", 0x08, 0x0, HDA_OUTPUT
),
3019 HDA_BIND_MUTE("Front Playback Switch", 0x08, 2, HDA_INPUT
),
3020 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x09, 0x0, HDA_OUTPUT
),
3021 HDA_BIND_MUTE("Headphone Playback Switch", 0x09, 2, HDA_INPUT
),
3022 HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT
),
3023 HDA_BIND_MUTE_MONO("Mono Playback Switch", 0x0a, 1, 2, HDA_INPUT
),
3027 static struct snd_kcontrol_new alc260_input_mixer
[] = {
3028 HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT
),
3029 HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT
),
3030 HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT
),
3031 HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT
),
3032 HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT
),
3033 HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT
),
3034 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x07, 0x01, HDA_INPUT
),
3035 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x07, 0x01, HDA_INPUT
),
3039 static struct snd_kcontrol_new alc260_pc_beep_mixer
[] = {
3040 HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x07, 0x05, HDA_INPUT
),
3041 HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x07, 0x05, HDA_INPUT
),
3045 static struct snd_kcontrol_new alc260_hp_3013_mixer
[] = {
3046 HDA_CODEC_VOLUME("Front Playback Volume", 0x09, 0x0, HDA_OUTPUT
),
3047 HDA_CODEC_MUTE("Front Playback Switch", 0x10, 0x0, HDA_OUTPUT
),
3048 HDA_CODEC_VOLUME("Aux-In Playback Volume", 0x07, 0x06, HDA_INPUT
),
3049 HDA_CODEC_MUTE("Aux-In Playback Switch", 0x07, 0x06, HDA_INPUT
),
3050 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x08, 0x0, HDA_OUTPUT
),
3051 HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT
),
3052 HDA_CODEC_VOLUME_MONO("iSpeaker Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT
),
3053 HDA_CODEC_MUTE_MONO("iSpeaker Playback Switch", 0x11, 1, 0x0, HDA_OUTPUT
),
3057 /* Fujitsu S702x series laptops. ALC260 pin usage: Mic/Line jack = 0x12,
3058 * HP jack = 0x14, CD audio = 0x16, internal speaker = 0x10.
3060 static struct snd_kcontrol_new alc260_fujitsu_mixer
[] = {
3061 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x08, 0x0, HDA_OUTPUT
),
3062 HDA_BIND_MUTE("Headphone Playback Switch", 0x08, 2, HDA_INPUT
),
3063 ALC_PIN_MODE("Headphone Jack Mode", 0x14, ALC_PIN_DIR_INOUT
),
3064 HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT
),
3065 HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT
),
3066 HDA_CODEC_VOLUME("Mic/Line Playback Volume", 0x07, 0x0, HDA_INPUT
),
3067 HDA_CODEC_MUTE("Mic/Line Playback Switch", 0x07, 0x0, HDA_INPUT
),
3068 ALC_PIN_MODE("Mic/Line Jack Mode", 0x12, ALC_PIN_DIR_IN
),
3069 HDA_CODEC_VOLUME("Beep Playback Volume", 0x07, 0x05, HDA_INPUT
),
3070 HDA_CODEC_MUTE("Beep Playback Switch", 0x07, 0x05, HDA_INPUT
),
3071 HDA_CODEC_VOLUME("Internal Speaker Playback Volume", 0x09, 0x0, HDA_OUTPUT
),
3072 HDA_BIND_MUTE("Internal Speaker Playback Switch", 0x09, 2, HDA_INPUT
),
3076 /* Mixer for Acer TravelMate(/Extensa/Aspire) notebooks. Note that current
3077 * versions of the ALC260 don't act on requests to enable mic bias from NID
3078 * 0x0f (used to drive the headphone jack in these laptops). The ALC260
3079 * datasheet doesn't mention this restriction. At this stage it's not clear
3080 * whether this behaviour is intentional or is a hardware bug in chip
3081 * revisions available in early 2006. Therefore for now allow the
3082 * "Headphone Jack Mode" control to span all choices, but if it turns out
3083 * that the lack of mic bias for this NID is intentional we could change the
3084 * mode from ALC_PIN_DIR_INOUT to ALC_PIN_DIR_INOUT_NOMICBIAS.
3086 * In addition, Acer TravelMate(/Extensa/Aspire) notebooks in early 2006
3087 * don't appear to make the mic bias available from the "line" jack, even
3088 * though the NID used for this jack (0x14) can supply it. The theory is
3089 * that perhaps Acer have included blocking capacitors between the ALC260
3090 * and the output jack. If this turns out to be the case for all such
3091 * models the "Line Jack Mode" mode could be changed from ALC_PIN_DIR_INOUT
3092 * to ALC_PIN_DIR_INOUT_NOMICBIAS.
3094 static struct snd_kcontrol_new alc260_acer_mixer
[] = {
3095 HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT
),
3096 HDA_BIND_MUTE("Master Playback Switch", 0x08, 2, HDA_INPUT
),
3097 ALC_PIN_MODE("Headphone Jack Mode", 0x0f, ALC_PIN_DIR_INOUT
),
3098 HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT
),
3099 HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT
),
3100 HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT
),
3101 HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT
),
3102 ALC_PIN_MODE("Mic Jack Mode", 0x12, ALC_PIN_DIR_IN
),
3103 HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT
),
3104 HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT
),
3105 ALC_PIN_MODE("Line Jack Mode", 0x14, ALC_PIN_DIR_INOUT
),
3106 HDA_CODEC_VOLUME("Beep Playback Volume", 0x07, 0x05, HDA_INPUT
),
3107 HDA_CODEC_MUTE("Beep Playback Switch", 0x07, 0x05, HDA_INPUT
),
3111 /* capture mixer elements */
3112 static struct snd_kcontrol_new alc260_capture_mixer
[] = {
3113 HDA_CODEC_VOLUME("Capture Volume", 0x04, 0x0, HDA_INPUT
),
3114 HDA_CODEC_MUTE("Capture Switch", 0x04, 0x0, HDA_INPUT
),
3115 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x05, 0x0, HDA_INPUT
),
3116 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x05, 0x0, HDA_INPUT
),
3118 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
3119 /* The multiple "Capture Source" controls confuse alsamixer
3120 * So call somewhat different..
3121 * FIXME: the controls appear in the "playback" view!
3123 /* .name = "Capture Source", */
3124 .name
= "Input Source",
3126 .info
= alc_mux_enum_info
,
3127 .get
= alc_mux_enum_get
,
3128 .put
= alc_mux_enum_put
,
3133 static struct snd_kcontrol_new alc260_capture_alt_mixer
[] = {
3134 HDA_CODEC_VOLUME("Capture Volume", 0x05, 0x0, HDA_INPUT
),
3135 HDA_CODEC_MUTE("Capture Switch", 0x05, 0x0, HDA_INPUT
),
3137 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
3138 /* The multiple "Capture Source" controls confuse alsamixer
3139 * So call somewhat different..
3140 * FIXME: the controls appear in the "playback" view!
3142 /* .name = "Capture Source", */
3143 .name
= "Input Source",
3145 .info
= alc_mux_enum_info
,
3146 .get
= alc_mux_enum_get
,
3147 .put
= alc_mux_enum_put
,
3153 * initialization verbs
3155 static struct hda_verb alc260_init_verbs
[] = {
3156 /* Line In pin widget for input */
3157 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_IN
},
3158 /* CD pin widget for input */
3159 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_IN
},
3160 /* Mic1 (rear panel) pin widget for input and vref at 80% */
3161 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_VREF80
},
3162 /* Mic2 (front panel) pin widget for input and vref at 80% */
3163 {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_VREF80
},
3164 /* LINE-2 is used for line-out in rear */
3165 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_OUT
},
3166 /* select line-out */
3167 {0x0e, AC_VERB_SET_CONNECT_SEL
, 0x00},
3169 {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_OUT
},
3171 {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_HP
},
3173 {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_OUT
},
3174 /* mute capture amp left and right */
3175 {0x04, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(0)},
3176 /* set connection select to line in (default select for this ADC) */
3177 {0x04, AC_VERB_SET_CONNECT_SEL
, 0x02},
3178 /* mute capture amp left and right */
3179 {0x05, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(0)},
3180 /* set connection select to line in (default select for this ADC) */
3181 {0x05, AC_VERB_SET_CONNECT_SEL
, 0x02},
3182 /* set vol=0 Line-Out mixer amp left and right */
3183 {0x08, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_ZERO
},
3184 /* unmute pin widget amp left and right (no gain on this amp) */
3185 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_UNMUTE
},
3186 /* set vol=0 HP mixer amp left and right */
3187 {0x09, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_ZERO
},
3188 /* unmute pin widget amp left and right (no gain on this amp) */
3189 {0x10, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_UNMUTE
},
3190 /* set vol=0 Mono mixer amp left and right */
3191 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_ZERO
},
3192 /* unmute pin widget amp left and right (no gain on this amp) */
3193 {0x11, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_UNMUTE
},
3194 /* unmute LINE-2 out pin */
3195 {0x15, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_UNMUTE
},
3196 /* Amp Indexes: CD = 0x04, Line In 1 = 0x02, Mic 1 = 0x00 & Line In 2 = 0x03 */
3198 {0x07, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(4)},
3200 {0x07, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(2)},
3202 {0x07, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(0)},
3203 /* Amp Indexes: DAC = 0x01 & mixer = 0x00 */
3204 /* mute Front out path */
3205 {0x08, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_MUTE(0)},
3206 {0x08, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_MUTE(1)},
3207 /* mute Headphone out path */
3208 {0x09, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_MUTE(0)},
3209 {0x09, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_MUTE(1)},
3210 /* mute Mono out path */
3211 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_MUTE(0)},
3212 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_MUTE(1)},
3216 #if 0 /* should be identical with alc260_init_verbs? */
3217 static struct hda_verb alc260_hp_init_verbs
[] = {
3218 /* Headphone and output */
3219 {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL
, 0xc0},
3221 {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL
, 0x40},
3222 /* Mic1 (rear panel) pin widget for input and vref at 80% */
3223 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL
, 0x24},
3224 /* Mic2 (front panel) pin widget for input and vref at 80% */
3225 {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL
, 0x24},
3226 /* Line In pin widget for input */
3227 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL
, 0x20},
3228 /* Line-2 pin widget for output */
3229 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL
, 0x40},
3230 /* CD pin widget for input */
3231 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL
, 0x20},
3232 /* unmute amp left and right */
3233 {0x04, AC_VERB_SET_AMP_GAIN_MUTE
, 0x7000},
3234 /* set connection select to line in (default select for this ADC) */
3235 {0x04, AC_VERB_SET_CONNECT_SEL
, 0x02},
3236 /* unmute Line-Out mixer amp left and right (volume = 0) */
3237 {0x08, AC_VERB_SET_AMP_GAIN_MUTE
, 0xb000},
3238 /* mute pin widget amp left and right (no gain on this amp) */
3239 {0x15, AC_VERB_SET_AMP_GAIN_MUTE
, 0x0000},
3240 /* unmute HP mixer amp left and right (volume = 0) */
3241 {0x09, AC_VERB_SET_AMP_GAIN_MUTE
, 0xb000},
3242 /* mute pin widget amp left and right (no gain on this amp) */
3243 {0x10, AC_VERB_SET_AMP_GAIN_MUTE
, 0x0000},
3244 /* Amp Indexes: CD = 0x04, Line In 1 = 0x02, Mic 1 = 0x00 & Line In 2 = 0x03 */
3246 {0x07, AC_VERB_SET_AMP_GAIN_MUTE
, (0x7000 | (0x04 << 8))},
3247 /* unmute Line In */
3248 {0x07, AC_VERB_SET_AMP_GAIN_MUTE
, (0x7000 | (0x02 << 8))},
3250 {0x07, AC_VERB_SET_AMP_GAIN_MUTE
, (0x7000 | (0x00 << 8))},
3251 /* Amp Indexes: DAC = 0x01 & mixer = 0x00 */
3252 /* Unmute Front out path */
3253 {0x08, AC_VERB_SET_AMP_GAIN_MUTE
, (0x7000 | (0x00 << 8))},
3254 {0x08, AC_VERB_SET_AMP_GAIN_MUTE
, (0x7000 | (0x01 << 8))},
3255 /* Unmute Headphone out path */
3256 {0x09, AC_VERB_SET_AMP_GAIN_MUTE
, (0x7000 | (0x00 << 8))},
3257 {0x09, AC_VERB_SET_AMP_GAIN_MUTE
, (0x7000 | (0x01 << 8))},
3258 /* Unmute Mono out path */
3259 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE
, (0x7000 | (0x00 << 8))},
3260 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE
, (0x7000 | (0x01 << 8))},
3265 static struct hda_verb alc260_hp_3013_init_verbs
[] = {
3266 /* Line out and output */
3267 {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL
, 0x40},
3269 {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL
, 0x40},
3270 /* Mic1 (rear panel) pin widget for input and vref at 80% */
3271 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL
, 0x24},
3272 /* Mic2 (front panel) pin widget for input and vref at 80% */
3273 {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL
, 0x24},
3274 /* Line In pin widget for input */
3275 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL
, 0x20},
3276 /* Headphone pin widget for output */
3277 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL
, 0xc0},
3278 /* CD pin widget for input */
3279 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL
, 0x20},
3280 /* unmute amp left and right */
3281 {0x04, AC_VERB_SET_AMP_GAIN_MUTE
, 0x7000},
3282 /* set connection select to line in (default select for this ADC) */
3283 {0x04, AC_VERB_SET_CONNECT_SEL
, 0x02},
3284 /* unmute Line-Out mixer amp left and right (volume = 0) */
3285 {0x08, AC_VERB_SET_AMP_GAIN_MUTE
, 0xb000},
3286 /* mute pin widget amp left and right (no gain on this amp) */
3287 {0x15, AC_VERB_SET_AMP_GAIN_MUTE
, 0x0000},
3288 /* unmute HP mixer amp left and right (volume = 0) */
3289 {0x09, AC_VERB_SET_AMP_GAIN_MUTE
, 0xb000},
3290 /* mute pin widget amp left and right (no gain on this amp) */
3291 {0x10, AC_VERB_SET_AMP_GAIN_MUTE
, 0x0000},
3292 /* Amp Indexes: CD = 0x04, Line In 1 = 0x02, Mic 1 = 0x00 & Line In 2 = 0x03 */
3294 {0x07, AC_VERB_SET_AMP_GAIN_MUTE
, (0x7000 | (0x04 << 8))},
3295 /* unmute Line In */
3296 {0x07, AC_VERB_SET_AMP_GAIN_MUTE
, (0x7000 | (0x02 << 8))},
3298 {0x07, AC_VERB_SET_AMP_GAIN_MUTE
, (0x7000 | (0x00 << 8))},
3299 /* Amp Indexes: DAC = 0x01 & mixer = 0x00 */
3300 /* Unmute Front out path */
3301 {0x08, AC_VERB_SET_AMP_GAIN_MUTE
, (0x7000 | (0x00 << 8))},
3302 {0x08, AC_VERB_SET_AMP_GAIN_MUTE
, (0x7000 | (0x01 << 8))},
3303 /* Unmute Headphone out path */
3304 {0x09, AC_VERB_SET_AMP_GAIN_MUTE
, (0x7000 | (0x00 << 8))},
3305 {0x09, AC_VERB_SET_AMP_GAIN_MUTE
, (0x7000 | (0x01 << 8))},
3306 /* Unmute Mono out path */
3307 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE
, (0x7000 | (0x00 << 8))},
3308 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE
, (0x7000 | (0x01 << 8))},
3312 /* Initialisation sequence for ALC260 as configured in Fujitsu S702x
3313 * laptops. ALC260 pin usage: Mic/Line jack = 0x12, HP jack = 0x14, CD
3314 * audio = 0x16, internal speaker = 0x10.
3316 static struct hda_verb alc260_fujitsu_init_verbs
[] = {
3317 /* Disable all GPIOs */
3318 {0x01, AC_VERB_SET_GPIO_MASK
, 0},
3319 /* Internal speaker is connected to headphone pin */
3320 {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_HP
},
3321 /* Headphone/Line-out jack connects to Line1 pin; make it an output */
3322 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_OUT
},
3323 /* Mic/Line-in jack is connected to mic1 pin, so make it an input */
3324 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_IN
},
3325 /* Ensure all other unused pins are disabled and muted. */
3326 {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL
, 0},
3327 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_MUTE(0)},
3328 {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL
, 0},
3329 {0x11, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_MUTE(0)},
3330 {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL
, 0},
3331 {0x13, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_MUTE(0)},
3332 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL
, 0},
3333 {0x15, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_MUTE(0)},
3335 /* Disable digital (SPDIF) pins */
3336 {0x03, AC_VERB_SET_DIGI_CONVERT_1
, 0},
3337 {0x06, AC_VERB_SET_DIGI_CONVERT_1
, 0},
3339 /* Ensure Line1 pin widget takes its input from the OUT1 sum bus
3340 * when acting as an output.
3342 {0x0d, AC_VERB_SET_CONNECT_SEL
, 0},
3344 /* Start with output sum widgets muted and their output gains at min */
3345 {0x08, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_MUTE(0)},
3346 {0x08, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_MUTE(1)},
3347 {0x08, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_ZERO
},
3348 {0x09, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_MUTE(0)},
3349 {0x09, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_MUTE(1)},
3350 {0x09, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_ZERO
},
3351 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_MUTE(0)},
3352 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_MUTE(1)},
3353 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_ZERO
},
3355 /* Unmute HP pin widget amp left and right (no equiv mixer ctrl) */
3356 {0x10, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_UNMUTE
},
3357 /* Unmute Line1 pin widget output buffer since it starts as an output.
3358 * If the pin mode is changed by the user the pin mode control will
3359 * take care of enabling the pin's input/output buffers as needed.
3360 * Therefore there's no need to enable the input buffer at this
3363 {0x14, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_UNMUTE
},
3364 /* Unmute input buffer of pin widget used for Line-in (no equiv
3367 {0x12, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(0)},
3369 /* Mute capture amp left and right */
3370 {0x04, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_MUTE(0)},
3371 /* Set ADC connection select to match default mixer setting - line
3374 {0x04, AC_VERB_SET_CONNECT_SEL
, 0x00},
3376 /* Do the same for the second ADC: mute capture input amp and
3377 * set ADC connection to line in (on mic1 pin)
3379 {0x05, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_MUTE(0)},
3380 {0x05, AC_VERB_SET_CONNECT_SEL
, 0x00},
3382 /* Mute all inputs to mixer widget (even unconnected ones) */
3383 {0x07, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_MUTE(0)}, /* mic1 pin */
3384 {0x07, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_MUTE(1)}, /* mic2 pin */
3385 {0x07, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_MUTE(2)}, /* line1 pin */
3386 {0x07, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_MUTE(3)}, /* line2 pin */
3387 {0x07, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_MUTE(4)}, /* CD pin */
3388 {0x07, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_MUTE(5)}, /* Beep-gen pin */
3389 {0x07, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_MUTE(6)}, /* Line-out pin */
3390 {0x07, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_MUTE(7)}, /* HP-pin pin */
3395 /* Initialisation sequence for ALC260 as configured in Acer TravelMate and
3396 * similar laptops (adapted from Fujitsu init verbs).
3398 static struct hda_verb alc260_acer_init_verbs
[] = {
3399 /* On TravelMate laptops, GPIO 0 enables the internal speaker and
3400 * the headphone jack. Turn this on and rely on the standard mute
3401 * methods whenever the user wants to turn these outputs off.
3403 {0x01, AC_VERB_SET_GPIO_MASK
, 0x01},
3404 {0x01, AC_VERB_SET_GPIO_DIRECTION
, 0x01},
3405 {0x01, AC_VERB_SET_GPIO_DATA
, 0x01},
3406 /* Internal speaker/Headphone jack is connected to Line-out pin */
3407 {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_HP
},
3408 /* Internal microphone/Mic jack is connected to Mic1 pin */
3409 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_VREF50
},
3410 /* Line In jack is connected to Line1 pin */
3411 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_IN
},
3412 /* Ensure all other unused pins are disabled and muted. */
3413 {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL
, 0},
3414 {0x10, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_MUTE(0)},
3415 {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL
, 0},
3416 {0x11, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_MUTE(0)},
3417 {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL
, 0},
3418 {0x13, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_MUTE(0)},
3419 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL
, 0},
3420 {0x15, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_MUTE(0)},
3421 /* Disable digital (SPDIF) pins */
3422 {0x03, AC_VERB_SET_DIGI_CONVERT_1
, 0},
3423 {0x06, AC_VERB_SET_DIGI_CONVERT_1
, 0},
3425 /* Ensure Mic1 and Line1 pin widgets take input from the OUT1 sum
3426 * bus when acting as outputs.
3428 {0x0b, AC_VERB_SET_CONNECT_SEL
, 0},
3429 {0x0d, AC_VERB_SET_CONNECT_SEL
, 0},
3431 /* Start with output sum widgets muted and their output gains at min */
3432 {0x08, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_MUTE(0)},
3433 {0x08, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_MUTE(1)},
3434 {0x08, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_ZERO
},
3435 {0x09, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_MUTE(0)},
3436 {0x09, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_MUTE(1)},
3437 {0x09, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_ZERO
},
3438 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_MUTE(0)},
3439 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_MUTE(1)},
3440 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_ZERO
},
3442 /* Unmute Line-out pin widget amp left and right (no equiv mixer ctrl) */
3443 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_UNMUTE
},
3444 /* Unmute Mic1 and Line1 pin widget input buffers since they start as
3445 * inputs. If the pin mode is changed by the user the pin mode control
3446 * will take care of enabling the pin's input/output buffers as needed.
3447 * Therefore there's no need to enable the input buffer at this
3450 {0x12, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(0)},
3451 {0x14, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(0)},
3453 /* Mute capture amp left and right */
3454 {0x04, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_MUTE(0)},
3455 /* Set ADC connection select to match default mixer setting - mic
3458 {0x04, AC_VERB_SET_CONNECT_SEL
, 0x00},
3460 /* Do similar with the second ADC: mute capture input amp and
3461 * set ADC connection to mic to match ALSA's default state.
3463 {0x05, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_MUTE(0)},
3464 {0x05, AC_VERB_SET_CONNECT_SEL
, 0x00},
3466 /* Mute all inputs to mixer widget (even unconnected ones) */
3467 {0x07, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_MUTE(0)}, /* mic1 pin */
3468 {0x07, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_MUTE(1)}, /* mic2 pin */
3469 {0x07, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_MUTE(2)}, /* line1 pin */
3470 {0x07, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_MUTE(3)}, /* line2 pin */
3471 {0x07, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_MUTE(4)}, /* CD pin */
3472 {0x07, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_MUTE(5)}, /* Beep-gen pin */
3473 {0x07, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_MUTE(6)}, /* Line-out pin */
3474 {0x07, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_MUTE(7)}, /* HP-pin pin */
3479 /* Test configuration for debugging, modelled after the ALC880 test
3482 #ifdef CONFIG_SND_DEBUG
3483 static hda_nid_t alc260_test_dac_nids
[1] = {
3486 static hda_nid_t alc260_test_adc_nids
[2] = {
3489 /* For testing the ALC260, each input MUX needs its own definition since
3490 * the signal assignments are different. This assumes that the first ADC
3493 static struct hda_input_mux alc260_test_capture_sources
[2] = {
3497 { "MIC1 pin", 0x0 },
3498 { "MIC2 pin", 0x1 },
3499 { "LINE1 pin", 0x2 },
3500 { "LINE2 pin", 0x3 },
3502 { "LINE-OUT pin", 0x5 },
3503 { "HP-OUT pin", 0x6 },
3509 { "MIC1 pin", 0x0 },
3510 { "MIC2 pin", 0x1 },
3511 { "LINE1 pin", 0x2 },
3512 { "LINE2 pin", 0x3 },
3515 { "LINE-OUT pin", 0x6 },
3516 { "HP-OUT pin", 0x7 },
3520 static struct snd_kcontrol_new alc260_test_mixer
[] = {
3521 /* Output driver widgets */
3522 HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT
),
3523 HDA_BIND_MUTE_MONO("Mono Playback Switch", 0x0a, 1, 2, HDA_INPUT
),
3524 HDA_CODEC_VOLUME("LOUT2 Playback Volume", 0x09, 0x0, HDA_OUTPUT
),
3525 HDA_BIND_MUTE("LOUT2 Playback Switch", 0x09, 2, HDA_INPUT
),
3526 HDA_CODEC_VOLUME("LOUT1 Playback Volume", 0x08, 0x0, HDA_OUTPUT
),
3527 HDA_BIND_MUTE("LOUT1 Playback Switch", 0x08, 2, HDA_INPUT
),
3529 /* Modes for retasking pin widgets
3530 * Note: the ALC260 doesn't seem to act on requests to enable mic
3531 * bias from NIDs 0x0f and 0x10. The ALC260 datasheet doesn't
3532 * mention this restriction. At this stage it's not clear whether
3533 * this behaviour is intentional or is a hardware bug in chip
3534 * revisions available at least up until early 2006. Therefore for
3535 * now allow the "HP-OUT" and "LINE-OUT" Mode controls to span all
3536 * choices, but if it turns out that the lack of mic bias for these
3537 * NIDs is intentional we could change their modes from
3538 * ALC_PIN_DIR_INOUT to ALC_PIN_DIR_INOUT_NOMICBIAS.
3540 ALC_PIN_MODE("HP-OUT pin mode", 0x10, ALC_PIN_DIR_INOUT
),
3541 ALC_PIN_MODE("LINE-OUT pin mode", 0x0f, ALC_PIN_DIR_INOUT
),
3542 ALC_PIN_MODE("LINE2 pin mode", 0x15, ALC_PIN_DIR_INOUT
),
3543 ALC_PIN_MODE("LINE1 pin mode", 0x14, ALC_PIN_DIR_INOUT
),
3544 ALC_PIN_MODE("MIC2 pin mode", 0x13, ALC_PIN_DIR_INOUT
),
3545 ALC_PIN_MODE("MIC1 pin mode", 0x12, ALC_PIN_DIR_INOUT
),
3547 /* Loopback mixer controls */
3548 HDA_CODEC_VOLUME("MIC1 Playback Volume", 0x07, 0x00, HDA_INPUT
),
3549 HDA_CODEC_MUTE("MIC1 Playback Switch", 0x07, 0x00, HDA_INPUT
),
3550 HDA_CODEC_VOLUME("MIC2 Playback Volume", 0x07, 0x01, HDA_INPUT
),
3551 HDA_CODEC_MUTE("MIC2 Playback Switch", 0x07, 0x01, HDA_INPUT
),
3552 HDA_CODEC_VOLUME("LINE1 Playback Volume", 0x07, 0x02, HDA_INPUT
),
3553 HDA_CODEC_MUTE("LINE1 Playback Switch", 0x07, 0x02, HDA_INPUT
),
3554 HDA_CODEC_VOLUME("LINE2 Playback Volume", 0x07, 0x03, HDA_INPUT
),
3555 HDA_CODEC_MUTE("LINE2 Playback Switch", 0x07, 0x03, HDA_INPUT
),
3556 HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT
),
3557 HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT
),
3558 HDA_CODEC_VOLUME("Beep Playback Volume", 0x07, 0x05, HDA_INPUT
),
3559 HDA_CODEC_MUTE("Beep Playback Switch", 0x07, 0x05, HDA_INPUT
),
3560 HDA_CODEC_VOLUME("LINE-OUT loopback Playback Volume", 0x07, 0x06, HDA_INPUT
),
3561 HDA_CODEC_MUTE("LINE-OUT loopback Playback Switch", 0x07, 0x06, HDA_INPUT
),
3562 HDA_CODEC_VOLUME("HP-OUT loopback Playback Volume", 0x07, 0x7, HDA_INPUT
),
3563 HDA_CODEC_MUTE("HP-OUT loopback Playback Switch", 0x07, 0x7, HDA_INPUT
),
3565 /* Controls for GPIO pins, assuming they are configured as outputs */
3566 ALC_GPIO_DATA_SWITCH("GPIO pin 0", 0x01, 0x01),
3567 ALC_GPIO_DATA_SWITCH("GPIO pin 1", 0x01, 0x02),
3568 ALC_GPIO_DATA_SWITCH("GPIO pin 2", 0x01, 0x04),
3569 ALC_GPIO_DATA_SWITCH("GPIO pin 3", 0x01, 0x08),
3571 /* Switches to allow the digital IO pins to be enabled. The datasheet
3572 * is ambigious as to which NID is which; testing on laptops which
3573 * make this output available should provide clarification.
3575 ALC_SPDIF_CTRL_SWITCH("SPDIF Playback Switch", 0x03, 0x01),
3576 ALC_SPDIF_CTRL_SWITCH("SPDIF Capture Switch", 0x06, 0x01),
3580 static struct hda_verb alc260_test_init_verbs
[] = {
3581 /* Enable all GPIOs as outputs with an initial value of 0 */
3582 {0x01, AC_VERB_SET_GPIO_DIRECTION
, 0x0f},
3583 {0x01, AC_VERB_SET_GPIO_DATA
, 0x00},
3584 {0x01, AC_VERB_SET_GPIO_MASK
, 0x0f},
3586 /* Enable retasking pins as output, initially without power amp */
3587 {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_OUT
},
3588 {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_OUT
},
3589 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_OUT
},
3590 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_OUT
},
3591 {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_OUT
},
3592 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_OUT
},
3594 /* Disable digital (SPDIF) pins initially, but users can enable
3595 * them via a mixer switch. In the case of SPDIF-out, this initverb
3596 * payload also sets the generation to 0, output to be in "consumer"
3597 * PCM format, copyright asserted, no pre-emphasis and no validity
3600 {0x03, AC_VERB_SET_DIGI_CONVERT_1
, 0},
3601 {0x06, AC_VERB_SET_DIGI_CONVERT_1
, 0},
3603 /* Ensure mic1, mic2, line1 and line2 pin widgets take input from the
3604 * OUT1 sum bus when acting as an output.
3606 {0x0b, AC_VERB_SET_CONNECT_SEL
, 0},
3607 {0x0c, AC_VERB_SET_CONNECT_SEL
, 0},
3608 {0x0d, AC_VERB_SET_CONNECT_SEL
, 0},
3609 {0x0e, AC_VERB_SET_CONNECT_SEL
, 0},
3611 /* Start with output sum widgets muted and their output gains at min */
3612 {0x08, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_MUTE(0)},
3613 {0x08, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_MUTE(1)},
3614 {0x08, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_ZERO
},
3615 {0x09, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_MUTE(0)},
3616 {0x09, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_MUTE(1)},
3617 {0x09, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_ZERO
},
3618 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_MUTE(0)},
3619 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_MUTE(1)},
3620 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_ZERO
},
3622 /* Unmute retasking pin widget output buffers since the default
3623 * state appears to be output. As the pin mode is changed by the
3624 * user the pin mode control will take care of enabling the pin's
3625 * input/output buffers as needed.
3627 {0x10, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_UNMUTE
},
3628 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_UNMUTE
},
3629 {0x15, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_UNMUTE
},
3630 {0x14, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_UNMUTE
},
3631 {0x13, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_UNMUTE
},
3632 {0x12, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_UNMUTE
},
3633 /* Also unmute the mono-out pin widget */
3634 {0x11, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_UNMUTE
},
3636 /* Mute capture amp left and right */
3637 {0x04, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_MUTE(0)},
3638 /* Set ADC connection select to match default mixer setting (mic1
3641 {0x04, AC_VERB_SET_CONNECT_SEL
, 0x00},
3643 /* Do the same for the second ADC: mute capture input amp and
3644 * set ADC connection to mic1 pin
3646 {0x05, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_MUTE(0)},
3647 {0x05, AC_VERB_SET_CONNECT_SEL
, 0x00},
3649 /* Mute all inputs to mixer widget (even unconnected ones) */
3650 {0x07, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_MUTE(0)}, /* mic1 pin */
3651 {0x07, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_MUTE(1)}, /* mic2 pin */
3652 {0x07, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_MUTE(2)}, /* line1 pin */
3653 {0x07, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_MUTE(3)}, /* line2 pin */
3654 {0x07, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_MUTE(4)}, /* CD pin */
3655 {0x07, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_MUTE(5)}, /* Beep-gen pin */
3656 {0x07, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_MUTE(6)}, /* Line-out pin */
3657 {0x07, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_MUTE(7)}, /* HP-pin pin */
3663 static struct hda_pcm_stream alc260_pcm_analog_playback
= {
3669 static struct hda_pcm_stream alc260_pcm_analog_capture
= {
3675 #define alc260_pcm_digital_playback alc880_pcm_digital_playback
3676 #define alc260_pcm_digital_capture alc880_pcm_digital_capture
3679 * for BIOS auto-configuration
3682 static int alc260_add_playback_controls(struct alc_spec
*spec
, hda_nid_t nid
,
3686 unsigned long vol_val
, sw_val
;
3690 if (nid
>= 0x0f && nid
< 0x11) {
3691 nid_vol
= nid
- 0x7;
3692 vol_val
= HDA_COMPOSE_AMP_VAL(nid_vol
, 3, 0, HDA_OUTPUT
);
3693 sw_val
= HDA_COMPOSE_AMP_VAL(nid
, 3, 0, HDA_OUTPUT
);
3694 } else if (nid
== 0x11) {
3695 nid_vol
= nid
- 0x7;
3696 vol_val
= HDA_COMPOSE_AMP_VAL(nid_vol
, 2, 0, HDA_OUTPUT
);
3697 sw_val
= HDA_COMPOSE_AMP_VAL(nid
, 2, 0, HDA_OUTPUT
);
3698 } else if (nid
>= 0x12 && nid
<= 0x15) {
3700 vol_val
= HDA_COMPOSE_AMP_VAL(nid_vol
, 3, 0, HDA_OUTPUT
);
3701 sw_val
= HDA_COMPOSE_AMP_VAL(nid
, 3, 0, HDA_OUTPUT
);
3705 snprintf(name
, sizeof(name
), "%s Playback Volume", pfx
);
3706 if ((err
= add_control(spec
, ALC_CTL_WIDGET_VOL
, name
, vol_val
)) < 0)
3708 snprintf(name
, sizeof(name
), "%s Playback Switch", pfx
);
3709 if ((err
= add_control(spec
, ALC_CTL_WIDGET_MUTE
, name
, sw_val
)) < 0)
3714 /* add playback controls from the parsed DAC table */
3715 static int alc260_auto_create_multi_out_ctls(struct alc_spec
*spec
,
3716 const struct auto_pin_cfg
*cfg
)
3721 spec
->multiout
.num_dacs
= 1;
3722 spec
->multiout
.dac_nids
= spec
->private_dac_nids
;
3723 spec
->multiout
.dac_nids
[0] = 0x02;
3725 nid
= cfg
->line_out_pins
[0];
3727 err
= alc260_add_playback_controls(spec
, nid
, "Front");
3732 nid
= cfg
->speaker_pins
[0];
3734 err
= alc260_add_playback_controls(spec
, nid
, "Speaker");
3739 nid
= cfg
->hp_pins
[0];
3741 err
= alc260_add_playback_controls(spec
, nid
, "Headphone");
3748 /* create playback/capture controls for input pins */
3749 static int alc260_auto_create_analog_input_ctls(struct alc_spec
*spec
,
3750 const struct auto_pin_cfg
*cfg
)
3752 struct hda_input_mux
*imux
= &spec
->private_imux
;
3755 for (i
= 0; i
< AUTO_PIN_LAST
; i
++) {
3756 if (cfg
->input_pins
[i
] >= 0x12) {
3757 idx
= cfg
->input_pins
[i
] - 0x12;
3758 err
= new_analog_input(spec
, cfg
->input_pins
[i
],
3759 auto_pin_cfg_labels
[i
], idx
, 0x07);
3762 imux
->items
[imux
->num_items
].label
= auto_pin_cfg_labels
[i
];
3763 imux
->items
[imux
->num_items
].index
= idx
;
3766 if ((cfg
->input_pins
[i
] >= 0x0f) && (cfg
->input_pins
[i
] <= 0x10)){
3767 idx
= cfg
->input_pins
[i
] - 0x09;
3768 err
= new_analog_input(spec
, cfg
->input_pins
[i
],
3769 auto_pin_cfg_labels
[i
], idx
, 0x07);
3772 imux
->items
[imux
->num_items
].label
= auto_pin_cfg_labels
[i
];
3773 imux
->items
[imux
->num_items
].index
= idx
;
3780 static void alc260_auto_set_output_and_unmute(struct hda_codec
*codec
,
3781 hda_nid_t nid
, int pin_type
,
3785 snd_hda_codec_write(codec
, nid
, 0, AC_VERB_SET_PIN_WIDGET_CONTROL
, pin_type
);
3786 snd_hda_codec_write(codec
, nid
, 0, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_UNMUTE
);
3787 /* need the manual connection? */
3789 int idx
= nid
- 0x12;
3790 snd_hda_codec_write(codec
, idx
+ 0x0b, 0,
3791 AC_VERB_SET_CONNECT_SEL
, sel_idx
);
3796 static void alc260_auto_init_multi_out(struct hda_codec
*codec
)
3798 struct alc_spec
*spec
= codec
->spec
;
3801 nid
= spec
->autocfg
.line_out_pins
[0];
3803 alc260_auto_set_output_and_unmute(codec
, nid
, PIN_OUT
, 0);
3805 nid
= spec
->autocfg
.speaker_pins
[0];
3807 alc260_auto_set_output_and_unmute(codec
, nid
, PIN_OUT
, 0);
3809 nid
= spec
->autocfg
.hp_pins
[0];
3811 alc260_auto_set_output_and_unmute(codec
, nid
, PIN_OUT
, 0);
3814 #define ALC260_PIN_CD_NID 0x16
3815 static void alc260_auto_init_analog_input(struct hda_codec
*codec
)
3817 struct alc_spec
*spec
= codec
->spec
;
3820 for (i
= 0; i
< AUTO_PIN_LAST
; i
++) {
3821 hda_nid_t nid
= spec
->autocfg
.input_pins
[i
];
3823 snd_hda_codec_write(codec
, nid
, 0, AC_VERB_SET_PIN_WIDGET_CONTROL
,
3824 i
<= AUTO_PIN_FRONT_MIC
? PIN_VREF80
: PIN_IN
);
3825 if (nid
!= ALC260_PIN_CD_NID
)
3826 snd_hda_codec_write(codec
, nid
, 0, AC_VERB_SET_AMP_GAIN_MUTE
,
3833 * generic initialization of ADC, input mixers and output mixers
3835 static struct hda_verb alc260_volume_init_verbs
[] = {
3837 * Unmute ADC0-1 and set the default input to mic-in
3839 {0x04, AC_VERB_SET_CONNECT_SEL
, 0x00},
3840 {0x04, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(0)},
3841 {0x05, AC_VERB_SET_CONNECT_SEL
, 0x00},
3842 {0x05, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(0)},
3844 /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
3846 * Note: PASD motherboards uses the Line In 2 as the input for front panel
3849 /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
3850 {0x07, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(0)},
3851 {0x07, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(1)},
3852 {0x07, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(2)},
3853 {0x07, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(3)},
3854 {0x07, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(4)},
3857 * Set up output mixers (0x08 - 0x0a)
3859 /* set vol=0 to output mixers */
3860 {0x08, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_ZERO
},
3861 {0x09, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_ZERO
},
3862 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_ZERO
},
3863 /* set up input amps for analog loopback */
3864 /* Amp Indices: DAC = 0, mixer = 1 */
3865 {0x08, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(0)},
3866 {0x08, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(1)},
3867 {0x09, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(0)},
3868 {0x09, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(1)},
3869 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(0)},
3870 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(1)},
3875 static int alc260_parse_auto_config(struct hda_codec
*codec
)
3877 struct alc_spec
*spec
= codec
->spec
;
3880 static hda_nid_t alc260_ignore
[] = { 0x17, 0 };
3882 if ((err
= snd_hda_parse_pin_def_config(codec
, &spec
->autocfg
,
3883 alc260_ignore
)) < 0)
3885 if ((err
= alc260_auto_create_multi_out_ctls(spec
, &spec
->autocfg
)) < 0)
3887 if (! spec
->kctl_alloc
)
3888 return 0; /* can't find valid BIOS pin config */
3889 if ((err
= alc260_auto_create_analog_input_ctls(spec
, &spec
->autocfg
)) < 0)
3892 spec
->multiout
.max_channels
= 2;
3894 if (spec
->autocfg
.dig_out_pin
)
3895 spec
->multiout
.dig_out_nid
= ALC260_DIGOUT_NID
;
3896 if (spec
->kctl_alloc
)
3897 spec
->mixers
[spec
->num_mixers
++] = spec
->kctl_alloc
;
3899 spec
->init_verbs
[spec
->num_init_verbs
++] = alc260_volume_init_verbs
;
3901 spec
->num_mux_defs
= 1;
3902 spec
->input_mux
= &spec
->private_imux
;
3904 /* check whether NID 0x04 is valid */
3905 wcap
= get_wcaps(codec
, 0x04);
3906 wcap
= (wcap
& AC_WCAP_TYPE
) >> AC_WCAP_TYPE_SHIFT
; /* get type */
3907 if (wcap
!= AC_WID_AUD_IN
) {
3908 spec
->adc_nids
= alc260_adc_nids_alt
;
3909 spec
->num_adc_nids
= ARRAY_SIZE(alc260_adc_nids_alt
);
3910 spec
->mixers
[spec
->num_mixers
] = alc260_capture_alt_mixer
;
3912 spec
->adc_nids
= alc260_adc_nids
;
3913 spec
->num_adc_nids
= ARRAY_SIZE(alc260_adc_nids
);
3914 spec
->mixers
[spec
->num_mixers
] = alc260_capture_mixer
;
3921 /* additional initialization for auto-configuration model */
3922 static void alc260_auto_init(struct hda_codec
*codec
)
3924 alc260_auto_init_multi_out(codec
);
3925 alc260_auto_init_analog_input(codec
);
3929 * ALC260 configurations
3931 static struct hda_board_config alc260_cfg_tbl
[] = {
3932 { .modelname
= "basic", .config
= ALC260_BASIC
},
3933 { .pci_subvendor
= 0x104d, .pci_subdevice
= 0x81bb,
3934 .config
= ALC260_BASIC
}, /* Sony VAIO */
3935 { .pci_subvendor
= 0x104d, .pci_subdevice
= 0x81cc,
3936 .config
= ALC260_BASIC
}, /* Sony VAIO VGN-S3HP */
3937 { .pci_subvendor
= 0x104d, .pci_subdevice
= 0x81cd,
3938 .config
= ALC260_BASIC
}, /* Sony VAIO */
3939 { .pci_subvendor
= 0x152d, .pci_subdevice
= 0x0729,
3940 .config
= ALC260_BASIC
}, /* CTL Travel Master U553W */
3941 { .modelname
= "hp", .config
= ALC260_HP
},
3942 { .modelname
= "hp-3013", .config
= ALC260_HP_3013
},
3943 { .pci_subvendor
= 0x103c, .pci_subdevice
= 0x3010, .config
= ALC260_HP_3013
},
3944 { .pci_subvendor
= 0x103c, .pci_subdevice
= 0x3011, .config
= ALC260_HP
},
3945 { .pci_subvendor
= 0x103c, .pci_subdevice
= 0x3012, .config
= ALC260_HP_3013
},
3946 { .pci_subvendor
= 0x103c, .pci_subdevice
= 0x3013, .config
= ALC260_HP_3013
},
3947 { .pci_subvendor
= 0x103c, .pci_subdevice
= 0x3014, .config
= ALC260_HP
},
3948 { .pci_subvendor
= 0x103c, .pci_subdevice
= 0x3015, .config
= ALC260_HP
},
3949 { .pci_subvendor
= 0x103c, .pci_subdevice
= 0x3016, .config
= ALC260_HP
},
3950 { .modelname
= "fujitsu", .config
= ALC260_FUJITSU_S702X
},
3951 { .pci_subvendor
= 0x10cf, .pci_subdevice
= 0x1326, .config
= ALC260_FUJITSU_S702X
},
3952 { .modelname
= "acer", .config
= ALC260_ACER
},
3953 { .pci_subvendor
= 0x1025, .pci_subdevice
= 0x008f, .config
= ALC260_ACER
},
3954 #ifdef CONFIG_SND_DEBUG
3955 { .modelname
= "test", .config
= ALC260_TEST
},
3957 { .modelname
= "auto", .config
= ALC260_AUTO
},
3961 static struct alc_config_preset alc260_presets
[] = {
3963 .mixers
= { alc260_base_output_mixer
,
3965 alc260_pc_beep_mixer
,
3966 alc260_capture_mixer
},
3967 .init_verbs
= { alc260_init_verbs
},
3968 .num_dacs
= ARRAY_SIZE(alc260_dac_nids
),
3969 .dac_nids
= alc260_dac_nids
,
3970 .num_adc_nids
= ARRAY_SIZE(alc260_adc_nids
),
3971 .adc_nids
= alc260_adc_nids
,
3972 .num_channel_mode
= ARRAY_SIZE(alc260_modes
),
3973 .channel_mode
= alc260_modes
,
3974 .input_mux
= &alc260_capture_source
,
3977 .mixers
= { alc260_base_output_mixer
,
3979 alc260_capture_alt_mixer
},
3980 .init_verbs
= { alc260_init_verbs
},
3981 .num_dacs
= ARRAY_SIZE(alc260_dac_nids
),
3982 .dac_nids
= alc260_dac_nids
,
3983 .num_adc_nids
= ARRAY_SIZE(alc260_hp_adc_nids
),
3984 .adc_nids
= alc260_hp_adc_nids
,
3985 .num_channel_mode
= ARRAY_SIZE(alc260_modes
),
3986 .channel_mode
= alc260_modes
,
3987 .input_mux
= &alc260_capture_source
,
3989 [ALC260_HP_3013
] = {
3990 .mixers
= { alc260_hp_3013_mixer
,
3992 alc260_capture_alt_mixer
},
3993 .init_verbs
= { alc260_hp_3013_init_verbs
},
3994 .num_dacs
= ARRAY_SIZE(alc260_dac_nids
),
3995 .dac_nids
= alc260_dac_nids
,
3996 .num_adc_nids
= ARRAY_SIZE(alc260_hp_adc_nids
),
3997 .adc_nids
= alc260_hp_adc_nids
,
3998 .num_channel_mode
= ARRAY_SIZE(alc260_modes
),
3999 .channel_mode
= alc260_modes
,
4000 .input_mux
= &alc260_capture_source
,
4002 [ALC260_FUJITSU_S702X
] = {
4003 .mixers
= { alc260_fujitsu_mixer
,
4004 alc260_capture_mixer
},
4005 .init_verbs
= { alc260_fujitsu_init_verbs
},
4006 .num_dacs
= ARRAY_SIZE(alc260_dac_nids
),
4007 .dac_nids
= alc260_dac_nids
,
4008 .num_adc_nids
= ARRAY_SIZE(alc260_dual_adc_nids
),
4009 .adc_nids
= alc260_dual_adc_nids
,
4010 .num_channel_mode
= ARRAY_SIZE(alc260_modes
),
4011 .channel_mode
= alc260_modes
,
4012 .num_mux_defs
= ARRAY_SIZE(alc260_fujitsu_capture_sources
),
4013 .input_mux
= alc260_fujitsu_capture_sources
,
4016 .mixers
= { alc260_acer_mixer
,
4017 alc260_capture_mixer
},
4018 .init_verbs
= { alc260_acer_init_verbs
},
4019 .num_dacs
= ARRAY_SIZE(alc260_dac_nids
),
4020 .dac_nids
= alc260_dac_nids
,
4021 .num_adc_nids
= ARRAY_SIZE(alc260_dual_adc_nids
),
4022 .adc_nids
= alc260_dual_adc_nids
,
4023 .num_channel_mode
= ARRAY_SIZE(alc260_modes
),
4024 .channel_mode
= alc260_modes
,
4025 .num_mux_defs
= ARRAY_SIZE(alc260_acer_capture_sources
),
4026 .input_mux
= alc260_acer_capture_sources
,
4028 #ifdef CONFIG_SND_DEBUG
4030 .mixers
= { alc260_test_mixer
,
4031 alc260_capture_mixer
},
4032 .init_verbs
= { alc260_test_init_verbs
},
4033 .num_dacs
= ARRAY_SIZE(alc260_test_dac_nids
),
4034 .dac_nids
= alc260_test_dac_nids
,
4035 .num_adc_nids
= ARRAY_SIZE(alc260_test_adc_nids
),
4036 .adc_nids
= alc260_test_adc_nids
,
4037 .num_channel_mode
= ARRAY_SIZE(alc260_modes
),
4038 .channel_mode
= alc260_modes
,
4039 .num_mux_defs
= ARRAY_SIZE(alc260_test_capture_sources
),
4040 .input_mux
= alc260_test_capture_sources
,
4045 static int patch_alc260(struct hda_codec
*codec
)
4047 struct alc_spec
*spec
;
4048 int err
, board_config
;
4050 spec
= kzalloc(sizeof(*spec
), GFP_KERNEL
);
4056 board_config
= snd_hda_check_board_config(codec
, alc260_cfg_tbl
);
4057 if (board_config
< 0 || board_config
>= ALC260_MODEL_LAST
) {
4058 snd_printd(KERN_INFO
"hda_codec: Unknown model for ALC260, "
4059 "trying auto-probe from BIOS...\n");
4060 board_config
= ALC260_AUTO
;
4063 if (board_config
== ALC260_AUTO
) {
4064 /* automatic parse from the BIOS config */
4065 err
= alc260_parse_auto_config(codec
);
4071 "hda_codec: Cannot set up configuration "
4072 "from BIOS. Using base mode...\n");
4073 board_config
= ALC260_BASIC
;
4077 if (board_config
!= ALC260_AUTO
)
4078 setup_preset(spec
, &alc260_presets
[board_config
]);
4080 spec
->stream_name_analog
= "ALC260 Analog";
4081 spec
->stream_analog_playback
= &alc260_pcm_analog_playback
;
4082 spec
->stream_analog_capture
= &alc260_pcm_analog_capture
;
4084 spec
->stream_name_digital
= "ALC260 Digital";
4085 spec
->stream_digital_playback
= &alc260_pcm_digital_playback
;
4086 spec
->stream_digital_capture
= &alc260_pcm_digital_capture
;
4088 codec
->patch_ops
= alc_patch_ops
;
4089 if (board_config
== ALC260_AUTO
)
4090 spec
->init_hook
= alc260_auto_init
;
4099 * ALC882 is almost identical with ALC880 but has cleaner and more flexible
4100 * configuration. Each pin widget can choose any input DACs and a mixer.
4101 * Each ADC is connected from a mixer of all inputs. This makes possible
4102 * 6-channel independent captures.
4104 * In addition, an independent DAC for the multi-playback (not used in this
4107 #define ALC882_DIGOUT_NID 0x06
4108 #define ALC882_DIGIN_NID 0x0a
4110 static struct hda_channel_mode alc882_ch_modes
[1] = {
4114 static hda_nid_t alc882_dac_nids
[4] = {
4115 /* front, rear, clfe, rear_surr */
4116 0x02, 0x03, 0x04, 0x05
4119 /* identical with ALC880 */
4120 #define alc882_adc_nids alc880_adc_nids
4121 #define alc882_adc_nids_alt alc880_adc_nids_alt
4124 /* FIXME: should be a matrix-type input source selection */
4126 static struct hda_input_mux alc882_capture_source
= {
4130 { "Front Mic", 0x1 },
4135 #define alc882_mux_enum_info alc_mux_enum_info
4136 #define alc882_mux_enum_get alc_mux_enum_get
4138 static int alc882_mux_enum_put(struct snd_kcontrol
*kcontrol
, struct snd_ctl_elem_value
*ucontrol
)
4140 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
4141 struct alc_spec
*spec
= codec
->spec
;
4142 const struct hda_input_mux
*imux
= spec
->input_mux
;
4143 unsigned int adc_idx
= snd_ctl_get_ioffidx(kcontrol
, &ucontrol
->id
);
4144 static hda_nid_t capture_mixers
[3] = { 0x24, 0x23, 0x22 };
4145 hda_nid_t nid
= capture_mixers
[adc_idx
];
4146 unsigned int *cur_val
= &spec
->cur_mux
[adc_idx
];
4147 unsigned int i
, idx
;
4149 idx
= ucontrol
->value
.enumerated
.item
[0];
4150 if (idx
>= imux
->num_items
)
4151 idx
= imux
->num_items
- 1;
4152 if (*cur_val
== idx
&& ! codec
->in_resume
)
4154 for (i
= 0; i
< imux
->num_items
; i
++) {
4155 unsigned int v
= (i
== idx
) ? 0x7000 : 0x7080;
4156 snd_hda_codec_write(codec
, nid
, 0, AC_VERB_SET_AMP_GAIN_MUTE
,
4157 v
| (imux
->items
[i
].index
<< 8));
4166 static struct hda_verb alc882_sixstack_ch6_init
[] = {
4167 { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL
, 0x00 },
4168 { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_OUT
},
4169 { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_OUT
},
4170 { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_OUT
},
4177 static struct hda_verb alc882_sixstack_ch8_init
[] = {
4178 { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_OUT
},
4179 { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_OUT
},
4180 { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_OUT
},
4181 { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_OUT
},
4185 static struct hda_channel_mode alc882_sixstack_modes
[2] = {
4186 { 6, alc882_sixstack_ch6_init
},
4187 { 8, alc882_sixstack_ch8_init
},
4190 /* Pin assignment: Front=0x14, Rear=0x15, CLFE=0x16, Side=0x17
4191 * Mic=0x18, Front Mic=0x19, Line-In=0x1a, HP=0x1b
4193 static struct snd_kcontrol_new alc882_base_mixer
[] = {
4194 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT
),
4195 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT
),
4196 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT
),
4197 HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT
),
4198 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT
),
4199 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT
),
4200 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT
),
4201 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT
),
4202 HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT
),
4203 HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT
),
4204 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT
),
4205 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT
),
4206 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT
),
4207 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT
),
4208 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT
),
4209 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT
),
4210 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT
),
4211 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT
),
4212 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT
),
4213 HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT
),
4214 HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT
),
4218 static struct snd_kcontrol_new alc882_chmode_mixer
[] = {
4220 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
4221 .name
= "Channel Mode",
4222 .info
= alc_ch_mode_info
,
4223 .get
= alc_ch_mode_get
,
4224 .put
= alc_ch_mode_put
,
4229 static struct hda_verb alc882_init_verbs
[] = {
4230 /* Front mixer: unmute input/output amp left and right (volume = 0) */
4231 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_ZERO
},
4232 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_MUTE(0)},
4233 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_MUTE(1)},
4235 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_ZERO
},
4236 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_MUTE(0)},
4237 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_MUTE(1)},
4239 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_ZERO
},
4240 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_MUTE(0)},
4241 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_MUTE(1)},
4243 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_ZERO
},
4244 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_MUTE(0)},
4245 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_MUTE(1)},
4247 /* Front Pin: output 0 (0x0c) */
4248 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_OUT
},
4249 {0x14, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_UNMUTE
},
4250 {0x14, AC_VERB_SET_CONNECT_SEL
, 0x00},
4251 /* Rear Pin: output 1 (0x0d) */
4252 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_OUT
},
4253 {0x15, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_UNMUTE
},
4254 {0x15, AC_VERB_SET_CONNECT_SEL
, 0x01},
4255 /* CLFE Pin: output 2 (0x0e) */
4256 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_OUT
},
4257 {0x16, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_UNMUTE
},
4258 {0x16, AC_VERB_SET_CONNECT_SEL
, 0x02},
4259 /* Side Pin: output 3 (0x0f) */
4260 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_OUT
},
4261 {0x17, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_UNMUTE
},
4262 {0x17, AC_VERB_SET_CONNECT_SEL
, 0x03},
4263 /* Mic (rear) pin: input vref at 80% */
4264 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_VREF80
},
4265 {0x18, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_MUTE
},
4266 /* Front Mic pin: input vref at 80% */
4267 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_VREF80
},
4268 {0x19, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_MUTE
},
4269 /* Line In pin: input */
4270 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_IN
},
4271 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_MUTE
},
4272 /* Line-2 In: Headphone output (output 0 - 0x0c) */
4273 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_HP
},
4274 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_UNMUTE
},
4275 {0x1b, AC_VERB_SET_CONNECT_SEL
, 0x00},
4276 /* CD pin widget for input */
4277 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_IN
},
4279 /* FIXME: use matrix-type input source selection */
4280 /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
4281 /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
4282 {0x24, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(0)},
4283 {0x24, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_MUTE(3)},
4284 {0x24, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_MUTE(2)},
4285 {0x24, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_MUTE(4)},
4287 {0x23, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(0)},
4288 {0x23, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_MUTE(3)},
4289 {0x23, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_MUTE(2)},
4290 {0x23, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_MUTE(4)},
4292 {0x22, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(0)},
4293 {0x22, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_MUTE(3)},
4294 {0x22, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_MUTE(2)},
4295 {0x22, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_MUTE(4)},
4296 /* ADC1: mute amp left and right */
4297 {0x07, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_MUTE(0)},
4298 {0x07, AC_VERB_SET_CONNECT_SEL
, 0x00},
4299 /* ADC2: mute amp left and right */
4300 {0x08, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_MUTE(0)},
4301 {0x08, AC_VERB_SET_CONNECT_SEL
, 0x00},
4302 /* ADC3: mute amp left and right */
4303 {0x09, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_MUTE(0)},
4304 {0x09, AC_VERB_SET_CONNECT_SEL
, 0x00},
4309 static struct hda_verb alc882_eapd_verbs
[] = {
4310 /* change to EAPD mode */
4311 {0x20, AC_VERB_SET_COEF_INDEX
, 0x07},
4312 {0x20, AC_VERB_SET_PROC_COEF
, 0x3060},
4317 * generic initialization of ADC, input mixers and output mixers
4319 static struct hda_verb alc882_auto_init_verbs
[] = {
4321 * Unmute ADC0-2 and set the default input to mic-in
4323 {0x07, AC_VERB_SET_CONNECT_SEL
, 0x00},
4324 {0x07, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(0)},
4325 {0x08, AC_VERB_SET_CONNECT_SEL
, 0x00},
4326 {0x08, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(0)},
4327 {0x09, AC_VERB_SET_CONNECT_SEL
, 0x00},
4328 {0x09, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(0)},
4330 /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
4332 * Note: PASD motherboards uses the Line In 2 as the input for front panel
4335 /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
4336 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(0)},
4337 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(1)},
4338 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(2)},
4339 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(3)},
4340 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(4)},
4343 * Set up output mixers (0x0c - 0x0f)
4345 /* set vol=0 to output mixers */
4346 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_ZERO
},
4347 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_ZERO
},
4348 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_ZERO
},
4349 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_ZERO
},
4350 /* set up input amps for analog loopback */
4351 /* Amp Indices: DAC = 0, mixer = 1 */
4352 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(0)},
4353 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(1)},
4354 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(0)},
4355 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(1)},
4356 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(0)},
4357 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(1)},
4358 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(0)},
4359 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(1)},
4360 {0x26, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(0)},
4361 {0x26, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(1)},
4363 /* FIXME: use matrix-type input source selection */
4364 /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
4365 /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
4366 {0x24, AC_VERB_SET_AMP_GAIN_MUTE
, (0x7000 | (0x00 << 8))},
4367 {0x24, AC_VERB_SET_AMP_GAIN_MUTE
, (0x7080 | (0x03 << 8))},
4368 {0x24, AC_VERB_SET_AMP_GAIN_MUTE
, (0x7080 | (0x02 << 8))},
4369 {0x24, AC_VERB_SET_AMP_GAIN_MUTE
, (0x7080 | (0x04 << 8))},
4371 {0x23, AC_VERB_SET_AMP_GAIN_MUTE
, (0x7000 | (0x00 << 8))},
4372 {0x23, AC_VERB_SET_AMP_GAIN_MUTE
, (0x7080 | (0x03 << 8))},
4373 {0x23, AC_VERB_SET_AMP_GAIN_MUTE
, (0x7080 | (0x02 << 8))},
4374 {0x23, AC_VERB_SET_AMP_GAIN_MUTE
, (0x7080 | (0x04 << 8))},
4376 {0x22, AC_VERB_SET_AMP_GAIN_MUTE
, (0x7000 | (0x00 << 8))},
4377 {0x22, AC_VERB_SET_AMP_GAIN_MUTE
, (0x7080 | (0x03 << 8))},
4378 {0x22, AC_VERB_SET_AMP_GAIN_MUTE
, (0x7080 | (0x02 << 8))},
4379 {0x22, AC_VERB_SET_AMP_GAIN_MUTE
, (0x7080 | (0x04 << 8))},
4384 /* capture mixer elements */
4385 static struct snd_kcontrol_new alc882_capture_alt_mixer
[] = {
4386 HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT
),
4387 HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT
),
4388 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT
),
4389 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT
),
4391 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
4392 /* The multiple "Capture Source" controls confuse alsamixer
4393 * So call somewhat different..
4394 * FIXME: the controls appear in the "playback" view!
4396 /* .name = "Capture Source", */
4397 .name
= "Input Source",
4399 .info
= alc882_mux_enum_info
,
4400 .get
= alc882_mux_enum_get
,
4401 .put
= alc882_mux_enum_put
,
4406 static struct snd_kcontrol_new alc882_capture_mixer
[] = {
4407 HDA_CODEC_VOLUME("Capture Volume", 0x07, 0x0, HDA_INPUT
),
4408 HDA_CODEC_MUTE("Capture Switch", 0x07, 0x0, HDA_INPUT
),
4409 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x08, 0x0, HDA_INPUT
),
4410 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x08, 0x0, HDA_INPUT
),
4411 HDA_CODEC_VOLUME_IDX("Capture Volume", 2, 0x09, 0x0, HDA_INPUT
),
4412 HDA_CODEC_MUTE_IDX("Capture Switch", 2, 0x09, 0x0, HDA_INPUT
),
4414 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
4415 /* The multiple "Capture Source" controls confuse alsamixer
4416 * So call somewhat different..
4417 * FIXME: the controls appear in the "playback" view!
4419 /* .name = "Capture Source", */
4420 .name
= "Input Source",
4422 .info
= alc882_mux_enum_info
,
4423 .get
= alc882_mux_enum_get
,
4424 .put
= alc882_mux_enum_put
,
4429 /* pcm configuration: identiacal with ALC880 */
4430 #define alc882_pcm_analog_playback alc880_pcm_analog_playback
4431 #define alc882_pcm_analog_capture alc880_pcm_analog_capture
4432 #define alc882_pcm_digital_playback alc880_pcm_digital_playback
4433 #define alc882_pcm_digital_capture alc880_pcm_digital_capture
4436 * configuration and preset
4438 static struct hda_board_config alc882_cfg_tbl
[] = {
4439 { .modelname
= "3stack-dig", .config
= ALC882_3ST_DIG
},
4440 { .modelname
= "6stack-dig", .config
= ALC882_6ST_DIG
},
4441 { .pci_subvendor
= 0x1462, .pci_subdevice
= 0x6668,
4442 .config
= ALC882_6ST_DIG
}, /* MSI */
4443 { .pci_subvendor
= 0x105b, .pci_subdevice
= 0x6668,
4444 .config
= ALC882_6ST_DIG
}, /* Foxconn */
4445 { .pci_subvendor
= 0x1019, .pci_subdevice
= 0x6668,
4446 .config
= ALC882_6ST_DIG
}, /* ECS to Intel*/
4447 { .modelname
= "arima", .config
= ALC882_ARIMA
},
4448 { .pci_subvendor
= 0x161f, .pci_subdevice
= 0x2054,
4449 .config
= ALC882_ARIMA
}, /* Arima W820Di1 */
4450 { .modelname
= "auto", .config
= ALC882_AUTO
},
4454 static struct alc_config_preset alc882_presets
[] = {
4455 [ALC882_3ST_DIG
] = {
4456 .mixers
= { alc882_base_mixer
},
4457 .init_verbs
= { alc882_init_verbs
},
4458 .num_dacs
= ARRAY_SIZE(alc882_dac_nids
),
4459 .dac_nids
= alc882_dac_nids
,
4460 .dig_out_nid
= ALC882_DIGOUT_NID
,
4461 .dig_in_nid
= ALC882_DIGIN_NID
,
4462 .num_channel_mode
= ARRAY_SIZE(alc882_ch_modes
),
4463 .channel_mode
= alc882_ch_modes
,
4465 .input_mux
= &alc882_capture_source
,
4467 [ALC882_6ST_DIG
] = {
4468 .mixers
= { alc882_base_mixer
, alc882_chmode_mixer
},
4469 .init_verbs
= { alc882_init_verbs
},
4470 .num_dacs
= ARRAY_SIZE(alc882_dac_nids
),
4471 .dac_nids
= alc882_dac_nids
,
4472 .dig_out_nid
= ALC882_DIGOUT_NID
,
4473 .dig_in_nid
= ALC882_DIGIN_NID
,
4474 .num_channel_mode
= ARRAY_SIZE(alc882_sixstack_modes
),
4475 .channel_mode
= alc882_sixstack_modes
,
4476 .input_mux
= &alc882_capture_source
,
4479 .mixers
= { alc882_base_mixer
, alc882_chmode_mixer
},
4480 .init_verbs
= { alc882_init_verbs
, alc882_eapd_verbs
},
4481 .num_dacs
= ARRAY_SIZE(alc882_dac_nids
),
4482 .dac_nids
= alc882_dac_nids
,
4483 .num_channel_mode
= ARRAY_SIZE(alc882_sixstack_modes
),
4484 .channel_mode
= alc882_sixstack_modes
,
4485 .input_mux
= &alc882_capture_source
,
4491 * BIOS auto configuration
4493 static void alc882_auto_set_output_and_unmute(struct hda_codec
*codec
,
4494 hda_nid_t nid
, int pin_type
,
4498 struct alc_spec
*spec
= codec
->spec
;
4501 if (spec
->multiout
.dac_nids
[dac_idx
] == 0x25)
4504 idx
= spec
->multiout
.dac_nids
[dac_idx
] - 2;
4506 snd_hda_codec_write(codec
, nid
, 0, AC_VERB_SET_PIN_WIDGET_CONTROL
, pin_type
);
4507 snd_hda_codec_write(codec
, nid
, 0, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_UNMUTE
);
4508 snd_hda_codec_write(codec
, nid
, 0, AC_VERB_SET_CONNECT_SEL
, idx
);
4512 static void alc882_auto_init_multi_out(struct hda_codec
*codec
)
4514 struct alc_spec
*spec
= codec
->spec
;
4517 for (i
= 0; i
<= HDA_SIDE
; i
++) {
4518 hda_nid_t nid
= spec
->autocfg
.line_out_pins
[i
];
4520 alc882_auto_set_output_and_unmute(codec
, nid
, PIN_OUT
, i
);
4524 static void alc882_auto_init_hp_out(struct hda_codec
*codec
)
4526 struct alc_spec
*spec
= codec
->spec
;
4529 pin
= spec
->autocfg
.hp_pins
[0];
4530 if (pin
) /* connect to front */
4531 alc882_auto_set_output_and_unmute(codec
, pin
, PIN_HP
, 0); /* use dac 0 */
4534 #define alc882_is_input_pin(nid) alc880_is_input_pin(nid)
4535 #define ALC882_PIN_CD_NID ALC880_PIN_CD_NID
4537 static void alc882_auto_init_analog_input(struct hda_codec
*codec
)
4539 struct alc_spec
*spec
= codec
->spec
;
4542 for (i
= 0; i
< AUTO_PIN_LAST
; i
++) {
4543 hda_nid_t nid
= spec
->autocfg
.input_pins
[i
];
4544 if (alc882_is_input_pin(nid
)) {
4545 snd_hda_codec_write(codec
, nid
, 0, AC_VERB_SET_PIN_WIDGET_CONTROL
,
4546 i
<= AUTO_PIN_FRONT_MIC
? PIN_VREF80
: PIN_IN
);
4547 if (nid
!= ALC882_PIN_CD_NID
)
4548 snd_hda_codec_write(codec
, nid
, 0, AC_VERB_SET_AMP_GAIN_MUTE
,
4554 /* almost identical with ALC880 parser... */
4555 static int alc882_parse_auto_config(struct hda_codec
*codec
)
4557 struct alc_spec
*spec
= codec
->spec
;
4558 int err
= alc880_parse_auto_config(codec
);
4563 /* hack - override the init verbs */
4564 spec
->init_verbs
[0] = alc882_auto_init_verbs
;
4568 /* additional initialization for auto-configuration model */
4569 static void alc882_auto_init(struct hda_codec
*codec
)
4571 alc882_auto_init_multi_out(codec
);
4572 alc882_auto_init_hp_out(codec
);
4573 alc882_auto_init_analog_input(codec
);
4576 static int patch_alc882(struct hda_codec
*codec
)
4578 struct alc_spec
*spec
;
4579 int err
, board_config
;
4581 spec
= kzalloc(sizeof(*spec
), GFP_KERNEL
);
4587 board_config
= snd_hda_check_board_config(codec
, alc882_cfg_tbl
);
4589 if (board_config
< 0 || board_config
>= ALC882_MODEL_LAST
) {
4590 printk(KERN_INFO
"hda_codec: Unknown model for ALC882, "
4591 "trying auto-probe from BIOS...\n");
4592 board_config
= ALC882_AUTO
;
4595 if (board_config
== ALC882_AUTO
) {
4596 /* automatic parse from the BIOS config */
4597 err
= alc882_parse_auto_config(codec
);
4603 "hda_codec: Cannot set up configuration "
4604 "from BIOS. Using base mode...\n");
4605 board_config
= ALC882_3ST_DIG
;
4609 if (board_config
!= ALC882_AUTO
)
4610 setup_preset(spec
, &alc882_presets
[board_config
]);
4612 spec
->stream_name_analog
= "ALC882 Analog";
4613 spec
->stream_analog_playback
= &alc882_pcm_analog_playback
;
4614 spec
->stream_analog_capture
= &alc882_pcm_analog_capture
;
4616 spec
->stream_name_digital
= "ALC882 Digital";
4617 spec
->stream_digital_playback
= &alc882_pcm_digital_playback
;
4618 spec
->stream_digital_capture
= &alc882_pcm_digital_capture
;
4620 if (! spec
->adc_nids
&& spec
->input_mux
) {
4621 /* check whether NID 0x07 is valid */
4622 unsigned int wcap
= get_wcaps(codec
, 0x07);
4623 wcap
= (wcap
& AC_WCAP_TYPE
) >> AC_WCAP_TYPE_SHIFT
; /* get type */
4624 if (wcap
!= AC_WID_AUD_IN
) {
4625 spec
->adc_nids
= alc882_adc_nids_alt
;
4626 spec
->num_adc_nids
= ARRAY_SIZE(alc882_adc_nids_alt
);
4627 spec
->mixers
[spec
->num_mixers
] = alc882_capture_alt_mixer
;
4630 spec
->adc_nids
= alc882_adc_nids
;
4631 spec
->num_adc_nids
= ARRAY_SIZE(alc882_adc_nids
);
4632 spec
->mixers
[spec
->num_mixers
] = alc882_capture_mixer
;
4637 codec
->patch_ops
= alc_patch_ops
;
4638 if (board_config
== ALC882_AUTO
)
4639 spec
->init_hook
= alc882_auto_init
;
4647 * ALC883 is almost identical with ALC880 but has cleaner and more flexible
4648 * configuration. Each pin widget can choose any input DACs and a mixer.
4649 * Each ADC is connected from a mixer of all inputs. This makes possible
4650 * 6-channel independent captures.
4652 * In addition, an independent DAC for the multi-playback (not used in this
4655 #define ALC883_DIGOUT_NID 0x06
4656 #define ALC883_DIGIN_NID 0x0a
4658 static hda_nid_t alc883_dac_nids
[4] = {
4659 /* front, rear, clfe, rear_surr */
4660 0x02, 0x04, 0x03, 0x05
4663 static hda_nid_t alc883_adc_nids
[2] = {
4668 /* FIXME: should be a matrix-type input source selection */
4670 static struct hda_input_mux alc883_capture_source
= {
4674 { "Front Mic", 0x1 },
4679 #define alc883_mux_enum_info alc_mux_enum_info
4680 #define alc883_mux_enum_get alc_mux_enum_get
4682 static int alc883_mux_enum_put(struct snd_kcontrol
*kcontrol
,
4683 struct snd_ctl_elem_value
*ucontrol
)
4685 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
4686 struct alc_spec
*spec
= codec
->spec
;
4687 const struct hda_input_mux
*imux
= spec
->input_mux
;
4688 unsigned int adc_idx
= snd_ctl_get_ioffidx(kcontrol
, &ucontrol
->id
);
4689 static hda_nid_t capture_mixers
[3] = { 0x24, 0x23, 0x22 };
4690 hda_nid_t nid
= capture_mixers
[adc_idx
];
4691 unsigned int *cur_val
= &spec
->cur_mux
[adc_idx
];
4692 unsigned int i
, idx
;
4694 idx
= ucontrol
->value
.enumerated
.item
[0];
4695 if (idx
>= imux
->num_items
)
4696 idx
= imux
->num_items
- 1;
4697 if (*cur_val
== idx
&& ! codec
->in_resume
)
4699 for (i
= 0; i
< imux
->num_items
; i
++) {
4700 unsigned int v
= (i
== idx
) ? 0x7000 : 0x7080;
4701 snd_hda_codec_write(codec
, nid
, 0, AC_VERB_SET_AMP_GAIN_MUTE
,
4702 v
| (imux
->items
[i
].index
<< 8));
4710 static struct hda_channel_mode alc883_3ST_2ch_modes
[1] = {
4717 static struct hda_verb alc883_3ST_ch2_init
[] = {
4718 { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_VREF80
},
4719 { 0x18, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_MUTE
},
4720 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_IN
},
4721 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_MUTE
},
4728 static struct hda_verb alc883_3ST_ch6_init
[] = {
4729 { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_OUT
},
4730 { 0x18, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_UNMUTE
},
4731 { 0x18, AC_VERB_SET_CONNECT_SEL
, 0x02 },
4732 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_OUT
},
4733 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_UNMUTE
},
4734 { 0x1a, AC_VERB_SET_CONNECT_SEL
, 0x01 },
4738 static struct hda_channel_mode alc883_3ST_6ch_modes
[2] = {
4739 { 2, alc883_3ST_ch2_init
},
4740 { 6, alc883_3ST_ch6_init
},
4746 static struct hda_verb alc883_sixstack_ch6_init
[] = {
4747 { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL
, 0x00 },
4748 { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_OUT
},
4749 { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_OUT
},
4750 { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_OUT
},
4757 static struct hda_verb alc883_sixstack_ch8_init
[] = {
4758 { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_OUT
},
4759 { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_OUT
},
4760 { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_OUT
},
4761 { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_OUT
},
4765 static struct hda_channel_mode alc883_sixstack_modes
[2] = {
4766 { 6, alc883_sixstack_ch6_init
},
4767 { 8, alc883_sixstack_ch8_init
},
4770 /* Pin assignment: Front=0x14, Rear=0x15, CLFE=0x16, Side=0x17
4771 * Mic=0x18, Front Mic=0x19, Line-In=0x1a, HP=0x1b
4774 static struct snd_kcontrol_new alc883_base_mixer
[] = {
4775 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT
),
4776 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT
),
4777 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT
),
4778 HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT
),
4779 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT
),
4780 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT
),
4781 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT
),
4782 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT
),
4783 HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT
),
4784 HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT
),
4785 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT
),
4786 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT
),
4787 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT
),
4788 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT
),
4789 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT
),
4790 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT
),
4791 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT
),
4792 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT
),
4793 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT
),
4794 HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT
),
4795 HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT
),
4796 HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT
),
4797 HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT
),
4798 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT
),
4799 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT
),
4801 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
4802 /* .name = "Capture Source", */
4803 .name
= "Input Source",
4805 .info
= alc883_mux_enum_info
,
4806 .get
= alc883_mux_enum_get
,
4807 .put
= alc883_mux_enum_put
,
4812 static struct snd_kcontrol_new alc883_3ST_2ch_mixer
[] = {
4813 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT
),
4814 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT
),
4815 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT
),
4816 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT
),
4817 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT
),
4818 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT
),
4819 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT
),
4820 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT
),
4821 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT
),
4822 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT
),
4823 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT
),
4824 HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT
),
4825 HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT
),
4826 HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT
),
4827 HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT
),
4828 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT
),
4829 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT
),
4831 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
4832 /* .name = "Capture Source", */
4833 .name
= "Input Source",
4835 .info
= alc883_mux_enum_info
,
4836 .get
= alc883_mux_enum_get
,
4837 .put
= alc883_mux_enum_put
,
4842 static struct snd_kcontrol_new alc883_3ST_6ch_mixer
[] = {
4843 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT
),
4844 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT
),
4845 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT
),
4846 HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT
),
4847 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT
),
4848 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT
),
4849 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT
),
4850 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT
),
4851 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT
),
4852 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT
),
4853 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT
),
4854 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT
),
4855 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT
),
4856 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT
),
4857 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT
),
4858 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT
),
4859 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT
),
4860 HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT
),
4861 HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT
),
4862 HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT
),
4863 HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT
),
4864 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT
),
4865 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT
),
4867 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
4868 /* .name = "Capture Source", */
4869 .name
= "Input Source",
4871 .info
= alc883_mux_enum_info
,
4872 .get
= alc883_mux_enum_get
,
4873 .put
= alc883_mux_enum_put
,
4878 static struct snd_kcontrol_new alc883_chmode_mixer
[] = {
4880 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
4881 .name
= "Channel Mode",
4882 .info
= alc_ch_mode_info
,
4883 .get
= alc_ch_mode_get
,
4884 .put
= alc_ch_mode_put
,
4889 static struct hda_verb alc883_init_verbs
[] = {
4890 /* ADC1: mute amp left and right */
4891 {0x08, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_MUTE(0)},
4892 {0x08, AC_VERB_SET_CONNECT_SEL
, 0x00},
4893 /* ADC2: mute amp left and right */
4894 {0x09, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_MUTE(0)},
4895 {0x09, AC_VERB_SET_CONNECT_SEL
, 0x00},
4896 /* Front mixer: unmute input/output amp left and right (volume = 0) */
4897 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_ZERO
},
4898 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_MUTE(0)},
4899 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_MUTE(1)},
4901 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_ZERO
},
4902 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_MUTE(0)},
4903 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_MUTE(1)},
4905 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_ZERO
},
4906 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_MUTE(0)},
4907 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_MUTE(1)},
4909 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_ZERO
},
4910 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_MUTE(0)},
4911 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_MUTE(1)},
4913 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(0)},
4914 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(1)},
4915 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(2)},
4916 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(3)},
4917 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(4)},
4919 /* Front Pin: output 0 (0x0c) */
4920 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_OUT
},
4921 {0x14, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_UNMUTE
},
4922 {0x14, AC_VERB_SET_CONNECT_SEL
, 0x00},
4923 /* Rear Pin: output 1 (0x0d) */
4924 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_OUT
},
4925 {0x15, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_UNMUTE
},
4926 {0x15, AC_VERB_SET_CONNECT_SEL
, 0x01},
4927 /* CLFE Pin: output 2 (0x0e) */
4928 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_OUT
},
4929 {0x16, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_UNMUTE
},
4930 {0x16, AC_VERB_SET_CONNECT_SEL
, 0x02},
4931 /* Side Pin: output 3 (0x0f) */
4932 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_OUT
},
4933 {0x17, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_UNMUTE
},
4934 {0x17, AC_VERB_SET_CONNECT_SEL
, 0x03},
4935 /* Mic (rear) pin: input vref at 80% */
4936 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_VREF80
},
4937 {0x18, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_MUTE
},
4938 /* Front Mic pin: input vref at 80% */
4939 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_VREF80
},
4940 {0x19, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_MUTE
},
4941 /* Line In pin: input */
4942 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_IN
},
4943 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_MUTE
},
4944 /* Line-2 In: Headphone output (output 0 - 0x0c) */
4945 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_HP
},
4946 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_UNMUTE
},
4947 {0x1b, AC_VERB_SET_CONNECT_SEL
, 0x00},
4948 /* CD pin widget for input */
4949 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_IN
},
4951 /* FIXME: use matrix-type input source selection */
4952 /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
4954 {0x23, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(0)},
4955 {0x23, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(1)},
4956 {0x23, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(2)},
4957 {0x23, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(4)},
4959 {0x22, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(0)},
4960 {0x22, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(1)},
4961 {0x22, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(2)},
4962 {0x22, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(4)},
4967 * generic initialization of ADC, input mixers and output mixers
4969 static struct hda_verb alc883_auto_init_verbs
[] = {
4971 * Unmute ADC0-2 and set the default input to mic-in
4973 {0x08, AC_VERB_SET_CONNECT_SEL
, 0x00},
4974 {0x08, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(0)},
4975 {0x09, AC_VERB_SET_CONNECT_SEL
, 0x00},
4976 {0x09, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(0)},
4978 /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
4980 * Note: PASD motherboards uses the Line In 2 as the input for front panel
4983 /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
4984 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(0)},
4985 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(1)},
4986 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(2)},
4987 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(3)},
4988 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(4)},
4991 * Set up output mixers (0x0c - 0x0f)
4993 /* set vol=0 to output mixers */
4994 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_ZERO
},
4995 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_ZERO
},
4996 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_ZERO
},
4997 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_ZERO
},
4998 /* set up input amps for analog loopback */
4999 /* Amp Indices: DAC = 0, mixer = 1 */
5000 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(0)},
5001 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(1)},
5002 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(0)},
5003 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(1)},
5004 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(0)},
5005 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(1)},
5006 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(0)},
5007 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(1)},
5008 {0x26, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(0)},
5009 {0x26, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(1)},
5011 /* FIXME: use matrix-type input source selection */
5012 /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
5014 {0x23, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(0)},
5015 {0x23, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(1)},
5016 {0x23, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(2)},
5017 //{0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
5018 {0x23, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(4)},
5020 {0x22, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(0)},
5021 {0x22, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(1)},
5022 {0x22, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(2)},
5023 //{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
5024 {0x23, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(4)},
5029 /* capture mixer elements */
5030 static struct snd_kcontrol_new alc883_capture_mixer
[] = {
5031 HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT
),
5032 HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT
),
5033 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT
),
5034 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT
),
5036 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
5037 /* The multiple "Capture Source" controls confuse alsamixer
5038 * So call somewhat different..
5039 * FIXME: the controls appear in the "playback" view!
5041 /* .name = "Capture Source", */
5042 .name
= "Input Source",
5044 .info
= alc882_mux_enum_info
,
5045 .get
= alc882_mux_enum_get
,
5046 .put
= alc882_mux_enum_put
,
5051 /* pcm configuration: identiacal with ALC880 */
5052 #define alc883_pcm_analog_playback alc880_pcm_analog_playback
5053 #define alc883_pcm_analog_capture alc880_pcm_analog_capture
5054 #define alc883_pcm_digital_playback alc880_pcm_digital_playback
5055 #define alc883_pcm_digital_capture alc880_pcm_digital_capture
5058 * configuration and preset
5060 static struct hda_board_config alc883_cfg_tbl
[] = {
5061 { .modelname
= "3stack-dig", .config
= ALC883_3ST_2ch_DIG
},
5062 { .modelname
= "3stack-6ch-dig", .config
= ALC883_3ST_6ch_DIG
},
5063 { .pci_subvendor
= 0x1019, .pci_subdevice
= 0x6668,
5064 .config
= ALC883_3ST_6ch_DIG
}, /* ECS to Intel*/
5065 { .modelname
= "3stack-6ch", .config
= ALC883_3ST_6ch
},
5066 { .pci_subvendor
= 0x108e, .pci_subdevice
= 0x534d,
5067 .config
= ALC883_3ST_6ch
},
5068 { .pci_subvendor
= 0x8086, .pci_subdevice
= 0xd601,
5069 .config
= ALC883_3ST_6ch
}, /* D102GGC */
5070 { .modelname
= "6stack-dig", .config
= ALC883_6ST_DIG
},
5071 { .pci_subvendor
= 0x1462, .pci_subdevice
= 0x6668,
5072 .config
= ALC883_6ST_DIG
}, /* MSI */
5073 { .pci_subvendor
= 0x105b, .pci_subdevice
= 0x6668,
5074 .config
= ALC883_6ST_DIG
}, /* Foxconn */
5075 { .modelname
= "6stack-dig-demo", .config
= ALC888_DEMO_BOARD
},
5076 { .modelname
= "acer", .config
= ALC883_ACER
},
5077 { .pci_subvendor
= 0x1025, .pci_subdevice
= 0/*0x0102*/,
5078 .config
= ALC883_ACER
},
5079 { .pci_subvendor
= 0x1025, .pci_subdevice
= 0x0102,
5080 .config
= ALC883_ACER
},
5081 { .pci_subvendor
= 0x1025, .pci_subdevice
= 0x009f,
5082 .config
= ALC883_ACER
},
5083 { .modelname
= "auto", .config
= ALC883_AUTO
},
5087 static struct alc_config_preset alc883_presets
[] = {
5088 [ALC883_3ST_2ch_DIG
] = {
5089 .mixers
= { alc883_3ST_2ch_mixer
},
5090 .init_verbs
= { alc883_init_verbs
},
5091 .num_dacs
= ARRAY_SIZE(alc883_dac_nids
),
5092 .dac_nids
= alc883_dac_nids
,
5093 .dig_out_nid
= ALC883_DIGOUT_NID
,
5094 .num_adc_nids
= ARRAY_SIZE(alc883_adc_nids
),
5095 .adc_nids
= alc883_adc_nids
,
5096 .dig_in_nid
= ALC883_DIGIN_NID
,
5097 .num_channel_mode
= ARRAY_SIZE(alc883_3ST_2ch_modes
),
5098 .channel_mode
= alc883_3ST_2ch_modes
,
5099 .input_mux
= &alc883_capture_source
,
5101 [ALC883_3ST_6ch_DIG
] = {
5102 .mixers
= { alc883_3ST_6ch_mixer
, alc883_chmode_mixer
},
5103 .init_verbs
= { alc883_init_verbs
},
5104 .num_dacs
= ARRAY_SIZE(alc883_dac_nids
),
5105 .dac_nids
= alc883_dac_nids
,
5106 .dig_out_nid
= ALC883_DIGOUT_NID
,
5107 .num_adc_nids
= ARRAY_SIZE(alc883_adc_nids
),
5108 .adc_nids
= alc883_adc_nids
,
5109 .dig_in_nid
= ALC883_DIGIN_NID
,
5110 .num_channel_mode
= ARRAY_SIZE(alc883_3ST_6ch_modes
),
5111 .channel_mode
= alc883_3ST_6ch_modes
,
5113 .input_mux
= &alc883_capture_source
,
5115 [ALC883_3ST_6ch
] = {
5116 .mixers
= { alc883_3ST_6ch_mixer
, alc883_chmode_mixer
},
5117 .init_verbs
= { alc883_init_verbs
},
5118 .num_dacs
= ARRAY_SIZE(alc883_dac_nids
),
5119 .dac_nids
= alc883_dac_nids
,
5120 .num_adc_nids
= ARRAY_SIZE(alc883_adc_nids
),
5121 .adc_nids
= alc883_adc_nids
,
5122 .num_channel_mode
= ARRAY_SIZE(alc883_3ST_6ch_modes
),
5123 .channel_mode
= alc883_3ST_6ch_modes
,
5125 .input_mux
= &alc883_capture_source
,
5127 [ALC883_6ST_DIG
] = {
5128 .mixers
= { alc883_base_mixer
, alc883_chmode_mixer
},
5129 .init_verbs
= { alc883_init_verbs
},
5130 .num_dacs
= ARRAY_SIZE(alc883_dac_nids
),
5131 .dac_nids
= alc883_dac_nids
,
5132 .dig_out_nid
= ALC883_DIGOUT_NID
,
5133 .num_adc_nids
= ARRAY_SIZE(alc883_adc_nids
),
5134 .adc_nids
= alc883_adc_nids
,
5135 .dig_in_nid
= ALC883_DIGIN_NID
,
5136 .num_channel_mode
= ARRAY_SIZE(alc883_sixstack_modes
),
5137 .channel_mode
= alc883_sixstack_modes
,
5138 .input_mux
= &alc883_capture_source
,
5140 [ALC888_DEMO_BOARD
] = {
5141 .mixers
= { alc883_base_mixer
, alc883_chmode_mixer
},
5142 .init_verbs
= { alc883_init_verbs
},
5143 .num_dacs
= ARRAY_SIZE(alc883_dac_nids
),
5144 .dac_nids
= alc883_dac_nids
,
5145 .dig_out_nid
= ALC883_DIGOUT_NID
,
5146 .num_adc_nids
= ARRAY_SIZE(alc883_adc_nids
),
5147 .adc_nids
= alc883_adc_nids
,
5148 .dig_in_nid
= ALC883_DIGIN_NID
,
5149 .num_channel_mode
= ARRAY_SIZE(alc883_sixstack_modes
),
5150 .channel_mode
= alc883_sixstack_modes
,
5151 .input_mux
= &alc883_capture_source
,
5154 .mixers
= { alc883_base_mixer
,
5155 alc883_chmode_mixer
},
5156 /* On TravelMate laptops, GPIO 0 enables the internal speaker
5157 * and the headphone jack. Turn this on and rely on the
5158 * standard mute methods whenever the user wants to turn
5159 * these outputs off.
5161 .init_verbs
= { alc883_init_verbs
, alc880_gpio1_init_verbs
},
5162 .num_dacs
= ARRAY_SIZE(alc883_dac_nids
),
5163 .dac_nids
= alc883_dac_nids
,
5164 .num_adc_nids
= ARRAY_SIZE(alc883_adc_nids
),
5165 .adc_nids
= alc883_adc_nids
,
5166 .num_channel_mode
= ARRAY_SIZE(alc883_3ST_2ch_modes
),
5167 .channel_mode
= alc883_3ST_2ch_modes
,
5168 .input_mux
= &alc883_capture_source
,
5174 * BIOS auto configuration
5176 static void alc883_auto_set_output_and_unmute(struct hda_codec
*codec
,
5177 hda_nid_t nid
, int pin_type
,
5181 struct alc_spec
*spec
= codec
->spec
;
5184 if (spec
->multiout
.dac_nids
[dac_idx
] == 0x25)
5187 idx
= spec
->multiout
.dac_nids
[dac_idx
] - 2;
5189 snd_hda_codec_write(codec
, nid
, 0, AC_VERB_SET_PIN_WIDGET_CONTROL
,
5191 snd_hda_codec_write(codec
, nid
, 0, AC_VERB_SET_AMP_GAIN_MUTE
,
5193 snd_hda_codec_write(codec
, nid
, 0, AC_VERB_SET_CONNECT_SEL
, idx
);
5197 static void alc883_auto_init_multi_out(struct hda_codec
*codec
)
5199 struct alc_spec
*spec
= codec
->spec
;
5202 for (i
= 0; i
<= HDA_SIDE
; i
++) {
5203 hda_nid_t nid
= spec
->autocfg
.line_out_pins
[i
];
5205 alc883_auto_set_output_and_unmute(codec
, nid
, PIN_OUT
, i
);
5209 static void alc883_auto_init_hp_out(struct hda_codec
*codec
)
5211 struct alc_spec
*spec
= codec
->spec
;
5214 pin
= spec
->autocfg
.hp_pins
[0];
5215 if (pin
) /* connect to front */
5217 alc883_auto_set_output_and_unmute(codec
, pin
, PIN_HP
, 0);
5220 #define alc883_is_input_pin(nid) alc880_is_input_pin(nid)
5221 #define ALC883_PIN_CD_NID ALC880_PIN_CD_NID
5223 static void alc883_auto_init_analog_input(struct hda_codec
*codec
)
5225 struct alc_spec
*spec
= codec
->spec
;
5228 for (i
= 0; i
< AUTO_PIN_LAST
; i
++) {
5229 hda_nid_t nid
= spec
->autocfg
.input_pins
[i
];
5230 if (alc883_is_input_pin(nid
)) {
5231 snd_hda_codec_write(codec
, nid
, 0,
5232 AC_VERB_SET_PIN_WIDGET_CONTROL
,
5233 (i
<= AUTO_PIN_FRONT_MIC
?
5234 PIN_VREF80
: PIN_IN
));
5235 if (nid
!= ALC883_PIN_CD_NID
)
5236 snd_hda_codec_write(codec
, nid
, 0,
5237 AC_VERB_SET_AMP_GAIN_MUTE
,
5243 /* almost identical with ALC880 parser... */
5244 static int alc883_parse_auto_config(struct hda_codec
*codec
)
5246 struct alc_spec
*spec
= codec
->spec
;
5247 int err
= alc880_parse_auto_config(codec
);
5252 /* hack - override the init verbs */
5253 spec
->init_verbs
[0] = alc883_auto_init_verbs
;
5254 spec
->mixers
[spec
->num_mixers
] = alc883_capture_mixer
;
5259 /* additional initialization for auto-configuration model */
5260 static void alc883_auto_init(struct hda_codec
*codec
)
5262 alc883_auto_init_multi_out(codec
);
5263 alc883_auto_init_hp_out(codec
);
5264 alc883_auto_init_analog_input(codec
);
5267 static int patch_alc883(struct hda_codec
*codec
)
5269 struct alc_spec
*spec
;
5270 int err
, board_config
;
5272 spec
= kzalloc(sizeof(*spec
), GFP_KERNEL
);
5278 board_config
= snd_hda_check_board_config(codec
, alc883_cfg_tbl
);
5279 if (board_config
< 0 || board_config
>= ALC883_MODEL_LAST
) {
5280 printk(KERN_INFO
"hda_codec: Unknown model for ALC883, "
5281 "trying auto-probe from BIOS...\n");
5282 board_config
= ALC883_AUTO
;
5285 if (board_config
== ALC883_AUTO
) {
5286 /* automatic parse from the BIOS config */
5287 err
= alc883_parse_auto_config(codec
);
5293 "hda_codec: Cannot set up configuration "
5294 "from BIOS. Using base mode...\n");
5295 board_config
= ALC883_3ST_2ch_DIG
;
5299 if (board_config
!= ALC883_AUTO
)
5300 setup_preset(spec
, &alc883_presets
[board_config
]);
5302 spec
->stream_name_analog
= "ALC883 Analog";
5303 spec
->stream_analog_playback
= &alc883_pcm_analog_playback
;
5304 spec
->stream_analog_capture
= &alc883_pcm_analog_capture
;
5306 spec
->stream_name_digital
= "ALC883 Digital";
5307 spec
->stream_digital_playback
= &alc883_pcm_digital_playback
;
5308 spec
->stream_digital_capture
= &alc883_pcm_digital_capture
;
5310 if (! spec
->adc_nids
&& spec
->input_mux
) {
5311 spec
->adc_nids
= alc883_adc_nids
;
5312 spec
->num_adc_nids
= ARRAY_SIZE(alc883_adc_nids
);
5315 codec
->patch_ops
= alc_patch_ops
;
5316 if (board_config
== ALC883_AUTO
)
5317 spec
->init_hook
= alc883_auto_init
;
5326 #define ALC262_DIGOUT_NID ALC880_DIGOUT_NID
5327 #define ALC262_DIGIN_NID ALC880_DIGIN_NID
5329 #define alc262_dac_nids alc260_dac_nids
5330 #define alc262_adc_nids alc882_adc_nids
5331 #define alc262_adc_nids_alt alc882_adc_nids_alt
5333 #define alc262_modes alc260_modes
5334 #define alc262_capture_source alc882_capture_source
5336 static struct snd_kcontrol_new alc262_base_mixer
[] = {
5337 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT
),
5338 HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT
),
5339 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT
),
5340 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT
),
5341 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT
),
5342 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT
),
5343 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT
),
5344 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT
),
5345 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT
),
5346 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT
),
5347 /* HDA_CODEC_VOLUME("PC Beep Playback Volume", 0x0b, 0x05, HDA_INPUT),
5348 HDA_CODEC_MUTE("PC Beelp Playback Switch", 0x0b, 0x05, HDA_INPUT), */
5349 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0D, 0x0, HDA_OUTPUT
),
5350 HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT
),
5351 HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT
),
5352 HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x16, 2, 0x0, HDA_OUTPUT
),
5356 static struct snd_kcontrol_new alc262_HP_BPC_mixer
[] = {
5357 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT
),
5358 HDA_CODEC_MUTE("Front Playback Switch", 0x15, 0x0, HDA_OUTPUT
),
5359 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT
),
5360 HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT
),
5361 HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x16, 2, 0x0, HDA_OUTPUT
),
5363 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT
),
5364 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT
),
5365 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT
),
5366 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT
),
5367 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT
),
5368 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT
),
5369 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT
),
5370 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT
),
5371 HDA_CODEC_VOLUME("PC Beep Playback Volume", 0x0b, 0x05, HDA_INPUT
),
5372 HDA_CODEC_MUTE("PC Beep Playback Switch", 0x0b, 0x05, HDA_INPUT
),
5373 HDA_CODEC_VOLUME("AUX IN Playback Volume", 0x0b, 0x06, HDA_INPUT
),
5374 HDA_CODEC_MUTE("AUX IN Playback Switch", 0x0b, 0x06, HDA_INPUT
),
5378 #define alc262_capture_mixer alc882_capture_mixer
5379 #define alc262_capture_alt_mixer alc882_capture_alt_mixer
5382 * generic initialization of ADC, input mixers and output mixers
5384 static struct hda_verb alc262_init_verbs
[] = {
5386 * Unmute ADC0-2 and set the default input to mic-in
5388 {0x07, AC_VERB_SET_CONNECT_SEL
, 0x00},
5389 {0x07, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(0)},
5390 {0x08, AC_VERB_SET_CONNECT_SEL
, 0x00},
5391 {0x08, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(0)},
5392 {0x09, AC_VERB_SET_CONNECT_SEL
, 0x00},
5393 {0x09, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(0)},
5395 /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
5397 * Note: PASD motherboards uses the Line In 2 as the input for front panel
5400 /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
5401 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(0)},
5402 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(1)},
5403 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(2)},
5404 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(3)},
5405 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(4)},
5408 * Set up output mixers (0x0c - 0x0e)
5410 /* set vol=0 to output mixers */
5411 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_ZERO
},
5412 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_ZERO
},
5413 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_ZERO
},
5414 /* set up input amps for analog loopback */
5415 /* Amp Indices: DAC = 0, mixer = 1 */
5416 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(0)},
5417 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(1)},
5418 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(0)},
5419 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(1)},
5420 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(0)},
5421 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(1)},
5423 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL
, 0x40},
5424 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL
, 0xc0},
5425 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL
, 0x40},
5426 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL
, 0x24},
5427 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL
, 0x20},
5428 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL
, 0x20},
5430 {0x14, AC_VERB_SET_AMP_GAIN_MUTE
, 0x0000},
5431 {0x15, AC_VERB_SET_AMP_GAIN_MUTE
, 0x0000},
5432 {0x16, AC_VERB_SET_AMP_GAIN_MUTE
, 0x0000},
5433 {0x18, AC_VERB_SET_AMP_GAIN_MUTE
, 0x0000},
5434 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE
, 0x0000},
5436 {0x14, AC_VERB_SET_CONNECT_SEL
, 0x00},
5437 {0x15, AC_VERB_SET_CONNECT_SEL
, 0x01},
5439 /* FIXME: use matrix-type input source selection */
5440 /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
5441 /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
5442 {0x24, AC_VERB_SET_AMP_GAIN_MUTE
, (0x7000 | (0x00 << 8))},
5443 {0x24, AC_VERB_SET_AMP_GAIN_MUTE
, (0x7080 | (0x03 << 8))},
5444 {0x24, AC_VERB_SET_AMP_GAIN_MUTE
, (0x7080 | (0x02 << 8))},
5445 {0x24, AC_VERB_SET_AMP_GAIN_MUTE
, (0x7080 | (0x04 << 8))},
5447 {0x23, AC_VERB_SET_AMP_GAIN_MUTE
, (0x7000 | (0x00 << 8))},
5448 {0x23, AC_VERB_SET_AMP_GAIN_MUTE
, (0x7080 | (0x03 << 8))},
5449 {0x23, AC_VERB_SET_AMP_GAIN_MUTE
, (0x7080 | (0x02 << 8))},
5450 {0x23, AC_VERB_SET_AMP_GAIN_MUTE
, (0x7080 | (0x04 << 8))},
5452 {0x22, AC_VERB_SET_AMP_GAIN_MUTE
, (0x7000 | (0x00 << 8))},
5453 {0x22, AC_VERB_SET_AMP_GAIN_MUTE
, (0x7080 | (0x03 << 8))},
5454 {0x22, AC_VERB_SET_AMP_GAIN_MUTE
, (0x7080 | (0x02 << 8))},
5455 {0x22, AC_VERB_SET_AMP_GAIN_MUTE
, (0x7080 | (0x04 << 8))},
5462 * 0x14 = headphone/spdif-out, 0x15 = internal speaker
5465 #define ALC_HP_EVENT 0x37
5467 static struct hda_verb alc262_fujitsu_unsol_verbs
[] = {
5468 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE
, AC_USRSP_EN
| ALC_HP_EVENT
},
5469 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_HP
},
5473 static struct hda_input_mux alc262_fujitsu_capture_source
= {
5481 static struct hda_input_mux alc262_HP_capture_source
= {
5485 { "Front Mic", 0x3 },
5492 /* mute/unmute internal speaker according to the hp jack and mute state */
5493 static void alc262_fujitsu_automute(struct hda_codec
*codec
, int force
)
5495 struct alc_spec
*spec
= codec
->spec
;
5498 if (force
|| ! spec
->sense_updated
) {
5499 unsigned int present
;
5500 /* need to execute and sync at first */
5501 snd_hda_codec_read(codec
, 0x14, 0, AC_VERB_SET_PIN_SENSE
, 0);
5502 present
= snd_hda_codec_read(codec
, 0x14, 0,
5503 AC_VERB_GET_PIN_SENSE
, 0);
5504 spec
->jack_present
= (present
& 0x80000000) != 0;
5505 spec
->sense_updated
= 1;
5507 if (spec
->jack_present
) {
5508 /* mute internal speaker */
5509 snd_hda_codec_amp_update(codec
, 0x15, 0, HDA_OUTPUT
, 0,
5511 snd_hda_codec_amp_update(codec
, 0x15, 1, HDA_OUTPUT
, 0,
5514 /* unmute internal speaker if necessary */
5515 mute
= snd_hda_codec_amp_read(codec
, 0x14, 0, HDA_OUTPUT
, 0);
5516 snd_hda_codec_amp_update(codec
, 0x15, 0, HDA_OUTPUT
, 0,
5518 mute
= snd_hda_codec_amp_read(codec
, 0x14, 1, HDA_OUTPUT
, 0);
5519 snd_hda_codec_amp_update(codec
, 0x15, 1, HDA_OUTPUT
, 0,
5524 /* unsolicited event for HP jack sensing */
5525 static void alc262_fujitsu_unsol_event(struct hda_codec
*codec
,
5528 if ((res
>> 26) != ALC_HP_EVENT
)
5530 alc262_fujitsu_automute(codec
, 1);
5533 /* bind volumes of both NID 0x0c and 0x0d */
5534 static int alc262_fujitsu_master_vol_put(struct snd_kcontrol
*kcontrol
,
5535 struct snd_ctl_elem_value
*ucontrol
)
5537 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
5538 long *valp
= ucontrol
->value
.integer
.value
;
5541 change
= snd_hda_codec_amp_update(codec
, 0x0c, 0, HDA_OUTPUT
, 0,
5542 0x7f, valp
[0] & 0x7f);
5543 change
|= snd_hda_codec_amp_update(codec
, 0x0c, 1, HDA_OUTPUT
, 0,
5544 0x7f, valp
[1] & 0x7f);
5545 snd_hda_codec_amp_update(codec
, 0x0d, 0, HDA_OUTPUT
, 0,
5546 0x7f, valp
[0] & 0x7f);
5547 snd_hda_codec_amp_update(codec
, 0x0d, 1, HDA_OUTPUT
, 0,
5548 0x7f, valp
[1] & 0x7f);
5552 /* bind hp and internal speaker mute (with plug check) */
5553 static int alc262_fujitsu_master_sw_put(struct snd_kcontrol
*kcontrol
,
5554 struct snd_ctl_elem_value
*ucontrol
)
5556 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
5557 long *valp
= ucontrol
->value
.integer
.value
;
5560 change
= snd_hda_codec_amp_update(codec
, 0x14, 0, HDA_OUTPUT
, 0,
5561 0x80, valp
[0] ? 0 : 0x80);
5562 change
|= snd_hda_codec_amp_update(codec
, 0x14, 1, HDA_OUTPUT
, 0,
5563 0x80, valp
[1] ? 0 : 0x80);
5564 if (change
|| codec
->in_resume
)
5565 alc262_fujitsu_automute(codec
, codec
->in_resume
);
5569 static struct snd_kcontrol_new alc262_fujitsu_mixer
[] = {
5571 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
5572 .name
= "Master Playback Volume",
5573 .info
= snd_hda_mixer_amp_volume_info
,
5574 .get
= snd_hda_mixer_amp_volume_get
,
5575 .put
= alc262_fujitsu_master_vol_put
,
5576 .tlv
= { .c
= snd_hda_mixer_amp_tlv
},
5577 .private_value
= HDA_COMPOSE_AMP_VAL(0x0c, 3, 0, HDA_OUTPUT
),
5580 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
5581 .name
= "Master Playback Switch",
5582 .info
= snd_hda_mixer_amp_switch_info
,
5583 .get
= snd_hda_mixer_amp_switch_get
,
5584 .put
= alc262_fujitsu_master_sw_put
,
5585 .private_value
= HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT
),
5587 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT
),
5588 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT
),
5589 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT
),
5590 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT
),
5591 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT
),
5595 /* additional init verbs for Benq laptops */
5596 static struct hda_verb alc262_EAPD_verbs
[] = {
5597 {0x20, AC_VERB_SET_COEF_INDEX
, 0x07},
5598 {0x20, AC_VERB_SET_PROC_COEF
, 0x3070},
5602 /* add playback controls from the parsed DAC table */
5603 static int alc262_auto_create_multi_out_ctls(struct alc_spec
*spec
, const struct auto_pin_cfg
*cfg
)
5608 spec
->multiout
.num_dacs
= 1; /* only use one dac */
5609 spec
->multiout
.dac_nids
= spec
->private_dac_nids
;
5610 spec
->multiout
.dac_nids
[0] = 2;
5612 nid
= cfg
->line_out_pins
[0];
5614 if ((err
= add_control(spec
, ALC_CTL_WIDGET_VOL
, "Front Playback Volume",
5615 HDA_COMPOSE_AMP_VAL(0x0c, 3, 0, HDA_OUTPUT
))) < 0)
5617 if ((err
= add_control(spec
, ALC_CTL_WIDGET_MUTE
, "Front Playback Switch",
5618 HDA_COMPOSE_AMP_VAL(nid
, 3, 0, HDA_OUTPUT
))) < 0)
5622 nid
= cfg
->speaker_pins
[0];
5625 if ((err
= add_control(spec
, ALC_CTL_WIDGET_VOL
, "Speaker Playback Volume",
5626 HDA_COMPOSE_AMP_VAL(0x0e, 2, 0, HDA_OUTPUT
))) < 0)
5628 if ((err
= add_control(spec
, ALC_CTL_WIDGET_MUTE
, "Speaker Playback Switch",
5629 HDA_COMPOSE_AMP_VAL(nid
, 2, 0, HDA_OUTPUT
))) < 0)
5632 if ((err
= add_control(spec
, ALC_CTL_WIDGET_MUTE
, "Speaker Playback Switch",
5633 HDA_COMPOSE_AMP_VAL(nid
, 3, 0, HDA_OUTPUT
))) < 0)
5637 nid
= cfg
->hp_pins
[0];
5639 /* spec->multiout.hp_nid = 2; */
5641 if ((err
= add_control(spec
, ALC_CTL_WIDGET_VOL
, "Headphone Playback Volume",
5642 HDA_COMPOSE_AMP_VAL(0x0e, 2, 0, HDA_OUTPUT
))) < 0)
5644 if ((err
= add_control(spec
, ALC_CTL_WIDGET_MUTE
, "Headphone Playback Switch",
5645 HDA_COMPOSE_AMP_VAL(nid
, 2, 0, HDA_OUTPUT
))) < 0)
5648 if ((err
= add_control(spec
, ALC_CTL_WIDGET_MUTE
, "Headphone Playback Switch",
5649 HDA_COMPOSE_AMP_VAL(nid
, 3, 0, HDA_OUTPUT
))) < 0)
5656 /* identical with ALC880 */
5657 #define alc262_auto_create_analog_input_ctls alc880_auto_create_analog_input_ctls
5660 * generic initialization of ADC, input mixers and output mixers
5662 static struct hda_verb alc262_volume_init_verbs
[] = {
5664 * Unmute ADC0-2 and set the default input to mic-in
5666 {0x07, AC_VERB_SET_CONNECT_SEL
, 0x00},
5667 {0x07, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(0)},
5668 {0x08, AC_VERB_SET_CONNECT_SEL
, 0x00},
5669 {0x08, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(0)},
5670 {0x09, AC_VERB_SET_CONNECT_SEL
, 0x00},
5671 {0x09, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(0)},
5673 /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
5675 * Note: PASD motherboards uses the Line In 2 as the input for front panel
5678 /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
5679 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(0)},
5680 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(1)},
5681 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(2)},
5682 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(3)},
5683 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(4)},
5686 * Set up output mixers (0x0c - 0x0f)
5688 /* set vol=0 to output mixers */
5689 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_ZERO
},
5690 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_ZERO
},
5691 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_ZERO
},
5693 /* set up input amps for analog loopback */
5694 /* Amp Indices: DAC = 0, mixer = 1 */
5695 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(0)},
5696 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(1)},
5697 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(0)},
5698 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(1)},
5699 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(0)},
5700 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(1)},
5702 /* FIXME: use matrix-type input source selection */
5703 /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
5704 /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
5705 {0x24, AC_VERB_SET_AMP_GAIN_MUTE
, (0x7000 | (0x00 << 8))},
5706 {0x24, AC_VERB_SET_AMP_GAIN_MUTE
, (0x7080 | (0x03 << 8))},
5707 {0x24, AC_VERB_SET_AMP_GAIN_MUTE
, (0x7080 | (0x02 << 8))},
5708 {0x24, AC_VERB_SET_AMP_GAIN_MUTE
, (0x7080 | (0x04 << 8))},
5710 {0x23, AC_VERB_SET_AMP_GAIN_MUTE
, (0x7000 | (0x00 << 8))},
5711 {0x23, AC_VERB_SET_AMP_GAIN_MUTE
, (0x7080 | (0x03 << 8))},
5712 {0x23, AC_VERB_SET_AMP_GAIN_MUTE
, (0x7080 | (0x02 << 8))},
5713 {0x23, AC_VERB_SET_AMP_GAIN_MUTE
, (0x7080 | (0x04 << 8))},
5715 {0x22, AC_VERB_SET_AMP_GAIN_MUTE
, (0x7000 | (0x00 << 8))},
5716 {0x22, AC_VERB_SET_AMP_GAIN_MUTE
, (0x7080 | (0x03 << 8))},
5717 {0x22, AC_VERB_SET_AMP_GAIN_MUTE
, (0x7080 | (0x02 << 8))},
5718 {0x22, AC_VERB_SET_AMP_GAIN_MUTE
, (0x7080 | (0x04 << 8))},
5723 static struct hda_verb alc262_HP_BPC_init_verbs
[] = {
5725 * Unmute ADC0-2 and set the default input to mic-in
5727 {0x07, AC_VERB_SET_CONNECT_SEL
, 0x00},
5728 {0x07, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(0)},
5729 {0x08, AC_VERB_SET_CONNECT_SEL
, 0x00},
5730 {0x08, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(0)},
5731 {0x09, AC_VERB_SET_CONNECT_SEL
, 0x00},
5732 {0x09, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(0)},
5734 /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
5736 * Note: PASD motherboards uses the Line In 2 as the input for front panel
5739 /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
5740 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(0)},
5741 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(1)},
5742 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(2)},
5743 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(3)},
5744 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(4)},
5745 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(5)},
5746 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(6)},
5749 * Set up output mixers (0x0c - 0x0e)
5751 /* set vol=0 to output mixers */
5752 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_ZERO
},
5753 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_ZERO
},
5754 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_ZERO
},
5756 /* set up input amps for analog loopback */
5757 /* Amp Indices: DAC = 0, mixer = 1 */
5758 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(0)},
5759 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(1)},
5760 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(0)},
5761 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(1)},
5762 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(0)},
5763 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(1)},
5765 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL
, 0xc0},
5766 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_OUT
},
5767 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_OUT
},
5769 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_UNMUTE
},
5770 {0x15, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_UNMUTE
},
5772 {0x1b, AC_VERB_SET_CONNECT_SEL
, 0x00},
5773 {0x15, AC_VERB_SET_CONNECT_SEL
, 0x00},
5775 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL
, 0x20},
5776 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL
, 0x24},
5777 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL
, 0x24},
5778 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL
, 0x20},
5779 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL
, 0x20},
5781 {0x14, AC_VERB_SET_AMP_GAIN_MUTE
, 0x7023 },
5782 {0x18, AC_VERB_SET_AMP_GAIN_MUTE
, 0x7000 },
5783 {0x19, AC_VERB_SET_AMP_GAIN_MUTE
, 0x7000 },
5784 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE
, 0x7023 },
5785 {0x1c, AC_VERB_SET_AMP_GAIN_MUTE
, 0x7000 },
5786 {0x1d, AC_VERB_SET_AMP_GAIN_MUTE
, 0x7000 },
5789 /* FIXME: use matrix-type input source selection */
5790 /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
5791 /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
5792 {0x24, AC_VERB_SET_AMP_GAIN_MUTE
, (0x7000 | (0x00 << 8))},
5793 {0x24, AC_VERB_SET_AMP_GAIN_MUTE
, (0x7000 | (0x03 << 8))},
5794 {0x24, AC_VERB_SET_AMP_GAIN_MUTE
, (0x7000 | (0x02 << 8))},
5795 {0x24, AC_VERB_SET_AMP_GAIN_MUTE
, (0x7000 | (0x04 << 8))},
5797 {0x23, AC_VERB_SET_AMP_GAIN_MUTE
, (0x7000 | (0x00 << 8))},
5798 {0x23, AC_VERB_SET_AMP_GAIN_MUTE
, (0x7000 | (0x03 << 8))},
5799 {0x23, AC_VERB_SET_AMP_GAIN_MUTE
, (0x7000 | (0x02 << 8))},
5800 {0x23, AC_VERB_SET_AMP_GAIN_MUTE
, (0x7000 | (0x04 << 8))},
5802 {0x22, AC_VERB_SET_AMP_GAIN_MUTE
, (0x7000 | (0x00 << 8))},
5803 {0x22, AC_VERB_SET_AMP_GAIN_MUTE
, (0x7000 | (0x03 << 8))},
5804 {0x22, AC_VERB_SET_AMP_GAIN_MUTE
, (0x7000 | (0x02 << 8))},
5805 {0x22, AC_VERB_SET_AMP_GAIN_MUTE
, (0x7000 | (0x04 << 8))},
5810 /* pcm configuration: identiacal with ALC880 */
5811 #define alc262_pcm_analog_playback alc880_pcm_analog_playback
5812 #define alc262_pcm_analog_capture alc880_pcm_analog_capture
5813 #define alc262_pcm_digital_playback alc880_pcm_digital_playback
5814 #define alc262_pcm_digital_capture alc880_pcm_digital_capture
5817 * BIOS auto configuration
5819 static int alc262_parse_auto_config(struct hda_codec
*codec
)
5821 struct alc_spec
*spec
= codec
->spec
;
5823 static hda_nid_t alc262_ignore
[] = { 0x1d, 0 };
5825 if ((err
= snd_hda_parse_pin_def_config(codec
, &spec
->autocfg
,
5826 alc262_ignore
)) < 0)
5828 if (! spec
->autocfg
.line_outs
)
5829 return 0; /* can't find valid BIOS pin config */
5830 if ((err
= alc262_auto_create_multi_out_ctls(spec
, &spec
->autocfg
)) < 0 ||
5831 (err
= alc262_auto_create_analog_input_ctls(spec
, &spec
->autocfg
)) < 0)
5834 spec
->multiout
.max_channels
= spec
->multiout
.num_dacs
* 2;
5836 if (spec
->autocfg
.dig_out_pin
)
5837 spec
->multiout
.dig_out_nid
= ALC262_DIGOUT_NID
;
5838 if (spec
->autocfg
.dig_in_pin
)
5839 spec
->dig_in_nid
= ALC262_DIGIN_NID
;
5841 if (spec
->kctl_alloc
)
5842 spec
->mixers
[spec
->num_mixers
++] = spec
->kctl_alloc
;
5844 spec
->init_verbs
[spec
->num_init_verbs
++] = alc262_volume_init_verbs
;
5845 spec
->num_mux_defs
= 1;
5846 spec
->input_mux
= &spec
->private_imux
;
5851 #define alc262_auto_init_multi_out alc882_auto_init_multi_out
5852 #define alc262_auto_init_hp_out alc882_auto_init_hp_out
5853 #define alc262_auto_init_analog_input alc882_auto_init_analog_input
5856 /* init callback for auto-configuration model -- overriding the default init */
5857 static void alc262_auto_init(struct hda_codec
*codec
)
5859 alc262_auto_init_multi_out(codec
);
5860 alc262_auto_init_hp_out(codec
);
5861 alc262_auto_init_analog_input(codec
);
5865 * configuration and preset
5867 static struct hda_board_config alc262_cfg_tbl
[] = {
5868 { .modelname
= "basic", .config
= ALC262_BASIC
},
5869 { .modelname
= "fujitsu", .config
= ALC262_FUJITSU
},
5870 { .pci_subvendor
= 0x10cf, .pci_subdevice
= 0x1397,
5871 .config
= ALC262_FUJITSU
},
5872 { .modelname
= "hp-bpc", .config
= ALC262_HP_BPC
},
5873 { .pci_subvendor
= 0x103c, .pci_subdevice
= 0x280c,
5874 .config
= ALC262_HP_BPC
}, /* xw4400 */
5875 { .pci_subvendor
= 0x103c, .pci_subdevice
= 0x3014,
5876 .config
= ALC262_HP_BPC
}, /* xw6400 */
5877 { .pci_subvendor
= 0x103c, .pci_subdevice
= 0x3015,
5878 .config
= ALC262_HP_BPC
}, /* xw8400 */
5879 { .pci_subvendor
= 0x103c, .pci_subdevice
= 0x12fe,
5880 .config
= ALC262_HP_BPC
}, /* xw9400 */
5881 { .modelname
= "benq", .config
= ALC262_BENQ_ED8
},
5882 { .pci_subvendor
= 0x17ff, .pci_subdevice
= 0x0560,
5883 .config
= ALC262_BENQ_ED8
},
5884 { .modelname
= "auto", .config
= ALC262_AUTO
},
5888 static struct alc_config_preset alc262_presets
[] = {
5890 .mixers
= { alc262_base_mixer
},
5891 .init_verbs
= { alc262_init_verbs
},
5892 .num_dacs
= ARRAY_SIZE(alc262_dac_nids
),
5893 .dac_nids
= alc262_dac_nids
,
5895 .num_channel_mode
= ARRAY_SIZE(alc262_modes
),
5896 .channel_mode
= alc262_modes
,
5897 .input_mux
= &alc262_capture_source
,
5899 [ALC262_FUJITSU
] = {
5900 .mixers
= { alc262_fujitsu_mixer
},
5901 .init_verbs
= { alc262_init_verbs
, alc262_fujitsu_unsol_verbs
},
5902 .num_dacs
= ARRAY_SIZE(alc262_dac_nids
),
5903 .dac_nids
= alc262_dac_nids
,
5905 .dig_out_nid
= ALC262_DIGOUT_NID
,
5906 .num_channel_mode
= ARRAY_SIZE(alc262_modes
),
5907 .channel_mode
= alc262_modes
,
5908 .input_mux
= &alc262_fujitsu_capture_source
,
5909 .unsol_event
= alc262_fujitsu_unsol_event
,
5912 .mixers
= { alc262_HP_BPC_mixer
},
5913 .init_verbs
= { alc262_HP_BPC_init_verbs
},
5914 .num_dacs
= ARRAY_SIZE(alc262_dac_nids
),
5915 .dac_nids
= alc262_dac_nids
,
5917 .num_channel_mode
= ARRAY_SIZE(alc262_modes
),
5918 .channel_mode
= alc262_modes
,
5919 .input_mux
= &alc262_HP_capture_source
,
5921 [ALC262_BENQ_ED8
] = {
5922 .mixers
= { alc262_base_mixer
},
5923 .init_verbs
= { alc262_init_verbs
, alc262_EAPD_verbs
},
5924 .num_dacs
= ARRAY_SIZE(alc262_dac_nids
),
5925 .dac_nids
= alc262_dac_nids
,
5927 .num_channel_mode
= ARRAY_SIZE(alc262_modes
),
5928 .channel_mode
= alc262_modes
,
5929 .input_mux
= &alc262_capture_source
,
5933 static int patch_alc262(struct hda_codec
*codec
)
5935 struct alc_spec
*spec
;
5939 spec
= kcalloc(1, sizeof(*spec
), GFP_KERNEL
);
5945 /* pshou 07/11/05 set a zero PCM sample to DAC when FIFO is under-run */
5948 snd_hda_codec_write(codec
, 0x1a, 0, AC_VERB_SET_COEF_INDEX
, 7);
5949 tmp
= snd_hda_codec_read(codec
, 0x20, 0, AC_VERB_GET_PROC_COEF
, 0);
5950 snd_hda_codec_write(codec
, 0x1a, 0, AC_VERB_SET_COEF_INDEX
, 7);
5951 snd_hda_codec_write(codec
, 0x1a, 0, AC_VERB_SET_PROC_COEF
, tmp
| 0x80);
5955 board_config
= snd_hda_check_board_config(codec
, alc262_cfg_tbl
);
5957 if (board_config
< 0 || board_config
>= ALC262_MODEL_LAST
) {
5958 printk(KERN_INFO
"hda_codec: Unknown model for ALC262, "
5959 "trying auto-probe from BIOS...\n");
5960 board_config
= ALC262_AUTO
;
5963 if (board_config
== ALC262_AUTO
) {
5964 /* automatic parse from the BIOS config */
5965 err
= alc262_parse_auto_config(codec
);
5971 "hda_codec: Cannot set up configuration "
5972 "from BIOS. Using base mode...\n");
5973 board_config
= ALC262_BASIC
;
5977 if (board_config
!= ALC262_AUTO
)
5978 setup_preset(spec
, &alc262_presets
[board_config
]);
5980 spec
->stream_name_analog
= "ALC262 Analog";
5981 spec
->stream_analog_playback
= &alc262_pcm_analog_playback
;
5982 spec
->stream_analog_capture
= &alc262_pcm_analog_capture
;
5984 spec
->stream_name_digital
= "ALC262 Digital";
5985 spec
->stream_digital_playback
= &alc262_pcm_digital_playback
;
5986 spec
->stream_digital_capture
= &alc262_pcm_digital_capture
;
5988 if (! spec
->adc_nids
&& spec
->input_mux
) {
5989 /* check whether NID 0x07 is valid */
5990 unsigned int wcap
= get_wcaps(codec
, 0x07);
5992 wcap
= (wcap
& AC_WCAP_TYPE
) >> AC_WCAP_TYPE_SHIFT
; /* get type */
5993 if (wcap
!= AC_WID_AUD_IN
) {
5994 spec
->adc_nids
= alc262_adc_nids_alt
;
5995 spec
->num_adc_nids
= ARRAY_SIZE(alc262_adc_nids_alt
);
5996 spec
->mixers
[spec
->num_mixers
] = alc262_capture_alt_mixer
;
5999 spec
->adc_nids
= alc262_adc_nids
;
6000 spec
->num_adc_nids
= ARRAY_SIZE(alc262_adc_nids
);
6001 spec
->mixers
[spec
->num_mixers
] = alc262_capture_mixer
;
6006 codec
->patch_ops
= alc_patch_ops
;
6007 if (board_config
== ALC262_AUTO
)
6008 spec
->init_hook
= alc262_auto_init
;
6014 * ALC861 channel source setting (2/6 channel selection for 3-stack)
6018 * set the path ways for 2 channel output
6019 * need to set the codec line out and mic 1 pin widgets to inputs
6021 static struct hda_verb alc861_threestack_ch2_init
[] = {
6022 /* set pin widget 1Ah (line in) for input */
6023 { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL
, 0x20 },
6024 /* set pin widget 18h (mic1/2) for input, for mic also enable the vref */
6025 { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL
, 0x24 },
6027 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE
, 0xb00c },
6029 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE
, (0x7000 | (0x01 << 8)) }, /*mic*/
6030 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE
, (0x7000 | (0x02 << 8)) }, /*line-in*/
6036 * need to set the codec line out and mic 1 pin widgets to outputs
6038 static struct hda_verb alc861_threestack_ch6_init
[] = {
6039 /* set pin widget 1Ah (line in) for output (Back Surround)*/
6040 { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL
, 0x40 },
6041 /* set pin widget 18h (mic1) for output (CLFE)*/
6042 { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL
, 0x40 },
6044 { 0x0c, AC_VERB_SET_CONNECT_SEL
, 0x00 },
6045 { 0x0d, AC_VERB_SET_CONNECT_SEL
, 0x00 },
6047 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE
, 0xb080 },
6049 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE
, (0x7080 | (0x01 << 8)) }, /*mic*/
6050 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE
, (0x7080 | (0x02 << 8)) }, /*line in*/
6055 static struct hda_channel_mode alc861_threestack_modes
[2] = {
6056 { 2, alc861_threestack_ch2_init
},
6057 { 6, alc861_threestack_ch6_init
},
6059 /* Set mic1 as input and unmute the mixer */
6060 static struct hda_verb alc861_uniwill_m31_ch2_init
[] = {
6061 { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL
, 0x24 },
6062 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE
, (0x7080 | (0x01 << 8)) }, /*mic*/
6065 /* Set mic1 as output and mute mixer */
6066 static struct hda_verb alc861_uniwill_m31_ch4_init
[] = {
6067 { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL
, 0x40 },
6068 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE
, (0x7000 | (0x01 << 8)) }, /*mic*/
6072 static struct hda_channel_mode alc861_uniwill_m31_modes
[2] = {
6073 { 2, alc861_uniwill_m31_ch2_init
},
6074 { 4, alc861_uniwill_m31_ch4_init
},
6079 static struct snd_kcontrol_new alc861_base_mixer
[] = {
6080 /* output mixer control */
6081 HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT
),
6082 HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT
),
6083 HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT
),
6084 HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT
),
6085 HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT
),
6087 /*Input mixer control */
6088 /* HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
6089 HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT), */
6090 HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT
),
6091 HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT
),
6092 HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT
),
6093 HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT
),
6094 HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT
),
6095 HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT
),
6096 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT
),
6097 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_INPUT
),
6099 /* Capture mixer control */
6100 HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT
),
6101 HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT
),
6103 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
6104 .name
= "Capture Source",
6106 .info
= alc_mux_enum_info
,
6107 .get
= alc_mux_enum_get
,
6108 .put
= alc_mux_enum_put
,
6113 static struct snd_kcontrol_new alc861_3ST_mixer
[] = {
6114 /* output mixer control */
6115 HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT
),
6116 HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT
),
6117 HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT
),
6118 HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT
),
6119 /*HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT), */
6121 /* Input mixer control */
6122 /* HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
6123 HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT), */
6124 HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT
),
6125 HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT
),
6126 HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT
),
6127 HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT
),
6128 HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT
),
6129 HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT
),
6130 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT
),
6131 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_INPUT
),
6133 /* Capture mixer control */
6134 HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT
),
6135 HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT
),
6137 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
6138 .name
= "Capture Source",
6140 .info
= alc_mux_enum_info
,
6141 .get
= alc_mux_enum_get
,
6142 .put
= alc_mux_enum_put
,
6145 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
6146 .name
= "Channel Mode",
6147 .info
= alc_ch_mode_info
,
6148 .get
= alc_ch_mode_get
,
6149 .put
= alc_ch_mode_put
,
6150 .private_value
= ARRAY_SIZE(alc861_threestack_modes
),
6154 static struct snd_kcontrol_new alc861_uniwill_m31_mixer
[] = {
6155 /* output mixer control */
6156 HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT
),
6157 HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT
),
6158 HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT
),
6159 HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT
),
6160 /*HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT), */
6162 /* Input mixer control */
6163 /* HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
6164 HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT), */
6165 HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT
),
6166 HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT
),
6167 HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT
),
6168 HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT
),
6169 HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT
),
6170 HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT
),
6171 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT
),
6172 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_INPUT
),
6174 /* Capture mixer control */
6175 HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT
),
6176 HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT
),
6178 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
6179 .name
= "Capture Source",
6181 .info
= alc_mux_enum_info
,
6182 .get
= alc_mux_enum_get
,
6183 .put
= alc_mux_enum_put
,
6186 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
6187 .name
= "Channel Mode",
6188 .info
= alc_ch_mode_info
,
6189 .get
= alc_ch_mode_get
,
6190 .put
= alc_ch_mode_put
,
6191 .private_value
= ARRAY_SIZE(alc861_uniwill_m31_modes
),
6197 * generic initialization of ADC, input mixers and output mixers
6199 static struct hda_verb alc861_base_init_verbs
[] = {
6201 * Unmute ADC0 and set the default input to mic-in
6203 /* port-A for surround (rear panel) */
6204 { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL
, 0x40 },
6205 { 0x0e, AC_VERB_SET_CONNECT_SEL
, 0x00 },
6206 /* port-B for mic-in (rear panel) with vref */
6207 { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL
, 0x24 },
6208 /* port-C for line-in (rear panel) */
6209 { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL
, 0x20 },
6210 /* port-D for Front */
6211 { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL
, 0x40 },
6212 { 0x0b, AC_VERB_SET_CONNECT_SEL
, 0x00 },
6213 /* port-E for HP out (front panel) */
6214 { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL
, 0xc0 },
6215 /* route front PCM to HP */
6216 { 0x0f, AC_VERB_SET_CONNECT_SEL
, 0x01 },
6217 /* port-F for mic-in (front panel) with vref */
6218 { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL
, 0x24 },
6219 /* port-G for CLFE (rear panel) */
6220 { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL
, 0x40 },
6221 { 0x1f, AC_VERB_SET_CONNECT_SEL
, 0x00 },
6222 /* port-H for side (rear panel) */
6223 { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL
, 0x40 },
6224 { 0x20, AC_VERB_SET_CONNECT_SEL
, 0x00 },
6226 { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL
, 0x20 },
6227 /* route front mic to ADC1*/
6228 {0x08, AC_VERB_SET_CONNECT_SEL
, 0x00},
6229 {0x08, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(0)},
6231 /* Unmute DAC0~3 & spdif out*/
6232 {0x03, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_UNMUTE
},
6233 {0x04, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_UNMUTE
},
6234 {0x05, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_UNMUTE
},
6235 {0x06, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_UNMUTE
},
6236 {0x07, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_UNMUTE
},
6238 /* Unmute Mixer 14 (mic) 1c (Line in)*/
6239 {0x014, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(0)},
6240 {0x014, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(1)},
6241 {0x01c, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(0)},
6242 {0x01c, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(1)},
6244 /* Unmute Stereo Mixer 15 */
6245 {0x15, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(0)},
6246 {0x15, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(1)},
6247 {0x15, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(2)},
6248 {0x15, AC_VERB_SET_AMP_GAIN_MUTE
, 0xb00c }, //Output 0~12 step
6250 {0x16, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(0)},
6251 {0x16, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(1)},
6252 {0x17, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(0)},
6253 {0x17, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(1)},
6254 {0x18, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(0)},
6255 {0x18, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(1)},
6256 {0x19, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(0)},
6257 {0x19, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(1)},
6258 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(3)}, // hp used DAC 3 (Front)
6259 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(2)},
6264 static struct hda_verb alc861_threestack_init_verbs
[] = {
6266 * Unmute ADC0 and set the default input to mic-in
6268 /* port-A for surround (rear panel) */
6269 { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL
, 0x00 },
6270 /* port-B for mic-in (rear panel) with vref */
6271 { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL
, 0x24 },
6272 /* port-C for line-in (rear panel) */
6273 { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL
, 0x20 },
6274 /* port-D for Front */
6275 { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL
, 0x40 },
6276 { 0x0b, AC_VERB_SET_CONNECT_SEL
, 0x00 },
6277 /* port-E for HP out (front panel) */
6278 { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL
, 0xc0 },
6279 /* route front PCM to HP */
6280 { 0x0f, AC_VERB_SET_CONNECT_SEL
, 0x01 },
6281 /* port-F for mic-in (front panel) with vref */
6282 { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL
, 0x24 },
6283 /* port-G for CLFE (rear panel) */
6284 { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL
, 0x00 },
6285 /* port-H for side (rear panel) */
6286 { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL
, 0x00 },
6288 { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL
, 0x20 },
6289 /* route front mic to ADC1*/
6290 {0x08, AC_VERB_SET_CONNECT_SEL
, 0x00},
6291 {0x08, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(0)},
6292 /* Unmute DAC0~3 & spdif out*/
6293 {0x03, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_UNMUTE
},
6294 {0x04, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_UNMUTE
},
6295 {0x05, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_UNMUTE
},
6296 {0x06, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_UNMUTE
},
6297 {0x07, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_UNMUTE
},
6299 /* Unmute Mixer 14 (mic) 1c (Line in)*/
6300 {0x014, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(0)},
6301 {0x014, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(1)},
6302 {0x01c, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(0)},
6303 {0x01c, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(1)},
6305 /* Unmute Stereo Mixer 15 */
6306 {0x15, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(0)},
6307 {0x15, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(1)},
6308 {0x15, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(2)},
6309 {0x15, AC_VERB_SET_AMP_GAIN_MUTE
, 0xb00c }, //Output 0~12 step
6311 {0x16, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(0)},
6312 {0x16, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(1)},
6313 {0x17, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(0)},
6314 {0x17, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(1)},
6315 {0x18, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(0)},
6316 {0x18, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(1)},
6317 {0x19, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(0)},
6318 {0x19, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(1)},
6319 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(3)}, // hp used DAC 3 (Front)
6320 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(2)},
6324 static struct hda_verb alc861_uniwill_m31_init_verbs
[] = {
6326 * Unmute ADC0 and set the default input to mic-in
6328 /* port-A for surround (rear panel) */
6329 { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL
, 0x00 },
6330 /* port-B for mic-in (rear panel) with vref */
6331 { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL
, 0x24 },
6332 /* port-C for line-in (rear panel) */
6333 { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL
, 0x20 },
6334 /* port-D for Front */
6335 { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL
, 0x40 },
6336 { 0x0b, AC_VERB_SET_CONNECT_SEL
, 0x00 },
6337 /* port-E for HP out (front panel) */
6338 { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL
, 0x24 }, // this has to be set to VREF80
6339 /* route front PCM to HP */
6340 { 0x0f, AC_VERB_SET_CONNECT_SEL
, 0x01 },
6341 /* port-F for mic-in (front panel) with vref */
6342 { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL
, 0x24 },
6343 /* port-G for CLFE (rear panel) */
6344 { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL
, 0x00 },
6345 /* port-H for side (rear panel) */
6346 { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL
, 0x00 },
6348 { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL
, 0x20 },
6349 /* route front mic to ADC1*/
6350 {0x08, AC_VERB_SET_CONNECT_SEL
, 0x00},
6351 {0x08, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(0)},
6352 /* Unmute DAC0~3 & spdif out*/
6353 {0x03, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_UNMUTE
},
6354 {0x04, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_UNMUTE
},
6355 {0x05, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_UNMUTE
},
6356 {0x06, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_UNMUTE
},
6357 {0x07, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_UNMUTE
},
6359 /* Unmute Mixer 14 (mic) 1c (Line in)*/
6360 {0x014, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(0)},
6361 {0x014, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(1)},
6362 {0x01c, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(0)},
6363 {0x01c, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(1)},
6365 /* Unmute Stereo Mixer 15 */
6366 {0x15, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(0)},
6367 {0x15, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(1)},
6368 {0x15, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(2)},
6369 {0x15, AC_VERB_SET_AMP_GAIN_MUTE
, 0xb00c }, //Output 0~12 step
6371 {0x16, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(0)},
6372 {0x16, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(1)},
6373 {0x17, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(0)},
6374 {0x17, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(1)},
6375 {0x18, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(0)},
6376 {0x18, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(1)},
6377 {0x19, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(0)},
6378 {0x19, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(1)},
6379 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(3)}, // hp used DAC 3 (Front)
6380 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(2)},
6385 * generic initialization of ADC, input mixers and output mixers
6387 static struct hda_verb alc861_auto_init_verbs
[] = {
6389 * Unmute ADC0 and set the default input to mic-in
6391 // {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
6392 {0x08, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(0)},
6394 /* Unmute DAC0~3 & spdif out*/
6395 {0x03, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_MUTE
},
6396 {0x04, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_MUTE
},
6397 {0x05, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_MUTE
},
6398 {0x06, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_MUTE
},
6399 {0x07, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_UNMUTE
},
6401 /* Unmute Mixer 14 (mic) 1c (Line in)*/
6402 {0x014, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(0)},
6403 {0x014, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(1)},
6404 {0x01c, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(0)},
6405 {0x01c, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(1)},
6407 /* Unmute Stereo Mixer 15 */
6408 {0x15, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(0)},
6409 {0x15, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(1)},
6410 {0x15, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(2)},
6411 {0x15, AC_VERB_SET_AMP_GAIN_MUTE
, 0xb00c},
6413 {0x16, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(0)},
6414 {0x16, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(1)},
6415 {0x17, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(0)},
6416 {0x17, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(1)},
6417 {0x18, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(0)},
6418 {0x18, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(1)},
6419 {0x19, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(0)},
6420 {0x19, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(1)},
6422 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_MUTE(0)},
6423 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_MUTE(1)},
6424 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(2)},
6425 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(3)},
6426 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_MUTE(0)},
6427 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_MUTE(1)},
6428 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(2)},
6429 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(3)},
6431 {0x08, AC_VERB_SET_CONNECT_SEL
, 0x00}, // set Mic 1
6436 /* pcm configuration: identiacal with ALC880 */
6437 #define alc861_pcm_analog_playback alc880_pcm_analog_playback
6438 #define alc861_pcm_analog_capture alc880_pcm_analog_capture
6439 #define alc861_pcm_digital_playback alc880_pcm_digital_playback
6440 #define alc861_pcm_digital_capture alc880_pcm_digital_capture
6443 #define ALC861_DIGOUT_NID 0x07
6445 static struct hda_channel_mode alc861_8ch_modes
[1] = {
6449 static hda_nid_t alc861_dac_nids
[4] = {
6450 /* front, surround, clfe, side */
6451 0x03, 0x06, 0x05, 0x04
6454 static hda_nid_t alc660_dac_nids
[3] = {
6455 /* front, clfe, surround */
6459 static hda_nid_t alc861_adc_nids
[1] = {
6464 static struct hda_input_mux alc861_capture_source
= {
6468 { "Front Mic", 0x3 },
6475 /* fill in the dac_nids table from the parsed pin configuration */
6476 static int alc861_auto_fill_dac_nids(struct alc_spec
*spec
, const struct auto_pin_cfg
*cfg
)
6481 spec
->multiout
.dac_nids
= spec
->private_dac_nids
;
6482 for (i
= 0; i
< cfg
->line_outs
; i
++) {
6483 nid
= cfg
->line_out_pins
[i
];
6485 if (i
>= ARRAY_SIZE(alc861_dac_nids
))
6487 spec
->multiout
.dac_nids
[i
] = alc861_dac_nids
[i
];
6490 spec
->multiout
.num_dacs
= cfg
->line_outs
;
6494 /* add playback controls from the parsed DAC table */
6495 static int alc861_auto_create_multi_out_ctls(struct alc_spec
*spec
,
6496 const struct auto_pin_cfg
*cfg
)
6499 static const char *chname
[4] = { "Front", "Surround", NULL
/*CLFE*/, "Side" };
6503 for (i
= 0; i
< cfg
->line_outs
; i
++) {
6504 nid
= spec
->multiout
.dac_nids
[i
];
6509 if ((err
= add_control(spec
, ALC_CTL_BIND_MUTE
, "Center Playback Switch",
6510 HDA_COMPOSE_AMP_VAL(nid
, 1, 0, HDA_OUTPUT
))) < 0)
6512 if ((err
= add_control(spec
, ALC_CTL_BIND_MUTE
, "LFE Playback Switch",
6513 HDA_COMPOSE_AMP_VAL(nid
, 2, 0, HDA_OUTPUT
))) < 0)
6516 for (idx
= 0; idx
< ARRAY_SIZE(alc861_dac_nids
) - 1; idx
++)
6517 if (nid
== alc861_dac_nids
[idx
])
6519 sprintf(name
, "%s Playback Switch", chname
[idx
]);
6520 if ((err
= add_control(spec
, ALC_CTL_BIND_MUTE
, name
,
6521 HDA_COMPOSE_AMP_VAL(nid
, 3, 0, HDA_OUTPUT
))) < 0)
6528 static int alc861_auto_create_hp_ctls(struct alc_spec
*spec
, hda_nid_t pin
)
6536 if ((pin
>= 0x0b && pin
<= 0x10) || pin
== 0x1f || pin
== 0x20) {
6538 if ((err
= add_control(spec
, ALC_CTL_WIDGET_MUTE
, "Headphone Playback Switch",
6539 HDA_COMPOSE_AMP_VAL(nid
, 3, 0, HDA_OUTPUT
))) < 0)
6541 spec
->multiout
.hp_nid
= nid
;
6546 /* create playback/capture controls for input pins */
6547 static int alc861_auto_create_analog_input_ctls(struct alc_spec
*spec
, const struct auto_pin_cfg
*cfg
)
6549 struct hda_input_mux
*imux
= &spec
->private_imux
;
6550 int i
, err
, idx
, idx1
;
6552 for (i
= 0; i
< AUTO_PIN_LAST
; i
++) {
6553 switch(cfg
->input_pins
[i
]) {
6578 err
= new_analog_input(spec
, cfg
->input_pins
[i
],
6579 auto_pin_cfg_labels
[i
], idx
, 0x15);
6583 imux
->items
[imux
->num_items
].label
= auto_pin_cfg_labels
[i
];
6584 imux
->items
[imux
->num_items
].index
= idx1
;
6590 static struct snd_kcontrol_new alc861_capture_mixer
[] = {
6591 HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT
),
6592 HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT
),
6595 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
6596 /* The multiple "Capture Source" controls confuse alsamixer
6597 * So call somewhat different..
6598 *FIXME: the controls appear in the "playback" view!
6600 /* .name = "Capture Source", */
6601 .name
= "Input Source",
6603 .info
= alc_mux_enum_info
,
6604 .get
= alc_mux_enum_get
,
6605 .put
= alc_mux_enum_put
,
6610 static void alc861_auto_set_output_and_unmute(struct hda_codec
*codec
, hda_nid_t nid
,
6611 int pin_type
, int dac_idx
)
6615 snd_hda_codec_write(codec
, nid
, 0, AC_VERB_SET_PIN_WIDGET_CONTROL
, pin_type
);
6616 snd_hda_codec_write(codec
, dac_idx
, 0, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_UNMUTE
);
6620 static void alc861_auto_init_multi_out(struct hda_codec
*codec
)
6622 struct alc_spec
*spec
= codec
->spec
;
6625 for (i
= 0; i
< spec
->autocfg
.line_outs
; i
++) {
6626 hda_nid_t nid
= spec
->autocfg
.line_out_pins
[i
];
6628 alc861_auto_set_output_and_unmute(codec
, nid
, PIN_OUT
, spec
->multiout
.dac_nids
[i
]);
6632 static void alc861_auto_init_hp_out(struct hda_codec
*codec
)
6634 struct alc_spec
*spec
= codec
->spec
;
6637 pin
= spec
->autocfg
.hp_pins
[0];
6638 if (pin
) /* connect to front */
6639 alc861_auto_set_output_and_unmute(codec
, pin
, PIN_HP
, spec
->multiout
.dac_nids
[0]);
6642 static void alc861_auto_init_analog_input(struct hda_codec
*codec
)
6644 struct alc_spec
*spec
= codec
->spec
;
6647 for (i
= 0; i
< AUTO_PIN_LAST
; i
++) {
6648 hda_nid_t nid
= spec
->autocfg
.input_pins
[i
];
6649 if ((nid
>=0x0c) && (nid
<=0x11)) {
6650 snd_hda_codec_write(codec
, nid
, 0, AC_VERB_SET_PIN_WIDGET_CONTROL
,
6651 i
<= AUTO_PIN_FRONT_MIC
? PIN_VREF80
: PIN_IN
);
6656 /* parse the BIOS configuration and set up the alc_spec */
6657 /* return 1 if successful, 0 if the proper config is not found, or a negative error code */
6658 static int alc861_parse_auto_config(struct hda_codec
*codec
)
6660 struct alc_spec
*spec
= codec
->spec
;
6662 static hda_nid_t alc861_ignore
[] = { 0x1d, 0 };
6664 if ((err
= snd_hda_parse_pin_def_config(codec
, &spec
->autocfg
,
6665 alc861_ignore
)) < 0)
6667 if (! spec
->autocfg
.line_outs
)
6668 return 0; /* can't find valid BIOS pin config */
6670 if ((err
= alc861_auto_fill_dac_nids(spec
, &spec
->autocfg
)) < 0 ||
6671 (err
= alc861_auto_create_multi_out_ctls(spec
, &spec
->autocfg
)) < 0 ||
6672 (err
= alc861_auto_create_hp_ctls(spec
, spec
->autocfg
.hp_pins
[0])) < 0 ||
6673 (err
= alc861_auto_create_analog_input_ctls(spec
, &spec
->autocfg
)) < 0)
6676 spec
->multiout
.max_channels
= spec
->multiout
.num_dacs
* 2;
6678 if (spec
->autocfg
.dig_out_pin
)
6679 spec
->multiout
.dig_out_nid
= ALC861_DIGOUT_NID
;
6681 if (spec
->kctl_alloc
)
6682 spec
->mixers
[spec
->num_mixers
++] = spec
->kctl_alloc
;
6684 spec
->init_verbs
[spec
->num_init_verbs
++] = alc861_auto_init_verbs
;
6686 spec
->num_mux_defs
= 1;
6687 spec
->input_mux
= &spec
->private_imux
;
6689 spec
->adc_nids
= alc861_adc_nids
;
6690 spec
->num_adc_nids
= ARRAY_SIZE(alc861_adc_nids
);
6691 spec
->mixers
[spec
->num_mixers
] = alc861_capture_mixer
;
6697 /* additional initialization for auto-configuration model */
6698 static void alc861_auto_init(struct hda_codec
*codec
)
6700 alc861_auto_init_multi_out(codec
);
6701 alc861_auto_init_hp_out(codec
);
6702 alc861_auto_init_analog_input(codec
);
6707 * configuration and preset
6709 static struct hda_board_config alc861_cfg_tbl
[] = {
6710 { .modelname
= "3stack", .config
= ALC861_3ST
},
6711 { .pci_subvendor
= 0x8086, .pci_subdevice
= 0xd600,
6712 .config
= ALC861_3ST
},
6713 { .modelname
= "3stack-660", .config
= ALC660_3ST
},
6714 { .pci_subvendor
= 0x1043, .pci_subdevice
= 0x81e7,
6715 .config
= ALC660_3ST
},
6716 { .modelname
= "3stack-dig", .config
= ALC861_3ST_DIG
},
6717 { .modelname
= "6stack-dig", .config
= ALC861_6ST_DIG
},
6718 { .modelname
= "uniwill-m31", .config
= ALC861_UNIWILL_M31
},
6719 { .pci_subvendor
= 0x1584, .pci_subdevice
= 0x9072,
6720 .config
= ALC861_UNIWILL_M31
},
6721 { .modelname
= "auto", .config
= ALC861_AUTO
},
6725 static struct alc_config_preset alc861_presets
[] = {
6727 .mixers
= { alc861_3ST_mixer
},
6728 .init_verbs
= { alc861_threestack_init_verbs
},
6729 .num_dacs
= ARRAY_SIZE(alc861_dac_nids
),
6730 .dac_nids
= alc861_dac_nids
,
6731 .num_channel_mode
= ARRAY_SIZE(alc861_threestack_modes
),
6732 .channel_mode
= alc861_threestack_modes
,
6734 .num_adc_nids
= ARRAY_SIZE(alc861_adc_nids
),
6735 .adc_nids
= alc861_adc_nids
,
6736 .input_mux
= &alc861_capture_source
,
6738 [ALC861_3ST_DIG
] = {
6739 .mixers
= { alc861_base_mixer
},
6740 .init_verbs
= { alc861_threestack_init_verbs
},
6741 .num_dacs
= ARRAY_SIZE(alc861_dac_nids
),
6742 .dac_nids
= alc861_dac_nids
,
6743 .dig_out_nid
= ALC861_DIGOUT_NID
,
6744 .num_channel_mode
= ARRAY_SIZE(alc861_threestack_modes
),
6745 .channel_mode
= alc861_threestack_modes
,
6747 .num_adc_nids
= ARRAY_SIZE(alc861_adc_nids
),
6748 .adc_nids
= alc861_adc_nids
,
6749 .input_mux
= &alc861_capture_source
,
6751 [ALC861_6ST_DIG
] = {
6752 .mixers
= { alc861_base_mixer
},
6753 .init_verbs
= { alc861_base_init_verbs
},
6754 .num_dacs
= ARRAY_SIZE(alc861_dac_nids
),
6755 .dac_nids
= alc861_dac_nids
,
6756 .dig_out_nid
= ALC861_DIGOUT_NID
,
6757 .num_channel_mode
= ARRAY_SIZE(alc861_8ch_modes
),
6758 .channel_mode
= alc861_8ch_modes
,
6759 .num_adc_nids
= ARRAY_SIZE(alc861_adc_nids
),
6760 .adc_nids
= alc861_adc_nids
,
6761 .input_mux
= &alc861_capture_source
,
6764 .mixers
= { alc861_3ST_mixer
},
6765 .init_verbs
= { alc861_threestack_init_verbs
},
6766 .num_dacs
= ARRAY_SIZE(alc660_dac_nids
),
6767 .dac_nids
= alc660_dac_nids
,
6768 .num_channel_mode
= ARRAY_SIZE(alc861_threestack_modes
),
6769 .channel_mode
= alc861_threestack_modes
,
6771 .num_adc_nids
= ARRAY_SIZE(alc861_adc_nids
),
6772 .adc_nids
= alc861_adc_nids
,
6773 .input_mux
= &alc861_capture_source
,
6775 [ALC861_UNIWILL_M31
] = {
6776 .mixers
= { alc861_uniwill_m31_mixer
},
6777 .init_verbs
= { alc861_uniwill_m31_init_verbs
},
6778 .num_dacs
= ARRAY_SIZE(alc861_dac_nids
),
6779 .dac_nids
= alc861_dac_nids
,
6780 .dig_out_nid
= ALC861_DIGOUT_NID
,
6781 .num_channel_mode
= ARRAY_SIZE(alc861_uniwill_m31_modes
),
6782 .channel_mode
= alc861_uniwill_m31_modes
,
6784 .num_adc_nids
= ARRAY_SIZE(alc861_adc_nids
),
6785 .adc_nids
= alc861_adc_nids
,
6786 .input_mux
= &alc861_capture_source
,
6792 static int patch_alc861(struct hda_codec
*codec
)
6794 struct alc_spec
*spec
;
6798 spec
= kcalloc(1, sizeof(*spec
), GFP_KERNEL
);
6804 board_config
= snd_hda_check_board_config(codec
, alc861_cfg_tbl
);
6806 if (board_config
< 0 || board_config
>= ALC861_MODEL_LAST
) {
6807 printk(KERN_INFO
"hda_codec: Unknown model for ALC861, "
6808 "trying auto-probe from BIOS...\n");
6809 board_config
= ALC861_AUTO
;
6812 if (board_config
== ALC861_AUTO
) {
6813 /* automatic parse from the BIOS config */
6814 err
= alc861_parse_auto_config(codec
);
6820 "hda_codec: Cannot set up configuration "
6821 "from BIOS. Using base mode...\n");
6822 board_config
= ALC861_3ST_DIG
;
6826 if (board_config
!= ALC861_AUTO
)
6827 setup_preset(spec
, &alc861_presets
[board_config
]);
6829 spec
->stream_name_analog
= "ALC861 Analog";
6830 spec
->stream_analog_playback
= &alc861_pcm_analog_playback
;
6831 spec
->stream_analog_capture
= &alc861_pcm_analog_capture
;
6833 spec
->stream_name_digital
= "ALC861 Digital";
6834 spec
->stream_digital_playback
= &alc861_pcm_digital_playback
;
6835 spec
->stream_digital_capture
= &alc861_pcm_digital_capture
;
6837 codec
->patch_ops
= alc_patch_ops
;
6838 if (board_config
== ALC861_AUTO
)
6839 spec
->init_hook
= alc861_auto_init
;
6847 struct hda_codec_preset snd_hda_preset_realtek
[] = {
6848 { .id
= 0x10ec0260, .name
= "ALC260", .patch
= patch_alc260
},
6849 { .id
= 0x10ec0262, .name
= "ALC262", .patch
= patch_alc262
},
6850 { .id
= 0x10ec0880, .name
= "ALC880", .patch
= patch_alc880
},
6851 { .id
= 0x10ec0882, .name
= "ALC882", .patch
= patch_alc882
},
6852 { .id
= 0x10ec0883, .name
= "ALC883", .patch
= patch_alc883
},
6853 { .id
= 0x10ec0885, .name
= "ALC885", .patch
= patch_alc882
},
6854 { .id
= 0x10ec0888, .name
= "ALC888", .patch
= patch_alc883
},
6855 { .id
= 0x10ec0861, .rev
= 0x100300, .name
= "ALC861",
6856 .patch
= patch_alc861
},
6857 { .id
= 0x10ec0861, .rev
= 0x100340, .name
= "ALC660",
6858 .patch
= patch_alc861
},