2 * Universal Interface for Intel High Definition Audio Codec
4 * HD audio interface patch for Realtek ALC 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 <linux/init.h>
27 #include <linux/delay.h>
28 #include <linux/slab.h>
29 #include <linux/pci.h>
30 #include <linux/module.h>
31 #include <sound/core.h>
32 #include <sound/jack.h>
33 #include "hda_codec.h"
34 #include "hda_local.h"
38 /* unsol event tags */
39 #define ALC_FRONT_EVENT 0x01
40 #define ALC_DCVOL_EVENT 0x02
41 #define ALC_HP_EVENT 0x04
42 #define ALC_MIC_EVENT 0x08
45 #define GPIO_MASK 0x03
47 /* extra amp-initialization sequence types */
56 struct alc_customize_define
{
58 unsigned char port_connectivity
;
59 unsigned char check_sum
;
60 unsigned char customization
;
61 unsigned char external_amp
;
62 unsigned int enable_pcbeep
:1;
63 unsigned int platform_type
:1;
65 unsigned int override
:1;
66 unsigned int fixup
:1; /* Means that this sku is set by driver, not read from hw */
72 hda_nid_t pin
; /* multi-io widget pin NID */
73 hda_nid_t dac
; /* DAC to be connected */
74 unsigned int ctl_in
; /* cached input-pin control value */
78 ALC_AUTOMUTE_PIN
, /* change the pin control */
79 ALC_AUTOMUTE_AMP
, /* mute/unmute the pin AMP */
80 ALC_AUTOMUTE_MIXER
, /* mute/unmute mixer widget AMP */
84 /* codec parameterization */
85 const struct snd_kcontrol_new
*mixers
[5]; /* mixer arrays */
86 unsigned int num_mixers
;
87 const struct snd_kcontrol_new
*cap_mixer
; /* capture mixer */
88 unsigned int beep_amp
; /* beep amp value, set via set_beep_amp() */
90 const struct hda_verb
*init_verbs
[10]; /* initialization verbs
94 unsigned int num_init_verbs
;
96 char stream_name_analog
[32]; /* analog PCM stream */
97 const struct hda_pcm_stream
*stream_analog_playback
;
98 const struct hda_pcm_stream
*stream_analog_capture
;
99 const struct hda_pcm_stream
*stream_analog_alt_playback
;
100 const struct hda_pcm_stream
*stream_analog_alt_capture
;
102 char stream_name_digital
[32]; /* digital PCM stream */
103 const struct hda_pcm_stream
*stream_digital_playback
;
104 const struct hda_pcm_stream
*stream_digital_capture
;
107 struct hda_multi_out multiout
; /* playback set-up
108 * max_channels, dacs must be set
109 * dig_out_nid and hp_nid are optional
111 hda_nid_t alt_dac_nid
;
112 hda_nid_t slave_dig_outs
[3]; /* optional - for auto-parsing */
116 unsigned int num_adc_nids
;
117 const hda_nid_t
*adc_nids
;
118 const hda_nid_t
*capsrc_nids
;
119 hda_nid_t dig_in_nid
; /* digital-in NID; optional */
120 hda_nid_t mixer_nid
; /* analog-mixer NID */
121 DECLARE_BITMAP(vol_ctls
, 0x20 << 1);
122 DECLARE_BITMAP(sw_ctls
, 0x20 << 1);
124 /* capture setup for dynamic dual-adc switch */
126 unsigned int cur_adc_stream_tag
;
127 unsigned int cur_adc_format
;
130 unsigned int num_mux_defs
;
131 const struct hda_input_mux
*input_mux
;
132 unsigned int cur_mux
[3];
133 hda_nid_t ext_mic_pin
;
134 hda_nid_t dock_mic_pin
;
135 hda_nid_t int_mic_pin
;
138 const struct hda_channel_mode
*channel_mode
;
139 int num_channel_mode
;
141 int const_channel_count
;
142 int ext_channel_count
;
144 /* PCM information */
145 struct hda_pcm pcm_rec
[3]; /* used in alc_build_pcms() */
147 /* dynamic controls, init_verbs and input_mux */
148 struct auto_pin_cfg autocfg
;
149 struct alc_customize_define cdefine
;
150 struct snd_array kctls
;
151 struct hda_input_mux private_imux
[3];
152 hda_nid_t private_dac_nids
[AUTO_CFG_MAX_OUTS
];
153 hda_nid_t private_adc_nids
[AUTO_CFG_MAX_OUTS
];
154 hda_nid_t private_capsrc_nids
[AUTO_CFG_MAX_OUTS
];
155 hda_nid_t imux_pins
[HDA_MAX_NUM_INPUTS
];
156 unsigned int dyn_adc_idx
[HDA_MAX_NUM_INPUTS
];
157 int int_mic_idx
, ext_mic_idx
, dock_mic_idx
; /* for auto-mic */
160 void (*init_hook
)(struct hda_codec
*codec
);
161 void (*unsol_event
)(struct hda_codec
*codec
, unsigned int res
);
162 #ifdef CONFIG_SND_HDA_POWER_SAVE
163 void (*power_hook
)(struct hda_codec
*codec
);
165 void (*shutup
)(struct hda_codec
*codec
);
166 void (*automute_hook
)(struct hda_codec
*codec
);
168 /* for pin sensing */
169 unsigned int hp_jack_present
:1;
170 unsigned int line_jack_present
:1;
171 unsigned int master_mute
:1;
172 unsigned int auto_mic
:1;
173 unsigned int auto_mic_valid_imux
:1; /* valid imux for auto-mic */
174 unsigned int automute_speaker
:1; /* automute speaker outputs */
175 unsigned int automute_lo
:1; /* automute LO outputs */
176 unsigned int detect_hp
:1; /* Headphone detection enabled */
177 unsigned int detect_lo
:1; /* Line-out detection enabled */
178 unsigned int automute_speaker_possible
:1; /* there are speakers and either LO or HP */
179 unsigned int automute_lo_possible
:1; /* there are line outs and HP */
180 unsigned int keep_vref_in_automute
:1; /* Don't clear VREF in automute */
183 unsigned int no_analog
:1; /* digital I/O only */
184 unsigned int dyn_adc_switch
:1; /* switch ADCs (for ALC275) */
185 unsigned int single_input_src
:1;
186 unsigned int vol_in_capsrc
:1; /* use capsrc volume (ADC has no vol) */
187 unsigned int parse_flags
; /* passed to snd_hda_parse_pin_defcfg() */
188 unsigned int shared_mic_hp
:1; /* HP/Mic-in sharing */
190 /* auto-mute control */
192 hda_nid_t automute_mixer_nid
[AUTO_CFG_MAX_OUTS
];
195 int codec_variant
; /* flag for other variants */
197 /* for virtual master */
198 hda_nid_t vmaster_nid
;
199 #ifdef CONFIG_SND_HDA_POWER_SAVE
200 struct hda_loopback_check loopback
;
205 unsigned int pll_coef_idx
, pll_coef_bit
;
210 const struct alc_fixup
*fixup_list
;
211 const char *fixup_name
;
215 struct alc_multi_io multi_io
[4];
218 struct snd_array bind_ctls
;
221 #define ALC_MODEL_AUTO 0 /* common for all chips */
223 static bool check_amp_caps(struct hda_codec
*codec
, hda_nid_t nid
,
224 int dir
, unsigned int bits
)
228 if (get_wcaps(codec
, nid
) & (1 << (dir
+ 1)))
229 if (query_amp_caps(codec
, nid
, dir
) & bits
)
234 #define nid_has_mute(codec, nid, dir) \
235 check_amp_caps(codec, nid, dir, AC_AMPCAP_MUTE)
236 #define nid_has_volume(codec, nid, dir) \
237 check_amp_caps(codec, nid, dir, AC_AMPCAP_NUM_STEPS)
242 static int alc_mux_enum_info(struct snd_kcontrol
*kcontrol
,
243 struct snd_ctl_elem_info
*uinfo
)
245 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
246 struct alc_spec
*spec
= codec
->spec
;
247 unsigned int mux_idx
= snd_ctl_get_ioffidx(kcontrol
, &uinfo
->id
);
248 if (mux_idx
>= spec
->num_mux_defs
)
250 if (!spec
->input_mux
[mux_idx
].num_items
&& mux_idx
> 0)
252 return snd_hda_input_mux_info(&spec
->input_mux
[mux_idx
], uinfo
);
255 static int alc_mux_enum_get(struct snd_kcontrol
*kcontrol
,
256 struct snd_ctl_elem_value
*ucontrol
)
258 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
259 struct alc_spec
*spec
= codec
->spec
;
260 unsigned int adc_idx
= snd_ctl_get_ioffidx(kcontrol
, &ucontrol
->id
);
262 ucontrol
->value
.enumerated
.item
[0] = spec
->cur_mux
[adc_idx
];
266 static bool alc_dyn_adc_pcm_resetup(struct hda_codec
*codec
, int cur
)
268 struct alc_spec
*spec
= codec
->spec
;
269 hda_nid_t new_adc
= spec
->adc_nids
[spec
->dyn_adc_idx
[cur
]];
271 if (spec
->cur_adc
&& spec
->cur_adc
!= new_adc
) {
272 /* stream is running, let's swap the current ADC */
273 __snd_hda_codec_cleanup_stream(codec
, spec
->cur_adc
, 1);
274 spec
->cur_adc
= new_adc
;
275 snd_hda_codec_setup_stream(codec
, new_adc
,
276 spec
->cur_adc_stream_tag
, 0,
277 spec
->cur_adc_format
);
283 static inline hda_nid_t
get_capsrc(struct alc_spec
*spec
, int idx
)
285 return spec
->capsrc_nids
?
286 spec
->capsrc_nids
[idx
] : spec
->adc_nids
[idx
];
289 static void call_update_outputs(struct hda_codec
*codec
);
291 /* select the given imux item; either unmute exclusively or select the route */
292 static int alc_mux_select(struct hda_codec
*codec
, unsigned int adc_idx
,
293 unsigned int idx
, bool force
)
295 struct alc_spec
*spec
= codec
->spec
;
296 const struct hda_input_mux
*imux
;
297 unsigned int mux_idx
;
298 int i
, type
, num_conns
;
301 mux_idx
= adc_idx
>= spec
->num_mux_defs
? 0 : adc_idx
;
302 imux
= &spec
->input_mux
[mux_idx
];
303 if (!imux
->num_items
&& mux_idx
> 0)
304 imux
= &spec
->input_mux
[0];
305 if (!imux
->num_items
)
308 if (idx
>= imux
->num_items
)
309 idx
= imux
->num_items
- 1;
310 if (spec
->cur_mux
[adc_idx
] == idx
&& !force
)
312 spec
->cur_mux
[adc_idx
] = idx
;
314 /* for shared I/O, change the pin-control accordingly */
315 if (spec
->shared_mic_hp
) {
316 /* NOTE: this assumes that there are only two inputs, the
317 * first is the real internal mic and the second is HP jack.
319 snd_hda_codec_write(codec
, spec
->autocfg
.inputs
[1].pin
, 0,
320 AC_VERB_SET_PIN_WIDGET_CONTROL
,
321 spec
->cur_mux
[adc_idx
] ?
322 PIN_VREF80
: PIN_HP
);
323 spec
->automute_speaker
= !spec
->cur_mux
[adc_idx
];
324 call_update_outputs(codec
);
327 if (spec
->dyn_adc_switch
) {
328 alc_dyn_adc_pcm_resetup(codec
, idx
);
329 adc_idx
= spec
->dyn_adc_idx
[idx
];
332 nid
= get_capsrc(spec
, adc_idx
);
335 num_conns
= snd_hda_get_conn_list(codec
, nid
, NULL
);
339 type
= get_wcaps_type(get_wcaps(codec
, nid
));
340 if (type
== AC_WID_AUD_MIX
) {
341 /* Matrix-mixer style (e.g. ALC882) */
342 int active
= imux
->items
[idx
].index
;
343 for (i
= 0; i
< num_conns
; i
++) {
344 unsigned int v
= (i
== active
) ? 0 : HDA_AMP_MUTE
;
345 snd_hda_codec_amp_stereo(codec
, nid
, HDA_INPUT
, i
,
349 /* MUX style (e.g. ALC880) */
350 snd_hda_codec_write_cache(codec
, nid
, 0,
351 AC_VERB_SET_CONNECT_SEL
,
352 imux
->items
[idx
].index
);
357 static int alc_mux_enum_put(struct snd_kcontrol
*kcontrol
,
358 struct snd_ctl_elem_value
*ucontrol
)
360 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
361 unsigned int adc_idx
= snd_ctl_get_ioffidx(kcontrol
, &ucontrol
->id
);
362 return alc_mux_select(codec
, adc_idx
,
363 ucontrol
->value
.enumerated
.item
[0], false);
367 * set up the input pin config (depending on the given auto-pin type)
369 static void alc_set_input_pin(struct hda_codec
*codec
, hda_nid_t nid
,
372 unsigned int val
= PIN_IN
;
374 if (auto_pin_type
== AUTO_PIN_MIC
) {
377 oldval
= snd_hda_codec_read(codec
, nid
, 0,
378 AC_VERB_GET_PIN_WIDGET_CONTROL
, 0);
379 pincap
= snd_hda_query_pin_caps(codec
, nid
);
380 pincap
= (pincap
& AC_PINCAP_VREF
) >> AC_PINCAP_VREF_SHIFT
;
381 /* if the default pin setup is vref50, we give it priority */
382 if ((pincap
& AC_PINCAP_VREF_80
) && oldval
!= PIN_VREF50
)
384 else if (pincap
& AC_PINCAP_VREF_50
)
386 else if (pincap
& AC_PINCAP_VREF_100
)
388 else if (pincap
& AC_PINCAP_VREF_GRD
)
391 snd_hda_codec_write(codec
, nid
, 0, AC_VERB_SET_PIN_WIDGET_CONTROL
, val
);
395 * Append the given mixer and verb elements for the later use
396 * The mixer array is referred in build_controls(), and init_verbs are
399 static void add_mixer(struct alc_spec
*spec
, const struct snd_kcontrol_new
*mix
)
401 if (snd_BUG_ON(spec
->num_mixers
>= ARRAY_SIZE(spec
->mixers
)))
403 spec
->mixers
[spec
->num_mixers
++] = mix
;
406 static void add_verb(struct alc_spec
*spec
, const struct hda_verb
*verb
)
408 if (snd_BUG_ON(spec
->num_init_verbs
>= ARRAY_SIZE(spec
->init_verbs
)))
410 spec
->init_verbs
[spec
->num_init_verbs
++] = verb
;
414 * GPIO setup tables, used in initialization
416 /* Enable GPIO mask and set output */
417 static const struct hda_verb alc_gpio1_init_verbs
[] = {
418 {0x01, AC_VERB_SET_GPIO_MASK
, 0x01},
419 {0x01, AC_VERB_SET_GPIO_DIRECTION
, 0x01},
420 {0x01, AC_VERB_SET_GPIO_DATA
, 0x01},
424 static const struct hda_verb alc_gpio2_init_verbs
[] = {
425 {0x01, AC_VERB_SET_GPIO_MASK
, 0x02},
426 {0x01, AC_VERB_SET_GPIO_DIRECTION
, 0x02},
427 {0x01, AC_VERB_SET_GPIO_DATA
, 0x02},
431 static const struct hda_verb alc_gpio3_init_verbs
[] = {
432 {0x01, AC_VERB_SET_GPIO_MASK
, 0x03},
433 {0x01, AC_VERB_SET_GPIO_DIRECTION
, 0x03},
434 {0x01, AC_VERB_SET_GPIO_DATA
, 0x03},
439 * Fix hardware PLL issue
440 * On some codecs, the analog PLL gating control must be off while
441 * the default value is 1.
443 static void alc_fix_pll(struct hda_codec
*codec
)
445 struct alc_spec
*spec
= codec
->spec
;
450 snd_hda_codec_write(codec
, spec
->pll_nid
, 0, AC_VERB_SET_COEF_INDEX
,
452 val
= snd_hda_codec_read(codec
, spec
->pll_nid
, 0,
453 AC_VERB_GET_PROC_COEF
, 0);
454 snd_hda_codec_write(codec
, spec
->pll_nid
, 0, AC_VERB_SET_COEF_INDEX
,
456 snd_hda_codec_write(codec
, spec
->pll_nid
, 0, AC_VERB_SET_PROC_COEF
,
457 val
& ~(1 << spec
->pll_coef_bit
));
460 static void alc_fix_pll_init(struct hda_codec
*codec
, hda_nid_t nid
,
461 unsigned int coef_idx
, unsigned int coef_bit
)
463 struct alc_spec
*spec
= codec
->spec
;
465 spec
->pll_coef_idx
= coef_idx
;
466 spec
->pll_coef_bit
= coef_bit
;
471 * Jack detections for HP auto-mute and mic-switch
474 /* check each pin in the given array; returns true if any of them is plugged */
475 static bool detect_jacks(struct hda_codec
*codec
, int num_pins
, hda_nid_t
*pins
)
479 for (i
= 0; i
< num_pins
; i
++) {
480 hda_nid_t nid
= pins
[i
];
483 present
|= snd_hda_jack_detect(codec
, nid
);
488 /* standard HP/line-out auto-mute helper */
489 static void do_automute(struct hda_codec
*codec
, int num_pins
, hda_nid_t
*pins
,
490 bool mute
, bool hp_out
)
492 struct alc_spec
*spec
= codec
->spec
;
493 unsigned int mute_bits
= mute
? HDA_AMP_MUTE
: 0;
494 unsigned int pin_bits
= mute
? 0 : (hp_out
? PIN_HP
: PIN_OUT
);
497 for (i
= 0; i
< num_pins
; i
++) {
498 hda_nid_t nid
= pins
[i
];
502 switch (spec
->automute_mode
) {
503 case ALC_AUTOMUTE_PIN
:
504 /* don't reset VREF value in case it's controlling
505 * the amp (see alc861_fixup_asus_amp_vref_0f())
507 if (spec
->keep_vref_in_automute
) {
508 val
= snd_hda_codec_read(codec
, nid
, 0,
509 AC_VERB_GET_PIN_WIDGET_CONTROL
, 0);
514 snd_hda_codec_write(codec
, nid
, 0,
515 AC_VERB_SET_PIN_WIDGET_CONTROL
,
518 case ALC_AUTOMUTE_AMP
:
519 snd_hda_codec_amp_stereo(codec
, nid
, HDA_OUTPUT
, 0,
520 HDA_AMP_MUTE
, mute_bits
);
522 case ALC_AUTOMUTE_MIXER
:
523 nid
= spec
->automute_mixer_nid
[i
];
526 snd_hda_codec_amp_stereo(codec
, nid
, HDA_INPUT
, 0,
527 HDA_AMP_MUTE
, mute_bits
);
528 snd_hda_codec_amp_stereo(codec
, nid
, HDA_INPUT
, 1,
529 HDA_AMP_MUTE
, mute_bits
);
535 /* Toggle outputs muting */
536 static void update_outputs(struct hda_codec
*codec
)
538 struct alc_spec
*spec
= codec
->spec
;
541 /* Control HP pins/amps depending on master_mute state;
542 * in general, HP pins/amps control should be enabled in all cases,
543 * but currently set only for master_mute, just to be safe
545 if (!spec
->shared_mic_hp
) /* don't change HP-pin when shared with mic */
546 do_automute(codec
, ARRAY_SIZE(spec
->autocfg
.hp_pins
),
547 spec
->autocfg
.hp_pins
, spec
->master_mute
, true);
549 if (!spec
->automute_speaker
)
552 on
= spec
->hp_jack_present
| spec
->line_jack_present
;
553 on
|= spec
->master_mute
;
554 do_automute(codec
, ARRAY_SIZE(spec
->autocfg
.speaker_pins
),
555 spec
->autocfg
.speaker_pins
, on
, false);
557 /* toggle line-out mutes if needed, too */
558 /* if LO is a copy of either HP or Speaker, don't need to handle it */
559 if (spec
->autocfg
.line_out_pins
[0] == spec
->autocfg
.hp_pins
[0] ||
560 spec
->autocfg
.line_out_pins
[0] == spec
->autocfg
.speaker_pins
[0])
562 if (!spec
->automute_lo
)
565 on
= spec
->hp_jack_present
;
566 on
|= spec
->master_mute
;
567 do_automute(codec
, ARRAY_SIZE(spec
->autocfg
.line_out_pins
),
568 spec
->autocfg
.line_out_pins
, on
, false);
571 static void call_update_outputs(struct hda_codec
*codec
)
573 struct alc_spec
*spec
= codec
->spec
;
574 if (spec
->automute_hook
)
575 spec
->automute_hook(codec
);
577 update_outputs(codec
);
580 /* standard HP-automute helper */
581 static void alc_hp_automute(struct hda_codec
*codec
)
583 struct alc_spec
*spec
= codec
->spec
;
585 spec
->hp_jack_present
=
586 detect_jacks(codec
, ARRAY_SIZE(spec
->autocfg
.hp_pins
),
587 spec
->autocfg
.hp_pins
);
588 if (!spec
->detect_hp
|| (!spec
->automute_speaker
&& !spec
->automute_lo
))
590 call_update_outputs(codec
);
593 /* standard line-out-automute helper */
594 static void alc_line_automute(struct hda_codec
*codec
)
596 struct alc_spec
*spec
= codec
->spec
;
598 /* check LO jack only when it's different from HP */
599 if (spec
->autocfg
.line_out_pins
[0] == spec
->autocfg
.hp_pins
[0])
602 spec
->line_jack_present
=
603 detect_jacks(codec
, ARRAY_SIZE(spec
->autocfg
.line_out_pins
),
604 spec
->autocfg
.line_out_pins
);
605 if (!spec
->automute_speaker
|| !spec
->detect_lo
)
607 call_update_outputs(codec
);
610 #define get_connection_index(codec, mux, nid) \
611 snd_hda_get_conn_index(codec, mux, nid, 0)
613 /* standard mic auto-switch helper */
614 static void alc_mic_automute(struct hda_codec
*codec
)
616 struct alc_spec
*spec
= codec
->spec
;
617 hda_nid_t
*pins
= spec
->imux_pins
;
619 if (!spec
->auto_mic
|| !spec
->auto_mic_valid_imux
)
621 if (snd_BUG_ON(!spec
->adc_nids
))
623 if (snd_BUG_ON(spec
->int_mic_idx
< 0 || spec
->ext_mic_idx
< 0))
626 if (snd_hda_jack_detect(codec
, pins
[spec
->ext_mic_idx
]))
627 alc_mux_select(codec
, 0, spec
->ext_mic_idx
, false);
628 else if (spec
->dock_mic_idx
>= 0 &&
629 snd_hda_jack_detect(codec
, pins
[spec
->dock_mic_idx
]))
630 alc_mux_select(codec
, 0, spec
->dock_mic_idx
, false);
632 alc_mux_select(codec
, 0, spec
->int_mic_idx
, false);
635 /* handle the specified unsol action (ALC_XXX_EVENT) */
636 static void alc_exec_unsol_event(struct hda_codec
*codec
, int action
)
640 alc_hp_automute(codec
);
642 case ALC_FRONT_EVENT
:
643 alc_line_automute(codec
);
646 alc_mic_automute(codec
);
649 snd_hda_jack_report_sync(codec
);
652 /* unsolicited event for HP jack sensing */
653 static void alc_sku_unsol_event(struct hda_codec
*codec
, unsigned int res
)
655 if (codec
->vendor_id
== 0x10ec0880)
659 res
= snd_hda_jack_get_action(codec
, res
);
660 alc_exec_unsol_event(codec
, res
);
663 /* call init functions of standard auto-mute helpers */
664 static void alc_inithook(struct hda_codec
*codec
)
666 alc_hp_automute(codec
);
667 alc_line_automute(codec
);
668 alc_mic_automute(codec
);
671 /* additional initialization for ALC888 variants */
672 static void alc888_coef_init(struct hda_codec
*codec
)
676 snd_hda_codec_write(codec
, 0x20, 0, AC_VERB_SET_COEF_INDEX
, 0);
677 tmp
= snd_hda_codec_read(codec
, 0x20, 0, AC_VERB_GET_PROC_COEF
, 0);
678 snd_hda_codec_write(codec
, 0x20, 0, AC_VERB_SET_COEF_INDEX
, 7);
679 if ((tmp
& 0xf0) == 0x20)
681 snd_hda_codec_read(codec
, 0x20, 0,
682 AC_VERB_SET_PROC_COEF
, 0x830);
685 snd_hda_codec_read(codec
, 0x20, 0,
686 AC_VERB_SET_PROC_COEF
, 0x3030);
689 /* additional initialization for ALC889 variants */
690 static void alc889_coef_init(struct hda_codec
*codec
)
694 snd_hda_codec_write(codec
, 0x20, 0, AC_VERB_SET_COEF_INDEX
, 7);
695 tmp
= snd_hda_codec_read(codec
, 0x20, 0, AC_VERB_GET_PROC_COEF
, 0);
696 snd_hda_codec_write(codec
, 0x20, 0, AC_VERB_SET_COEF_INDEX
, 7);
697 snd_hda_codec_write(codec
, 0x20, 0, AC_VERB_SET_PROC_COEF
, tmp
|0x2010);
700 /* turn on/off EAPD control (only if available) */
701 static void set_eapd(struct hda_codec
*codec
, hda_nid_t nid
, int on
)
703 if (get_wcaps_type(get_wcaps(codec
, nid
)) != AC_WID_PIN
)
705 if (snd_hda_query_pin_caps(codec
, nid
) & AC_PINCAP_EAPD
)
706 snd_hda_codec_write(codec
, nid
, 0, AC_VERB_SET_EAPD_BTLENABLE
,
710 /* turn on/off EAPD controls of the codec */
711 static void alc_auto_setup_eapd(struct hda_codec
*codec
, bool on
)
713 /* We currently only handle front, HP */
714 static hda_nid_t pins
[] = {
715 0x0f, 0x10, 0x14, 0x15, 0
718 for (p
= pins
; *p
; p
++)
719 set_eapd(codec
, *p
, on
);
722 /* generic shutup callback;
723 * just turning off EPAD and a little pause for avoiding pop-noise
725 static void alc_eapd_shutup(struct hda_codec
*codec
)
727 alc_auto_setup_eapd(codec
, false);
731 /* generic EAPD initialization */
732 static void alc_auto_init_amp(struct hda_codec
*codec
, int type
)
736 alc_auto_setup_eapd(codec
, true);
739 snd_hda_sequence_write(codec
, alc_gpio1_init_verbs
);
742 snd_hda_sequence_write(codec
, alc_gpio2_init_verbs
);
745 snd_hda_sequence_write(codec
, alc_gpio3_init_verbs
);
747 case ALC_INIT_DEFAULT
:
748 switch (codec
->vendor_id
) {
750 snd_hda_codec_write(codec
, 0x1a, 0,
751 AC_VERB_SET_COEF_INDEX
, 7);
752 tmp
= snd_hda_codec_read(codec
, 0x1a, 0,
753 AC_VERB_GET_PROC_COEF
, 0);
754 snd_hda_codec_write(codec
, 0x1a, 0,
755 AC_VERB_SET_COEF_INDEX
, 7);
756 snd_hda_codec_write(codec
, 0x1a, 0,
757 AC_VERB_SET_PROC_COEF
,
766 /*case 0x10ec0889:*/ /* this causes an SPDIF problem */
767 alc889_coef_init(codec
);
770 alc888_coef_init(codec
);
772 #if 0 /* XXX: This may cause the silent output on speaker on some machines */
775 snd_hda_codec_write(codec
, 0x20, 0,
776 AC_VERB_SET_COEF_INDEX
, 7);
777 tmp
= snd_hda_codec_read(codec
, 0x20, 0,
778 AC_VERB_GET_PROC_COEF
, 0);
779 snd_hda_codec_write(codec
, 0x20, 0,
780 AC_VERB_SET_COEF_INDEX
, 7);
781 snd_hda_codec_write(codec
, 0x20, 0,
782 AC_VERB_SET_PROC_COEF
,
792 * Auto-Mute mode mixer enum support
794 static int alc_automute_mode_info(struct snd_kcontrol
*kcontrol
,
795 struct snd_ctl_elem_info
*uinfo
)
797 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
798 struct alc_spec
*spec
= codec
->spec
;
799 static const char * const texts2
[] = {
800 "Disabled", "Enabled"
802 static const char * const texts3
[] = {
803 "Disabled", "Speaker Only", "Line-Out+Speaker"
805 const char * const *texts
;
807 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_ENUMERATED
;
809 if (spec
->automute_speaker_possible
&& spec
->automute_lo_possible
) {
810 uinfo
->value
.enumerated
.items
= 3;
813 uinfo
->value
.enumerated
.items
= 2;
816 if (uinfo
->value
.enumerated
.item
>= uinfo
->value
.enumerated
.items
)
817 uinfo
->value
.enumerated
.item
= uinfo
->value
.enumerated
.items
- 1;
818 strcpy(uinfo
->value
.enumerated
.name
,
819 texts
[uinfo
->value
.enumerated
.item
]);
823 static int alc_automute_mode_get(struct snd_kcontrol
*kcontrol
,
824 struct snd_ctl_elem_value
*ucontrol
)
826 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
827 struct alc_spec
*spec
= codec
->spec
;
828 unsigned int val
= 0;
829 if (spec
->automute_speaker
)
831 if (spec
->automute_lo
)
834 ucontrol
->value
.enumerated
.item
[0] = val
;
838 static int alc_automute_mode_put(struct snd_kcontrol
*kcontrol
,
839 struct snd_ctl_elem_value
*ucontrol
)
841 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
842 struct alc_spec
*spec
= codec
->spec
;
844 switch (ucontrol
->value
.enumerated
.item
[0]) {
846 if (!spec
->automute_speaker
&& !spec
->automute_lo
)
848 spec
->automute_speaker
= 0;
849 spec
->automute_lo
= 0;
852 if (spec
->automute_speaker_possible
) {
853 if (!spec
->automute_lo
&& spec
->automute_speaker
)
855 spec
->automute_speaker
= 1;
856 spec
->automute_lo
= 0;
857 } else if (spec
->automute_lo_possible
) {
858 if (spec
->automute_lo
)
860 spec
->automute_lo
= 1;
865 if (!spec
->automute_lo_possible
|| !spec
->automute_speaker_possible
)
867 if (spec
->automute_speaker
&& spec
->automute_lo
)
869 spec
->automute_speaker
= 1;
870 spec
->automute_lo
= 1;
875 call_update_outputs(codec
);
879 static const struct snd_kcontrol_new alc_automute_mode_enum
= {
880 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
881 .name
= "Auto-Mute Mode",
882 .info
= alc_automute_mode_info
,
883 .get
= alc_automute_mode_get
,
884 .put
= alc_automute_mode_put
,
887 static struct snd_kcontrol_new
*alc_kcontrol_new(struct alc_spec
*spec
)
889 snd_array_init(&spec
->kctls
, sizeof(struct snd_kcontrol_new
), 32);
890 return snd_array_new(&spec
->kctls
);
893 static int alc_add_automute_mode_enum(struct hda_codec
*codec
)
895 struct alc_spec
*spec
= codec
->spec
;
896 struct snd_kcontrol_new
*knew
;
898 knew
= alc_kcontrol_new(spec
);
901 *knew
= alc_automute_mode_enum
;
902 knew
->name
= kstrdup("Auto-Mute Mode", GFP_KERNEL
);
909 * Check the availability of HP/line-out auto-mute;
910 * Set up appropriately if really supported
912 static void alc_init_automute(struct hda_codec
*codec
)
914 struct alc_spec
*spec
= codec
->spec
;
915 struct auto_pin_cfg
*cfg
= &spec
->autocfg
;
921 if (cfg
->line_out_pins
[0])
923 if (cfg
->speaker_pins
[0])
925 if (present
< 2) /* need two different output types */
928 if (!cfg
->speaker_pins
[0] &&
929 cfg
->line_out_type
== AUTO_PIN_SPEAKER_OUT
) {
930 memcpy(cfg
->speaker_pins
, cfg
->line_out_pins
,
931 sizeof(cfg
->speaker_pins
));
932 cfg
->speaker_outs
= cfg
->line_outs
;
935 if (!cfg
->hp_pins
[0] &&
936 cfg
->line_out_type
== AUTO_PIN_HP_OUT
) {
937 memcpy(cfg
->hp_pins
, cfg
->line_out_pins
,
938 sizeof(cfg
->hp_pins
));
939 cfg
->hp_outs
= cfg
->line_outs
;
942 spec
->automute_mode
= ALC_AUTOMUTE_PIN
;
944 for (i
= 0; i
< cfg
->hp_outs
; i
++) {
945 hda_nid_t nid
= cfg
->hp_pins
[i
];
946 if (!is_jack_detectable(codec
, nid
))
948 snd_printdd("realtek: Enable HP auto-muting on NID 0x%x\n",
950 snd_hda_jack_detect_enable(codec
, nid
, ALC_HP_EVENT
);
954 if (cfg
->line_out_type
== AUTO_PIN_LINE_OUT
&& cfg
->line_outs
) {
955 if (cfg
->speaker_outs
)
956 for (i
= 0; i
< cfg
->line_outs
; i
++) {
957 hda_nid_t nid
= cfg
->line_out_pins
[i
];
958 if (!is_jack_detectable(codec
, nid
))
960 snd_printdd("realtek: Enable Line-Out "
961 "auto-muting on NID 0x%x\n", nid
);
962 snd_hda_jack_detect_enable(codec
, nid
,
966 spec
->automute_lo_possible
= spec
->detect_hp
;
969 spec
->automute_speaker_possible
= cfg
->speaker_outs
&&
970 (spec
->detect_hp
|| spec
->detect_lo
);
972 spec
->automute_lo
= spec
->automute_lo_possible
;
973 spec
->automute_speaker
= spec
->automute_speaker_possible
;
975 if (spec
->automute_speaker_possible
|| spec
->automute_lo_possible
) {
976 /* create a control for automute mode */
977 alc_add_automute_mode_enum(codec
);
978 spec
->unsol_event
= alc_sku_unsol_event
;
982 /* return the position of NID in the list, or -1 if not found */
983 static int find_idx_in_nid_list(hda_nid_t nid
, const hda_nid_t
*list
, int nums
)
986 for (i
= 0; i
< nums
; i
++)
992 /* check whether dynamic ADC-switching is available */
993 static bool alc_check_dyn_adc_switch(struct hda_codec
*codec
)
995 struct alc_spec
*spec
= codec
->spec
;
996 struct hda_input_mux
*imux
= &spec
->private_imux
[0];
1000 if (imux
!= spec
->input_mux
) /* no dynamic imux? */
1003 for (n
= 0; n
< spec
->num_adc_nids
; n
++) {
1004 cap
= spec
->private_capsrc_nids
[n
];
1005 for (i
= 0; i
< imux
->num_items
; i
++) {
1006 pin
= spec
->imux_pins
[i
];
1009 if (get_connection_index(codec
, cap
, pin
) < 0)
1012 if (i
>= imux
->num_items
)
1013 return true; /* no ADC-switch is needed */
1016 for (i
= 0; i
< imux
->num_items
; i
++) {
1017 pin
= spec
->imux_pins
[i
];
1018 for (n
= 0; n
< spec
->num_adc_nids
; n
++) {
1019 cap
= spec
->private_capsrc_nids
[n
];
1020 idx
= get_connection_index(codec
, cap
, pin
);
1022 imux
->items
[i
].index
= idx
;
1023 spec
->dyn_adc_idx
[i
] = n
;
1029 snd_printdd("realtek: enabling ADC switching\n");
1030 spec
->dyn_adc_switch
= 1;
1034 /* rebuild imux for matching with the given auto-mic pins (if not yet) */
1035 static bool alc_rebuild_imux_for_auto_mic(struct hda_codec
*codec
)
1037 struct alc_spec
*spec
= codec
->spec
;
1038 struct hda_input_mux
*imux
;
1039 static char * const texts
[3] = {
1040 "Mic", "Internal Mic", "Dock Mic"
1044 if (!spec
->auto_mic
)
1046 imux
= &spec
->private_imux
[0];
1047 if (spec
->input_mux
== imux
)
1049 spec
->imux_pins
[0] = spec
->ext_mic_pin
;
1050 spec
->imux_pins
[1] = spec
->int_mic_pin
;
1051 spec
->imux_pins
[2] = spec
->dock_mic_pin
;
1052 for (i
= 0; i
< 3; i
++) {
1053 strcpy(imux
->items
[i
].label
, texts
[i
]);
1054 if (spec
->imux_pins
[i
]) {
1055 hda_nid_t pin
= spec
->imux_pins
[i
];
1057 for (c
= 0; c
< spec
->num_adc_nids
; c
++) {
1058 hda_nid_t cap
= get_capsrc(spec
, c
);
1059 int idx
= get_connection_index(codec
, cap
, pin
);
1061 imux
->items
[i
].index
= idx
;
1065 imux
->num_items
= i
+ 1;
1068 spec
->num_mux_defs
= 1;
1069 spec
->input_mux
= imux
;
1073 /* check whether all auto-mic pins are valid; setup indices if OK */
1074 static bool alc_auto_mic_check_imux(struct hda_codec
*codec
)
1076 struct alc_spec
*spec
= codec
->spec
;
1077 const struct hda_input_mux
*imux
;
1079 if (!spec
->auto_mic
)
1081 if (spec
->auto_mic_valid_imux
)
1082 return true; /* already checked */
1084 /* fill up imux indices */
1085 if (!alc_check_dyn_adc_switch(codec
)) {
1090 imux
= spec
->input_mux
;
1091 spec
->ext_mic_idx
= find_idx_in_nid_list(spec
->ext_mic_pin
,
1092 spec
->imux_pins
, imux
->num_items
);
1093 spec
->int_mic_idx
= find_idx_in_nid_list(spec
->int_mic_pin
,
1094 spec
->imux_pins
, imux
->num_items
);
1095 spec
->dock_mic_idx
= find_idx_in_nid_list(spec
->dock_mic_pin
,
1096 spec
->imux_pins
, imux
->num_items
);
1097 if (spec
->ext_mic_idx
< 0 || spec
->int_mic_idx
< 0) {
1099 return false; /* no corresponding imux */
1102 snd_hda_jack_detect_enable(codec
, spec
->ext_mic_pin
, ALC_MIC_EVENT
);
1103 if (spec
->dock_mic_pin
)
1104 snd_hda_jack_detect_enable(codec
, spec
->dock_mic_pin
,
1107 spec
->auto_mic_valid_imux
= 1;
1113 * Check the availability of auto-mic switch;
1114 * Set up if really supported
1116 static void alc_init_auto_mic(struct hda_codec
*codec
)
1118 struct alc_spec
*spec
= codec
->spec
;
1119 struct auto_pin_cfg
*cfg
= &spec
->autocfg
;
1120 hda_nid_t fixed
, ext
, dock
;
1123 if (spec
->shared_mic_hp
)
1124 return; /* no auto-mic for the shared I/O */
1126 spec
->ext_mic_idx
= spec
->int_mic_idx
= spec
->dock_mic_idx
= -1;
1128 fixed
= ext
= dock
= 0;
1129 for (i
= 0; i
< cfg
->num_inputs
; i
++) {
1130 hda_nid_t nid
= cfg
->inputs
[i
].pin
;
1131 unsigned int defcfg
;
1132 defcfg
= snd_hda_codec_get_pincfg(codec
, nid
);
1133 switch (snd_hda_get_input_pin_attr(defcfg
)) {
1134 case INPUT_PIN_ATTR_INT
:
1136 return; /* already occupied */
1137 if (cfg
->inputs
[i
].type
!= AUTO_PIN_MIC
)
1138 return; /* invalid type */
1141 case INPUT_PIN_ATTR_UNUSED
:
1142 return; /* invalid entry */
1143 case INPUT_PIN_ATTR_DOCK
:
1145 return; /* already occupied */
1146 if (cfg
->inputs
[i
].type
> AUTO_PIN_LINE_IN
)
1147 return; /* invalid type */
1152 return; /* already occupied */
1153 if (cfg
->inputs
[i
].type
!= AUTO_PIN_MIC
)
1154 return; /* invalid type */
1165 if (!is_jack_detectable(codec
, ext
))
1166 return; /* no unsol support */
1167 if (dock
&& !is_jack_detectable(codec
, dock
))
1168 return; /* no unsol support */
1170 /* check imux indices */
1171 spec
->ext_mic_pin
= ext
;
1172 spec
->int_mic_pin
= fixed
;
1173 spec
->dock_mic_pin
= dock
;
1176 if (!alc_auto_mic_check_imux(codec
))
1179 snd_printdd("realtek: Enable auto-mic switch on NID 0x%x/0x%x/0x%x\n",
1181 spec
->unsol_event
= alc_sku_unsol_event
;
1184 /* check the availabilities of auto-mute and auto-mic switches */
1185 static void alc_auto_check_switches(struct hda_codec
*codec
)
1187 alc_init_automute(codec
);
1188 alc_init_auto_mic(codec
);
1192 * Realtek SSID verification
1195 /* Could be any non-zero and even value. When used as fixup, tells
1196 * the driver to ignore any present sku defines.
1198 #define ALC_FIXUP_SKU_IGNORE (2)
1200 static int alc_auto_parse_customize_define(struct hda_codec
*codec
)
1202 unsigned int ass
, tmp
, i
;
1204 struct alc_spec
*spec
= codec
->spec
;
1206 spec
->cdefine
.enable_pcbeep
= 1; /* assume always enabled */
1208 if (spec
->cdefine
.fixup
) {
1209 ass
= spec
->cdefine
.sku_cfg
;
1210 if (ass
== ALC_FIXUP_SKU_IGNORE
)
1215 ass
= codec
->subsystem_id
& 0xffff;
1216 if (ass
!= codec
->bus
->pci
->subsystem_device
&& (ass
& 1))
1220 if (codec
->vendor_id
== 0x10ec0260)
1222 ass
= snd_hda_codec_get_pincfg(codec
, nid
);
1225 printk(KERN_INFO
"hda_codec: %s: SKU not ready 0x%08x\n",
1226 codec
->chip_name
, ass
);
1232 for (i
= 1; i
< 16; i
++) {
1236 if (((ass
>> 16) & 0xf) != tmp
)
1239 spec
->cdefine
.port_connectivity
= ass
>> 30;
1240 spec
->cdefine
.enable_pcbeep
= (ass
& 0x100000) >> 20;
1241 spec
->cdefine
.check_sum
= (ass
>> 16) & 0xf;
1242 spec
->cdefine
.customization
= ass
>> 8;
1244 spec
->cdefine
.sku_cfg
= ass
;
1245 spec
->cdefine
.external_amp
= (ass
& 0x38) >> 3;
1246 spec
->cdefine
.platform_type
= (ass
& 0x4) >> 2;
1247 spec
->cdefine
.swap
= (ass
& 0x2) >> 1;
1248 spec
->cdefine
.override
= ass
& 0x1;
1250 snd_printd("SKU: Nid=0x%x sku_cfg=0x%08x\n",
1251 nid
, spec
->cdefine
.sku_cfg
);
1252 snd_printd("SKU: port_connectivity=0x%x\n",
1253 spec
->cdefine
.port_connectivity
);
1254 snd_printd("SKU: enable_pcbeep=0x%x\n", spec
->cdefine
.enable_pcbeep
);
1255 snd_printd("SKU: check_sum=0x%08x\n", spec
->cdefine
.check_sum
);
1256 snd_printd("SKU: customization=0x%08x\n", spec
->cdefine
.customization
);
1257 snd_printd("SKU: external_amp=0x%x\n", spec
->cdefine
.external_amp
);
1258 snd_printd("SKU: platform_type=0x%x\n", spec
->cdefine
.platform_type
);
1259 snd_printd("SKU: swap=0x%x\n", spec
->cdefine
.swap
);
1260 snd_printd("SKU: override=0x%x\n", spec
->cdefine
.override
);
1265 /* return true if the given NID is found in the list */
1266 static bool found_in_nid_list(hda_nid_t nid
, const hda_nid_t
*list
, int nums
)
1268 return find_idx_in_nid_list(nid
, list
, nums
) >= 0;
1271 /* check subsystem ID and set up device-specific initialization;
1272 * return 1 if initialized, 0 if invalid SSID
1274 /* 32-bit subsystem ID for BIOS loading in HD Audio codec.
1275 * 31 ~ 16 : Manufacture ID
1277 * 7 ~ 0 : Assembly ID
1278 * port-A --> pin 39/41, port-E --> pin 14/15, port-D --> pin 35/36
1280 static int alc_subsystem_id(struct hda_codec
*codec
,
1281 hda_nid_t porta
, hda_nid_t porte
,
1282 hda_nid_t portd
, hda_nid_t porti
)
1284 unsigned int ass
, tmp
, i
;
1286 struct alc_spec
*spec
= codec
->spec
;
1288 if (spec
->cdefine
.fixup
) {
1289 ass
= spec
->cdefine
.sku_cfg
;
1290 if (ass
== ALC_FIXUP_SKU_IGNORE
)
1295 ass
= codec
->subsystem_id
& 0xffff;
1296 if ((ass
!= codec
->bus
->pci
->subsystem_device
) && (ass
& 1))
1299 /* invalid SSID, check the special NID pin defcfg instead */
1301 * 31~30 : port connectivity
1304 * 19~16 : Check sum (15:1)
1309 if (codec
->vendor_id
== 0x10ec0260)
1311 ass
= snd_hda_codec_get_pincfg(codec
, nid
);
1312 snd_printd("realtek: No valid SSID, "
1313 "checking pincfg 0x%08x for NID 0x%x\n",
1317 if ((ass
>> 30) != 1) /* no physical connection */
1322 for (i
= 1; i
< 16; i
++) {
1326 if (((ass
>> 16) & 0xf) != tmp
)
1329 snd_printd("realtek: Enabling init ASM_ID=0x%04x CODEC_ID=%08x\n",
1330 ass
& 0xffff, codec
->vendor_id
);
1334 * 2 : 0 --> Desktop, 1 --> Laptop
1335 * 3~5 : External Amplifier control
1338 tmp
= (ass
& 0x38) >> 3; /* external Amp control */
1341 spec
->init_amp
= ALC_INIT_GPIO1
;
1344 spec
->init_amp
= ALC_INIT_GPIO2
;
1347 spec
->init_amp
= ALC_INIT_GPIO3
;
1351 spec
->init_amp
= ALC_INIT_DEFAULT
;
1355 /* is laptop or Desktop and enable the function "Mute internal speaker
1356 * when the external headphone out jack is plugged"
1358 if (!(ass
& 0x8000))
1361 * 10~8 : Jack location
1362 * 12~11: Headphone out -> 00: PortA, 01: PortE, 02: PortD, 03: Resvered
1364 * 15 : 1 --> enable the function "Mute internal speaker
1365 * when the external headphone out jack is plugged"
1367 if (!spec
->autocfg
.hp_pins
[0] &&
1368 !(spec
->autocfg
.line_out_pins
[0] &&
1369 spec
->autocfg
.line_out_type
== AUTO_PIN_HP_OUT
)) {
1371 tmp
= (ass
>> 11) & 0x3; /* HP to chassis */
1382 if (found_in_nid_list(nid
, spec
->autocfg
.line_out_pins
,
1383 spec
->autocfg
.line_outs
))
1385 spec
->autocfg
.hp_pins
[0] = nid
;
1390 /* Check the validity of ALC subsystem-id
1391 * ports contains an array of 4 pin NIDs for port-A, E, D and I */
1392 static void alc_ssid_check(struct hda_codec
*codec
, const hda_nid_t
*ports
)
1394 if (!alc_subsystem_id(codec
, ports
[0], ports
[1], ports
[2], ports
[3])) {
1395 struct alc_spec
*spec
= codec
->spec
;
1396 snd_printd("realtek: "
1397 "Enable default setup for auto mode as fallback\n");
1398 spec
->init_amp
= ALC_INIT_DEFAULT
;
1403 * Fix-up pin default configurations and add default verbs
1411 struct alc_model_fixup
{
1422 const struct alc_pincfg
*pins
;
1423 const struct hda_verb
*verbs
;
1424 void (*func
)(struct hda_codec
*codec
,
1425 const struct alc_fixup
*fix
,
1439 ALC_FIXUP_ACT_PRE_PROBE
,
1440 ALC_FIXUP_ACT_PROBE
,
1444 static void alc_apply_fixup(struct hda_codec
*codec
, int action
)
1446 struct alc_spec
*spec
= codec
->spec
;
1447 int id
= spec
->fixup_id
;
1448 #ifdef CONFIG_SND_DEBUG_VERBOSE
1449 const char *modelname
= spec
->fixup_name
;
1453 if (!spec
->fixup_list
)
1457 const struct alc_fixup
*fix
= spec
->fixup_list
+ id
;
1458 const struct alc_pincfg
*cfg
;
1460 switch (fix
->type
) {
1462 if (action
!= ALC_FIXUP_ACT_PRE_PROBE
|| !fix
->v
.sku
)
1464 snd_printdd(KERN_INFO
"hda_codec: %s: "
1465 "Apply sku override for %s\n",
1466 codec
->chip_name
, modelname
);
1467 spec
->cdefine
.sku_cfg
= fix
->v
.sku
;
1468 spec
->cdefine
.fixup
= 1;
1470 case ALC_FIXUP_PINS
:
1472 if (action
!= ALC_FIXUP_ACT_PRE_PROBE
|| !cfg
)
1474 snd_printdd(KERN_INFO
"hda_codec: %s: "
1475 "Apply pincfg for %s\n",
1476 codec
->chip_name
, modelname
);
1477 for (; cfg
->nid
; cfg
++)
1478 snd_hda_codec_set_pincfg(codec
, cfg
->nid
,
1481 case ALC_FIXUP_VERBS
:
1482 if (action
!= ALC_FIXUP_ACT_PROBE
|| !fix
->v
.verbs
)
1484 snd_printdd(KERN_INFO
"hda_codec: %s: "
1485 "Apply fix-verbs for %s\n",
1486 codec
->chip_name
, modelname
);
1487 add_verb(codec
->spec
, fix
->v
.verbs
);
1489 case ALC_FIXUP_FUNC
:
1492 snd_printdd(KERN_INFO
"hda_codec: %s: "
1493 "Apply fix-func for %s\n",
1494 codec
->chip_name
, modelname
);
1495 fix
->v
.func(codec
, fix
, action
);
1498 snd_printk(KERN_ERR
"hda_codec: %s: "
1499 "Invalid fixup type %d\n",
1500 codec
->chip_name
, fix
->type
);
1511 static void alc_pick_fixup(struct hda_codec
*codec
,
1512 const struct alc_model_fixup
*models
,
1513 const struct snd_pci_quirk
*quirk
,
1514 const struct alc_fixup
*fixlist
)
1516 struct alc_spec
*spec
= codec
->spec
;
1517 const struct snd_pci_quirk
*q
;
1519 const char *name
= NULL
;
1521 if (codec
->modelname
&& models
) {
1522 while (models
->name
) {
1523 if (!strcmp(codec
->modelname
, models
->name
)) {
1525 name
= models
->name
;
1532 q
= snd_pci_quirk_lookup(codec
->bus
->pci
, quirk
);
1535 #ifdef CONFIG_SND_DEBUG_VERBOSE
1541 for (q
= quirk
; q
->subvendor
; q
++) {
1542 unsigned int vendorid
=
1543 q
->subdevice
| (q
->subvendor
<< 16);
1544 if (vendorid
== codec
->subsystem_id
) {
1546 #ifdef CONFIG_SND_DEBUG_VERBOSE
1554 spec
->fixup_id
= id
;
1556 spec
->fixup_list
= fixlist
;
1557 spec
->fixup_name
= name
;
1562 * COEF access helper functions
1564 static int alc_read_coef_idx(struct hda_codec
*codec
,
1565 unsigned int coef_idx
)
1568 snd_hda_codec_write(codec
, 0x20, 0, AC_VERB_SET_COEF_INDEX
,
1570 val
= snd_hda_codec_read(codec
, 0x20, 0,
1571 AC_VERB_GET_PROC_COEF
, 0);
1575 static void alc_write_coef_idx(struct hda_codec
*codec
, unsigned int coef_idx
,
1576 unsigned int coef_val
)
1578 snd_hda_codec_write(codec
, 0x20, 0, AC_VERB_SET_COEF_INDEX
,
1580 snd_hda_codec_write(codec
, 0x20, 0, AC_VERB_SET_PROC_COEF
,
1584 /* a special bypass for COEF 0; read the cached value at the second time */
1585 static unsigned int alc_get_coef0(struct hda_codec
*codec
)
1587 struct alc_spec
*spec
= codec
->spec
;
1589 spec
->coef0
= alc_read_coef_idx(codec
, 0);
1594 * Digital I/O handling
1597 /* set right pin controls for digital I/O */
1598 static void alc_auto_init_digital(struct hda_codec
*codec
)
1600 struct alc_spec
*spec
= codec
->spec
;
1604 for (i
= 0; i
< spec
->autocfg
.dig_outs
; i
++) {
1605 pin
= spec
->autocfg
.dig_out_pins
[i
];
1608 snd_hda_codec_write(codec
, pin
, 0,
1609 AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_OUT
);
1611 dac
= spec
->multiout
.dig_out_nid
;
1613 dac
= spec
->slave_dig_outs
[i
- 1];
1614 if (!dac
|| !(get_wcaps(codec
, dac
) & AC_WCAP_OUT_AMP
))
1616 snd_hda_codec_write(codec
, dac
, 0,
1617 AC_VERB_SET_AMP_GAIN_MUTE
,
1620 pin
= spec
->autocfg
.dig_in_pin
;
1622 snd_hda_codec_write(codec
, pin
, 0,
1623 AC_VERB_SET_PIN_WIDGET_CONTROL
,
1627 /* parse digital I/Os and set up NIDs in BIOS auto-parse mode */
1628 static void alc_auto_parse_digital(struct hda_codec
*codec
)
1630 struct alc_spec
*spec
= codec
->spec
;
1634 /* support multiple SPDIFs; the secondary is set up as a slave */
1636 for (i
= 0; i
< spec
->autocfg
.dig_outs
; i
++) {
1638 err
= snd_hda_get_connections(codec
,
1639 spec
->autocfg
.dig_out_pins
[i
],
1640 conn
, ARRAY_SIZE(conn
));
1643 dig_nid
= conn
[0]; /* assume the first element is audio-out */
1645 spec
->multiout
.dig_out_nid
= dig_nid
;
1646 spec
->dig_out_type
= spec
->autocfg
.dig_out_type
[0];
1648 spec
->multiout
.slave_dig_outs
= spec
->slave_dig_outs
;
1649 if (nums
>= ARRAY_SIZE(spec
->slave_dig_outs
) - 1)
1651 spec
->slave_dig_outs
[nums
- 1] = dig_nid
;
1656 if (spec
->autocfg
.dig_in_pin
) {
1657 dig_nid
= codec
->start_nid
;
1658 for (i
= 0; i
< codec
->num_nodes
; i
++, dig_nid
++) {
1659 unsigned int wcaps
= get_wcaps(codec
, dig_nid
);
1660 if (get_wcaps_type(wcaps
) != AC_WID_AUD_IN
)
1662 if (!(wcaps
& AC_WCAP_DIGITAL
))
1664 if (!(wcaps
& AC_WCAP_CONN_LIST
))
1666 err
= get_connection_index(codec
, dig_nid
,
1667 spec
->autocfg
.dig_in_pin
);
1669 spec
->dig_in_nid
= dig_nid
;
1677 * capture mixer elements
1679 static int alc_cap_vol_info(struct snd_kcontrol
*kcontrol
,
1680 struct snd_ctl_elem_info
*uinfo
)
1682 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
1683 struct alc_spec
*spec
= codec
->spec
;
1687 mutex_lock(&codec
->control_mutex
);
1688 if (spec
->vol_in_capsrc
)
1689 val
= HDA_COMPOSE_AMP_VAL(spec
->capsrc_nids
[0], 3, 0, HDA_OUTPUT
);
1691 val
= HDA_COMPOSE_AMP_VAL(spec
->adc_nids
[0], 3, 0, HDA_INPUT
);
1692 kcontrol
->private_value
= val
;
1693 err
= snd_hda_mixer_amp_volume_info(kcontrol
, uinfo
);
1694 mutex_unlock(&codec
->control_mutex
);
1698 static int alc_cap_vol_tlv(struct snd_kcontrol
*kcontrol
, int op_flag
,
1699 unsigned int size
, unsigned int __user
*tlv
)
1701 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
1702 struct alc_spec
*spec
= codec
->spec
;
1706 mutex_lock(&codec
->control_mutex
);
1707 if (spec
->vol_in_capsrc
)
1708 val
= HDA_COMPOSE_AMP_VAL(spec
->capsrc_nids
[0], 3, 0, HDA_OUTPUT
);
1710 val
= HDA_COMPOSE_AMP_VAL(spec
->adc_nids
[0], 3, 0, HDA_INPUT
);
1711 kcontrol
->private_value
= val
;
1712 err
= snd_hda_mixer_amp_tlv(kcontrol
, op_flag
, size
, tlv
);
1713 mutex_unlock(&codec
->control_mutex
);
1717 typedef int (*getput_call_t
)(struct snd_kcontrol
*kcontrol
,
1718 struct snd_ctl_elem_value
*ucontrol
);
1720 static int alc_cap_getput_caller(struct snd_kcontrol
*kcontrol
,
1721 struct snd_ctl_elem_value
*ucontrol
,
1722 getput_call_t func
, bool check_adc_switch
)
1724 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
1725 struct alc_spec
*spec
= codec
->spec
;
1728 mutex_lock(&codec
->control_mutex
);
1729 if (check_adc_switch
&& spec
->dyn_adc_switch
) {
1730 for (i
= 0; i
< spec
->num_adc_nids
; i
++) {
1731 kcontrol
->private_value
=
1732 HDA_COMPOSE_AMP_VAL(spec
->adc_nids
[i
],
1734 err
= func(kcontrol
, ucontrol
);
1739 i
= snd_ctl_get_ioffidx(kcontrol
, &ucontrol
->id
);
1740 if (spec
->vol_in_capsrc
)
1741 kcontrol
->private_value
=
1742 HDA_COMPOSE_AMP_VAL(spec
->capsrc_nids
[i
],
1745 kcontrol
->private_value
=
1746 HDA_COMPOSE_AMP_VAL(spec
->adc_nids
[i
],
1748 err
= func(kcontrol
, ucontrol
);
1751 mutex_unlock(&codec
->control_mutex
);
1755 static int alc_cap_vol_get(struct snd_kcontrol
*kcontrol
,
1756 struct snd_ctl_elem_value
*ucontrol
)
1758 return alc_cap_getput_caller(kcontrol
, ucontrol
,
1759 snd_hda_mixer_amp_volume_get
, false);
1762 static int alc_cap_vol_put(struct snd_kcontrol
*kcontrol
,
1763 struct snd_ctl_elem_value
*ucontrol
)
1765 return alc_cap_getput_caller(kcontrol
, ucontrol
,
1766 snd_hda_mixer_amp_volume_put
, true);
1769 /* capture mixer elements */
1770 #define alc_cap_sw_info snd_ctl_boolean_stereo_info
1772 static int alc_cap_sw_get(struct snd_kcontrol
*kcontrol
,
1773 struct snd_ctl_elem_value
*ucontrol
)
1775 return alc_cap_getput_caller(kcontrol
, ucontrol
,
1776 snd_hda_mixer_amp_switch_get
, false);
1779 static int alc_cap_sw_put(struct snd_kcontrol
*kcontrol
,
1780 struct snd_ctl_elem_value
*ucontrol
)
1782 return alc_cap_getput_caller(kcontrol
, ucontrol
,
1783 snd_hda_mixer_amp_switch_put
, true);
1786 #define _DEFINE_CAPMIX(num) \
1788 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
1789 .name = "Capture Switch", \
1790 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE, \
1792 .info = alc_cap_sw_info, \
1793 .get = alc_cap_sw_get, \
1794 .put = alc_cap_sw_put, \
1797 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
1798 .name = "Capture Volume", \
1799 .access = (SNDRV_CTL_ELEM_ACCESS_READWRITE | \
1800 SNDRV_CTL_ELEM_ACCESS_TLV_READ | \
1801 SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK), \
1803 .info = alc_cap_vol_info, \
1804 .get = alc_cap_vol_get, \
1805 .put = alc_cap_vol_put, \
1806 .tlv = { .c = alc_cap_vol_tlv }, \
1809 #define _DEFINE_CAPSRC(num) \
1811 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
1812 /* .name = "Capture Source", */ \
1813 .name = "Input Source", \
1815 .info = alc_mux_enum_info, \
1816 .get = alc_mux_enum_get, \
1817 .put = alc_mux_enum_put, \
1820 #define DEFINE_CAPMIX(num) \
1821 static const struct snd_kcontrol_new alc_capture_mixer ## num[] = { \
1822 _DEFINE_CAPMIX(num), \
1823 _DEFINE_CAPSRC(num), \
1827 #define DEFINE_CAPMIX_NOSRC(num) \
1828 static const struct snd_kcontrol_new alc_capture_mixer_nosrc ## num[] = { \
1829 _DEFINE_CAPMIX(num), \
1833 /* up to three ADCs */
1837 DEFINE_CAPMIX_NOSRC(1);
1838 DEFINE_CAPMIX_NOSRC(2);
1839 DEFINE_CAPMIX_NOSRC(3);
1842 * virtual master controls
1846 * slave controls for virtual master
1848 static const char * const alc_slave_pfxs
[] = {
1849 "Front", "Surround", "Center", "LFE", "Side",
1850 "Headphone", "Speaker", "Mono", "Line-Out",
1851 "CLFE", "Bass Speaker", "PCM",
1856 * build control elements
1859 #define NID_MAPPING (-1)
1861 #define SUBDEV_SPEAKER_ (0 << 6)
1862 #define SUBDEV_HP_ (1 << 6)
1863 #define SUBDEV_LINE_ (2 << 6)
1864 #define SUBDEV_SPEAKER(x) (SUBDEV_SPEAKER_ | ((x) & 0x3f))
1865 #define SUBDEV_HP(x) (SUBDEV_HP_ | ((x) & 0x3f))
1866 #define SUBDEV_LINE(x) (SUBDEV_LINE_ | ((x) & 0x3f))
1868 static void alc_free_kctls(struct hda_codec
*codec
);
1870 #ifdef CONFIG_SND_HDA_INPUT_BEEP
1871 /* additional beep mixers; the actual parameters are overwritten at build */
1872 static const struct snd_kcontrol_new alc_beep_mixer
[] = {
1873 HDA_CODEC_VOLUME("Beep Playback Volume", 0, 0, HDA_INPUT
),
1874 HDA_CODEC_MUTE_BEEP("Beep Playback Switch", 0, 0, HDA_INPUT
),
1879 static int __alc_build_controls(struct hda_codec
*codec
)
1881 struct alc_spec
*spec
= codec
->spec
;
1882 struct snd_kcontrol
*kctl
= NULL
;
1883 const struct snd_kcontrol_new
*knew
;
1888 for (i
= 0; i
< spec
->num_mixers
; i
++) {
1889 err
= snd_hda_add_new_ctls(codec
, spec
->mixers
[i
]);
1893 if (spec
->cap_mixer
) {
1894 err
= snd_hda_add_new_ctls(codec
, spec
->cap_mixer
);
1898 if (spec
->multiout
.dig_out_nid
) {
1899 err
= snd_hda_create_spdif_out_ctls(codec
,
1900 spec
->multiout
.dig_out_nid
,
1901 spec
->multiout
.dig_out_nid
);
1904 if (!spec
->no_analog
) {
1905 err
= snd_hda_create_spdif_share_sw(codec
,
1909 spec
->multiout
.share_spdif
= 1;
1912 if (spec
->dig_in_nid
) {
1913 err
= snd_hda_create_spdif_in_ctls(codec
, spec
->dig_in_nid
);
1918 #ifdef CONFIG_SND_HDA_INPUT_BEEP
1919 /* create beep controls if needed */
1920 if (spec
->beep_amp
) {
1921 const struct snd_kcontrol_new
*knew
;
1922 for (knew
= alc_beep_mixer
; knew
->name
; knew
++) {
1923 struct snd_kcontrol
*kctl
;
1924 kctl
= snd_ctl_new1(knew
, codec
);
1927 kctl
->private_value
= spec
->beep_amp
;
1928 err
= snd_hda_ctl_add(codec
, 0, kctl
);
1935 /* if we have no master control, let's create it */
1936 if (!spec
->no_analog
&&
1937 !snd_hda_find_mixer_ctl(codec
, "Master Playback Volume")) {
1938 unsigned int vmaster_tlv
[4];
1939 snd_hda_set_vmaster_tlv(codec
, spec
->vmaster_nid
,
1940 HDA_OUTPUT
, vmaster_tlv
);
1941 err
= snd_hda_add_vmaster(codec
, "Master Playback Volume",
1942 vmaster_tlv
, alc_slave_pfxs
,
1947 if (!spec
->no_analog
&&
1948 !snd_hda_find_mixer_ctl(codec
, "Master Playback Switch")) {
1949 err
= snd_hda_add_vmaster(codec
, "Master Playback Switch",
1950 NULL
, alc_slave_pfxs
,
1956 /* assign Capture Source enums to NID */
1957 if (spec
->capsrc_nids
|| spec
->adc_nids
) {
1958 kctl
= snd_hda_find_mixer_ctl(codec
, "Capture Source");
1960 kctl
= snd_hda_find_mixer_ctl(codec
, "Input Source");
1961 for (i
= 0; kctl
&& i
< kctl
->count
; i
++) {
1962 err
= snd_hda_add_nid(codec
, kctl
, i
,
1963 get_capsrc(spec
, i
));
1968 if (spec
->cap_mixer
&& spec
->adc_nids
) {
1969 const char *kname
= kctl
? kctl
->id
.name
: NULL
;
1970 for (knew
= spec
->cap_mixer
; knew
->name
; knew
++) {
1971 if (kname
&& strcmp(knew
->name
, kname
) == 0)
1973 kctl
= snd_hda_find_mixer_ctl(codec
, knew
->name
);
1974 for (i
= 0; kctl
&& i
< kctl
->count
; i
++) {
1975 err
= snd_hda_add_nid(codec
, kctl
, i
,
1983 /* other nid->control mapping */
1984 for (i
= 0; i
< spec
->num_mixers
; i
++) {
1985 for (knew
= spec
->mixers
[i
]; knew
->name
; knew
++) {
1986 if (knew
->iface
!= NID_MAPPING
)
1988 kctl
= snd_hda_find_mixer_ctl(codec
, knew
->name
);
1991 u
= knew
->subdevice
;
1992 for (j
= 0; j
< 4; j
++, u
>>= 8) {
1997 case SUBDEV_SPEAKER_
:
1998 nid
= spec
->autocfg
.speaker_pins
[nid
];
2001 nid
= spec
->autocfg
.line_out_pins
[nid
];
2004 nid
= spec
->autocfg
.hp_pins
[nid
];
2009 err
= snd_hda_add_nid(codec
, kctl
, 0, nid
);
2013 u
= knew
->private_value
;
2014 for (j
= 0; j
< 4; j
++, u
>>= 8) {
2018 err
= snd_hda_add_nid(codec
, kctl
, 0, nid
);
2025 alc_free_kctls(codec
); /* no longer needed */
2030 static int alc_build_controls(struct hda_codec
*codec
)
2032 struct alc_spec
*spec
= codec
->spec
;
2033 int err
= __alc_build_controls(codec
);
2036 return snd_hda_jack_add_kctls(codec
, &spec
->autocfg
);
2044 static void alc_init_special_input_src(struct hda_codec
*codec
);
2046 static int alc_init(struct hda_codec
*codec
)
2048 struct alc_spec
*spec
= codec
->spec
;
2052 alc_auto_init_amp(codec
, spec
->init_amp
);
2054 for (i
= 0; i
< spec
->num_init_verbs
; i
++)
2055 snd_hda_sequence_write(codec
, spec
->init_verbs
[i
]);
2056 alc_init_special_input_src(codec
);
2058 if (spec
->init_hook
)
2059 spec
->init_hook(codec
);
2061 alc_apply_fixup(codec
, ALC_FIXUP_ACT_INIT
);
2063 snd_hda_jack_report_sync(codec
);
2065 hda_call_check_power_status(codec
, 0x01);
2069 static void alc_unsol_event(struct hda_codec
*codec
, unsigned int res
)
2071 struct alc_spec
*spec
= codec
->spec
;
2073 if (spec
->unsol_event
)
2074 spec
->unsol_event(codec
, res
);
2077 #ifdef CONFIG_SND_HDA_POWER_SAVE
2078 static int alc_check_power_status(struct hda_codec
*codec
, hda_nid_t nid
)
2080 struct alc_spec
*spec
= codec
->spec
;
2081 return snd_hda_check_amp_list_power(codec
, &spec
->loopback
, nid
);
2086 * Analog playback callbacks
2088 static int alc_playback_pcm_open(struct hda_pcm_stream
*hinfo
,
2089 struct hda_codec
*codec
,
2090 struct snd_pcm_substream
*substream
)
2092 struct alc_spec
*spec
= codec
->spec
;
2093 return snd_hda_multi_out_analog_open(codec
, &spec
->multiout
, substream
,
2097 static int alc_playback_pcm_prepare(struct hda_pcm_stream
*hinfo
,
2098 struct hda_codec
*codec
,
2099 unsigned int stream_tag
,
2100 unsigned int format
,
2101 struct snd_pcm_substream
*substream
)
2103 struct alc_spec
*spec
= codec
->spec
;
2104 return snd_hda_multi_out_analog_prepare(codec
, &spec
->multiout
,
2105 stream_tag
, format
, substream
);
2108 static int alc_playback_pcm_cleanup(struct hda_pcm_stream
*hinfo
,
2109 struct hda_codec
*codec
,
2110 struct snd_pcm_substream
*substream
)
2112 struct alc_spec
*spec
= codec
->spec
;
2113 return snd_hda_multi_out_analog_cleanup(codec
, &spec
->multiout
);
2119 static int alc_dig_playback_pcm_open(struct hda_pcm_stream
*hinfo
,
2120 struct hda_codec
*codec
,
2121 struct snd_pcm_substream
*substream
)
2123 struct alc_spec
*spec
= codec
->spec
;
2124 return snd_hda_multi_out_dig_open(codec
, &spec
->multiout
);
2127 static int alc_dig_playback_pcm_prepare(struct hda_pcm_stream
*hinfo
,
2128 struct hda_codec
*codec
,
2129 unsigned int stream_tag
,
2130 unsigned int format
,
2131 struct snd_pcm_substream
*substream
)
2133 struct alc_spec
*spec
= codec
->spec
;
2134 return snd_hda_multi_out_dig_prepare(codec
, &spec
->multiout
,
2135 stream_tag
, format
, substream
);
2138 static int alc_dig_playback_pcm_cleanup(struct hda_pcm_stream
*hinfo
,
2139 struct hda_codec
*codec
,
2140 struct snd_pcm_substream
*substream
)
2142 struct alc_spec
*spec
= codec
->spec
;
2143 return snd_hda_multi_out_dig_cleanup(codec
, &spec
->multiout
);
2146 static int alc_dig_playback_pcm_close(struct hda_pcm_stream
*hinfo
,
2147 struct hda_codec
*codec
,
2148 struct snd_pcm_substream
*substream
)
2150 struct alc_spec
*spec
= codec
->spec
;
2151 return snd_hda_multi_out_dig_close(codec
, &spec
->multiout
);
2157 static int alc_alt_capture_pcm_prepare(struct hda_pcm_stream
*hinfo
,
2158 struct hda_codec
*codec
,
2159 unsigned int stream_tag
,
2160 unsigned int format
,
2161 struct snd_pcm_substream
*substream
)
2163 struct alc_spec
*spec
= codec
->spec
;
2165 snd_hda_codec_setup_stream(codec
, spec
->adc_nids
[substream
->number
+ 1],
2166 stream_tag
, 0, format
);
2170 static int alc_alt_capture_pcm_cleanup(struct hda_pcm_stream
*hinfo
,
2171 struct hda_codec
*codec
,
2172 struct snd_pcm_substream
*substream
)
2174 struct alc_spec
*spec
= codec
->spec
;
2176 snd_hda_codec_cleanup_stream(codec
,
2177 spec
->adc_nids
[substream
->number
+ 1]);
2181 /* analog capture with dynamic dual-adc changes */
2182 static int dyn_adc_capture_pcm_prepare(struct hda_pcm_stream
*hinfo
,
2183 struct hda_codec
*codec
,
2184 unsigned int stream_tag
,
2185 unsigned int format
,
2186 struct snd_pcm_substream
*substream
)
2188 struct alc_spec
*spec
= codec
->spec
;
2189 spec
->cur_adc
= spec
->adc_nids
[spec
->dyn_adc_idx
[spec
->cur_mux
[0]]];
2190 spec
->cur_adc_stream_tag
= stream_tag
;
2191 spec
->cur_adc_format
= format
;
2192 snd_hda_codec_setup_stream(codec
, spec
->cur_adc
, stream_tag
, 0, format
);
2196 static int dyn_adc_capture_pcm_cleanup(struct hda_pcm_stream
*hinfo
,
2197 struct hda_codec
*codec
,
2198 struct snd_pcm_substream
*substream
)
2200 struct alc_spec
*spec
= codec
->spec
;
2201 snd_hda_codec_cleanup_stream(codec
, spec
->cur_adc
);
2206 static const struct hda_pcm_stream dyn_adc_pcm_analog_capture
= {
2210 .nid
= 0, /* fill later */
2212 .prepare
= dyn_adc_capture_pcm_prepare
,
2213 .cleanup
= dyn_adc_capture_pcm_cleanup
2219 static const struct hda_pcm_stream alc_pcm_analog_playback
= {
2223 /* NID is set in alc_build_pcms */
2225 .open
= alc_playback_pcm_open
,
2226 .prepare
= alc_playback_pcm_prepare
,
2227 .cleanup
= alc_playback_pcm_cleanup
2231 static const struct hda_pcm_stream alc_pcm_analog_capture
= {
2235 /* NID is set in alc_build_pcms */
2238 static const struct hda_pcm_stream alc_pcm_analog_alt_playback
= {
2242 /* NID is set in alc_build_pcms */
2245 static const struct hda_pcm_stream alc_pcm_analog_alt_capture
= {
2246 .substreams
= 2, /* can be overridden */
2249 /* NID is set in alc_build_pcms */
2251 .prepare
= alc_alt_capture_pcm_prepare
,
2252 .cleanup
= alc_alt_capture_pcm_cleanup
2256 static const struct hda_pcm_stream alc_pcm_digital_playback
= {
2260 /* NID is set in alc_build_pcms */
2262 .open
= alc_dig_playback_pcm_open
,
2263 .close
= alc_dig_playback_pcm_close
,
2264 .prepare
= alc_dig_playback_pcm_prepare
,
2265 .cleanup
= alc_dig_playback_pcm_cleanup
2269 static const struct hda_pcm_stream alc_pcm_digital_capture
= {
2273 /* NID is set in alc_build_pcms */
2276 /* Used by alc_build_pcms to flag that a PCM has no playback stream */
2277 static const struct hda_pcm_stream alc_pcm_null_stream
= {
2283 static int alc_build_pcms(struct hda_codec
*codec
)
2285 struct alc_spec
*spec
= codec
->spec
;
2286 struct hda_pcm
*info
= spec
->pcm_rec
;
2287 const struct hda_pcm_stream
*p
;
2288 bool have_multi_adcs
;
2291 codec
->num_pcms
= 1;
2292 codec
->pcm_info
= info
;
2294 if (spec
->no_analog
)
2297 snprintf(spec
->stream_name_analog
, sizeof(spec
->stream_name_analog
),
2298 "%s Analog", codec
->chip_name
);
2299 info
->name
= spec
->stream_name_analog
;
2301 if (spec
->multiout
.num_dacs
> 0) {
2302 p
= spec
->stream_analog_playback
;
2304 p
= &alc_pcm_analog_playback
;
2305 info
->stream
[SNDRV_PCM_STREAM_PLAYBACK
] = *p
;
2306 info
->stream
[SNDRV_PCM_STREAM_PLAYBACK
].nid
= spec
->multiout
.dac_nids
[0];
2308 if (spec
->adc_nids
) {
2309 p
= spec
->stream_analog_capture
;
2311 if (spec
->dyn_adc_switch
)
2312 p
= &dyn_adc_pcm_analog_capture
;
2314 p
= &alc_pcm_analog_capture
;
2316 info
->stream
[SNDRV_PCM_STREAM_CAPTURE
] = *p
;
2317 info
->stream
[SNDRV_PCM_STREAM_CAPTURE
].nid
= spec
->adc_nids
[0];
2320 if (spec
->channel_mode
) {
2321 info
->stream
[SNDRV_PCM_STREAM_PLAYBACK
].channels_max
= 0;
2322 for (i
= 0; i
< spec
->num_channel_mode
; i
++) {
2323 if (spec
->channel_mode
[i
].channels
> info
->stream
[SNDRV_PCM_STREAM_PLAYBACK
].channels_max
) {
2324 info
->stream
[SNDRV_PCM_STREAM_PLAYBACK
].channels_max
= spec
->channel_mode
[i
].channels
;
2330 /* SPDIF for stream index #1 */
2331 if (spec
->multiout
.dig_out_nid
|| spec
->dig_in_nid
) {
2332 snprintf(spec
->stream_name_digital
,
2333 sizeof(spec
->stream_name_digital
),
2334 "%s Digital", codec
->chip_name
);
2335 codec
->num_pcms
= 2;
2336 codec
->slave_dig_outs
= spec
->multiout
.slave_dig_outs
;
2337 info
= spec
->pcm_rec
+ 1;
2338 info
->name
= spec
->stream_name_digital
;
2339 if (spec
->dig_out_type
)
2340 info
->pcm_type
= spec
->dig_out_type
;
2342 info
->pcm_type
= HDA_PCM_TYPE_SPDIF
;
2343 if (spec
->multiout
.dig_out_nid
) {
2344 p
= spec
->stream_digital_playback
;
2346 p
= &alc_pcm_digital_playback
;
2347 info
->stream
[SNDRV_PCM_STREAM_PLAYBACK
] = *p
;
2348 info
->stream
[SNDRV_PCM_STREAM_PLAYBACK
].nid
= spec
->multiout
.dig_out_nid
;
2350 if (spec
->dig_in_nid
) {
2351 p
= spec
->stream_digital_capture
;
2353 p
= &alc_pcm_digital_capture
;
2354 info
->stream
[SNDRV_PCM_STREAM_CAPTURE
] = *p
;
2355 info
->stream
[SNDRV_PCM_STREAM_CAPTURE
].nid
= spec
->dig_in_nid
;
2357 /* FIXME: do we need this for all Realtek codec models? */
2358 codec
->spdif_status_reset
= 1;
2361 if (spec
->no_analog
)
2364 /* If the use of more than one ADC is requested for the current
2365 * model, configure a second analog capture-only PCM.
2367 have_multi_adcs
= (spec
->num_adc_nids
> 1) &&
2368 !spec
->dyn_adc_switch
&& !spec
->auto_mic
&&
2369 (!spec
->input_mux
|| spec
->input_mux
->num_items
> 1);
2370 /* Additional Analaog capture for index #2 */
2371 if (spec
->alt_dac_nid
|| have_multi_adcs
) {
2372 codec
->num_pcms
= 3;
2373 info
= spec
->pcm_rec
+ 2;
2374 info
->name
= spec
->stream_name_analog
;
2375 if (spec
->alt_dac_nid
) {
2376 p
= spec
->stream_analog_alt_playback
;
2378 p
= &alc_pcm_analog_alt_playback
;
2379 info
->stream
[SNDRV_PCM_STREAM_PLAYBACK
] = *p
;
2380 info
->stream
[SNDRV_PCM_STREAM_PLAYBACK
].nid
=
2383 info
->stream
[SNDRV_PCM_STREAM_PLAYBACK
] =
2384 alc_pcm_null_stream
;
2385 info
->stream
[SNDRV_PCM_STREAM_PLAYBACK
].nid
= 0;
2387 if (have_multi_adcs
) {
2388 p
= spec
->stream_analog_alt_capture
;
2390 p
= &alc_pcm_analog_alt_capture
;
2391 info
->stream
[SNDRV_PCM_STREAM_CAPTURE
] = *p
;
2392 info
->stream
[SNDRV_PCM_STREAM_CAPTURE
].nid
=
2394 info
->stream
[SNDRV_PCM_STREAM_CAPTURE
].substreams
=
2395 spec
->num_adc_nids
- 1;
2397 info
->stream
[SNDRV_PCM_STREAM_CAPTURE
] =
2398 alc_pcm_null_stream
;
2399 info
->stream
[SNDRV_PCM_STREAM_CAPTURE
].nid
= 0;
2406 static inline void alc_shutup(struct hda_codec
*codec
)
2408 struct alc_spec
*spec
= codec
->spec
;
2410 if (spec
&& spec
->shutup
)
2411 spec
->shutup(codec
);
2412 snd_hda_shutup_pins(codec
);
2415 static void alc_free_kctls(struct hda_codec
*codec
)
2417 struct alc_spec
*spec
= codec
->spec
;
2419 if (spec
->kctls
.list
) {
2420 struct snd_kcontrol_new
*kctl
= spec
->kctls
.list
;
2422 for (i
= 0; i
< spec
->kctls
.used
; i
++)
2423 kfree(kctl
[i
].name
);
2425 snd_array_free(&spec
->kctls
);
2428 static void alc_free_bind_ctls(struct hda_codec
*codec
)
2430 struct alc_spec
*spec
= codec
->spec
;
2431 if (spec
->bind_ctls
.list
) {
2432 struct hda_bind_ctls
**ctl
= spec
->bind_ctls
.list
;
2434 for (i
= 0; i
< spec
->bind_ctls
.used
; i
++)
2437 snd_array_free(&spec
->bind_ctls
);
2440 static void alc_free(struct hda_codec
*codec
)
2442 struct alc_spec
*spec
= codec
->spec
;
2448 alc_free_kctls(codec
);
2449 alc_free_bind_ctls(codec
);
2451 snd_hda_detach_beep_device(codec
);
2454 #ifdef CONFIG_SND_HDA_POWER_SAVE
2455 static void alc_power_eapd(struct hda_codec
*codec
)
2457 alc_auto_setup_eapd(codec
, false);
2460 static int alc_suspend(struct hda_codec
*codec
, pm_message_t state
)
2462 struct alc_spec
*spec
= codec
->spec
;
2464 if (spec
&& spec
->power_hook
)
2465 spec
->power_hook(codec
);
2471 static int alc_resume(struct hda_codec
*codec
)
2473 msleep(150); /* to avoid pop noise */
2474 codec
->patch_ops
.init(codec
);
2475 snd_hda_codec_resume_amp(codec
);
2476 snd_hda_codec_resume_cache(codec
);
2477 hda_call_check_power_status(codec
, 0x01);
2484 static const struct hda_codec_ops alc_patch_ops
= {
2485 .build_controls
= alc_build_controls
,
2486 .build_pcms
= alc_build_pcms
,
2489 .unsol_event
= alc_unsol_event
,
2491 .resume
= alc_resume
,
2493 #ifdef CONFIG_SND_HDA_POWER_SAVE
2494 .suspend
= alc_suspend
,
2495 .check_power_status
= alc_check_power_status
,
2497 .reboot_notify
= alc_shutup
,
2500 /* replace the codec chip_name with the given string */
2501 static int alc_codec_rename(struct hda_codec
*codec
, const char *name
)
2503 kfree(codec
->chip_name
);
2504 codec
->chip_name
= kstrdup(name
, GFP_KERNEL
);
2505 if (!codec
->chip_name
) {
2513 * Rename codecs appropriately from COEF value
2515 struct alc_codec_rename_table
{
2516 unsigned int vendor_id
;
2517 unsigned short coef_mask
;
2518 unsigned short coef_bits
;
2522 static struct alc_codec_rename_table rename_tbl
[] = {
2523 { 0x10ec0269, 0xfff0, 0x3010, "ALC277" },
2524 { 0x10ec0269, 0xf0f0, 0x2010, "ALC259" },
2525 { 0x10ec0269, 0xf0f0, 0x3010, "ALC258" },
2526 { 0x10ec0269, 0x00f0, 0x0010, "ALC269VB" },
2527 { 0x10ec0269, 0xffff, 0xa023, "ALC259" },
2528 { 0x10ec0269, 0xffff, 0x6023, "ALC281X" },
2529 { 0x10ec0269, 0x00f0, 0x0020, "ALC269VC" },
2530 { 0x10ec0887, 0x00f0, 0x0030, "ALC887-VD" },
2531 { 0x10ec0888, 0x00f0, 0x0030, "ALC888-VD" },
2532 { 0x10ec0888, 0xf0f0, 0x3020, "ALC886" },
2533 { 0x10ec0899, 0x2000, 0x2000, "ALC899" },
2534 { 0x10ec0892, 0xffff, 0x8020, "ALC661" },
2535 { 0x10ec0892, 0xffff, 0x8011, "ALC661" },
2536 { 0x10ec0892, 0xffff, 0x4011, "ALC656" },
2537 { } /* terminator */
2540 static int alc_codec_rename_from_preset(struct hda_codec
*codec
)
2542 const struct alc_codec_rename_table
*p
;
2544 for (p
= rename_tbl
; p
->vendor_id
; p
++) {
2545 if (p
->vendor_id
!= codec
->vendor_id
)
2547 if ((alc_get_coef0(codec
) & p
->coef_mask
) == p
->coef_bits
)
2548 return alc_codec_rename(codec
, p
->name
);
2554 * Automatic parse of I/O pins from the BIOS configuration
2559 ALC_CTL_WIDGET_MUTE
,
2564 static const struct snd_kcontrol_new alc_control_templates
[] = {
2565 HDA_CODEC_VOLUME(NULL
, 0, 0, 0),
2566 HDA_CODEC_MUTE(NULL
, 0, 0, 0),
2567 HDA_BIND_MUTE(NULL
, 0, 0, 0),
2568 HDA_BIND_VOL(NULL
, 0),
2569 HDA_BIND_SW(NULL
, 0),
2572 /* add dynamic controls */
2573 static int add_control(struct alc_spec
*spec
, int type
, const char *name
,
2574 int cidx
, unsigned long val
)
2576 struct snd_kcontrol_new
*knew
;
2578 knew
= alc_kcontrol_new(spec
);
2581 *knew
= alc_control_templates
[type
];
2582 knew
->name
= kstrdup(name
, GFP_KERNEL
);
2586 if (get_amp_nid_(val
))
2587 knew
->subdevice
= HDA_SUBDEV_AMP_FLAG
;
2588 knew
->private_value
= val
;
2592 static int add_control_with_pfx(struct alc_spec
*spec
, int type
,
2593 const char *pfx
, const char *dir
,
2594 const char *sfx
, int cidx
, unsigned long val
)
2597 snprintf(name
, sizeof(name
), "%s %s %s", pfx
, dir
, sfx
);
2598 return add_control(spec
, type
, name
, cidx
, val
);
2601 #define add_pb_vol_ctrl(spec, type, pfx, val) \
2602 add_control_with_pfx(spec, type, pfx, "Playback", "Volume", 0, val)
2603 #define add_pb_sw_ctrl(spec, type, pfx, val) \
2604 add_control_with_pfx(spec, type, pfx, "Playback", "Switch", 0, val)
2605 #define __add_pb_vol_ctrl(spec, type, pfx, cidx, val) \
2606 add_control_with_pfx(spec, type, pfx, "Playback", "Volume", cidx, val)
2607 #define __add_pb_sw_ctrl(spec, type, pfx, cidx, val) \
2608 add_control_with_pfx(spec, type, pfx, "Playback", "Switch", cidx, val)
2610 static const char * const channel_name
[4] = {
2611 "Front", "Surround", "CLFE", "Side"
2614 static const char *alc_get_line_out_pfx(struct alc_spec
*spec
, int ch
,
2615 bool can_be_master
, int *index
)
2617 struct auto_pin_cfg
*cfg
= &spec
->autocfg
;
2620 if (cfg
->line_outs
== 1 && !spec
->multi_ios
&&
2621 !cfg
->hp_outs
&& !cfg
->speaker_outs
&& can_be_master
)
2624 switch (cfg
->line_out_type
) {
2625 case AUTO_PIN_SPEAKER_OUT
:
2626 if (cfg
->line_outs
== 1)
2628 if (cfg
->line_outs
== 2)
2629 return ch
? "Bass Speaker" : "Speaker";
2631 case AUTO_PIN_HP_OUT
:
2632 /* for multi-io case, only the primary out */
2633 if (ch
&& spec
->multi_ios
)
2638 if (cfg
->line_outs
== 1 && !spec
->multi_ios
)
2642 if (snd_BUG_ON(ch
>= ARRAY_SIZE(channel_name
)))
2645 return channel_name
[ch
];
2648 /* create input playback/capture controls for the given pin */
2649 static int new_analog_input(struct alc_spec
*spec
, hda_nid_t pin
,
2650 const char *ctlname
, int ctlidx
,
2651 int idx
, hda_nid_t mix_nid
)
2655 err
= __add_pb_vol_ctrl(spec
, ALC_CTL_WIDGET_VOL
, ctlname
, ctlidx
,
2656 HDA_COMPOSE_AMP_VAL(mix_nid
, 3, idx
, HDA_INPUT
));
2659 err
= __add_pb_sw_ctrl(spec
, ALC_CTL_WIDGET_MUTE
, ctlname
, ctlidx
,
2660 HDA_COMPOSE_AMP_VAL(mix_nid
, 3, idx
, HDA_INPUT
));
2666 static int alc_is_input_pin(struct hda_codec
*codec
, hda_nid_t nid
)
2668 unsigned int pincap
= snd_hda_query_pin_caps(codec
, nid
);
2669 return (pincap
& AC_PINCAP_IN
) != 0;
2672 /* Parse the codec tree and retrieve ADCs and corresponding capsrc MUXs */
2673 static int alc_auto_fill_adc_caps(struct hda_codec
*codec
)
2675 struct alc_spec
*spec
= codec
->spec
;
2677 hda_nid_t
*adc_nids
= spec
->private_adc_nids
;
2678 hda_nid_t
*cap_nids
= spec
->private_capsrc_nids
;
2679 int max_nums
= ARRAY_SIZE(spec
->private_adc_nids
);
2682 if (spec
->shared_mic_hp
)
2683 max_nums
= 1; /* no multi streams with the shared HP/mic */
2685 nid
= codec
->start_nid
;
2686 for (i
= 0; i
< codec
->num_nodes
; i
++, nid
++) {
2688 const hda_nid_t
*list
;
2689 unsigned int caps
= get_wcaps(codec
, nid
);
2690 int type
= get_wcaps_type(caps
);
2692 if (type
!= AC_WID_AUD_IN
|| (caps
& AC_WCAP_DIGITAL
))
2694 adc_nids
[nums
] = nid
;
2695 cap_nids
[nums
] = nid
;
2699 type
= get_wcaps_type(get_wcaps(codec
, src
));
2700 if (type
== AC_WID_PIN
)
2702 if (type
== AC_WID_AUD_SEL
) {
2703 cap_nids
[nums
] = src
;
2706 n
= snd_hda_get_conn_list(codec
, src
, &list
);
2708 cap_nids
[nums
] = src
;
2714 if (++nums
>= max_nums
)
2717 spec
->adc_nids
= spec
->private_adc_nids
;
2718 spec
->capsrc_nids
= spec
->private_capsrc_nids
;
2719 spec
->num_adc_nids
= nums
;
2723 /* create playback/capture controls for input pins */
2724 static int alc_auto_create_input_ctls(struct hda_codec
*codec
)
2726 struct alc_spec
*spec
= codec
->spec
;
2727 const struct auto_pin_cfg
*cfg
= &spec
->autocfg
;
2728 hda_nid_t mixer
= spec
->mixer_nid
;
2729 struct hda_input_mux
*imux
= &spec
->private_imux
[0];
2731 int i
, c
, err
, idx
, type_idx
= 0;
2732 const char *prev_label
= NULL
;
2734 num_adcs
= alc_auto_fill_adc_caps(codec
);
2738 for (i
= 0; i
< cfg
->num_inputs
; i
++) {
2742 pin
= cfg
->inputs
[i
].pin
;
2743 if (!alc_is_input_pin(codec
, pin
))
2746 label
= hda_get_autocfg_input_label(codec
, cfg
, i
);
2747 if (spec
->shared_mic_hp
&& !strcmp(label
, "Misc"))
2748 label
= "Headphone Mic";
2749 if (prev_label
&& !strcmp(label
, prev_label
))
2756 idx
= get_connection_index(codec
, mixer
, pin
);
2758 err
= new_analog_input(spec
, pin
,
2766 for (c
= 0; c
< num_adcs
; c
++) {
2767 hda_nid_t cap
= get_capsrc(spec
, c
);
2768 idx
= get_connection_index(codec
, cap
, pin
);
2770 spec
->imux_pins
[imux
->num_items
] = pin
;
2771 snd_hda_add_imux_item(imux
, label
, idx
, NULL
);
2777 spec
->num_mux_defs
= 1;
2778 spec
->input_mux
= imux
;
2783 /* create a shared input with the headphone out */
2784 static int alc_auto_create_shared_input(struct hda_codec
*codec
)
2786 struct alc_spec
*spec
= codec
->spec
;
2787 struct auto_pin_cfg
*cfg
= &spec
->autocfg
;
2788 unsigned int defcfg
;
2791 /* only one internal input pin? */
2792 if (cfg
->num_inputs
!= 1)
2794 defcfg
= snd_hda_codec_get_pincfg(codec
, cfg
->inputs
[0].pin
);
2795 if (snd_hda_get_input_pin_attr(defcfg
) != INPUT_PIN_ATTR_INT
)
2798 if (cfg
->hp_outs
== 1 && cfg
->line_out_type
== AUTO_PIN_SPEAKER_OUT
)
2799 nid
= cfg
->hp_pins
[0]; /* OK, we have a single HP-out */
2800 else if (cfg
->line_outs
== 1 && cfg
->line_out_type
== AUTO_PIN_HP_OUT
)
2801 nid
= cfg
->line_out_pins
[0]; /* OK, we have a single line-out */
2803 return 0; /* both not available */
2805 if (!(snd_hda_query_pin_caps(codec
, nid
) & AC_PINCAP_IN
))
2806 return 0; /* no input */
2808 cfg
->inputs
[1].pin
= nid
;
2809 cfg
->inputs
[1].type
= AUTO_PIN_MIC
;
2810 cfg
->num_inputs
= 2;
2811 spec
->shared_mic_hp
= 1;
2812 snd_printdd("realtek: Enable shared I/O jack on NID 0x%x\n", nid
);
2816 static void alc_set_pin_output(struct hda_codec
*codec
, hda_nid_t nid
,
2817 unsigned int pin_type
)
2819 snd_hda_codec_write(codec
, nid
, 0, AC_VERB_SET_PIN_WIDGET_CONTROL
,
2822 if (nid_has_mute(codec
, nid
, HDA_OUTPUT
))
2823 snd_hda_codec_write(codec
, nid
, 0, AC_VERB_SET_AMP_GAIN_MUTE
,
2827 static int get_pin_type(int line_out_type
)
2829 if (line_out_type
== AUTO_PIN_HP_OUT
)
2835 static void alc_auto_init_analog_input(struct hda_codec
*codec
)
2837 struct alc_spec
*spec
= codec
->spec
;
2838 struct auto_pin_cfg
*cfg
= &spec
->autocfg
;
2841 for (i
= 0; i
< cfg
->num_inputs
; i
++) {
2842 hda_nid_t nid
= cfg
->inputs
[i
].pin
;
2843 if (alc_is_input_pin(codec
, nid
)) {
2844 alc_set_input_pin(codec
, nid
, cfg
->inputs
[i
].type
);
2845 if (get_wcaps(codec
, nid
) & AC_WCAP_OUT_AMP
)
2846 snd_hda_codec_write(codec
, nid
, 0,
2847 AC_VERB_SET_AMP_GAIN_MUTE
,
2852 /* mute all loopback inputs */
2853 if (spec
->mixer_nid
) {
2854 int nums
= snd_hda_get_conn_list(codec
, spec
->mixer_nid
, NULL
);
2855 for (i
= 0; i
< nums
; i
++)
2856 snd_hda_codec_write(codec
, spec
->mixer_nid
, 0,
2857 AC_VERB_SET_AMP_GAIN_MUTE
,
2862 /* convert from MIX nid to DAC */
2863 static hda_nid_t
alc_auto_mix_to_dac(struct hda_codec
*codec
, hda_nid_t nid
)
2868 if (get_wcaps_type(get_wcaps(codec
, nid
)) == AC_WID_AUD_OUT
)
2870 num
= snd_hda_get_connections(codec
, nid
, list
, ARRAY_SIZE(list
));
2871 for (i
= 0; i
< num
; i
++) {
2872 if (get_wcaps_type(get_wcaps(codec
, list
[i
])) == AC_WID_AUD_OUT
)
2878 /* go down to the selector widget before the mixer */
2879 static hda_nid_t
alc_go_down_to_selector(struct hda_codec
*codec
, hda_nid_t pin
)
2882 int num
= snd_hda_get_connections(codec
, pin
, srcs
,
2885 get_wcaps_type(get_wcaps(codec
, srcs
[0])) != AC_WID_AUD_SEL
)
2890 /* get MIX nid connected to the given pin targeted to DAC */
2891 static hda_nid_t
alc_auto_dac_to_mix(struct hda_codec
*codec
, hda_nid_t pin
,
2897 pin
= alc_go_down_to_selector(codec
, pin
);
2898 num
= snd_hda_get_connections(codec
, pin
, mix
, ARRAY_SIZE(mix
));
2899 for (i
= 0; i
< num
; i
++) {
2900 if (alc_auto_mix_to_dac(codec
, mix
[i
]) == dac
)
2906 /* select the connection from pin to DAC if needed */
2907 static int alc_auto_select_dac(struct hda_codec
*codec
, hda_nid_t pin
,
2913 pin
= alc_go_down_to_selector(codec
, pin
);
2914 num
= snd_hda_get_connections(codec
, pin
, mix
, ARRAY_SIZE(mix
));
2917 for (i
= 0; i
< num
; i
++) {
2918 if (alc_auto_mix_to_dac(codec
, mix
[i
]) == dac
) {
2919 snd_hda_codec_update_cache(codec
, pin
, 0,
2920 AC_VERB_SET_CONNECT_SEL
, i
);
2927 /* look for an empty DAC slot */
2928 static hda_nid_t
alc_auto_look_for_dac(struct hda_codec
*codec
, hda_nid_t pin
)
2930 struct alc_spec
*spec
= codec
->spec
;
2934 pin
= alc_go_down_to_selector(codec
, pin
);
2935 num
= snd_hda_get_connections(codec
, pin
, srcs
, ARRAY_SIZE(srcs
));
2936 for (i
= 0; i
< num
; i
++) {
2937 hda_nid_t nid
= alc_auto_mix_to_dac(codec
, srcs
[i
]);
2940 if (found_in_nid_list(nid
, spec
->multiout
.dac_nids
,
2941 ARRAY_SIZE(spec
->private_dac_nids
)))
2943 if (found_in_nid_list(nid
, spec
->multiout
.hp_out_nid
,
2944 ARRAY_SIZE(spec
->multiout
.hp_out_nid
)))
2946 if (found_in_nid_list(nid
, spec
->multiout
.extra_out_nid
,
2947 ARRAY_SIZE(spec
->multiout
.extra_out_nid
)))
2954 /* check whether the DAC is reachable from the pin */
2955 static bool alc_auto_is_dac_reachable(struct hda_codec
*codec
,
2956 hda_nid_t pin
, hda_nid_t dac
)
2961 pin
= alc_go_down_to_selector(codec
, pin
);
2962 num
= snd_hda_get_connections(codec
, pin
, srcs
, ARRAY_SIZE(srcs
));
2963 for (i
= 0; i
< num
; i
++) {
2964 hda_nid_t nid
= alc_auto_mix_to_dac(codec
, srcs
[i
]);
2971 static hda_nid_t
get_dac_if_single(struct hda_codec
*codec
, hda_nid_t pin
)
2973 hda_nid_t sel
= alc_go_down_to_selector(codec
, pin
);
2974 if (snd_hda_get_conn_list(codec
, sel
, NULL
) == 1)
2975 return alc_auto_look_for_dac(codec
, pin
);
2979 /* return 0 if no possible DAC is found, 1 if one or more found */
2980 static int alc_auto_fill_extra_dacs(struct hda_codec
*codec
, int num_outs
,
2981 const hda_nid_t
*pins
, hda_nid_t
*dacs
)
2985 if (num_outs
&& !dacs
[0]) {
2986 dacs
[0] = alc_auto_look_for_dac(codec
, pins
[0]);
2991 for (i
= 1; i
< num_outs
; i
++)
2992 dacs
[i
] = get_dac_if_single(codec
, pins
[i
]);
2993 for (i
= 1; i
< num_outs
; i
++) {
2995 dacs
[i
] = alc_auto_look_for_dac(codec
, pins
[i
]);
3000 static int alc_auto_fill_multi_ios(struct hda_codec
*codec
,
3001 unsigned int location
, int offset
);
3002 static hda_nid_t
alc_look_for_out_vol_nid(struct hda_codec
*codec
,
3003 hda_nid_t pin
, hda_nid_t dac
);
3005 /* fill in the dac_nids table from the parsed pin configuration */
3006 static int alc_auto_fill_dac_nids(struct hda_codec
*codec
)
3008 struct alc_spec
*spec
= codec
->spec
;
3009 struct auto_pin_cfg
*cfg
= &spec
->autocfg
;
3010 unsigned int location
, defcfg
;
3012 bool redone
= false;
3016 /* set num_dacs once to full for alc_auto_look_for_dac() */
3017 spec
->multiout
.num_dacs
= cfg
->line_outs
;
3018 spec
->multiout
.hp_out_nid
[0] = 0;
3019 spec
->multiout
.extra_out_nid
[0] = 0;
3020 memset(spec
->private_dac_nids
, 0, sizeof(spec
->private_dac_nids
));
3021 spec
->multiout
.dac_nids
= spec
->private_dac_nids
;
3022 spec
->multi_ios
= 0;
3024 /* fill hard-wired DACs first */
3026 for (i
= 0; i
< cfg
->line_outs
; i
++)
3027 spec
->private_dac_nids
[i
] =
3028 get_dac_if_single(codec
, cfg
->line_out_pins
[i
]);
3030 spec
->multiout
.hp_out_nid
[0] =
3031 get_dac_if_single(codec
, cfg
->hp_pins
[0]);
3032 if (cfg
->speaker_outs
)
3033 spec
->multiout
.extra_out_nid
[0] =
3034 get_dac_if_single(codec
, cfg
->speaker_pins
[0]);
3037 for (i
= 0; i
< cfg
->line_outs
; i
++) {
3038 hda_nid_t pin
= cfg
->line_out_pins
[i
];
3039 if (spec
->private_dac_nids
[i
])
3041 spec
->private_dac_nids
[i
] = alc_auto_look_for_dac(codec
, pin
);
3042 if (!spec
->private_dac_nids
[i
] && !redone
) {
3043 /* if we can't find primary DACs, re-probe without
3044 * checking the hard-wired DACs
3051 /* re-count num_dacs and squash invalid entries */
3052 spec
->multiout
.num_dacs
= 0;
3053 for (i
= 0; i
< cfg
->line_outs
; i
++) {
3054 if (spec
->private_dac_nids
[i
])
3055 spec
->multiout
.num_dacs
++;
3057 memmove(spec
->private_dac_nids
+ i
,
3058 spec
->private_dac_nids
+ i
+ 1,
3059 sizeof(hda_nid_t
) * (cfg
->line_outs
- i
- 1));
3060 spec
->private_dac_nids
[cfg
->line_outs
- 1] = 0;
3064 if (cfg
->line_outs
== 1 && cfg
->line_out_type
!= AUTO_PIN_SPEAKER_OUT
) {
3065 /* try to fill multi-io first */
3066 defcfg
= snd_hda_codec_get_pincfg(codec
, cfg
->line_out_pins
[0]);
3067 location
= get_defcfg_location(defcfg
);
3069 num_pins
= alc_auto_fill_multi_ios(codec
, location
, 0);
3071 spec
->multi_ios
= num_pins
;
3072 spec
->ext_channel_count
= 2;
3073 spec
->multiout
.num_dacs
= num_pins
+ 1;
3077 if (cfg
->line_out_type
!= AUTO_PIN_HP_OUT
)
3078 alc_auto_fill_extra_dacs(codec
, cfg
->hp_outs
, cfg
->hp_pins
,
3079 spec
->multiout
.hp_out_nid
);
3080 if (cfg
->line_out_type
!= AUTO_PIN_SPEAKER_OUT
) {
3081 int err
= alc_auto_fill_extra_dacs(codec
, cfg
->speaker_outs
,
3083 spec
->multiout
.extra_out_nid
);
3084 /* if no speaker volume is assigned, try again as the primary
3087 if (!err
&& cfg
->speaker_outs
> 0 &&
3088 cfg
->line_out_type
== AUTO_PIN_HP_OUT
) {
3089 cfg
->hp_outs
= cfg
->line_outs
;
3090 memcpy(cfg
->hp_pins
, cfg
->line_out_pins
,
3091 sizeof(cfg
->hp_pins
));
3092 cfg
->line_outs
= cfg
->speaker_outs
;
3093 memcpy(cfg
->line_out_pins
, cfg
->speaker_pins
,
3094 sizeof(cfg
->speaker_pins
));
3095 cfg
->speaker_outs
= 0;
3096 memset(cfg
->speaker_pins
, 0, sizeof(cfg
->speaker_pins
));
3097 cfg
->line_out_type
= AUTO_PIN_SPEAKER_OUT
;
3103 if (!spec
->multi_ios
&&
3104 cfg
->line_out_type
== AUTO_PIN_SPEAKER_OUT
&&
3106 /* try multi-ios with HP + inputs */
3107 defcfg
= snd_hda_codec_get_pincfg(codec
, cfg
->hp_pins
[0]);
3108 location
= get_defcfg_location(defcfg
);
3110 num_pins
= alc_auto_fill_multi_ios(codec
, location
, 1);
3112 spec
->multi_ios
= num_pins
;
3113 spec
->ext_channel_count
= 2;
3114 spec
->multiout
.num_dacs
= num_pins
+ 1;
3118 if (cfg
->line_out_pins
[0])
3120 alc_look_for_out_vol_nid(codec
, cfg
->line_out_pins
[0],
3121 spec
->multiout
.dac_nids
[0]);
3125 static inline unsigned int get_ctl_pos(unsigned int data
)
3127 hda_nid_t nid
= get_amp_nid_(data
);
3128 unsigned int dir
= get_amp_direction_(data
);
3129 return (nid
<< 1) | dir
;
3132 #define is_ctl_used(bits, data) \
3133 test_bit(get_ctl_pos(data), bits)
3134 #define mark_ctl_usage(bits, data) \
3135 set_bit(get_ctl_pos(data), bits)
3137 static int alc_auto_add_vol_ctl(struct hda_codec
*codec
,
3138 const char *pfx
, int cidx
,
3139 hda_nid_t nid
, unsigned int chs
)
3141 struct alc_spec
*spec
= codec
->spec
;
3145 val
= HDA_COMPOSE_AMP_VAL(nid
, chs
, 0, HDA_OUTPUT
);
3146 if (is_ctl_used(spec
->vol_ctls
, val
) && chs
!= 2) /* exclude LFE */
3148 mark_ctl_usage(spec
->vol_ctls
, val
);
3149 return __add_pb_vol_ctrl(codec
->spec
, ALC_CTL_WIDGET_VOL
, pfx
, cidx
,
3153 static int alc_auto_add_stereo_vol(struct hda_codec
*codec
,
3154 const char *pfx
, int cidx
,
3158 if (get_wcaps(codec
, nid
) & AC_WCAP_STEREO
)
3160 return alc_auto_add_vol_ctl(codec
, pfx
, cidx
, nid
, chs
);
3163 /* create a mute-switch for the given mixer widget;
3164 * if it has multiple sources (e.g. DAC and loopback), create a bind-mute
3166 static int alc_auto_add_sw_ctl(struct hda_codec
*codec
,
3167 const char *pfx
, int cidx
,
3168 hda_nid_t nid
, unsigned int chs
)
3170 struct alc_spec
*spec
= codec
->spec
;
3176 wid_type
= get_wcaps_type(get_wcaps(codec
, nid
));
3177 if (wid_type
== AC_WID_PIN
|| wid_type
== AC_WID_AUD_OUT
) {
3178 type
= ALC_CTL_WIDGET_MUTE
;
3179 val
= HDA_COMPOSE_AMP_VAL(nid
, chs
, 0, HDA_OUTPUT
);
3180 } else if (snd_hda_get_conn_list(codec
, nid
, NULL
) == 1) {
3181 type
= ALC_CTL_WIDGET_MUTE
;
3182 val
= HDA_COMPOSE_AMP_VAL(nid
, chs
, 0, HDA_INPUT
);
3184 type
= ALC_CTL_BIND_MUTE
;
3185 val
= HDA_COMPOSE_AMP_VAL(nid
, chs
, 2, HDA_INPUT
);
3187 if (is_ctl_used(spec
->sw_ctls
, val
) && chs
!= 2) /* exclude LFE */
3189 mark_ctl_usage(spec
->sw_ctls
, val
);
3190 return __add_pb_sw_ctrl(codec
->spec
, type
, pfx
, cidx
, val
);
3193 static int alc_auto_add_stereo_sw(struct hda_codec
*codec
, const char *pfx
,
3194 int cidx
, hda_nid_t nid
)
3197 if (get_wcaps(codec
, nid
) & AC_WCAP_STEREO
)
3199 return alc_auto_add_sw_ctl(codec
, pfx
, cidx
, nid
, chs
);
3202 static hda_nid_t
alc_look_for_out_mute_nid(struct hda_codec
*codec
,
3203 hda_nid_t pin
, hda_nid_t dac
)
3205 hda_nid_t mix
= alc_auto_dac_to_mix(codec
, pin
, dac
);
3206 if (nid_has_mute(codec
, pin
, HDA_OUTPUT
))
3208 else if (mix
&& nid_has_mute(codec
, mix
, HDA_INPUT
))
3210 else if (nid_has_mute(codec
, dac
, HDA_OUTPUT
))
3215 static hda_nid_t
alc_look_for_out_vol_nid(struct hda_codec
*codec
,
3216 hda_nid_t pin
, hda_nid_t dac
)
3218 hda_nid_t mix
= alc_auto_dac_to_mix(codec
, pin
, dac
);
3219 if (nid_has_volume(codec
, dac
, HDA_OUTPUT
))
3221 else if (nid_has_volume(codec
, mix
, HDA_OUTPUT
))
3223 else if (nid_has_volume(codec
, pin
, HDA_OUTPUT
))
3228 /* add playback controls from the parsed DAC table */
3229 static int alc_auto_create_multi_out_ctls(struct hda_codec
*codec
,
3230 const struct auto_pin_cfg
*cfg
)
3232 struct alc_spec
*spec
= codec
->spec
;
3233 int i
, err
, noutputs
;
3235 noutputs
= cfg
->line_outs
;
3236 if (spec
->multi_ios
> 0 && cfg
->line_outs
< 3)
3237 noutputs
+= spec
->multi_ios
;
3239 for (i
= 0; i
< noutputs
; i
++) {
3245 dac
= spec
->multiout
.dac_nids
[i
];
3248 if (i
>= cfg
->line_outs
)
3249 pin
= spec
->multi_io
[i
- 1].pin
;
3251 pin
= cfg
->line_out_pins
[i
];
3253 sw
= alc_look_for_out_mute_nid(codec
, pin
, dac
);
3254 vol
= alc_look_for_out_vol_nid(codec
, pin
, dac
);
3255 name
= alc_get_line_out_pfx(spec
, i
, true, &index
);
3256 if (!name
|| !strcmp(name
, "CLFE")) {
3258 err
= alc_auto_add_vol_ctl(codec
, "Center", 0, vol
, 1);
3261 err
= alc_auto_add_vol_ctl(codec
, "LFE", 0, vol
, 2);
3264 err
= alc_auto_add_sw_ctl(codec
, "Center", 0, sw
, 1);
3267 err
= alc_auto_add_sw_ctl(codec
, "LFE", 0, sw
, 2);
3271 err
= alc_auto_add_stereo_vol(codec
, name
, index
, vol
);
3274 err
= alc_auto_add_stereo_sw(codec
, name
, index
, sw
);
3282 static int alc_auto_create_extra_out(struct hda_codec
*codec
, hda_nid_t pin
,
3283 hda_nid_t dac
, const char *pfx
,
3286 struct alc_spec
*spec
= codec
->spec
;
3292 /* the corresponding DAC is already occupied */
3293 if (!(get_wcaps(codec
, pin
) & AC_WCAP_OUT_AMP
))
3294 return 0; /* no way */
3295 /* create a switch only */
3296 val
= HDA_COMPOSE_AMP_VAL(pin
, 3, 0, HDA_OUTPUT
);
3297 if (is_ctl_used(spec
->sw_ctls
, val
))
3298 return 0; /* already created */
3299 mark_ctl_usage(spec
->sw_ctls
, val
);
3300 return __add_pb_sw_ctrl(spec
, ALC_CTL_WIDGET_MUTE
, pfx
, cidx
, val
);
3303 sw
= alc_look_for_out_mute_nid(codec
, pin
, dac
);
3304 vol
= alc_look_for_out_vol_nid(codec
, pin
, dac
);
3305 err
= alc_auto_add_stereo_vol(codec
, pfx
, cidx
, vol
);
3308 err
= alc_auto_add_stereo_sw(codec
, pfx
, cidx
, sw
);
3314 static struct hda_bind_ctls
*new_bind_ctl(struct hda_codec
*codec
,
3316 struct hda_ctl_ops
*ops
)
3318 struct alc_spec
*spec
= codec
->spec
;
3319 struct hda_bind_ctls
**ctlp
, *ctl
;
3320 snd_array_init(&spec
->bind_ctls
, sizeof(ctl
), 8);
3321 ctlp
= snd_array_new(&spec
->bind_ctls
);
3324 ctl
= kzalloc(sizeof(*ctl
) + sizeof(long) * (nums
+ 1), GFP_KERNEL
);
3331 /* add playback controls for speaker and HP outputs */
3332 static int alc_auto_create_extra_outs(struct hda_codec
*codec
, int num_pins
,
3333 const hda_nid_t
*pins
,
3334 const hda_nid_t
*dacs
,
3337 struct alc_spec
*spec
= codec
->spec
;
3338 struct hda_bind_ctls
*ctl
;
3342 if (!num_pins
|| !pins
[0])
3345 if (num_pins
== 1) {
3346 hda_nid_t dac
= *dacs
;
3348 dac
= spec
->multiout
.dac_nids
[0];
3349 return alc_auto_create_extra_out(codec
, *pins
, dac
, pfx
, 0);
3352 if (dacs
[num_pins
- 1]) {
3353 /* OK, we have a multi-output system with individual volumes */
3354 for (i
= 0; i
< num_pins
; i
++) {
3355 if (num_pins
>= 3) {
3356 snprintf(name
, sizeof(name
), "%s %s",
3357 pfx
, channel_name
[i
]);
3358 err
= alc_auto_create_extra_out(codec
, pins
[i
], dacs
[i
],
3361 err
= alc_auto_create_extra_out(codec
, pins
[i
], dacs
[i
],
3370 /* Let's create a bind-controls */
3371 ctl
= new_bind_ctl(codec
, num_pins
, &snd_hda_bind_sw
);
3375 for (i
= 0; i
< num_pins
; i
++) {
3376 if (get_wcaps(codec
, pins
[i
]) & AC_WCAP_OUT_AMP
)
3378 HDA_COMPOSE_AMP_VAL(pins
[i
], 3, 0, HDA_OUTPUT
);
3381 snprintf(name
, sizeof(name
), "%s Playback Switch", pfx
);
3382 err
= add_control(spec
, ALC_CTL_BIND_SW
, name
, 0, (long)ctl
);
3387 ctl
= new_bind_ctl(codec
, num_pins
, &snd_hda_bind_vol
);
3391 for (i
= 0; i
< num_pins
; i
++) {
3393 if (!pins
[i
] || !dacs
[i
])
3395 vol
= alc_look_for_out_vol_nid(codec
, pins
[i
], dacs
[i
]);
3398 HDA_COMPOSE_AMP_VAL(vol
, 3, 0, HDA_OUTPUT
);
3401 snprintf(name
, sizeof(name
), "%s Playback Volume", pfx
);
3402 err
= add_control(spec
, ALC_CTL_BIND_VOL
, name
, 0, (long)ctl
);
3409 static int alc_auto_create_hp_out(struct hda_codec
*codec
)
3411 struct alc_spec
*spec
= codec
->spec
;
3412 return alc_auto_create_extra_outs(codec
, spec
->autocfg
.hp_outs
,
3413 spec
->autocfg
.hp_pins
,
3414 spec
->multiout
.hp_out_nid
,
3418 static int alc_auto_create_speaker_out(struct hda_codec
*codec
)
3420 struct alc_spec
*spec
= codec
->spec
;
3421 return alc_auto_create_extra_outs(codec
, spec
->autocfg
.speaker_outs
,
3422 spec
->autocfg
.speaker_pins
,
3423 spec
->multiout
.extra_out_nid
,
3427 static void alc_auto_set_output_and_unmute(struct hda_codec
*codec
,
3428 hda_nid_t pin
, int pin_type
,
3432 hda_nid_t nid
, mix
= 0;
3433 hda_nid_t srcs
[HDA_MAX_CONNECTIONS
];
3435 alc_set_pin_output(codec
, pin
, pin_type
);
3436 nid
= alc_go_down_to_selector(codec
, pin
);
3437 num
= snd_hda_get_connections(codec
, nid
, srcs
, ARRAY_SIZE(srcs
));
3438 for (i
= 0; i
< num
; i
++) {
3439 if (alc_auto_mix_to_dac(codec
, srcs
[i
]) != dac
)
3447 /* need the manual connection? */
3449 snd_hda_codec_write(codec
, nid
, 0, AC_VERB_SET_CONNECT_SEL
, i
);
3450 /* unmute mixer widget inputs */
3451 if (nid_has_mute(codec
, mix
, HDA_INPUT
)) {
3452 snd_hda_codec_write(codec
, mix
, 0, AC_VERB_SET_AMP_GAIN_MUTE
,
3454 snd_hda_codec_write(codec
, mix
, 0, AC_VERB_SET_AMP_GAIN_MUTE
,
3457 /* initialize volume */
3458 nid
= alc_look_for_out_vol_nid(codec
, pin
, dac
);
3460 snd_hda_codec_write(codec
, nid
, 0, AC_VERB_SET_AMP_GAIN_MUTE
,
3463 /* unmute DAC if it's not assigned to a mixer */
3464 nid
= alc_look_for_out_mute_nid(codec
, pin
, dac
);
3465 if (nid
== mix
&& nid_has_mute(codec
, dac
, HDA_OUTPUT
))
3466 snd_hda_codec_write(codec
, dac
, 0, AC_VERB_SET_AMP_GAIN_MUTE
,
3470 static void alc_auto_init_multi_out(struct hda_codec
*codec
)
3472 struct alc_spec
*spec
= codec
->spec
;
3473 int pin_type
= get_pin_type(spec
->autocfg
.line_out_type
);
3476 for (i
= 0; i
<= HDA_SIDE
; i
++) {
3477 hda_nid_t nid
= spec
->autocfg
.line_out_pins
[i
];
3479 alc_auto_set_output_and_unmute(codec
, nid
, pin_type
,
3480 spec
->multiout
.dac_nids
[i
]);
3484 static void alc_auto_init_extra_out(struct hda_codec
*codec
)
3486 struct alc_spec
*spec
= codec
->spec
;
3490 for (i
= 0; i
< spec
->autocfg
.hp_outs
; i
++) {
3491 if (spec
->autocfg
.line_out_type
== AUTO_PIN_HP_OUT
)
3493 pin
= spec
->autocfg
.hp_pins
[i
];
3496 dac
= spec
->multiout
.hp_out_nid
[i
];
3498 if (i
> 0 && spec
->multiout
.hp_out_nid
[0])
3499 dac
= spec
->multiout
.hp_out_nid
[0];
3501 dac
= spec
->multiout
.dac_nids
[0];
3503 alc_auto_set_output_and_unmute(codec
, pin
, PIN_HP
, dac
);
3505 for (i
= 0; i
< spec
->autocfg
.speaker_outs
; i
++) {
3506 if (spec
->autocfg
.line_out_type
== AUTO_PIN_SPEAKER_OUT
)
3508 pin
= spec
->autocfg
.speaker_pins
[i
];
3511 dac
= spec
->multiout
.extra_out_nid
[i
];
3513 if (i
> 0 && spec
->multiout
.extra_out_nid
[0])
3514 dac
= spec
->multiout
.extra_out_nid
[0];
3516 dac
= spec
->multiout
.dac_nids
[0];
3518 alc_auto_set_output_and_unmute(codec
, pin
, PIN_OUT
, dac
);
3525 static int alc_auto_fill_multi_ios(struct hda_codec
*codec
,
3526 unsigned int location
,
3529 struct alc_spec
*spec
= codec
->spec
;
3530 struct auto_pin_cfg
*cfg
= &spec
->autocfg
;
3531 hda_nid_t prime_dac
= spec
->private_dac_nids
[0];
3532 int type
, i
, dacs
, num_pins
= 0;
3534 dacs
= spec
->multiout
.num_dacs
;
3535 for (type
= AUTO_PIN_LINE_IN
; type
>= AUTO_PIN_MIC
; type
--) {
3536 for (i
= 0; i
< cfg
->num_inputs
; i
++) {
3537 hda_nid_t nid
= cfg
->inputs
[i
].pin
;
3539 unsigned int defcfg
, caps
;
3540 if (cfg
->inputs
[i
].type
!= type
)
3542 defcfg
= snd_hda_codec_get_pincfg(codec
, nid
);
3543 if (get_defcfg_connect(defcfg
) != AC_JACK_PORT_COMPLEX
)
3545 if (location
&& get_defcfg_location(defcfg
) != location
)
3547 caps
= snd_hda_query_pin_caps(codec
, nid
);
3548 if (!(caps
& AC_PINCAP_OUT
))
3550 if (offset
&& offset
+ num_pins
< dacs
) {
3551 dac
= spec
->private_dac_nids
[offset
+ num_pins
];
3552 if (!alc_auto_is_dac_reachable(codec
, nid
, dac
))
3556 dac
= alc_auto_look_for_dac(codec
, nid
);
3559 spec
->multi_io
[num_pins
].pin
= nid
;
3560 spec
->multi_io
[num_pins
].dac
= dac
;
3562 spec
->private_dac_nids
[spec
->multiout
.num_dacs
++] = dac
;
3565 spec
->multiout
.num_dacs
= dacs
;
3567 /* clear up again */
3568 memset(spec
->private_dac_nids
+ dacs
, 0,
3569 sizeof(hda_nid_t
) * (AUTO_CFG_MAX_OUTS
- dacs
));
3570 spec
->private_dac_nids
[0] = prime_dac
;
3576 static int alc_auto_ch_mode_info(struct snd_kcontrol
*kcontrol
,
3577 struct snd_ctl_elem_info
*uinfo
)
3579 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
3580 struct alc_spec
*spec
= codec
->spec
;
3582 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_ENUMERATED
;
3584 uinfo
->value
.enumerated
.items
= spec
->multi_ios
+ 1;
3585 if (uinfo
->value
.enumerated
.item
> spec
->multi_ios
)
3586 uinfo
->value
.enumerated
.item
= spec
->multi_ios
;
3587 sprintf(uinfo
->value
.enumerated
.name
, "%dch",
3588 (uinfo
->value
.enumerated
.item
+ 1) * 2);
3592 static int alc_auto_ch_mode_get(struct snd_kcontrol
*kcontrol
,
3593 struct snd_ctl_elem_value
*ucontrol
)
3595 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
3596 struct alc_spec
*spec
= codec
->spec
;
3597 ucontrol
->value
.enumerated
.item
[0] = (spec
->ext_channel_count
- 1) / 2;
3601 static int alc_set_multi_io(struct hda_codec
*codec
, int idx
, bool output
)
3603 struct alc_spec
*spec
= codec
->spec
;
3604 hda_nid_t nid
= spec
->multi_io
[idx
].pin
;
3606 if (!spec
->multi_io
[idx
].ctl_in
)
3607 spec
->multi_io
[idx
].ctl_in
=
3608 snd_hda_codec_read(codec
, nid
, 0,
3609 AC_VERB_GET_PIN_WIDGET_CONTROL
, 0);
3611 snd_hda_codec_update_cache(codec
, nid
, 0,
3612 AC_VERB_SET_PIN_WIDGET_CONTROL
,
3614 if (get_wcaps(codec
, nid
) & AC_WCAP_OUT_AMP
)
3615 snd_hda_codec_amp_stereo(codec
, nid
, HDA_OUTPUT
, 0,
3617 alc_auto_select_dac(codec
, nid
, spec
->multi_io
[idx
].dac
);
3619 if (get_wcaps(codec
, nid
) & AC_WCAP_OUT_AMP
)
3620 snd_hda_codec_amp_stereo(codec
, nid
, HDA_OUTPUT
, 0,
3621 HDA_AMP_MUTE
, HDA_AMP_MUTE
);
3622 snd_hda_codec_update_cache(codec
, nid
, 0,
3623 AC_VERB_SET_PIN_WIDGET_CONTROL
,
3624 spec
->multi_io
[idx
].ctl_in
);
3629 static int alc_auto_ch_mode_put(struct snd_kcontrol
*kcontrol
,
3630 struct snd_ctl_elem_value
*ucontrol
)
3632 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
3633 struct alc_spec
*spec
= codec
->spec
;
3636 ch
= ucontrol
->value
.enumerated
.item
[0];
3637 if (ch
< 0 || ch
> spec
->multi_ios
)
3639 if (ch
== (spec
->ext_channel_count
- 1) / 2)
3641 spec
->ext_channel_count
= (ch
+ 1) * 2;
3642 for (i
= 0; i
< spec
->multi_ios
; i
++)
3643 alc_set_multi_io(codec
, i
, i
< ch
);
3644 spec
->multiout
.max_channels
= spec
->ext_channel_count
;
3645 if (spec
->need_dac_fix
&& !spec
->const_channel_count
)
3646 spec
->multiout
.num_dacs
= spec
->multiout
.max_channels
/ 2;
3650 static const struct snd_kcontrol_new alc_auto_channel_mode_enum
= {
3651 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
3652 .name
= "Channel Mode",
3653 .info
= alc_auto_ch_mode_info
,
3654 .get
= alc_auto_ch_mode_get
,
3655 .put
= alc_auto_ch_mode_put
,
3658 static int alc_auto_add_multi_channel_mode(struct hda_codec
*codec
)
3660 struct alc_spec
*spec
= codec
->spec
;
3662 if (spec
->multi_ios
> 0) {
3663 struct snd_kcontrol_new
*knew
;
3665 knew
= alc_kcontrol_new(spec
);
3668 *knew
= alc_auto_channel_mode_enum
;
3669 knew
->name
= kstrdup("Channel Mode", GFP_KERNEL
);
3676 /* filter out invalid adc_nids (and capsrc_nids) that don't give all
3679 static void alc_remove_invalid_adc_nids(struct hda_codec
*codec
)
3681 struct alc_spec
*spec
= codec
->spec
;
3682 const struct hda_input_mux
*imux
;
3683 hda_nid_t adc_nids
[ARRAY_SIZE(spec
->private_adc_nids
)];
3684 hda_nid_t capsrc_nids
[ARRAY_SIZE(spec
->private_adc_nids
)];
3687 imux
= spec
->input_mux
;
3690 if (spec
->dyn_adc_switch
)
3694 for (n
= 0; n
< spec
->num_adc_nids
; n
++) {
3695 hda_nid_t cap
= spec
->private_capsrc_nids
[n
];
3696 int num_conns
= snd_hda_get_conn_list(codec
, cap
, NULL
);
3697 for (i
= 0; i
< imux
->num_items
; i
++) {
3698 hda_nid_t pin
= spec
->imux_pins
[i
];
3700 if (get_connection_index(codec
, cap
, pin
) < 0)
3702 } else if (num_conns
<= imux
->items
[i
].index
)
3705 if (i
>= imux
->num_items
) {
3706 adc_nids
[nums
] = spec
->private_adc_nids
[n
];
3707 capsrc_nids
[nums
++] = cap
;
3711 /* check whether ADC-switch is possible */
3712 if (!alc_check_dyn_adc_switch(codec
)) {
3713 printk(KERN_WARNING
"hda_codec: %s: no valid ADC found;"
3714 " using fallback 0x%x\n",
3715 codec
->chip_name
, spec
->private_adc_nids
[0]);
3716 spec
->num_adc_nids
= 1;
3720 } else if (nums
!= spec
->num_adc_nids
) {
3721 memcpy(spec
->private_adc_nids
, adc_nids
,
3722 nums
* sizeof(hda_nid_t
));
3723 memcpy(spec
->private_capsrc_nids
, capsrc_nids
,
3724 nums
* sizeof(hda_nid_t
));
3725 spec
->num_adc_nids
= nums
;
3729 alc_auto_mic_check_imux(codec
); /* check auto-mic setups */
3730 else if (spec
->input_mux
->num_items
== 1)
3731 spec
->num_adc_nids
= 1; /* reduce to a single ADC */
3735 * initialize ADC paths
3737 static void alc_auto_init_adc(struct hda_codec
*codec
, int adc_idx
)
3739 struct alc_spec
*spec
= codec
->spec
;
3742 nid
= spec
->adc_nids
[adc_idx
];
3744 if (nid_has_mute(codec
, nid
, HDA_INPUT
)) {
3745 snd_hda_codec_write(codec
, nid
, 0,
3746 AC_VERB_SET_AMP_GAIN_MUTE
,
3750 if (!spec
->capsrc_nids
)
3752 nid
= spec
->capsrc_nids
[adc_idx
];
3753 if (nid_has_mute(codec
, nid
, HDA_OUTPUT
))
3754 snd_hda_codec_write(codec
, nid
, 0,
3755 AC_VERB_SET_AMP_GAIN_MUTE
,
3759 static void alc_auto_init_input_src(struct hda_codec
*codec
)
3761 struct alc_spec
*spec
= codec
->spec
;
3764 for (c
= 0; c
< spec
->num_adc_nids
; c
++)
3765 alc_auto_init_adc(codec
, c
);
3766 if (spec
->dyn_adc_switch
)
3769 nums
= spec
->num_adc_nids
;
3770 for (c
= 0; c
< nums
; c
++)
3771 alc_mux_select(codec
, 0, spec
->cur_mux
[c
], true);
3774 /* add mic boosts if needed */
3775 static int alc_auto_add_mic_boost(struct hda_codec
*codec
)
3777 struct alc_spec
*spec
= codec
->spec
;
3778 struct auto_pin_cfg
*cfg
= &spec
->autocfg
;
3782 const char *prev_label
= NULL
;
3784 for (i
= 0; i
< cfg
->num_inputs
; i
++) {
3785 if (cfg
->inputs
[i
].type
> AUTO_PIN_MIC
)
3787 nid
= cfg
->inputs
[i
].pin
;
3788 if (get_wcaps(codec
, nid
) & AC_WCAP_IN_AMP
) {
3790 char boost_label
[32];
3792 label
= hda_get_autocfg_input_label(codec
, cfg
, i
);
3793 if (spec
->shared_mic_hp
&& !strcmp(label
, "Misc"))
3794 label
= "Headphone Mic";
3795 if (prev_label
&& !strcmp(label
, prev_label
))
3801 snprintf(boost_label
, sizeof(boost_label
),
3802 "%s Boost Volume", label
);
3803 err
= add_control(spec
, ALC_CTL_WIDGET_VOL
,
3804 boost_label
, type_idx
,
3805 HDA_COMPOSE_AMP_VAL(nid
, 3, 0, HDA_INPUT
));
3813 /* select or unmute the given capsrc route */
3814 static void select_or_unmute_capsrc(struct hda_codec
*codec
, hda_nid_t cap
,
3817 if (get_wcaps_type(get_wcaps(codec
, cap
)) == AC_WID_AUD_MIX
) {
3818 snd_hda_codec_amp_stereo(codec
, cap
, HDA_INPUT
, idx
,
3820 } else if (snd_hda_get_conn_list(codec
, cap
, NULL
) > 1) {
3821 snd_hda_codec_write_cache(codec
, cap
, 0,
3822 AC_VERB_SET_CONNECT_SEL
, idx
);
3826 /* set the default connection to that pin */
3827 static int init_capsrc_for_pin(struct hda_codec
*codec
, hda_nid_t pin
)
3829 struct alc_spec
*spec
= codec
->spec
;
3834 for (i
= 0; i
< spec
->num_adc_nids
; i
++) {
3835 hda_nid_t cap
= get_capsrc(spec
, i
);
3838 idx
= get_connection_index(codec
, cap
, pin
);
3841 select_or_unmute_capsrc(codec
, cap
, idx
);
3842 return i
; /* return the found index */
3844 return -1; /* not found */
3847 /* initialize some special cases for input sources */
3848 static void alc_init_special_input_src(struct hda_codec
*codec
)
3850 struct alc_spec
*spec
= codec
->spec
;
3853 for (i
= 0; i
< spec
->autocfg
.num_inputs
; i
++)
3854 init_capsrc_for_pin(codec
, spec
->autocfg
.inputs
[i
].pin
);
3857 /* assign appropriate capture mixers */
3858 static void set_capture_mixer(struct hda_codec
*codec
)
3860 struct alc_spec
*spec
= codec
->spec
;
3861 static const struct snd_kcontrol_new
*caps
[2][3] = {
3862 { alc_capture_mixer_nosrc1
,
3863 alc_capture_mixer_nosrc2
,
3864 alc_capture_mixer_nosrc3
},
3865 { alc_capture_mixer1
,
3867 alc_capture_mixer3
},
3870 /* check whether either of ADC or MUX has a volume control */
3871 if (!nid_has_volume(codec
, spec
->adc_nids
[0], HDA_INPUT
)) {
3872 if (!spec
->capsrc_nids
)
3873 return; /* no volume */
3874 if (!nid_has_volume(codec
, spec
->capsrc_nids
[0], HDA_OUTPUT
))
3875 return; /* no volume in capsrc, too */
3876 spec
->vol_in_capsrc
= 1;
3879 if (spec
->num_adc_nids
> 0) {
3883 if (spec
->input_mux
&& spec
->input_mux
->num_items
> 1)
3885 if (spec
->auto_mic
) {
3888 } else if (spec
->dyn_adc_switch
)
3891 if (spec
->num_adc_nids
> 3)
3892 spec
->num_adc_nids
= 3;
3893 else if (!spec
->num_adc_nids
)
3895 num_adcs
= spec
->num_adc_nids
;
3897 spec
->cap_mixer
= caps
[mux
][num_adcs
- 1];
3902 * standard auto-parser initializations
3904 static void alc_auto_init_std(struct hda_codec
*codec
)
3906 struct alc_spec
*spec
= codec
->spec
;
3907 alc_auto_init_multi_out(codec
);
3908 alc_auto_init_extra_out(codec
);
3909 alc_auto_init_analog_input(codec
);
3910 alc_auto_init_input_src(codec
);
3911 alc_auto_init_digital(codec
);
3912 if (spec
->unsol_event
)
3913 alc_inithook(codec
);
3917 * Digital-beep handlers
3919 #ifdef CONFIG_SND_HDA_INPUT_BEEP
3920 #define set_beep_amp(spec, nid, idx, dir) \
3921 ((spec)->beep_amp = HDA_COMPOSE_AMP_VAL(nid, 3, idx, dir))
3923 static const struct snd_pci_quirk beep_white_list
[] = {
3924 SND_PCI_QUIRK(0x1043, 0x829f, "ASUS", 1),
3925 SND_PCI_QUIRK(0x1043, 0x83ce, "EeePC", 1),
3926 SND_PCI_QUIRK(0x1043, 0x831a, "EeePC", 1),
3927 SND_PCI_QUIRK(0x1043, 0x834a, "EeePC", 1),
3928 SND_PCI_QUIRK(0x8086, 0xd613, "Intel", 1),
3932 static inline int has_cdefine_beep(struct hda_codec
*codec
)
3934 struct alc_spec
*spec
= codec
->spec
;
3935 const struct snd_pci_quirk
*q
;
3936 q
= snd_pci_quirk_lookup(codec
->bus
->pci
, beep_white_list
);
3939 return spec
->cdefine
.enable_pcbeep
;
3942 #define set_beep_amp(spec, nid, idx, dir) /* NOP */
3943 #define has_cdefine_beep(codec) 0
3946 /* parse the BIOS configuration and set up the alc_spec */
3947 /* return 1 if successful, 0 if the proper config is not found,
3948 * or a negative error code
3950 static int alc_parse_auto_config(struct hda_codec
*codec
,
3951 const hda_nid_t
*ignore_nids
,
3952 const hda_nid_t
*ssid_nids
)
3954 struct alc_spec
*spec
= codec
->spec
;
3955 struct auto_pin_cfg
*cfg
= &spec
->autocfg
;
3958 err
= snd_hda_parse_pin_defcfg(codec
, cfg
, ignore_nids
,
3962 if (!cfg
->line_outs
) {
3963 if (cfg
->dig_outs
|| cfg
->dig_in_pin
) {
3964 spec
->multiout
.max_channels
= 2;
3965 spec
->no_analog
= 1;
3968 return 0; /* can't find valid BIOS pin config */
3971 if (cfg
->line_out_type
== AUTO_PIN_SPEAKER_OUT
&&
3972 cfg
->line_outs
<= cfg
->hp_outs
) {
3973 /* use HP as primary out */
3974 cfg
->speaker_outs
= cfg
->line_outs
;
3975 memcpy(cfg
->speaker_pins
, cfg
->line_out_pins
,
3976 sizeof(cfg
->speaker_pins
));
3977 cfg
->line_outs
= cfg
->hp_outs
;
3978 memcpy(cfg
->line_out_pins
, cfg
->hp_pins
, sizeof(cfg
->hp_pins
));
3980 memset(cfg
->hp_pins
, 0, sizeof(cfg
->hp_pins
));
3981 cfg
->line_out_type
= AUTO_PIN_HP_OUT
;
3984 err
= alc_auto_fill_dac_nids(codec
);
3987 err
= alc_auto_add_multi_channel_mode(codec
);
3990 err
= alc_auto_create_multi_out_ctls(codec
, cfg
);
3993 err
= alc_auto_create_hp_out(codec
);
3996 err
= alc_auto_create_speaker_out(codec
);
3999 err
= alc_auto_create_shared_input(codec
);
4002 err
= alc_auto_create_input_ctls(codec
);
4006 spec
->multiout
.max_channels
= spec
->multiout
.num_dacs
* 2;
4009 alc_auto_parse_digital(codec
);
4011 if (!spec
->no_analog
)
4012 alc_remove_invalid_adc_nids(codec
);
4015 alc_ssid_check(codec
, ssid_nids
);
4017 if (!spec
->no_analog
) {
4018 alc_auto_check_switches(codec
);
4019 err
= alc_auto_add_mic_boost(codec
);
4024 if (spec
->kctls
.list
)
4025 add_mixer(spec
, spec
->kctls
.list
);
4030 static int alc880_parse_auto_config(struct hda_codec
*codec
)
4032 static const hda_nid_t alc880_ignore
[] = { 0x1d, 0 };
4033 static const hda_nid_t alc880_ssids
[] = { 0x15, 0x1b, 0x14, 0 };
4034 return alc_parse_auto_config(codec
, alc880_ignore
, alc880_ssids
);
4037 #ifdef CONFIG_SND_HDA_POWER_SAVE
4038 static const struct hda_amp_list alc880_loopbacks
[] = {
4039 { 0x0b, HDA_INPUT
, 0 },
4040 { 0x0b, HDA_INPUT
, 1 },
4041 { 0x0b, HDA_INPUT
, 2 },
4042 { 0x0b, HDA_INPUT
, 3 },
4043 { 0x0b, HDA_INPUT
, 4 },
4053 ALC880_FIXUP_MEDION_RIM
,
4056 static const struct alc_fixup alc880_fixups
[] = {
4057 [ALC880_FIXUP_GPIO2
] = {
4058 .type
= ALC_FIXUP_VERBS
,
4059 .v
.verbs
= alc_gpio2_init_verbs
,
4061 [ALC880_FIXUP_MEDION_RIM
] = {
4062 .type
= ALC_FIXUP_VERBS
,
4063 .v
.verbs
= (const struct hda_verb
[]) {
4064 { 0x20, AC_VERB_SET_COEF_INDEX
, 0x07 },
4065 { 0x20, AC_VERB_SET_PROC_COEF
, 0x3060 },
4069 .chain_id
= ALC880_FIXUP_GPIO2
,
4073 static const struct snd_pci_quirk alc880_fixup_tbl
[] = {
4074 SND_PCI_QUIRK(0x161f, 0x205d, "Medion Rim 2150", ALC880_FIXUP_MEDION_RIM
),
4082 #ifdef CONFIG_SND_HDA_ENABLE_REALTEK_QUIRKS
4083 #define alc_board_config \
4084 snd_hda_check_board_config
4085 #define alc_board_codec_sid_config \
4086 snd_hda_check_board_codec_sid_config
4087 #include "alc_quirks.c"
4089 #define alc_board_config(codec, nums, models, tbl) -1
4090 #define alc_board_codec_sid_config(codec, nums, models, tbl) -1
4091 #define setup_preset(codec, x) /* NOP */
4095 * OK, here we have finally the patch for ALC880
4097 #ifdef CONFIG_SND_HDA_ENABLE_REALTEK_QUIRKS
4098 #include "alc880_quirks.c"
4101 static int patch_alc880(struct hda_codec
*codec
)
4103 struct alc_spec
*spec
;
4107 spec
= kzalloc(sizeof(*spec
), GFP_KERNEL
);
4113 spec
->mixer_nid
= 0x0b;
4114 spec
->need_dac_fix
= 1;
4116 board_config
= alc_board_config(codec
, ALC880_MODEL_LAST
,
4117 alc880_models
, alc880_cfg_tbl
);
4118 if (board_config
< 0) {
4119 printk(KERN_INFO
"hda_codec: %s: BIOS auto-probing.\n",
4121 board_config
= ALC_MODEL_AUTO
;
4124 if (board_config
== ALC_MODEL_AUTO
) {
4125 alc_pick_fixup(codec
, NULL
, alc880_fixup_tbl
, alc880_fixups
);
4126 alc_apply_fixup(codec
, ALC_FIXUP_ACT_PRE_PROBE
);
4129 if (board_config
== ALC_MODEL_AUTO
) {
4130 /* automatic parse from the BIOS config */
4131 err
= alc880_parse_auto_config(codec
);
4134 #ifdef CONFIG_SND_HDA_ENABLE_REALTEK_QUIRKS
4137 "hda_codec: Cannot set up configuration "
4138 "from BIOS. Using 3-stack mode...\n");
4139 board_config
= ALC880_3ST
;
4144 if (board_config
!= ALC_MODEL_AUTO
) {
4145 spec
->vmaster_nid
= 0x0c;
4146 setup_preset(codec
, &alc880_presets
[board_config
]);
4149 if (!spec
->no_analog
&& !spec
->adc_nids
) {
4150 alc_auto_fill_adc_caps(codec
);
4151 alc_rebuild_imux_for_auto_mic(codec
);
4152 alc_remove_invalid_adc_nids(codec
);
4155 if (!spec
->no_analog
&& !spec
->cap_mixer
)
4156 set_capture_mixer(codec
);
4158 if (!spec
->no_analog
) {
4159 err
= snd_hda_attach_beep_device(codec
, 0x1);
4162 set_beep_amp(spec
, 0x0b, 0x05, HDA_INPUT
);
4165 alc_apply_fixup(codec
, ALC_FIXUP_ACT_PROBE
);
4167 codec
->patch_ops
= alc_patch_ops
;
4168 if (board_config
== ALC_MODEL_AUTO
)
4169 spec
->init_hook
= alc_auto_init_std
;
4171 codec
->patch_ops
.build_controls
= __alc_build_controls
;
4172 #ifdef CONFIG_SND_HDA_POWER_SAVE
4173 if (!spec
->loopback
.amplist
)
4174 spec
->loopback
.amplist
= alc880_loopbacks
;
4188 static int alc260_parse_auto_config(struct hda_codec
*codec
)
4190 static const hda_nid_t alc260_ignore
[] = { 0x17, 0 };
4191 static const hda_nid_t alc260_ssids
[] = { 0x10, 0x15, 0x0f, 0 };
4192 return alc_parse_auto_config(codec
, alc260_ignore
, alc260_ssids
);
4195 #ifdef CONFIG_SND_HDA_POWER_SAVE
4196 static const struct hda_amp_list alc260_loopbacks
[] = {
4197 { 0x07, HDA_INPUT
, 0 },
4198 { 0x07, HDA_INPUT
, 1 },
4199 { 0x07, HDA_INPUT
, 2 },
4200 { 0x07, HDA_INPUT
, 3 },
4201 { 0x07, HDA_INPUT
, 4 },
4210 ALC260_FIXUP_HP_DC5750
,
4211 ALC260_FIXUP_HP_PIN_0F
,
4216 static const struct alc_fixup alc260_fixups
[] = {
4217 [ALC260_FIXUP_HP_DC5750
] = {
4218 .type
= ALC_FIXUP_PINS
,
4219 .v
.pins
= (const struct alc_pincfg
[]) {
4220 { 0x11, 0x90130110 }, /* speaker */
4224 [ALC260_FIXUP_HP_PIN_0F
] = {
4225 .type
= ALC_FIXUP_PINS
,
4226 .v
.pins
= (const struct alc_pincfg
[]) {
4227 { 0x0f, 0x01214000 }, /* HP */
4231 [ALC260_FIXUP_COEF
] = {
4232 .type
= ALC_FIXUP_VERBS
,
4233 .v
.verbs
= (const struct hda_verb
[]) {
4234 { 0x20, AC_VERB_SET_COEF_INDEX
, 0x07 },
4235 { 0x20, AC_VERB_SET_PROC_COEF
, 0x3040 },
4239 .chain_id
= ALC260_FIXUP_HP_PIN_0F
,
4241 [ALC260_FIXUP_GPIO1
] = {
4242 .type
= ALC_FIXUP_VERBS
,
4243 .v
.verbs
= alc_gpio1_init_verbs
,
4247 static const struct snd_pci_quirk alc260_fixup_tbl
[] = {
4248 SND_PCI_QUIRK(0x1025, 0x007b, "Acer C20x", ALC260_FIXUP_GPIO1
),
4249 SND_PCI_QUIRK(0x1025, 0x007f, "Acer Aspire 9500", ALC260_FIXUP_COEF
),
4250 SND_PCI_QUIRK(0x1025, 0x008f, "Acer", ALC260_FIXUP_GPIO1
),
4251 SND_PCI_QUIRK(0x103c, 0x280a, "HP dc5750", ALC260_FIXUP_HP_DC5750
),
4252 SND_PCI_QUIRK(0x1631, 0xc017, "PB V7900", ALC260_FIXUP_COEF
),
4258 #ifdef CONFIG_SND_HDA_ENABLE_REALTEK_QUIRKS
4259 #include "alc260_quirks.c"
4262 static int patch_alc260(struct hda_codec
*codec
)
4264 struct alc_spec
*spec
;
4265 int err
, board_config
;
4267 spec
= kzalloc(sizeof(*spec
), GFP_KERNEL
);
4273 spec
->mixer_nid
= 0x07;
4275 board_config
= alc_board_config(codec
, ALC260_MODEL_LAST
,
4276 alc260_models
, alc260_cfg_tbl
);
4277 if (board_config
< 0) {
4278 snd_printd(KERN_INFO
"hda_codec: %s: BIOS auto-probing.\n",
4280 board_config
= ALC_MODEL_AUTO
;
4283 if (board_config
== ALC_MODEL_AUTO
) {
4284 alc_pick_fixup(codec
, NULL
, alc260_fixup_tbl
, alc260_fixups
);
4285 alc_apply_fixup(codec
, ALC_FIXUP_ACT_PRE_PROBE
);
4288 if (board_config
== ALC_MODEL_AUTO
) {
4289 /* automatic parse from the BIOS config */
4290 err
= alc260_parse_auto_config(codec
);
4293 #ifdef CONFIG_SND_HDA_ENABLE_REALTEK_QUIRKS
4296 "hda_codec: Cannot set up configuration "
4297 "from BIOS. Using base mode...\n");
4298 board_config
= ALC260_BASIC
;
4303 if (board_config
!= ALC_MODEL_AUTO
) {
4304 setup_preset(codec
, &alc260_presets
[board_config
]);
4305 spec
->vmaster_nid
= 0x08;
4308 if (!spec
->no_analog
&& !spec
->adc_nids
) {
4309 alc_auto_fill_adc_caps(codec
);
4310 alc_rebuild_imux_for_auto_mic(codec
);
4311 alc_remove_invalid_adc_nids(codec
);
4314 if (!spec
->no_analog
&& !spec
->cap_mixer
)
4315 set_capture_mixer(codec
);
4317 if (!spec
->no_analog
) {
4318 err
= snd_hda_attach_beep_device(codec
, 0x1);
4321 set_beep_amp(spec
, 0x07, 0x05, HDA_INPUT
);
4324 alc_apply_fixup(codec
, ALC_FIXUP_ACT_PROBE
);
4326 codec
->patch_ops
= alc_patch_ops
;
4327 if (board_config
== ALC_MODEL_AUTO
)
4328 spec
->init_hook
= alc_auto_init_std
;
4330 codec
->patch_ops
.build_controls
= __alc_build_controls
;
4331 spec
->shutup
= alc_eapd_shutup
;
4332 #ifdef CONFIG_SND_HDA_POWER_SAVE
4333 if (!spec
->loopback
.amplist
)
4334 spec
->loopback
.amplist
= alc260_loopbacks
;
4346 * ALC882/883/885/888/889 support
4348 * ALC882 is almost identical with ALC880 but has cleaner and more flexible
4349 * configuration. Each pin widget can choose any input DACs and a mixer.
4350 * Each ADC is connected from a mixer of all inputs. This makes possible
4351 * 6-channel independent captures.
4353 * In addition, an independent DAC for the multi-playback (not used in this
4356 #ifdef CONFIG_SND_HDA_POWER_SAVE
4357 #define alc882_loopbacks alc880_loopbacks
4364 ALC882_FIXUP_ABIT_AW9D_MAX
,
4365 ALC882_FIXUP_LENOVO_Y530
,
4366 ALC882_FIXUP_PB_M5210
,
4367 ALC882_FIXUP_ACER_ASPIRE_7736
,
4368 ALC882_FIXUP_ASUS_W90V
,
4369 ALC889_FIXUP_VAIO_TT
,
4370 ALC888_FIXUP_EEE1601
,
4373 ALC883_FIXUP_ACER_EAPD
,
4376 ALC882_FIXUP_ASUS_W2JC
,
4377 ALC882_FIXUP_ACER_ASPIRE_4930G
,
4378 ALC882_FIXUP_ACER_ASPIRE_8930G
,
4379 ALC882_FIXUP_ASPIRE_8930G_VERBS
,
4380 ALC885_FIXUP_MACPRO_GPIO
,
4383 static void alc889_fixup_coef(struct hda_codec
*codec
,
4384 const struct alc_fixup
*fix
, int action
)
4386 if (action
!= ALC_FIXUP_ACT_INIT
)
4388 alc889_coef_init(codec
);
4391 /* toggle speaker-output according to the hp-jack state */
4392 static void alc882_gpio_mute(struct hda_codec
*codec
, int pin
, int muted
)
4394 unsigned int gpiostate
, gpiomask
, gpiodir
;
4396 gpiostate
= snd_hda_codec_read(codec
, codec
->afg
, 0,
4397 AC_VERB_GET_GPIO_DATA
, 0);
4400 gpiostate
|= (1 << pin
);
4402 gpiostate
&= ~(1 << pin
);
4404 gpiomask
= snd_hda_codec_read(codec
, codec
->afg
, 0,
4405 AC_VERB_GET_GPIO_MASK
, 0);
4406 gpiomask
|= (1 << pin
);
4408 gpiodir
= snd_hda_codec_read(codec
, codec
->afg
, 0,
4409 AC_VERB_GET_GPIO_DIRECTION
, 0);
4410 gpiodir
|= (1 << pin
);
4413 snd_hda_codec_write(codec
, codec
->afg
, 0,
4414 AC_VERB_SET_GPIO_MASK
, gpiomask
);
4415 snd_hda_codec_write(codec
, codec
->afg
, 0,
4416 AC_VERB_SET_GPIO_DIRECTION
, gpiodir
);
4420 snd_hda_codec_write(codec
, codec
->afg
, 0,
4421 AC_VERB_SET_GPIO_DATA
, gpiostate
);
4424 /* set up GPIO at initialization */
4425 static void alc885_fixup_macpro_gpio(struct hda_codec
*codec
,
4426 const struct alc_fixup
*fix
, int action
)
4428 if (action
!= ALC_FIXUP_ACT_INIT
)
4430 alc882_gpio_mute(codec
, 0, 0);
4431 alc882_gpio_mute(codec
, 1, 0);
4434 static const struct alc_fixup alc882_fixups
[] = {
4435 [ALC882_FIXUP_ABIT_AW9D_MAX
] = {
4436 .type
= ALC_FIXUP_PINS
,
4437 .v
.pins
= (const struct alc_pincfg
[]) {
4438 { 0x15, 0x01080104 }, /* side */
4439 { 0x16, 0x01011012 }, /* rear */
4440 { 0x17, 0x01016011 }, /* clfe */
4444 [ALC882_FIXUP_LENOVO_Y530
] = {
4445 .type
= ALC_FIXUP_PINS
,
4446 .v
.pins
= (const struct alc_pincfg
[]) {
4447 { 0x15, 0x99130112 }, /* rear int speakers */
4448 { 0x16, 0x99130111 }, /* subwoofer */
4452 [ALC882_FIXUP_PB_M5210
] = {
4453 .type
= ALC_FIXUP_VERBS
,
4454 .v
.verbs
= (const struct hda_verb
[]) {
4455 { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_VREF50
},
4459 [ALC882_FIXUP_ACER_ASPIRE_7736
] = {
4460 .type
= ALC_FIXUP_SKU
,
4461 .v
.sku
= ALC_FIXUP_SKU_IGNORE
,
4463 [ALC882_FIXUP_ASUS_W90V
] = {
4464 .type
= ALC_FIXUP_PINS
,
4465 .v
.pins
= (const struct alc_pincfg
[]) {
4466 { 0x16, 0x99130110 }, /* fix sequence for CLFE */
4470 [ALC889_FIXUP_VAIO_TT
] = {
4471 .type
= ALC_FIXUP_PINS
,
4472 .v
.pins
= (const struct alc_pincfg
[]) {
4473 { 0x17, 0x90170111 }, /* hidden surround speaker */
4477 [ALC888_FIXUP_EEE1601
] = {
4478 .type
= ALC_FIXUP_VERBS
,
4479 .v
.verbs
= (const struct hda_verb
[]) {
4480 { 0x20, AC_VERB_SET_COEF_INDEX
, 0x0b },
4481 { 0x20, AC_VERB_SET_PROC_COEF
, 0x0838 },
4485 [ALC882_FIXUP_EAPD
] = {
4486 .type
= ALC_FIXUP_VERBS
,
4487 .v
.verbs
= (const struct hda_verb
[]) {
4488 /* change to EAPD mode */
4489 { 0x20, AC_VERB_SET_COEF_INDEX
, 0x07 },
4490 { 0x20, AC_VERB_SET_PROC_COEF
, 0x3060 },
4494 [ALC883_FIXUP_EAPD
] = {
4495 .type
= ALC_FIXUP_VERBS
,
4496 .v
.verbs
= (const struct hda_verb
[]) {
4497 /* change to EAPD mode */
4498 { 0x20, AC_VERB_SET_COEF_INDEX
, 0x07 },
4499 { 0x20, AC_VERB_SET_PROC_COEF
, 0x3070 },
4503 [ALC883_FIXUP_ACER_EAPD
] = {
4504 .type
= ALC_FIXUP_VERBS
,
4505 .v
.verbs
= (const struct hda_verb
[]) {
4506 /* eanable EAPD on Acer laptops */
4507 { 0x20, AC_VERB_SET_COEF_INDEX
, 0x07 },
4508 { 0x20, AC_VERB_SET_PROC_COEF
, 0x3050 },
4512 [ALC882_FIXUP_GPIO3
] = {
4513 .type
= ALC_FIXUP_VERBS
,
4514 .v
.verbs
= alc_gpio3_init_verbs
,
4516 [ALC882_FIXUP_ASUS_W2JC
] = {
4517 .type
= ALC_FIXUP_VERBS
,
4518 .v
.verbs
= alc_gpio1_init_verbs
,
4520 .chain_id
= ALC882_FIXUP_EAPD
,
4522 [ALC889_FIXUP_COEF
] = {
4523 .type
= ALC_FIXUP_FUNC
,
4524 .v
.func
= alc889_fixup_coef
,
4526 [ALC882_FIXUP_ACER_ASPIRE_4930G
] = {
4527 .type
= ALC_FIXUP_PINS
,
4528 .v
.pins
= (const struct alc_pincfg
[]) {
4529 { 0x16, 0x99130111 }, /* CLFE speaker */
4530 { 0x17, 0x99130112 }, /* surround speaker */
4534 [ALC882_FIXUP_ACER_ASPIRE_8930G
] = {
4535 .type
= ALC_FIXUP_PINS
,
4536 .v
.pins
= (const struct alc_pincfg
[]) {
4537 { 0x16, 0x99130111 }, /* CLFE speaker */
4538 { 0x1b, 0x99130112 }, /* surround speaker */
4542 .chain_id
= ALC882_FIXUP_ASPIRE_8930G_VERBS
,
4544 [ALC882_FIXUP_ASPIRE_8930G_VERBS
] = {
4545 /* additional init verbs for Acer Aspire 8930G */
4546 .type
= ALC_FIXUP_VERBS
,
4547 .v
.verbs
= (const struct hda_verb
[]) {
4548 /* Enable all DACs */
4549 /* DAC DISABLE/MUTE 1? */
4550 /* setting bits 1-5 disables DAC nids 0x02-0x06
4551 * apparently. Init=0x38 */
4552 { 0x20, AC_VERB_SET_COEF_INDEX
, 0x03 },
4553 { 0x20, AC_VERB_SET_PROC_COEF
, 0x0000 },
4554 /* DAC DISABLE/MUTE 2? */
4555 /* some bit here disables the other DACs.
4557 { 0x20, AC_VERB_SET_COEF_INDEX
, 0x08 },
4558 { 0x20, AC_VERB_SET_PROC_COEF
, 0x0000 },
4560 * This laptop has a stereo digital microphone.
4561 * The mics are only 1cm apart which makes the stereo
4562 * useless. However, either the mic or the ALC889
4563 * makes the signal become a difference/sum signal
4564 * instead of standard stereo, which is annoying.
4565 * So instead we flip this bit which makes the
4566 * codec replicate the sum signal to both channels,
4567 * turning it into a normal mono mic.
4569 /* DMIC_CONTROL? Init value = 0x0001 */
4570 { 0x20, AC_VERB_SET_COEF_INDEX
, 0x0b },
4571 { 0x20, AC_VERB_SET_PROC_COEF
, 0x0003 },
4572 { 0x20, AC_VERB_SET_COEF_INDEX
, 0x07 },
4573 { 0x20, AC_VERB_SET_PROC_COEF
, 0x3050 },
4577 [ALC885_FIXUP_MACPRO_GPIO
] = {
4578 .type
= ALC_FIXUP_FUNC
,
4579 .v
.func
= alc885_fixup_macpro_gpio
,
4583 static const struct snd_pci_quirk alc882_fixup_tbl
[] = {
4584 SND_PCI_QUIRK(0x1025, 0x006c, "Acer Aspire 9810", ALC883_FIXUP_ACER_EAPD
),
4585 SND_PCI_QUIRK(0x1025, 0x0090, "Acer Aspire", ALC883_FIXUP_ACER_EAPD
),
4586 SND_PCI_QUIRK(0x1025, 0x010a, "Acer Ferrari 5000", ALC883_FIXUP_ACER_EAPD
),
4587 SND_PCI_QUIRK(0x1025, 0x0110, "Acer Aspire", ALC883_FIXUP_ACER_EAPD
),
4588 SND_PCI_QUIRK(0x1025, 0x0112, "Acer Aspire 9303", ALC883_FIXUP_ACER_EAPD
),
4589 SND_PCI_QUIRK(0x1025, 0x0121, "Acer Aspire 5920G", ALC883_FIXUP_ACER_EAPD
),
4590 SND_PCI_QUIRK(0x1025, 0x013e, "Acer Aspire 4930G",
4591 ALC882_FIXUP_ACER_ASPIRE_4930G
),
4592 SND_PCI_QUIRK(0x1025, 0x013f, "Acer Aspire 5930G",
4593 ALC882_FIXUP_ACER_ASPIRE_4930G
),
4594 SND_PCI_QUIRK(0x1025, 0x0145, "Acer Aspire 8930G",
4595 ALC882_FIXUP_ACER_ASPIRE_8930G
),
4596 SND_PCI_QUIRK(0x1025, 0x0146, "Acer Aspire 6935G",
4597 ALC882_FIXUP_ACER_ASPIRE_8930G
),
4598 SND_PCI_QUIRK(0x1025, 0x015e, "Acer Aspire 6930G",
4599 ALC882_FIXUP_ACER_ASPIRE_4930G
),
4600 SND_PCI_QUIRK(0x1025, 0x0166, "Acer Aspire 6530G",
4601 ALC882_FIXUP_ACER_ASPIRE_4930G
),
4602 SND_PCI_QUIRK(0x1025, 0x0142, "Acer Aspire 7730G",
4603 ALC882_FIXUP_ACER_ASPIRE_4930G
),
4604 SND_PCI_QUIRK(0x1025, 0x0155, "Packard-Bell M5120", ALC882_FIXUP_PB_M5210
),
4605 SND_PCI_QUIRK(0x1025, 0x0296, "Acer Aspire 7736z", ALC882_FIXUP_ACER_ASPIRE_7736
),
4606 SND_PCI_QUIRK(0x1043, 0x13c2, "Asus A7M", ALC882_FIXUP_EAPD
),
4607 SND_PCI_QUIRK(0x1043, 0x1873, "ASUS W90V", ALC882_FIXUP_ASUS_W90V
),
4608 SND_PCI_QUIRK(0x1043, 0x1971, "Asus W2JC", ALC882_FIXUP_ASUS_W2JC
),
4609 SND_PCI_QUIRK(0x1043, 0x835f, "Asus Eee 1601", ALC888_FIXUP_EEE1601
),
4610 SND_PCI_QUIRK(0x104d, 0x9047, "Sony Vaio TT", ALC889_FIXUP_VAIO_TT
),
4612 /* All Apple entries are in codec SSIDs */
4613 SND_PCI_QUIRK(0x106b, 0x0c00, "Mac Pro", ALC885_FIXUP_MACPRO_GPIO
),
4614 SND_PCI_QUIRK(0x106b, 0x1000, "iMac 24", ALC885_FIXUP_MACPRO_GPIO
),
4615 SND_PCI_QUIRK(0x106b, 0x2800, "AppleTV", ALC885_FIXUP_MACPRO_GPIO
),
4616 SND_PCI_QUIRK(0x106b, 0x3200, "iMac 7,1 Aluminum", ALC882_FIXUP_EAPD
),
4617 SND_PCI_QUIRK(0x106b, 0x3e00, "iMac 24 Aluminum", ALC885_FIXUP_MACPRO_GPIO
),
4619 SND_PCI_QUIRK(0x1071, 0x8258, "Evesham Voyaeger", ALC882_FIXUP_EAPD
),
4620 SND_PCI_QUIRK_VENDOR(0x1462, "MSI", ALC882_FIXUP_GPIO3
),
4621 SND_PCI_QUIRK(0x147b, 0x107a, "Abit AW9D-MAX", ALC882_FIXUP_ABIT_AW9D_MAX
),
4622 SND_PCI_QUIRK_VENDOR(0x1558, "Clevo laptop", ALC882_FIXUP_EAPD
),
4623 SND_PCI_QUIRK(0x161f, 0x2054, "Medion laptop", ALC883_FIXUP_EAPD
),
4624 SND_PCI_QUIRK(0x17aa, 0x3a0d, "Lenovo Y530", ALC882_FIXUP_LENOVO_Y530
),
4625 SND_PCI_QUIRK(0x8086, 0x0022, "DX58SO", ALC889_FIXUP_COEF
),
4630 * BIOS auto configuration
4632 /* almost identical with ALC880 parser... */
4633 static int alc882_parse_auto_config(struct hda_codec
*codec
)
4635 static const hda_nid_t alc882_ignore
[] = { 0x1d, 0 };
4636 static const hda_nid_t alc882_ssids
[] = { 0x15, 0x1b, 0x14, 0 };
4637 return alc_parse_auto_config(codec
, alc882_ignore
, alc882_ssids
);
4642 #ifdef CONFIG_SND_HDA_ENABLE_REALTEK_QUIRKS
4643 #include "alc882_quirks.c"
4646 static int patch_alc882(struct hda_codec
*codec
)
4648 struct alc_spec
*spec
;
4649 int err
, board_config
;
4651 spec
= kzalloc(sizeof(*spec
), GFP_KERNEL
);
4657 spec
->mixer_nid
= 0x0b;
4659 switch (codec
->vendor_id
) {
4664 /* ALC883 and variants */
4665 alc_fix_pll_init(codec
, 0x20, 0x0a, 10);
4669 err
= alc_codec_rename_from_preset(codec
);
4673 board_config
= alc_board_config(codec
, ALC882_MODEL_LAST
,
4674 alc882_models
, NULL
);
4675 if (board_config
< 0)
4676 board_config
= alc_board_codec_sid_config(codec
,
4677 ALC882_MODEL_LAST
, alc882_models
, alc882_ssid_cfg_tbl
);
4679 if (board_config
< 0) {
4680 printk(KERN_INFO
"hda_codec: %s: BIOS auto-probing.\n",
4682 board_config
= ALC_MODEL_AUTO
;
4685 if (board_config
== ALC_MODEL_AUTO
) {
4686 alc_pick_fixup(codec
, NULL
, alc882_fixup_tbl
, alc882_fixups
);
4687 alc_apply_fixup(codec
, ALC_FIXUP_ACT_PRE_PROBE
);
4690 alc_auto_parse_customize_define(codec
);
4692 if (board_config
== ALC_MODEL_AUTO
) {
4693 /* automatic parse from the BIOS config */
4694 err
= alc882_parse_auto_config(codec
);
4699 if (board_config
!= ALC_MODEL_AUTO
) {
4700 setup_preset(codec
, &alc882_presets
[board_config
]);
4701 spec
->vmaster_nid
= 0x0c;
4704 if (!spec
->no_analog
&& !spec
->adc_nids
) {
4705 alc_auto_fill_adc_caps(codec
);
4706 alc_rebuild_imux_for_auto_mic(codec
);
4707 alc_remove_invalid_adc_nids(codec
);
4710 if (!spec
->no_analog
&& !spec
->cap_mixer
)
4711 set_capture_mixer(codec
);
4713 if (!spec
->no_analog
&& has_cdefine_beep(codec
)) {
4714 err
= snd_hda_attach_beep_device(codec
, 0x1);
4717 set_beep_amp(spec
, 0x0b, 0x05, HDA_INPUT
);
4720 alc_apply_fixup(codec
, ALC_FIXUP_ACT_PROBE
);
4722 codec
->patch_ops
= alc_patch_ops
;
4723 if (board_config
== ALC_MODEL_AUTO
)
4724 spec
->init_hook
= alc_auto_init_std
;
4726 codec
->patch_ops
.build_controls
= __alc_build_controls
;
4728 #ifdef CONFIG_SND_HDA_POWER_SAVE
4729 if (!spec
->loopback
.amplist
)
4730 spec
->loopback
.amplist
= alc882_loopbacks
;
4744 static int alc262_parse_auto_config(struct hda_codec
*codec
)
4746 static const hda_nid_t alc262_ignore
[] = { 0x1d, 0 };
4747 static const hda_nid_t alc262_ssids
[] = { 0x15, 0x1b, 0x14, 0 };
4748 return alc_parse_auto_config(codec
, alc262_ignore
, alc262_ssids
);
4755 ALC262_FIXUP_FSC_H270
,
4756 ALC262_FIXUP_HP_Z200
,
4758 ALC262_FIXUP_LENOVO_3000
,
4760 ALC262_FIXUP_BENQ_T31
,
4763 static const struct alc_fixup alc262_fixups
[] = {
4764 [ALC262_FIXUP_FSC_H270
] = {
4765 .type
= ALC_FIXUP_PINS
,
4766 .v
.pins
= (const struct alc_pincfg
[]) {
4767 { 0x14, 0x99130110 }, /* speaker */
4768 { 0x15, 0x0221142f }, /* front HP */
4769 { 0x1b, 0x0121141f }, /* rear HP */
4773 [ALC262_FIXUP_HP_Z200
] = {
4774 .type
= ALC_FIXUP_PINS
,
4775 .v
.pins
= (const struct alc_pincfg
[]) {
4776 { 0x16, 0x99130120 }, /* internal speaker */
4780 [ALC262_FIXUP_TYAN
] = {
4781 .type
= ALC_FIXUP_PINS
,
4782 .v
.pins
= (const struct alc_pincfg
[]) {
4783 { 0x14, 0x1993e1f0 }, /* int AUX */
4787 [ALC262_FIXUP_LENOVO_3000
] = {
4788 .type
= ALC_FIXUP_VERBS
,
4789 .v
.verbs
= (const struct hda_verb
[]) {
4790 { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_VREF50
},
4794 .chain_id
= ALC262_FIXUP_BENQ
,
4796 [ALC262_FIXUP_BENQ
] = {
4797 .type
= ALC_FIXUP_VERBS
,
4798 .v
.verbs
= (const struct hda_verb
[]) {
4799 { 0x20, AC_VERB_SET_COEF_INDEX
, 0x07 },
4800 { 0x20, AC_VERB_SET_PROC_COEF
, 0x3070 },
4804 [ALC262_FIXUP_BENQ_T31
] = {
4805 .type
= ALC_FIXUP_VERBS
,
4806 .v
.verbs
= (const struct hda_verb
[]) {
4807 { 0x20, AC_VERB_SET_COEF_INDEX
, 0x07 },
4808 { 0x20, AC_VERB_SET_PROC_COEF
, 0x3050 },
4814 static const struct snd_pci_quirk alc262_fixup_tbl
[] = {
4815 SND_PCI_QUIRK(0x103c, 0x170b, "HP Z200", ALC262_FIXUP_HP_Z200
),
4816 SND_PCI_QUIRK(0x10cf, 0x1397, "Fujitsu", ALC262_FIXUP_BENQ
),
4817 SND_PCI_QUIRK(0x10cf, 0x142d, "Fujitsu Lifebook E8410", ALC262_FIXUP_BENQ
),
4818 SND_PCI_QUIRK(0x10f1, 0x2915, "Tyan Thunder n6650W", ALC262_FIXUP_TYAN
),
4819 SND_PCI_QUIRK(0x1734, 0x1147, "FSC Celsius H270", ALC262_FIXUP_FSC_H270
),
4820 SND_PCI_QUIRK(0x17aa, 0x384e, "Lenovo 3000", ALC262_FIXUP_LENOVO_3000
),
4821 SND_PCI_QUIRK(0x17ff, 0x0560, "Benq ED8", ALC262_FIXUP_BENQ
),
4822 SND_PCI_QUIRK(0x17ff, 0x058d, "Benq T31-16", ALC262_FIXUP_BENQ_T31
),
4827 #ifdef CONFIG_SND_HDA_POWER_SAVE
4828 #define alc262_loopbacks alc880_loopbacks
4833 static int patch_alc262(struct hda_codec
*codec
)
4835 struct alc_spec
*spec
;
4838 spec
= kzalloc(sizeof(*spec
), GFP_KERNEL
);
4844 spec
->mixer_nid
= 0x0b;
4847 /* pshou 07/11/05 set a zero PCM sample to DAC when FIFO is
4852 snd_hda_codec_write(codec
, 0x1a, 0, AC_VERB_SET_COEF_INDEX
, 7);
4853 tmp
= snd_hda_codec_read(codec
, 0x20, 0, AC_VERB_GET_PROC_COEF
, 0);
4854 snd_hda_codec_write(codec
, 0x1a, 0, AC_VERB_SET_COEF_INDEX
, 7);
4855 snd_hda_codec_write(codec
, 0x1a, 0, AC_VERB_SET_PROC_COEF
, tmp
| 0x80);
4858 alc_auto_parse_customize_define(codec
);
4860 alc_fix_pll_init(codec
, 0x20, 0x0a, 10);
4862 alc_pick_fixup(codec
, NULL
, alc262_fixup_tbl
, alc262_fixups
);
4863 alc_apply_fixup(codec
, ALC_FIXUP_ACT_PRE_PROBE
);
4865 /* automatic parse from the BIOS config */
4866 err
= alc262_parse_auto_config(codec
);
4870 if (!spec
->no_analog
&& !spec
->adc_nids
) {
4871 alc_auto_fill_adc_caps(codec
);
4872 alc_rebuild_imux_for_auto_mic(codec
);
4873 alc_remove_invalid_adc_nids(codec
);
4876 if (!spec
->no_analog
&& !spec
->cap_mixer
)
4877 set_capture_mixer(codec
);
4879 if (!spec
->no_analog
&& has_cdefine_beep(codec
)) {
4880 err
= snd_hda_attach_beep_device(codec
, 0x1);
4883 set_beep_amp(spec
, 0x0b, 0x05, HDA_INPUT
);
4886 alc_apply_fixup(codec
, ALC_FIXUP_ACT_PROBE
);
4888 codec
->patch_ops
= alc_patch_ops
;
4889 spec
->init_hook
= alc_auto_init_std
;
4890 spec
->shutup
= alc_eapd_shutup
;
4892 #ifdef CONFIG_SND_HDA_POWER_SAVE
4893 if (!spec
->loopback
.amplist
)
4894 spec
->loopback
.amplist
= alc262_loopbacks
;
4907 /* bind Beep switches of both NID 0x0f and 0x10 */
4908 static const struct hda_bind_ctls alc268_bind_beep_sw
= {
4909 .ops
= &snd_hda_bind_sw
,
4911 HDA_COMPOSE_AMP_VAL(0x0f, 3, 1, HDA_INPUT
),
4912 HDA_COMPOSE_AMP_VAL(0x10, 3, 1, HDA_INPUT
),
4917 static const struct snd_kcontrol_new alc268_beep_mixer
[] = {
4918 HDA_CODEC_VOLUME("Beep Playback Volume", 0x1d, 0x0, HDA_INPUT
),
4919 HDA_BIND_SW("Beep Playback Switch", &alc268_bind_beep_sw
),
4923 /* set PCBEEP vol = 0, mute connections */
4924 static const struct hda_verb alc268_beep_init_verbs
[] = {
4925 {0x1d, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(0)},
4926 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_MUTE(1)},
4927 {0x10, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_MUTE(1)},
4932 * BIOS auto configuration
4934 static int alc268_parse_auto_config(struct hda_codec
*codec
)
4936 static const hda_nid_t alc268_ssids
[] = { 0x15, 0x1b, 0x14, 0 };
4937 struct alc_spec
*spec
= codec
->spec
;
4938 int err
= alc_parse_auto_config(codec
, NULL
, alc268_ssids
);
4940 if (!spec
->no_analog
&& spec
->autocfg
.speaker_pins
[0] != 0x1d) {
4941 add_mixer(spec
, alc268_beep_mixer
);
4942 add_verb(spec
, alc268_beep_init_verbs
);
4950 static int patch_alc268(struct hda_codec
*codec
)
4952 struct alc_spec
*spec
;
4953 int i
, has_beep
, err
;
4955 spec
= kzalloc(sizeof(*spec
), GFP_KERNEL
);
4961 /* ALC268 has no aa-loopback mixer */
4963 /* automatic parse from the BIOS config */
4964 err
= alc268_parse_auto_config(codec
);
4969 for (i
= 0; i
< spec
->num_mixers
; i
++) {
4970 if (spec
->mixers
[i
] == alc268_beep_mixer
) {
4977 err
= snd_hda_attach_beep_device(codec
, 0x1);
4980 if (!query_amp_caps(codec
, 0x1d, HDA_INPUT
))
4981 /* override the amp caps for beep generator */
4982 snd_hda_override_amp_caps(codec
, 0x1d, HDA_INPUT
,
4983 (0x0c << AC_AMPCAP_OFFSET_SHIFT
) |
4984 (0x0c << AC_AMPCAP_NUM_STEPS_SHIFT
) |
4985 (0x07 << AC_AMPCAP_STEP_SIZE_SHIFT
) |
4986 (0 << AC_AMPCAP_MUTE_SHIFT
));
4989 if (!spec
->no_analog
&& !spec
->adc_nids
) {
4990 alc_auto_fill_adc_caps(codec
);
4991 alc_rebuild_imux_for_auto_mic(codec
);
4992 alc_remove_invalid_adc_nids(codec
);
4995 if (!spec
->no_analog
&& !spec
->cap_mixer
)
4996 set_capture_mixer(codec
);
4998 codec
->patch_ops
= alc_patch_ops
;
4999 spec
->init_hook
= alc_auto_init_std
;
5000 spec
->shutup
= alc_eapd_shutup
;
5012 #ifdef CONFIG_SND_HDA_POWER_SAVE
5013 #define alc269_loopbacks alc880_loopbacks
5016 static const struct hda_pcm_stream alc269_44k_pcm_analog_playback
= {
5020 .rates
= SNDRV_PCM_RATE_44100
, /* fixed rate */
5021 /* NID is set in alc_build_pcms */
5023 .open
= alc_playback_pcm_open
,
5024 .prepare
= alc_playback_pcm_prepare
,
5025 .cleanup
= alc_playback_pcm_cleanup
5029 static const struct hda_pcm_stream alc269_44k_pcm_analog_capture
= {
5033 .rates
= SNDRV_PCM_RATE_44100
, /* fixed rate */
5034 /* NID is set in alc_build_pcms */
5037 #ifdef CONFIG_SND_HDA_POWER_SAVE
5038 static int alc269_mic2_for_mute_led(struct hda_codec
*codec
)
5040 switch (codec
->subsystem_id
) {
5047 static int alc269_mic2_mute_check_ps(struct hda_codec
*codec
, hda_nid_t nid
)
5049 /* update mute-LED according to the speaker mute state */
5050 if (nid
== 0x01 || nid
== 0x14) {
5052 if (snd_hda_codec_amp_read(codec
, 0x14, 0, HDA_OUTPUT
, 0) &
5057 /* mic2 vref pin is used for mute LED control */
5058 snd_hda_codec_update_cache(codec
, 0x19, 0,
5059 AC_VERB_SET_PIN_WIDGET_CONTROL
,
5062 return alc_check_power_status(codec
, nid
);
5064 #endif /* CONFIG_SND_HDA_POWER_SAVE */
5066 /* different alc269-variants */
5068 ALC269_TYPE_ALC269VA
,
5069 ALC269_TYPE_ALC269VB
,
5070 ALC269_TYPE_ALC269VC
,
5074 * BIOS auto configuration
5076 static int alc269_parse_auto_config(struct hda_codec
*codec
)
5078 static const hda_nid_t alc269_ignore
[] = { 0x1d, 0 };
5079 static const hda_nid_t alc269_ssids
[] = { 0, 0x1b, 0x14, 0x21 };
5080 static const hda_nid_t alc269va_ssids
[] = { 0x15, 0x1b, 0x14, 0 };
5081 struct alc_spec
*spec
= codec
->spec
;
5082 const hda_nid_t
*ssids
= spec
->codec_variant
== ALC269_TYPE_ALC269VA
?
5083 alc269va_ssids
: alc269_ssids
;
5085 return alc_parse_auto_config(codec
, alc269_ignore
, ssids
);
5088 static void alc269_toggle_power_output(struct hda_codec
*codec
, int power_up
)
5090 int val
= alc_read_coef_idx(codec
, 0x04);
5095 alc_write_coef_idx(codec
, 0x04, val
);
5098 static void alc269_shutup(struct hda_codec
*codec
)
5100 if ((alc_get_coef0(codec
) & 0x00ff) == 0x017)
5101 alc269_toggle_power_output(codec
, 0);
5102 if ((alc_get_coef0(codec
) & 0x00ff) == 0x018) {
5103 alc269_toggle_power_output(codec
, 0);
5109 static int alc269_resume(struct hda_codec
*codec
)
5111 if ((alc_get_coef0(codec
) & 0x00ff) == 0x018) {
5112 alc269_toggle_power_output(codec
, 0);
5116 codec
->patch_ops
.init(codec
);
5118 if ((alc_get_coef0(codec
) & 0x00ff) == 0x017) {
5119 alc269_toggle_power_output(codec
, 1);
5123 if ((alc_get_coef0(codec
) & 0x00ff) == 0x018)
5124 alc269_toggle_power_output(codec
, 1);
5126 snd_hda_codec_resume_amp(codec
);
5127 snd_hda_codec_resume_cache(codec
);
5128 hda_call_check_power_status(codec
, 0x01);
5131 #endif /* CONFIG_PM */
5133 static void alc269_fixup_hweq(struct hda_codec
*codec
,
5134 const struct alc_fixup
*fix
, int action
)
5138 if (action
!= ALC_FIXUP_ACT_INIT
)
5140 coef
= alc_read_coef_idx(codec
, 0x1e);
5141 alc_write_coef_idx(codec
, 0x1e, coef
| 0x80);
5144 static void alc271_fixup_dmic(struct hda_codec
*codec
,
5145 const struct alc_fixup
*fix
, int action
)
5147 static const struct hda_verb verbs
[] = {
5148 {0x20, AC_VERB_SET_COEF_INDEX
, 0x0d},
5149 {0x20, AC_VERB_SET_PROC_COEF
, 0x4000},
5154 if (strcmp(codec
->chip_name
, "ALC271X"))
5156 cfg
= snd_hda_codec_get_pincfg(codec
, 0x12);
5157 if (get_defcfg_connect(cfg
) == AC_JACK_PORT_FIXED
)
5158 snd_hda_sequence_write(codec
, verbs
);
5161 static void alc269_fixup_pcm_44k(struct hda_codec
*codec
,
5162 const struct alc_fixup
*fix
, int action
)
5164 struct alc_spec
*spec
= codec
->spec
;
5166 if (action
!= ALC_FIXUP_ACT_PROBE
)
5169 /* Due to a hardware problem on Lenovo Ideadpad, we need to
5170 * fix the sample rate of analog I/O to 44.1kHz
5172 spec
->stream_analog_playback
= &alc269_44k_pcm_analog_playback
;
5173 spec
->stream_analog_capture
= &alc269_44k_pcm_analog_capture
;
5176 static void alc269_fixup_stereo_dmic(struct hda_codec
*codec
,
5177 const struct alc_fixup
*fix
, int action
)
5181 if (action
!= ALC_FIXUP_ACT_INIT
)
5183 /* The digital-mic unit sends PDM (differential signal) instead of
5184 * the standard PCM, thus you can't record a valid mono stream as is.
5185 * Below is a workaround specific to ALC269 to control the dmic
5186 * signal source as mono.
5188 coef
= alc_read_coef_idx(codec
, 0x07);
5189 alc_write_coef_idx(codec
, 0x07, coef
| 0x80);
5192 static void alc269_quanta_automute(struct hda_codec
*codec
)
5194 update_outputs(codec
);
5196 snd_hda_codec_write(codec
, 0x20, 0,
5197 AC_VERB_SET_COEF_INDEX
, 0x0c);
5198 snd_hda_codec_write(codec
, 0x20, 0,
5199 AC_VERB_SET_PROC_COEF
, 0x680);
5201 snd_hda_codec_write(codec
, 0x20, 0,
5202 AC_VERB_SET_COEF_INDEX
, 0x0c);
5203 snd_hda_codec_write(codec
, 0x20, 0,
5204 AC_VERB_SET_PROC_COEF
, 0x480);
5207 static void alc269_fixup_quanta_mute(struct hda_codec
*codec
,
5208 const struct alc_fixup
*fix
, int action
)
5210 struct alc_spec
*spec
= codec
->spec
;
5211 if (action
!= ALC_FIXUP_ACT_PROBE
)
5213 spec
->automute_hook
= alc269_quanta_automute
;
5217 ALC269_FIXUP_SONY_VAIO
,
5218 ALC275_FIXUP_SONY_VAIO_GPIO2
,
5219 ALC269_FIXUP_DELL_M101Z
,
5220 ALC269_FIXUP_SKU_IGNORE
,
5221 ALC269_FIXUP_ASUS_G73JW
,
5222 ALC269_FIXUP_LENOVO_EAPD
,
5223 ALC275_FIXUP_SONY_HWEQ
,
5225 ALC269_FIXUP_PCM_44K
,
5226 ALC269_FIXUP_STEREO_DMIC
,
5227 ALC269_FIXUP_QUANTA_MUTE
,
5228 ALC269_FIXUP_LIFEBOOK
,
5231 ALC269VB_FIXUP_AMIC
,
5232 ALC269VB_FIXUP_DMIC
,
5235 static const struct alc_fixup alc269_fixups
[] = {
5236 [ALC269_FIXUP_SONY_VAIO
] = {
5237 .type
= ALC_FIXUP_VERBS
,
5238 .v
.verbs
= (const struct hda_verb
[]) {
5239 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_VREFGRD
},
5243 [ALC275_FIXUP_SONY_VAIO_GPIO2
] = {
5244 .type
= ALC_FIXUP_VERBS
,
5245 .v
.verbs
= (const struct hda_verb
[]) {
5246 {0x01, AC_VERB_SET_GPIO_MASK
, 0x04},
5247 {0x01, AC_VERB_SET_GPIO_DIRECTION
, 0x04},
5248 {0x01, AC_VERB_SET_GPIO_DATA
, 0x00},
5252 .chain_id
= ALC269_FIXUP_SONY_VAIO
5254 [ALC269_FIXUP_DELL_M101Z
] = {
5255 .type
= ALC_FIXUP_VERBS
,
5256 .v
.verbs
= (const struct hda_verb
[]) {
5257 /* Enables internal speaker */
5258 {0x20, AC_VERB_SET_COEF_INDEX
, 13},
5259 {0x20, AC_VERB_SET_PROC_COEF
, 0x4040},
5263 [ALC269_FIXUP_SKU_IGNORE
] = {
5264 .type
= ALC_FIXUP_SKU
,
5265 .v
.sku
= ALC_FIXUP_SKU_IGNORE
,
5267 [ALC269_FIXUP_ASUS_G73JW
] = {
5268 .type
= ALC_FIXUP_PINS
,
5269 .v
.pins
= (const struct alc_pincfg
[]) {
5270 { 0x17, 0x99130111 }, /* subwoofer */
5274 [ALC269_FIXUP_LENOVO_EAPD
] = {
5275 .type
= ALC_FIXUP_VERBS
,
5276 .v
.verbs
= (const struct hda_verb
[]) {
5277 {0x14, AC_VERB_SET_EAPD_BTLENABLE
, 0},
5281 [ALC275_FIXUP_SONY_HWEQ
] = {
5282 .type
= ALC_FIXUP_FUNC
,
5283 .v
.func
= alc269_fixup_hweq
,
5285 .chain_id
= ALC275_FIXUP_SONY_VAIO_GPIO2
5287 [ALC271_FIXUP_DMIC
] = {
5288 .type
= ALC_FIXUP_FUNC
,
5289 .v
.func
= alc271_fixup_dmic
,
5291 [ALC269_FIXUP_PCM_44K
] = {
5292 .type
= ALC_FIXUP_FUNC
,
5293 .v
.func
= alc269_fixup_pcm_44k
,
5295 [ALC269_FIXUP_STEREO_DMIC
] = {
5296 .type
= ALC_FIXUP_FUNC
,
5297 .v
.func
= alc269_fixup_stereo_dmic
,
5299 [ALC269_FIXUP_QUANTA_MUTE
] = {
5300 .type
= ALC_FIXUP_FUNC
,
5301 .v
.func
= alc269_fixup_quanta_mute
,
5303 [ALC269_FIXUP_LIFEBOOK
] = {
5304 .type
= ALC_FIXUP_PINS
,
5305 .v
.pins
= (const struct alc_pincfg
[]) {
5306 { 0x1a, 0x2101103f }, /* dock line-out */
5307 { 0x1b, 0x23a11040 }, /* dock mic-in */
5311 .chain_id
= ALC269_FIXUP_QUANTA_MUTE
5313 [ALC269_FIXUP_AMIC
] = {
5314 .type
= ALC_FIXUP_PINS
,
5315 .v
.pins
= (const struct alc_pincfg
[]) {
5316 { 0x14, 0x99130110 }, /* speaker */
5317 { 0x15, 0x0121401f }, /* HP out */
5318 { 0x18, 0x01a19c20 }, /* mic */
5319 { 0x19, 0x99a3092f }, /* int-mic */
5323 [ALC269_FIXUP_DMIC
] = {
5324 .type
= ALC_FIXUP_PINS
,
5325 .v
.pins
= (const struct alc_pincfg
[]) {
5326 { 0x12, 0x99a3092f }, /* int-mic */
5327 { 0x14, 0x99130110 }, /* speaker */
5328 { 0x15, 0x0121401f }, /* HP out */
5329 { 0x18, 0x01a19c20 }, /* mic */
5333 [ALC269VB_FIXUP_AMIC
] = {
5334 .type
= ALC_FIXUP_PINS
,
5335 .v
.pins
= (const struct alc_pincfg
[]) {
5336 { 0x14, 0x99130110 }, /* speaker */
5337 { 0x18, 0x01a19c20 }, /* mic */
5338 { 0x19, 0x99a3092f }, /* int-mic */
5339 { 0x21, 0x0121401f }, /* HP out */
5343 [ALC269VB_FIXUP_DMIC
] = {
5344 .type
= ALC_FIXUP_PINS
,
5345 .v
.pins
= (const struct alc_pincfg
[]) {
5346 { 0x12, 0x99a3092f }, /* int-mic */
5347 { 0x14, 0x99130110 }, /* speaker */
5348 { 0x18, 0x01a19c20 }, /* mic */
5349 { 0x21, 0x0121401f }, /* HP out */
5355 static const struct snd_pci_quirk alc269_fixup_tbl
[] = {
5356 SND_PCI_QUIRK(0x1043, 0x1a13, "Asus G73Jw", ALC269_FIXUP_ASUS_G73JW
),
5357 SND_PCI_QUIRK(0x1043, 0x16e3, "ASUS UX50", ALC269_FIXUP_STEREO_DMIC
),
5358 SND_PCI_QUIRK(0x1043, 0x831a, "ASUS P901", ALC269_FIXUP_STEREO_DMIC
),
5359 SND_PCI_QUIRK(0x1043, 0x834a, "ASUS S101", ALC269_FIXUP_STEREO_DMIC
),
5360 SND_PCI_QUIRK(0x1043, 0x8398, "ASUS P1005", ALC269_FIXUP_STEREO_DMIC
),
5361 SND_PCI_QUIRK(0x1043, 0x83ce, "ASUS P1005", ALC269_FIXUP_STEREO_DMIC
),
5362 SND_PCI_QUIRK(0x104d, 0x9073, "Sony VAIO", ALC275_FIXUP_SONY_VAIO_GPIO2
),
5363 SND_PCI_QUIRK(0x104d, 0x907b, "Sony VAIO", ALC275_FIXUP_SONY_HWEQ
),
5364 SND_PCI_QUIRK(0x104d, 0x9084, "Sony VAIO", ALC275_FIXUP_SONY_HWEQ
),
5365 SND_PCI_QUIRK_VENDOR(0x104d, "Sony VAIO", ALC269_FIXUP_SONY_VAIO
),
5366 SND_PCI_QUIRK(0x1028, 0x0470, "Dell M101z", ALC269_FIXUP_DELL_M101Z
),
5367 SND_PCI_QUIRK_VENDOR(0x1025, "Acer Aspire", ALC271_FIXUP_DMIC
),
5368 SND_PCI_QUIRK(0x10cf, 0x1475, "Lifebook", ALC269_FIXUP_LIFEBOOK
),
5369 SND_PCI_QUIRK(0x17aa, 0x20f2, "Thinkpad SL410/510", ALC269_FIXUP_SKU_IGNORE
),
5370 SND_PCI_QUIRK(0x17aa, 0x215e, "Thinkpad L512", ALC269_FIXUP_SKU_IGNORE
),
5371 SND_PCI_QUIRK(0x17aa, 0x21b8, "Thinkpad Edge 14", ALC269_FIXUP_SKU_IGNORE
),
5372 SND_PCI_QUIRK(0x17aa, 0x21ca, "Thinkpad L412", ALC269_FIXUP_SKU_IGNORE
),
5373 SND_PCI_QUIRK(0x17aa, 0x21e9, "Thinkpad Edge 15", ALC269_FIXUP_SKU_IGNORE
),
5374 SND_PCI_QUIRK(0x17aa, 0x3bf8, "Quanta FL1", ALC269_FIXUP_QUANTA_MUTE
),
5375 SND_PCI_QUIRK(0x17aa, 0x3bf8, "Lenovo Ideapd", ALC269_FIXUP_PCM_44K
),
5376 SND_PCI_QUIRK(0x17aa, 0x9e54, "LENOVO NB", ALC269_FIXUP_LENOVO_EAPD
),
5379 /* Below is a quirk table taken from the old code.
5380 * Basically the device should work as is without the fixup table.
5381 * If BIOS doesn't give a proper info, enable the corresponding
5384 SND_PCI_QUIRK(0x1043, 0x8330, "ASUS Eeepc P703 P900A",
5386 SND_PCI_QUIRK(0x1043, 0x1013, "ASUS N61Da", ALC269_FIXUP_AMIC
),
5387 SND_PCI_QUIRK(0x1043, 0x1143, "ASUS B53f", ALC269_FIXUP_AMIC
),
5388 SND_PCI_QUIRK(0x1043, 0x1133, "ASUS UJ20ft", ALC269_FIXUP_AMIC
),
5389 SND_PCI_QUIRK(0x1043, 0x1183, "ASUS K72DR", ALC269_FIXUP_AMIC
),
5390 SND_PCI_QUIRK(0x1043, 0x11b3, "ASUS K52DR", ALC269_FIXUP_AMIC
),
5391 SND_PCI_QUIRK(0x1043, 0x11e3, "ASUS U33Jc", ALC269_FIXUP_AMIC
),
5392 SND_PCI_QUIRK(0x1043, 0x1273, "ASUS UL80Jt", ALC269_FIXUP_AMIC
),
5393 SND_PCI_QUIRK(0x1043, 0x1283, "ASUS U53Jc", ALC269_FIXUP_AMIC
),
5394 SND_PCI_QUIRK(0x1043, 0x12b3, "ASUS N82JV", ALC269_FIXUP_AMIC
),
5395 SND_PCI_QUIRK(0x1043, 0x12d3, "ASUS N61Jv", ALC269_FIXUP_AMIC
),
5396 SND_PCI_QUIRK(0x1043, 0x13a3, "ASUS UL30Vt", ALC269_FIXUP_AMIC
),
5397 SND_PCI_QUIRK(0x1043, 0x1373, "ASUS G73JX", ALC269_FIXUP_AMIC
),
5398 SND_PCI_QUIRK(0x1043, 0x1383, "ASUS UJ30Jc", ALC269_FIXUP_AMIC
),
5399 SND_PCI_QUIRK(0x1043, 0x13d3, "ASUS N61JA", ALC269_FIXUP_AMIC
),
5400 SND_PCI_QUIRK(0x1043, 0x1413, "ASUS UL50", ALC269_FIXUP_AMIC
),
5401 SND_PCI_QUIRK(0x1043, 0x1443, "ASUS UL30", ALC269_FIXUP_AMIC
),
5402 SND_PCI_QUIRK(0x1043, 0x1453, "ASUS M60Jv", ALC269_FIXUP_AMIC
),
5403 SND_PCI_QUIRK(0x1043, 0x1483, "ASUS UL80", ALC269_FIXUP_AMIC
),
5404 SND_PCI_QUIRK(0x1043, 0x14f3, "ASUS F83Vf", ALC269_FIXUP_AMIC
),
5405 SND_PCI_QUIRK(0x1043, 0x14e3, "ASUS UL20", ALC269_FIXUP_AMIC
),
5406 SND_PCI_QUIRK(0x1043, 0x1513, "ASUS UX30", ALC269_FIXUP_AMIC
),
5407 SND_PCI_QUIRK(0x1043, 0x1593, "ASUS N51Vn", ALC269_FIXUP_AMIC
),
5408 SND_PCI_QUIRK(0x1043, 0x15a3, "ASUS N60Jv", ALC269_FIXUP_AMIC
),
5409 SND_PCI_QUIRK(0x1043, 0x15b3, "ASUS N60Dp", ALC269_FIXUP_AMIC
),
5410 SND_PCI_QUIRK(0x1043, 0x15c3, "ASUS N70De", ALC269_FIXUP_AMIC
),
5411 SND_PCI_QUIRK(0x1043, 0x15e3, "ASUS F83T", ALC269_FIXUP_AMIC
),
5412 SND_PCI_QUIRK(0x1043, 0x1643, "ASUS M60J", ALC269_FIXUP_AMIC
),
5413 SND_PCI_QUIRK(0x1043, 0x1653, "ASUS U50", ALC269_FIXUP_AMIC
),
5414 SND_PCI_QUIRK(0x1043, 0x1693, "ASUS F50N", ALC269_FIXUP_AMIC
),
5415 SND_PCI_QUIRK(0x1043, 0x16a3, "ASUS F5Q", ALC269_FIXUP_AMIC
),
5416 SND_PCI_QUIRK(0x1043, 0x1723, "ASUS P80", ALC269_FIXUP_AMIC
),
5417 SND_PCI_QUIRK(0x1043, 0x1743, "ASUS U80", ALC269_FIXUP_AMIC
),
5418 SND_PCI_QUIRK(0x1043, 0x1773, "ASUS U20A", ALC269_FIXUP_AMIC
),
5419 SND_PCI_QUIRK(0x1043, 0x1883, "ASUS F81Se", ALC269_FIXUP_AMIC
),
5420 SND_PCI_QUIRK(0x152d, 0x1778, "Quanta ON1", ALC269_FIXUP_DMIC
),
5421 SND_PCI_QUIRK(0x17aa, 0x3be9, "Quanta Wistron", ALC269_FIXUP_AMIC
),
5422 SND_PCI_QUIRK(0x17aa, 0x3bf8, "Quanta FL1", ALC269_FIXUP_AMIC
),
5423 SND_PCI_QUIRK(0x17ff, 0x059a, "Quanta EL3", ALC269_FIXUP_DMIC
),
5424 SND_PCI_QUIRK(0x17ff, 0x059b, "Quanta JR1", ALC269_FIXUP_DMIC
),
5429 static const struct alc_model_fixup alc269_fixup_models
[] = {
5430 {.id
= ALC269_FIXUP_AMIC
, .name
= "laptop-amic"},
5431 {.id
= ALC269_FIXUP_DMIC
, .name
= "laptop-dmic"},
5436 static int alc269_fill_coef(struct hda_codec
*codec
)
5440 if ((alc_get_coef0(codec
) & 0x00ff) < 0x015) {
5441 alc_write_coef_idx(codec
, 0xf, 0x960b);
5442 alc_write_coef_idx(codec
, 0xe, 0x8817);
5445 if ((alc_get_coef0(codec
) & 0x00ff) == 0x016) {
5446 alc_write_coef_idx(codec
, 0xf, 0x960b);
5447 alc_write_coef_idx(codec
, 0xe, 0x8814);
5450 if ((alc_get_coef0(codec
) & 0x00ff) == 0x017) {
5451 val
= alc_read_coef_idx(codec
, 0x04);
5452 /* Power up output pin */
5453 alc_write_coef_idx(codec
, 0x04, val
| (1<<11));
5456 if ((alc_get_coef0(codec
) & 0x00ff) == 0x018) {
5457 val
= alc_read_coef_idx(codec
, 0xd);
5458 if ((val
& 0x0c00) >> 10 != 0x1) {
5459 /* Capless ramp up clock control */
5460 alc_write_coef_idx(codec
, 0xd, val
| (1<<10));
5462 val
= alc_read_coef_idx(codec
, 0x17);
5463 if ((val
& 0x01c0) >> 6 != 0x4) {
5464 /* Class D power on reset */
5465 alc_write_coef_idx(codec
, 0x17, val
| (1<<7));
5469 val
= alc_read_coef_idx(codec
, 0xd); /* Class D */
5470 alc_write_coef_idx(codec
, 0xd, val
| (1<<14));
5472 val
= alc_read_coef_idx(codec
, 0x4); /* HP */
5473 alc_write_coef_idx(codec
, 0x4, val
| (1<<11));
5480 static int patch_alc269(struct hda_codec
*codec
)
5482 struct alc_spec
*spec
;
5485 spec
= kzalloc(sizeof(*spec
), GFP_KERNEL
);
5491 spec
->mixer_nid
= 0x0b;
5493 alc_auto_parse_customize_define(codec
);
5495 err
= alc_codec_rename_from_preset(codec
);
5499 if (codec
->vendor_id
== 0x10ec0269) {
5500 spec
->codec_variant
= ALC269_TYPE_ALC269VA
;
5501 switch (alc_get_coef0(codec
) & 0x00f0) {
5503 if (codec
->bus
->pci
->subsystem_vendor
== 0x1025 &&
5504 spec
->cdefine
.platform_type
== 1)
5505 err
= alc_codec_rename(codec
, "ALC271X");
5506 spec
->codec_variant
= ALC269_TYPE_ALC269VB
;
5509 if (codec
->bus
->pci
->subsystem_vendor
== 0x17aa &&
5510 codec
->bus
->pci
->subsystem_device
== 0x21f3)
5511 err
= alc_codec_rename(codec
, "ALC3202");
5512 spec
->codec_variant
= ALC269_TYPE_ALC269VC
;
5515 alc_fix_pll_init(codec
, 0x20, 0x04, 15);
5519 alc269_fill_coef(codec
);
5522 alc_pick_fixup(codec
, alc269_fixup_models
,
5523 alc269_fixup_tbl
, alc269_fixups
);
5524 alc_apply_fixup(codec
, ALC_FIXUP_ACT_PRE_PROBE
);
5526 /* automatic parse from the BIOS config */
5527 err
= alc269_parse_auto_config(codec
);
5531 if (!spec
->no_analog
&& !spec
->adc_nids
) {
5532 alc_auto_fill_adc_caps(codec
);
5533 alc_rebuild_imux_for_auto_mic(codec
);
5534 alc_remove_invalid_adc_nids(codec
);
5537 if (!spec
->no_analog
&& !spec
->cap_mixer
)
5538 set_capture_mixer(codec
);
5540 if (!spec
->no_analog
&& has_cdefine_beep(codec
)) {
5541 err
= snd_hda_attach_beep_device(codec
, 0x1);
5544 set_beep_amp(spec
, 0x0b, 0x04, HDA_INPUT
);
5547 alc_apply_fixup(codec
, ALC_FIXUP_ACT_PROBE
);
5549 codec
->patch_ops
= alc_patch_ops
;
5551 codec
->patch_ops
.resume
= alc269_resume
;
5553 spec
->init_hook
= alc_auto_init_std
;
5554 spec
->shutup
= alc269_shutup
;
5556 #ifdef CONFIG_SND_HDA_POWER_SAVE
5557 if (!spec
->loopback
.amplist
)
5558 spec
->loopback
.amplist
= alc269_loopbacks
;
5559 if (alc269_mic2_for_mute_led(codec
))
5560 codec
->patch_ops
.check_power_status
= alc269_mic2_mute_check_ps
;
5574 static int alc861_parse_auto_config(struct hda_codec
*codec
)
5576 static const hda_nid_t alc861_ignore
[] = { 0x1d, 0 };
5577 static const hda_nid_t alc861_ssids
[] = { 0x0e, 0x0f, 0x0b, 0 };
5578 return alc_parse_auto_config(codec
, alc861_ignore
, alc861_ssids
);
5581 #ifdef CONFIG_SND_HDA_POWER_SAVE
5582 static const struct hda_amp_list alc861_loopbacks
[] = {
5583 { 0x15, HDA_INPUT
, 0 },
5584 { 0x15, HDA_INPUT
, 1 },
5585 { 0x15, HDA_INPUT
, 2 },
5586 { 0x15, HDA_INPUT
, 3 },
5592 /* Pin config fixes */
5594 ALC861_FIXUP_FSC_AMILO_PI1505
,
5595 ALC861_FIXUP_AMP_VREF_0F
,
5596 ALC861_FIXUP_NO_JACK_DETECT
,
5597 ALC861_FIXUP_ASUS_A6RP
,
5600 /* On some laptops, VREF of pin 0x0f is abused for controlling the main amp */
5601 static void alc861_fixup_asus_amp_vref_0f(struct hda_codec
*codec
,
5602 const struct alc_fixup
*fix
, int action
)
5604 struct alc_spec
*spec
= codec
->spec
;
5607 if (action
!= ALC_FIXUP_ACT_INIT
)
5609 val
= snd_hda_codec_read(codec
, 0x0f, 0,
5610 AC_VERB_GET_PIN_WIDGET_CONTROL
, 0);
5611 if (!(val
& (AC_PINCTL_IN_EN
| AC_PINCTL_OUT_EN
)))
5612 val
|= AC_PINCTL_IN_EN
;
5613 val
|= AC_PINCTL_VREF_50
;
5614 snd_hda_codec_write(codec
, 0x0f, 0,
5615 AC_VERB_SET_PIN_WIDGET_CONTROL
, val
);
5616 spec
->keep_vref_in_automute
= 1;
5619 /* suppress the jack-detection */
5620 static void alc_fixup_no_jack_detect(struct hda_codec
*codec
,
5621 const struct alc_fixup
*fix
, int action
)
5623 if (action
== ALC_FIXUP_ACT_PRE_PROBE
)
5624 codec
->no_jack_detect
= 1;
5627 static const struct alc_fixup alc861_fixups
[] = {
5628 [ALC861_FIXUP_FSC_AMILO_PI1505
] = {
5629 .type
= ALC_FIXUP_PINS
,
5630 .v
.pins
= (const struct alc_pincfg
[]) {
5631 { 0x0b, 0x0221101f }, /* HP */
5632 { 0x0f, 0x90170310 }, /* speaker */
5636 [ALC861_FIXUP_AMP_VREF_0F
] = {
5637 .type
= ALC_FIXUP_FUNC
,
5638 .v
.func
= alc861_fixup_asus_amp_vref_0f
,
5640 [ALC861_FIXUP_NO_JACK_DETECT
] = {
5641 .type
= ALC_FIXUP_FUNC
,
5642 .v
.func
= alc_fixup_no_jack_detect
,
5644 [ALC861_FIXUP_ASUS_A6RP
] = {
5645 .type
= ALC_FIXUP_FUNC
,
5646 .v
.func
= alc861_fixup_asus_amp_vref_0f
,
5648 .chain_id
= ALC861_FIXUP_NO_JACK_DETECT
,
5652 static const struct snd_pci_quirk alc861_fixup_tbl
[] = {
5653 SND_PCI_QUIRK(0x1043, 0x1393, "ASUS A6Rp", ALC861_FIXUP_ASUS_A6RP
),
5654 SND_PCI_QUIRK_VENDOR(0x1043, "ASUS laptop", ALC861_FIXUP_AMP_VREF_0F
),
5655 SND_PCI_QUIRK(0x1462, 0x7254, "HP DX2200", ALC861_FIXUP_NO_JACK_DETECT
),
5656 SND_PCI_QUIRK(0x1584, 0x2b01, "Haier W18", ALC861_FIXUP_AMP_VREF_0F
),
5657 SND_PCI_QUIRK(0x1584, 0x0000, "Uniwill ECS M31EI", ALC861_FIXUP_AMP_VREF_0F
),
5658 SND_PCI_QUIRK(0x1734, 0x10c7, "FSC Amilo Pi1505", ALC861_FIXUP_FSC_AMILO_PI1505
),
5664 static int patch_alc861(struct hda_codec
*codec
)
5666 struct alc_spec
*spec
;
5669 spec
= kzalloc(sizeof(*spec
), GFP_KERNEL
);
5675 spec
->mixer_nid
= 0x15;
5677 alc_pick_fixup(codec
, NULL
, alc861_fixup_tbl
, alc861_fixups
);
5678 alc_apply_fixup(codec
, ALC_FIXUP_ACT_PRE_PROBE
);
5680 /* automatic parse from the BIOS config */
5681 err
= alc861_parse_auto_config(codec
);
5685 if (!spec
->no_analog
&& !spec
->adc_nids
) {
5686 alc_auto_fill_adc_caps(codec
);
5687 alc_rebuild_imux_for_auto_mic(codec
);
5688 alc_remove_invalid_adc_nids(codec
);
5691 if (!spec
->no_analog
&& !spec
->cap_mixer
)
5692 set_capture_mixer(codec
);
5694 if (!spec
->no_analog
) {
5695 err
= snd_hda_attach_beep_device(codec
, 0x23);
5698 set_beep_amp(spec
, 0x23, 0, HDA_OUTPUT
);
5701 alc_apply_fixup(codec
, ALC_FIXUP_ACT_PROBE
);
5703 codec
->patch_ops
= alc_patch_ops
;
5704 spec
->init_hook
= alc_auto_init_std
;
5705 #ifdef CONFIG_SND_HDA_POWER_SAVE
5706 spec
->power_hook
= alc_power_eapd
;
5707 if (!spec
->loopback
.amplist
)
5708 spec
->loopback
.amplist
= alc861_loopbacks
;
5723 * In addition, an independent DAC
5725 #ifdef CONFIG_SND_HDA_POWER_SAVE
5726 #define alc861vd_loopbacks alc880_loopbacks
5729 static int alc861vd_parse_auto_config(struct hda_codec
*codec
)
5731 static const hda_nid_t alc861vd_ignore
[] = { 0x1d, 0 };
5732 static const hda_nid_t alc861vd_ssids
[] = { 0x15, 0x1b, 0x14, 0 };
5733 return alc_parse_auto_config(codec
, alc861vd_ignore
, alc861vd_ssids
);
5737 ALC660VD_FIX_ASUS_GPIO1
,
5738 ALC861VD_FIX_DALLAS
,
5741 /* exclude VREF80 */
5742 static void alc861vd_fixup_dallas(struct hda_codec
*codec
,
5743 const struct alc_fixup
*fix
, int action
)
5745 if (action
== ALC_FIXUP_ACT_PRE_PROBE
) {
5746 snd_hda_override_pin_caps(codec
, 0x18, 0x00001714);
5747 snd_hda_override_pin_caps(codec
, 0x19, 0x0000171c);
5751 static const struct alc_fixup alc861vd_fixups
[] = {
5752 [ALC660VD_FIX_ASUS_GPIO1
] = {
5753 .type
= ALC_FIXUP_VERBS
,
5754 .v
.verbs
= (const struct hda_verb
[]) {
5756 {0x01, AC_VERB_SET_GPIO_MASK
, 0x03},
5757 {0x01, AC_VERB_SET_GPIO_DIRECTION
, 0x01},
5758 {0x01, AC_VERB_SET_GPIO_DATA
, 0x01},
5762 [ALC861VD_FIX_DALLAS
] = {
5763 .type
= ALC_FIXUP_FUNC
,
5764 .v
.func
= alc861vd_fixup_dallas
,
5768 static const struct snd_pci_quirk alc861vd_fixup_tbl
[] = {
5769 SND_PCI_QUIRK(0x103c, 0x30bf, "HP TX1000", ALC861VD_FIX_DALLAS
),
5770 SND_PCI_QUIRK(0x1043, 0x1339, "ASUS A7-K", ALC660VD_FIX_ASUS_GPIO1
),
5771 SND_PCI_QUIRK(0x1179, 0xff31, "Toshiba L30-149", ALC861VD_FIX_DALLAS
),
5775 static const struct hda_verb alc660vd_eapd_verbs
[] = {
5776 {0x14, AC_VERB_SET_EAPD_BTLENABLE
, 2},
5777 {0x15, AC_VERB_SET_EAPD_BTLENABLE
, 2},
5783 static int patch_alc861vd(struct hda_codec
*codec
)
5785 struct alc_spec
*spec
;
5788 spec
= kzalloc(sizeof(*spec
), GFP_KERNEL
);
5794 spec
->mixer_nid
= 0x0b;
5796 alc_pick_fixup(codec
, NULL
, alc861vd_fixup_tbl
, alc861vd_fixups
);
5797 alc_apply_fixup(codec
, ALC_FIXUP_ACT_PRE_PROBE
);
5799 /* automatic parse from the BIOS config */
5800 err
= alc861vd_parse_auto_config(codec
);
5804 if (codec
->vendor_id
== 0x10ec0660) {
5805 /* always turn on EAPD */
5806 add_verb(spec
, alc660vd_eapd_verbs
);
5809 if (!spec
->no_analog
&& !spec
->adc_nids
) {
5810 alc_auto_fill_adc_caps(codec
);
5811 alc_rebuild_imux_for_auto_mic(codec
);
5812 alc_remove_invalid_adc_nids(codec
);
5815 if (!spec
->no_analog
&& !spec
->cap_mixer
)
5816 set_capture_mixer(codec
);
5818 if (!spec
->no_analog
) {
5819 err
= snd_hda_attach_beep_device(codec
, 0x23);
5822 set_beep_amp(spec
, 0x0b, 0x05, HDA_INPUT
);
5825 alc_apply_fixup(codec
, ALC_FIXUP_ACT_PROBE
);
5827 codec
->patch_ops
= alc_patch_ops
;
5829 spec
->init_hook
= alc_auto_init_std
;
5830 spec
->shutup
= alc_eapd_shutup
;
5831 #ifdef CONFIG_SND_HDA_POWER_SAVE
5832 if (!spec
->loopback
.amplist
)
5833 spec
->loopback
.amplist
= alc861vd_loopbacks
;
5846 * ALC662 is almost identical with ALC880 but has cleaner and more flexible
5847 * configuration. Each pin widget can choose any input DACs and a mixer.
5848 * Each ADC is connected from a mixer of all inputs. This makes possible
5849 * 6-channel independent captures.
5851 * In addition, an independent DAC for the multi-playback (not used in this
5854 #ifdef CONFIG_SND_HDA_POWER_SAVE
5855 #define alc662_loopbacks alc880_loopbacks
5859 * BIOS auto configuration
5862 static int alc662_parse_auto_config(struct hda_codec
*codec
)
5864 static const hda_nid_t alc662_ignore
[] = { 0x1d, 0 };
5865 static const hda_nid_t alc663_ssids
[] = { 0x15, 0x1b, 0x14, 0x21 };
5866 static const hda_nid_t alc662_ssids
[] = { 0x15, 0x1b, 0x14, 0 };
5867 const hda_nid_t
*ssids
;
5869 if (codec
->vendor_id
== 0x10ec0272 || codec
->vendor_id
== 0x10ec0663 ||
5870 codec
->vendor_id
== 0x10ec0665 || codec
->vendor_id
== 0x10ec0670)
5871 ssids
= alc663_ssids
;
5873 ssids
= alc662_ssids
;
5874 return alc_parse_auto_config(codec
, alc662_ignore
, ssids
);
5877 static void alc272_fixup_mario(struct hda_codec
*codec
,
5878 const struct alc_fixup
*fix
, int action
)
5880 if (action
!= ALC_FIXUP_ACT_PROBE
)
5882 if (snd_hda_override_amp_caps(codec
, 0x2, HDA_OUTPUT
,
5883 (0x3b << AC_AMPCAP_OFFSET_SHIFT
) |
5884 (0x3b << AC_AMPCAP_NUM_STEPS_SHIFT
) |
5885 (0x03 << AC_AMPCAP_STEP_SIZE_SHIFT
) |
5886 (0 << AC_AMPCAP_MUTE_SHIFT
)))
5888 "hda_codec: failed to override amp caps for NID 0x2\n");
5892 ALC662_FIXUP_ASPIRE
,
5893 ALC662_FIXUP_IDEAPAD
,
5895 ALC662_FIXUP_CZC_P10T
,
5896 ALC662_FIXUP_SKU_IGNORE
,
5897 ALC662_FIXUP_HP_RP5800
,
5898 ALC662_FIXUP_ASUS_MODE1
,
5899 ALC662_FIXUP_ASUS_MODE2
,
5900 ALC662_FIXUP_ASUS_MODE3
,
5901 ALC662_FIXUP_ASUS_MODE4
,
5902 ALC662_FIXUP_ASUS_MODE5
,
5903 ALC662_FIXUP_ASUS_MODE6
,
5904 ALC662_FIXUP_ASUS_MODE7
,
5905 ALC662_FIXUP_ASUS_MODE8
,
5906 ALC662_FIXUP_NO_JACK_DETECT
,
5909 static const struct alc_fixup alc662_fixups
[] = {
5910 [ALC662_FIXUP_ASPIRE
] = {
5911 .type
= ALC_FIXUP_PINS
,
5912 .v
.pins
= (const struct alc_pincfg
[]) {
5913 { 0x15, 0x99130112 }, /* subwoofer */
5917 [ALC662_FIXUP_IDEAPAD
] = {
5918 .type
= ALC_FIXUP_PINS
,
5919 .v
.pins
= (const struct alc_pincfg
[]) {
5920 { 0x17, 0x99130112 }, /* subwoofer */
5924 [ALC272_FIXUP_MARIO
] = {
5925 .type
= ALC_FIXUP_FUNC
,
5926 .v
.func
= alc272_fixup_mario
,
5928 [ALC662_FIXUP_CZC_P10T
] = {
5929 .type
= ALC_FIXUP_VERBS
,
5930 .v
.verbs
= (const struct hda_verb
[]) {
5931 {0x14, AC_VERB_SET_EAPD_BTLENABLE
, 0},
5935 [ALC662_FIXUP_SKU_IGNORE
] = {
5936 .type
= ALC_FIXUP_SKU
,
5937 .v
.sku
= ALC_FIXUP_SKU_IGNORE
,
5939 [ALC662_FIXUP_HP_RP5800
] = {
5940 .type
= ALC_FIXUP_PINS
,
5941 .v
.pins
= (const struct alc_pincfg
[]) {
5942 { 0x14, 0x0221201f }, /* HP out */
5946 .chain_id
= ALC662_FIXUP_SKU_IGNORE
5948 [ALC662_FIXUP_ASUS_MODE1
] = {
5949 .type
= ALC_FIXUP_PINS
,
5950 .v
.pins
= (const struct alc_pincfg
[]) {
5951 { 0x14, 0x99130110 }, /* speaker */
5952 { 0x18, 0x01a19c20 }, /* mic */
5953 { 0x19, 0x99a3092f }, /* int-mic */
5954 { 0x21, 0x0121401f }, /* HP out */
5958 .chain_id
= ALC662_FIXUP_SKU_IGNORE
5960 [ALC662_FIXUP_ASUS_MODE2
] = {
5961 .type
= ALC_FIXUP_PINS
,
5962 .v
.pins
= (const struct alc_pincfg
[]) {
5963 { 0x14, 0x99130110 }, /* speaker */
5964 { 0x18, 0x01a19820 }, /* mic */
5965 { 0x19, 0x99a3092f }, /* int-mic */
5966 { 0x1b, 0x0121401f }, /* HP out */
5970 .chain_id
= ALC662_FIXUP_SKU_IGNORE
5972 [ALC662_FIXUP_ASUS_MODE3
] = {
5973 .type
= ALC_FIXUP_PINS
,
5974 .v
.pins
= (const struct alc_pincfg
[]) {
5975 { 0x14, 0x99130110 }, /* speaker */
5976 { 0x15, 0x0121441f }, /* HP */
5977 { 0x18, 0x01a19840 }, /* mic */
5978 { 0x19, 0x99a3094f }, /* int-mic */
5979 { 0x21, 0x01211420 }, /* HP2 */
5983 .chain_id
= ALC662_FIXUP_SKU_IGNORE
5985 [ALC662_FIXUP_ASUS_MODE4
] = {
5986 .type
= ALC_FIXUP_PINS
,
5987 .v
.pins
= (const struct alc_pincfg
[]) {
5988 { 0x14, 0x99130110 }, /* speaker */
5989 { 0x16, 0x99130111 }, /* speaker */
5990 { 0x18, 0x01a19840 }, /* mic */
5991 { 0x19, 0x99a3094f }, /* int-mic */
5992 { 0x21, 0x0121441f }, /* HP */
5996 .chain_id
= ALC662_FIXUP_SKU_IGNORE
5998 [ALC662_FIXUP_ASUS_MODE5
] = {
5999 .type
= ALC_FIXUP_PINS
,
6000 .v
.pins
= (const struct alc_pincfg
[]) {
6001 { 0x14, 0x99130110 }, /* speaker */
6002 { 0x15, 0x0121441f }, /* HP */
6003 { 0x16, 0x99130111 }, /* speaker */
6004 { 0x18, 0x01a19840 }, /* mic */
6005 { 0x19, 0x99a3094f }, /* int-mic */
6009 .chain_id
= ALC662_FIXUP_SKU_IGNORE
6011 [ALC662_FIXUP_ASUS_MODE6
] = {
6012 .type
= ALC_FIXUP_PINS
,
6013 .v
.pins
= (const struct alc_pincfg
[]) {
6014 { 0x14, 0x99130110 }, /* speaker */
6015 { 0x15, 0x01211420 }, /* HP2 */
6016 { 0x18, 0x01a19840 }, /* mic */
6017 { 0x19, 0x99a3094f }, /* int-mic */
6018 { 0x1b, 0x0121441f }, /* HP */
6022 .chain_id
= ALC662_FIXUP_SKU_IGNORE
6024 [ALC662_FIXUP_ASUS_MODE7
] = {
6025 .type
= ALC_FIXUP_PINS
,
6026 .v
.pins
= (const struct alc_pincfg
[]) {
6027 { 0x14, 0x99130110 }, /* speaker */
6028 { 0x17, 0x99130111 }, /* speaker */
6029 { 0x18, 0x01a19840 }, /* mic */
6030 { 0x19, 0x99a3094f }, /* int-mic */
6031 { 0x1b, 0x01214020 }, /* HP */
6032 { 0x21, 0x0121401f }, /* HP */
6036 .chain_id
= ALC662_FIXUP_SKU_IGNORE
6038 [ALC662_FIXUP_ASUS_MODE8
] = {
6039 .type
= ALC_FIXUP_PINS
,
6040 .v
.pins
= (const struct alc_pincfg
[]) {
6041 { 0x14, 0x99130110 }, /* speaker */
6042 { 0x12, 0x99a30970 }, /* int-mic */
6043 { 0x15, 0x01214020 }, /* HP */
6044 { 0x17, 0x99130111 }, /* speaker */
6045 { 0x18, 0x01a19840 }, /* mic */
6046 { 0x21, 0x0121401f }, /* HP */
6050 .chain_id
= ALC662_FIXUP_SKU_IGNORE
6052 [ALC662_FIXUP_NO_JACK_DETECT
] = {
6053 .type
= ALC_FIXUP_FUNC
,
6054 .v
.func
= alc_fixup_no_jack_detect
,
6058 static const struct snd_pci_quirk alc662_fixup_tbl
[] = {
6059 SND_PCI_QUIRK(0x1019, 0x9087, "ECS", ALC662_FIXUP_ASUS_MODE2
),
6060 SND_PCI_QUIRK(0x1025, 0x0308, "Acer Aspire 8942G", ALC662_FIXUP_ASPIRE
),
6061 SND_PCI_QUIRK(0x1025, 0x031c, "Gateway NV79", ALC662_FIXUP_SKU_IGNORE
),
6062 SND_PCI_QUIRK(0x1025, 0x038b, "Acer Aspire 8943G", ALC662_FIXUP_ASPIRE
),
6063 SND_PCI_QUIRK(0x103c, 0x1632, "HP RP5800", ALC662_FIXUP_HP_RP5800
),
6064 SND_PCI_QUIRK(0x1043, 0x8469, "ASUS mobo", ALC662_FIXUP_NO_JACK_DETECT
),
6065 SND_PCI_QUIRK(0x105b, 0x0cd6, "Foxconn", ALC662_FIXUP_ASUS_MODE2
),
6066 SND_PCI_QUIRK(0x144d, 0xc051, "Samsung R720", ALC662_FIXUP_IDEAPAD
),
6067 SND_PCI_QUIRK(0x17aa, 0x38af, "Lenovo Ideapad Y550P", ALC662_FIXUP_IDEAPAD
),
6068 SND_PCI_QUIRK(0x17aa, 0x3a0d, "Lenovo Ideapad Y550", ALC662_FIXUP_IDEAPAD
),
6069 SND_PCI_QUIRK(0x1b35, 0x2206, "CZC P10T", ALC662_FIXUP_CZC_P10T
),
6072 /* Below is a quirk table taken from the old code.
6073 * Basically the device should work as is without the fixup table.
6074 * If BIOS doesn't give a proper info, enable the corresponding
6077 SND_PCI_QUIRK(0x1043, 0x1000, "ASUS N50Vm", ALC662_FIXUP_ASUS_MODE1
),
6078 SND_PCI_QUIRK(0x1043, 0x1092, "ASUS NB", ALC662_FIXUP_ASUS_MODE3
),
6079 SND_PCI_QUIRK(0x1043, 0x1173, "ASUS K73Jn", ALC662_FIXUP_ASUS_MODE1
),
6080 SND_PCI_QUIRK(0x1043, 0x11c3, "ASUS M70V", ALC662_FIXUP_ASUS_MODE3
),
6081 SND_PCI_QUIRK(0x1043, 0x11d3, "ASUS NB", ALC662_FIXUP_ASUS_MODE1
),
6082 SND_PCI_QUIRK(0x1043, 0x11f3, "ASUS NB", ALC662_FIXUP_ASUS_MODE2
),
6083 SND_PCI_QUIRK(0x1043, 0x1203, "ASUS NB", ALC662_FIXUP_ASUS_MODE1
),
6084 SND_PCI_QUIRK(0x1043, 0x1303, "ASUS G60J", ALC662_FIXUP_ASUS_MODE1
),
6085 SND_PCI_QUIRK(0x1043, 0x1333, "ASUS G60Jx", ALC662_FIXUP_ASUS_MODE1
),
6086 SND_PCI_QUIRK(0x1043, 0x1339, "ASUS NB", ALC662_FIXUP_ASUS_MODE2
),
6087 SND_PCI_QUIRK(0x1043, 0x13e3, "ASUS N71JA", ALC662_FIXUP_ASUS_MODE7
),
6088 SND_PCI_QUIRK(0x1043, 0x1463, "ASUS N71", ALC662_FIXUP_ASUS_MODE7
),
6089 SND_PCI_QUIRK(0x1043, 0x14d3, "ASUS G72", ALC662_FIXUP_ASUS_MODE8
),
6090 SND_PCI_QUIRK(0x1043, 0x1563, "ASUS N90", ALC662_FIXUP_ASUS_MODE3
),
6091 SND_PCI_QUIRK(0x1043, 0x15d3, "ASUS N50SF F50SF", ALC662_FIXUP_ASUS_MODE1
),
6092 SND_PCI_QUIRK(0x1043, 0x16c3, "ASUS NB", ALC662_FIXUP_ASUS_MODE2
),
6093 SND_PCI_QUIRK(0x1043, 0x16f3, "ASUS K40C K50C", ALC662_FIXUP_ASUS_MODE2
),
6094 SND_PCI_QUIRK(0x1043, 0x1733, "ASUS N81De", ALC662_FIXUP_ASUS_MODE1
),
6095 SND_PCI_QUIRK(0x1043, 0x1753, "ASUS NB", ALC662_FIXUP_ASUS_MODE2
),
6096 SND_PCI_QUIRK(0x1043, 0x1763, "ASUS NB", ALC662_FIXUP_ASUS_MODE6
),
6097 SND_PCI_QUIRK(0x1043, 0x1765, "ASUS NB", ALC662_FIXUP_ASUS_MODE6
),
6098 SND_PCI_QUIRK(0x1043, 0x1783, "ASUS NB", ALC662_FIXUP_ASUS_MODE2
),
6099 SND_PCI_QUIRK(0x1043, 0x1793, "ASUS F50GX", ALC662_FIXUP_ASUS_MODE1
),
6100 SND_PCI_QUIRK(0x1043, 0x17b3, "ASUS F70SL", ALC662_FIXUP_ASUS_MODE3
),
6101 SND_PCI_QUIRK(0x1043, 0x17f3, "ASUS X58LE", ALC662_FIXUP_ASUS_MODE2
),
6102 SND_PCI_QUIRK(0x1043, 0x1813, "ASUS NB", ALC662_FIXUP_ASUS_MODE2
),
6103 SND_PCI_QUIRK(0x1043, 0x1823, "ASUS NB", ALC662_FIXUP_ASUS_MODE5
),
6104 SND_PCI_QUIRK(0x1043, 0x1833, "ASUS NB", ALC662_FIXUP_ASUS_MODE6
),
6105 SND_PCI_QUIRK(0x1043, 0x1843, "ASUS NB", ALC662_FIXUP_ASUS_MODE2
),
6106 SND_PCI_QUIRK(0x1043, 0x1853, "ASUS F50Z", ALC662_FIXUP_ASUS_MODE1
),
6107 SND_PCI_QUIRK(0x1043, 0x1864, "ASUS NB", ALC662_FIXUP_ASUS_MODE2
),
6108 SND_PCI_QUIRK(0x1043, 0x1876, "ASUS NB", ALC662_FIXUP_ASUS_MODE2
),
6109 SND_PCI_QUIRK(0x1043, 0x1893, "ASUS M50Vm", ALC662_FIXUP_ASUS_MODE3
),
6110 SND_PCI_QUIRK(0x1043, 0x1894, "ASUS X55", ALC662_FIXUP_ASUS_MODE3
),
6111 SND_PCI_QUIRK(0x1043, 0x18b3, "ASUS N80Vc", ALC662_FIXUP_ASUS_MODE1
),
6112 SND_PCI_QUIRK(0x1043, 0x18c3, "ASUS VX5", ALC662_FIXUP_ASUS_MODE1
),
6113 SND_PCI_QUIRK(0x1043, 0x18d3, "ASUS N81Te", ALC662_FIXUP_ASUS_MODE1
),
6114 SND_PCI_QUIRK(0x1043, 0x18f3, "ASUS N505Tp", ALC662_FIXUP_ASUS_MODE1
),
6115 SND_PCI_QUIRK(0x1043, 0x1903, "ASUS F5GL", ALC662_FIXUP_ASUS_MODE1
),
6116 SND_PCI_QUIRK(0x1043, 0x1913, "ASUS NB", ALC662_FIXUP_ASUS_MODE2
),
6117 SND_PCI_QUIRK(0x1043, 0x1933, "ASUS F80Q", ALC662_FIXUP_ASUS_MODE2
),
6118 SND_PCI_QUIRK(0x1043, 0x1943, "ASUS Vx3V", ALC662_FIXUP_ASUS_MODE1
),
6119 SND_PCI_QUIRK(0x1043, 0x1953, "ASUS NB", ALC662_FIXUP_ASUS_MODE1
),
6120 SND_PCI_QUIRK(0x1043, 0x1963, "ASUS X71C", ALC662_FIXUP_ASUS_MODE3
),
6121 SND_PCI_QUIRK(0x1043, 0x1983, "ASUS N5051A", ALC662_FIXUP_ASUS_MODE1
),
6122 SND_PCI_QUIRK(0x1043, 0x1993, "ASUS N20", ALC662_FIXUP_ASUS_MODE1
),
6123 SND_PCI_QUIRK(0x1043, 0x19b3, "ASUS F7Z", ALC662_FIXUP_ASUS_MODE1
),
6124 SND_PCI_QUIRK(0x1043, 0x19c3, "ASUS F5Z/F6x", ALC662_FIXUP_ASUS_MODE2
),
6125 SND_PCI_QUIRK(0x1043, 0x19e3, "ASUS NB", ALC662_FIXUP_ASUS_MODE1
),
6126 SND_PCI_QUIRK(0x1043, 0x19f3, "ASUS NB", ALC662_FIXUP_ASUS_MODE4
),
6131 static const struct alc_model_fixup alc662_fixup_models
[] = {
6132 {.id
= ALC272_FIXUP_MARIO
, .name
= "mario"},
6133 {.id
= ALC662_FIXUP_ASUS_MODE1
, .name
= "asus-mode1"},
6134 {.id
= ALC662_FIXUP_ASUS_MODE2
, .name
= "asus-mode2"},
6135 {.id
= ALC662_FIXUP_ASUS_MODE3
, .name
= "asus-mode3"},
6136 {.id
= ALC662_FIXUP_ASUS_MODE4
, .name
= "asus-mode4"},
6137 {.id
= ALC662_FIXUP_ASUS_MODE5
, .name
= "asus-mode5"},
6138 {.id
= ALC662_FIXUP_ASUS_MODE6
, .name
= "asus-mode6"},
6139 {.id
= ALC662_FIXUP_ASUS_MODE7
, .name
= "asus-mode7"},
6140 {.id
= ALC662_FIXUP_ASUS_MODE8
, .name
= "asus-mode8"},
6147 static int patch_alc662(struct hda_codec
*codec
)
6149 struct alc_spec
*spec
;
6152 spec
= kzalloc(sizeof(*spec
), GFP_KERNEL
);
6158 spec
->mixer_nid
= 0x0b;
6160 /* handle multiple HPs as is */
6161 spec
->parse_flags
= HDA_PINCFG_NO_HP_FIXUP
;
6163 alc_auto_parse_customize_define(codec
);
6165 alc_fix_pll_init(codec
, 0x20, 0x04, 15);
6167 err
= alc_codec_rename_from_preset(codec
);
6171 if ((alc_get_coef0(codec
) & (1 << 14)) &&
6172 codec
->bus
->pci
->subsystem_vendor
== 0x1025 &&
6173 spec
->cdefine
.platform_type
== 1) {
6174 if (alc_codec_rename(codec
, "ALC272X") < 0)
6178 alc_pick_fixup(codec
, alc662_fixup_models
,
6179 alc662_fixup_tbl
, alc662_fixups
);
6180 alc_apply_fixup(codec
, ALC_FIXUP_ACT_PRE_PROBE
);
6181 /* automatic parse from the BIOS config */
6182 err
= alc662_parse_auto_config(codec
);
6186 if (!spec
->no_analog
&& !spec
->adc_nids
) {
6187 alc_auto_fill_adc_caps(codec
);
6188 alc_rebuild_imux_for_auto_mic(codec
);
6189 alc_remove_invalid_adc_nids(codec
);
6192 if (!spec
->no_analog
&& !spec
->cap_mixer
)
6193 set_capture_mixer(codec
);
6195 if (!spec
->no_analog
&& has_cdefine_beep(codec
)) {
6196 err
= snd_hda_attach_beep_device(codec
, 0x1);
6199 switch (codec
->vendor_id
) {
6201 set_beep_amp(spec
, 0x0b, 0x05, HDA_INPUT
);
6206 set_beep_amp(spec
, 0x0b, 0x04, HDA_INPUT
);
6209 set_beep_amp(spec
, 0x0b, 0x03, HDA_INPUT
);
6214 alc_apply_fixup(codec
, ALC_FIXUP_ACT_PROBE
);
6216 codec
->patch_ops
= alc_patch_ops
;
6217 spec
->init_hook
= alc_auto_init_std
;
6218 spec
->shutup
= alc_eapd_shutup
;
6220 #ifdef CONFIG_SND_HDA_POWER_SAVE
6221 if (!spec
->loopback
.amplist
)
6222 spec
->loopback
.amplist
= alc662_loopbacks
;
6236 static int alc680_parse_auto_config(struct hda_codec
*codec
)
6238 return alc_parse_auto_config(codec
, NULL
, NULL
);
6243 static int patch_alc680(struct hda_codec
*codec
)
6245 struct alc_spec
*spec
;
6248 spec
= kzalloc(sizeof(*spec
), GFP_KERNEL
);
6254 /* ALC680 has no aa-loopback mixer */
6256 /* automatic parse from the BIOS config */
6257 err
= alc680_parse_auto_config(codec
);
6263 if (!spec
->no_analog
&& !spec
->cap_mixer
)
6264 set_capture_mixer(codec
);
6266 codec
->patch_ops
= alc_patch_ops
;
6267 spec
->init_hook
= alc_auto_init_std
;
6275 static const struct hda_codec_preset snd_hda_preset_realtek
[] = {
6276 { .id
= 0x10ec0221, .name
= "ALC221", .patch
= patch_alc269
},
6277 { .id
= 0x10ec0260, .name
= "ALC260", .patch
= patch_alc260
},
6278 { .id
= 0x10ec0262, .name
= "ALC262", .patch
= patch_alc262
},
6279 { .id
= 0x10ec0267, .name
= "ALC267", .patch
= patch_alc268
},
6280 { .id
= 0x10ec0268, .name
= "ALC268", .patch
= patch_alc268
},
6281 { .id
= 0x10ec0269, .name
= "ALC269", .patch
= patch_alc269
},
6282 { .id
= 0x10ec0270, .name
= "ALC270", .patch
= patch_alc269
},
6283 { .id
= 0x10ec0272, .name
= "ALC272", .patch
= patch_alc662
},
6284 { .id
= 0x10ec0275, .name
= "ALC275", .patch
= patch_alc269
},
6285 { .id
= 0x10ec0276, .name
= "ALC276", .patch
= patch_alc269
},
6286 { .id
= 0x10ec0861, .rev
= 0x100340, .name
= "ALC660",
6287 .patch
= patch_alc861
},
6288 { .id
= 0x10ec0660, .name
= "ALC660-VD", .patch
= patch_alc861vd
},
6289 { .id
= 0x10ec0861, .name
= "ALC861", .patch
= patch_alc861
},
6290 { .id
= 0x10ec0862, .name
= "ALC861-VD", .patch
= patch_alc861vd
},
6291 { .id
= 0x10ec0662, .rev
= 0x100002, .name
= "ALC662 rev2",
6292 .patch
= patch_alc882
},
6293 { .id
= 0x10ec0662, .rev
= 0x100101, .name
= "ALC662 rev1",
6294 .patch
= patch_alc662
},
6295 { .id
= 0x10ec0662, .rev
= 0x100300, .name
= "ALC662 rev3",
6296 .patch
= patch_alc662
},
6297 { .id
= 0x10ec0663, .name
= "ALC663", .patch
= patch_alc662
},
6298 { .id
= 0x10ec0665, .name
= "ALC665", .patch
= patch_alc662
},
6299 { .id
= 0x10ec0670, .name
= "ALC670", .patch
= patch_alc662
},
6300 { .id
= 0x10ec0680, .name
= "ALC680", .patch
= patch_alc680
},
6301 { .id
= 0x10ec0880, .name
= "ALC880", .patch
= patch_alc880
},
6302 { .id
= 0x10ec0882, .name
= "ALC882", .patch
= patch_alc882
},
6303 { .id
= 0x10ec0883, .name
= "ALC883", .patch
= patch_alc882
},
6304 { .id
= 0x10ec0885, .rev
= 0x100101, .name
= "ALC889A",
6305 .patch
= patch_alc882
},
6306 { .id
= 0x10ec0885, .rev
= 0x100103, .name
= "ALC889A",
6307 .patch
= patch_alc882
},
6308 { .id
= 0x10ec0885, .name
= "ALC885", .patch
= patch_alc882
},
6309 { .id
= 0x10ec0887, .name
= "ALC887", .patch
= patch_alc882
},
6310 { .id
= 0x10ec0888, .rev
= 0x100101, .name
= "ALC1200",
6311 .patch
= patch_alc882
},
6312 { .id
= 0x10ec0888, .name
= "ALC888", .patch
= patch_alc882
},
6313 { .id
= 0x10ec0889, .name
= "ALC889", .patch
= patch_alc882
},
6314 { .id
= 0x10ec0892, .name
= "ALC892", .patch
= patch_alc662
},
6315 { .id
= 0x10ec0899, .name
= "ALC898", .patch
= patch_alc882
},
6319 MODULE_ALIAS("snd-hda-codec-id:10ec*");
6321 MODULE_LICENSE("GPL");
6322 MODULE_DESCRIPTION("Realtek HD-audio codec");
6324 static struct hda_codec_preset_list realtek_list
= {
6325 .preset
= snd_hda_preset_realtek
,
6326 .owner
= THIS_MODULE
,
6329 static int __init
patch_realtek_init(void)
6331 return snd_hda_add_codec_preset(&realtek_list
);
6334 static void __exit
patch_realtek_exit(void)
6336 snd_hda_delete_codec_preset(&realtek_list
);
6339 module_init(patch_realtek_init
)
6340 module_exit(patch_realtek_exit
)