]> git.ipfire.org Git - thirdparty/linux.git/blame - sound/pci/hda/patch_realtek.c
projects / thirdparty / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Merge branch 'fix/hda' into topic/hda
[thirdparty/linux.git] / sound / pci / hda / patch_realtek.c
CommitLineData
1da177e4
LT		 1/*
2 * Universal Interface for Intel High Definition Audio Codec
3 *
1d045db9 4 * HD audio interface patch for Realtek ALC codecs
1da177e4 5 *
df694daa
KY		 6 * Copyright (c) 2004 Kailang Yang <kailang@realtek.com.tw>
7 * PeiSen Hou <pshou@realtek.com.tw>
1da177e4 8 * Takashi Iwai <tiwai@suse.de>
7cf51e48 9 * Jonathan Woithe <jwoithe@physics.adelaide.edu.au>
1da177e4
LT		 10 *
11 * This driver is free software; you can redistribute it and/or modify
12 * it under the terms of the GNU General Public License as published by
13 * the Free Software Foundation; either version 2 of the License, or
14 * (at your option) any later version.
15 *
16 * This driver is distributed in the hope that it will be useful,
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 * GNU General Public License for more details.
20 *
21 * You should have received a copy of the GNU General Public License
22 * along with this program; if not, write to the Free Software
23 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
24 */
25
1da177e4
LT		 26#include <linux/init.h>
27#include <linux/delay.h>
28#include <linux/slab.h>
29#include <linux/pci.h>
da155d5b 30#include <linux/module.h>
1da177e4 31#include <sound/core.h>
9ad0e496 32#include <sound/jack.h>
1da177e4
LT		 33#include "hda_codec.h"
34#include "hda_local.h"
680cd536 35#include "hda_beep.h"
1da177e4 36
1d045db9
TI		 37/* unsol event tags */
38#define ALC_FRONT_EVENT 0x01
39#define ALC_DCVOL_EVENT 0x02
40#define ALC_HP_EVENT 0x04
41#define ALC_MIC_EVENT 0x08
d4a86d81 42
df694daa
KY		 43/* for GPIO Poll */
44#define GPIO_MASK 0x03
45
4a79ba34
TI		 46/* extra amp-initialization sequence types */
47enum {
48 ALC_INIT_NONE,
49 ALC_INIT_DEFAULT,
50 ALC_INIT_GPIO1,
51 ALC_INIT_GPIO2,
52 ALC_INIT_GPIO3,
53};
54
da00c244
KY		 55struct alc_customize_define {
56 unsigned int sku_cfg;
57 unsigned char port_connectivity;
58 unsigned char check_sum;
59 unsigned char customization;
60 unsigned char external_amp;
61 unsigned int enable_pcbeep:1;
62 unsigned int platform_type:1;
63 unsigned int swap:1;
64 unsigned int override:1;
90622917 65 unsigned int fixup:1; /* Means that this sku is set by driver, not read from hw */
da00c244
KY		 66};
67
b5bfbc67
TI		 68struct alc_fixup;
69
ce764ab2
TI		 70struct alc_multi_io {
71 hda_nid_t pin; /* multi-io widget pin NID */
72 hda_nid_t dac; /* DAC to be connected */
73 unsigned int ctl_in; /* cached input-pin control value */
74};
75
d922b51d 76enum {
3b8510ce
TI		 77 ALC_AUTOMUTE_PIN, /* change the pin control */
78 ALC_AUTOMUTE_AMP, /* mute/unmute the pin AMP */
79 ALC_AUTOMUTE_MIXER, /* mute/unmute mixer widget AMP */
d922b51d
TI		 80};
81
1da177e4
LT		 82struct alc_spec {
83 /* codec parameterization */
a9111321 84 const struct snd_kcontrol_new *mixers[5]; /* mixer arrays */
1da177e4 85 unsigned int num_mixers;
a9111321 86 const struct snd_kcontrol_new *cap_mixer; /* capture mixer */
45bdd1c1 87 unsigned int beep_amp; /* beep amp value, set via set_beep_amp() */
1da177e4 88
2d9c6482 89 const struct hda_verb *init_verbs[10]; /* initialization verbs
9c7f852e
TI		 90 * don't forget NULL
91 * termination!
e9edcee0
TI		 92 */
93 unsigned int num_init_verbs;
1da177e4 94
aa563af7 95 char stream_name_analog[32]; /* analog PCM stream */
a9111321
TI		 96 const struct hda_pcm_stream *stream_analog_playback;
97 const struct hda_pcm_stream *stream_analog_capture;
98 const struct hda_pcm_stream *stream_analog_alt_playback;
99 const struct hda_pcm_stream *stream_analog_alt_capture;
1da177e4 100
aa563af7 101 char stream_name_digital[32]; /* digital PCM stream */
a9111321
TI		 102 const struct hda_pcm_stream *stream_digital_playback;
103 const struct hda_pcm_stream *stream_digital_capture;
1da177e4
LT		 104
105 /* playback */
16ded525
TI		 106 struct hda_multi_out multiout; /* playback set-up
107 * max_channels, dacs must be set
108 * dig_out_nid and hp_nid are optional
109 */
6330079f 110 hda_nid_t alt_dac_nid;
6a05ac4a 111 hda_nid_t slave_dig_outs[3]; /* optional - for auto-parsing */
8c441982 112 int dig_out_type;
1da177e4
LT		 113
114 /* capture */
115 unsigned int num_adc_nids;
4c6d72d1
TI		 116 const hda_nid_t *adc_nids;
117 const hda_nid_t *capsrc_nids;
16ded525 118 hda_nid_t dig_in_nid; /* digital-in NID; optional */
1f0f4b80 119 hda_nid_t mixer_nid; /* analog-mixer NID */
527e4d73
TI		 120 DECLARE_BITMAP(vol_ctls, 0x20 << 1);
121 DECLARE_BITMAP(sw_ctls, 0x20 << 1);
1da177e4 122
840b64c0 123 /* capture setup for dynamic dual-adc switch */
840b64c0
TI		 124 hda_nid_t cur_adc;
125 unsigned int cur_adc_stream_tag;
126 unsigned int cur_adc_format;
127
1da177e4 128 /* capture source */
a1e8d2da 129 unsigned int num_mux_defs;
1da177e4
LT		 130 const struct hda_input_mux *input_mux;
131 unsigned int cur_mux[3];
21268961
TI		 132 hda_nid_t ext_mic_pin;
133 hda_nid_t dock_mic_pin;
134 hda_nid_t int_mic_pin;
1da177e4
LT		 135
136 /* channel model */
d2a6d7dc 137 const struct hda_channel_mode *channel_mode;
1da177e4 138 int num_channel_mode;
4e195a7b 139 int need_dac_fix;
3b315d70
HM		 140 int const_channel_count;
141 int ext_channel_count;
1da177e4
LT		 142
143 /* PCM information */
4c5186ed 144 struct hda_pcm pcm_rec[3]; /* used in alc_build_pcms() */
41e41f1f 145
e9edcee0
TI		 146 /* dynamic controls, init_verbs and input_mux */
147 struct auto_pin_cfg autocfg;
da00c244 148 struct alc_customize_define cdefine;
603c4019 149 struct snd_array kctls;
61b9b9b1 150 struct hda_input_mux private_imux[3];
41923e44 151 hda_nid_t private_dac_nids[AUTO_CFG_MAX_OUTS];
4953550a
TI		 152 hda_nid_t private_adc_nids[AUTO_CFG_MAX_OUTS];
153 hda_nid_t private_capsrc_nids[AUTO_CFG_MAX_OUTS];
21268961
TI		 154 hda_nid_t imux_pins[HDA_MAX_NUM_INPUTS];
155 unsigned int dyn_adc_idx[HDA_MAX_NUM_INPUTS];
156 int int_mic_idx, ext_mic_idx, dock_mic_idx; /* for auto-mic */
834be88d 157
ae6b813a
TI		 158 /* hooks */
159 void (*init_hook)(struct hda_codec *codec);
160 void (*unsol_event)(struct hda_codec *codec, unsigned int res);
f5de24b0 161#ifdef CONFIG_SND_HDA_POWER_SAVE
c97259df 162 void (*power_hook)(struct hda_codec *codec);
f5de24b0 163#endif
1c716153 164 void (*shutup)(struct hda_codec *codec);
24519911 165 void (*automute_hook)(struct hda_codec *codec);
ae6b813a 166
834be88d 167 /* for pin sensing */
42cf0d01 168 unsigned int hp_jack_present:1;
e6a5e1b7 169 unsigned int line_jack_present:1;
e9427969 170 unsigned int master_mute:1;
6c819492 171 unsigned int auto_mic:1;
21268961 172 unsigned int auto_mic_valid_imux:1; /* valid imux for auto-mic */
42cf0d01
DH		 173 unsigned int automute_speaker:1; /* automute speaker outputs */
174 unsigned int automute_lo:1; /* automute LO outputs */
175 unsigned int detect_hp:1; /* Headphone detection enabled */
176 unsigned int detect_lo:1; /* Line-out detection enabled */
177 unsigned int automute_speaker_possible:1; /* there are speakers and either LO or HP */
178 unsigned int automute_lo_possible:1; /* there are line outs and HP */
cb53c626 179
e64f14f4
TI		 180 /* other flags */
181 unsigned int no_analog :1; /* digital I/O only */
21268961 182 unsigned int dyn_adc_switch:1; /* switch ADCs (for ALC275) */
584c0c4c 183 unsigned int single_input_src:1;
d6cc9fab 184 unsigned int vol_in_capsrc:1; /* use capsrc volume (ADC has no vol) */
53c334ad 185 unsigned int parse_flags; /* passed to snd_hda_parse_pin_defcfg() */
24de183e 186 unsigned int shared_mic_hp:1; /* HP/Mic-in sharing */
d922b51d
TI		 187
188 /* auto-mute control */
189 int automute_mode;
3b8510ce 190 hda_nid_t automute_mixer_nid[AUTO_CFG_MAX_OUTS];
d922b51d 191
4a79ba34 192 int init_amp;
d433a678 193 int codec_variant; /* flag for other variants */
e64f14f4 194
2134ea4f
TI		 195 /* for virtual master */
196 hda_nid_t vmaster_nid;
cb53c626
TI		 197#ifdef CONFIG_SND_HDA_POWER_SAVE
198 struct hda_loopback_check loopback;
199#endif
2c3bf9ab
TI		 200
201 /* for PLL fix */
202 hda_nid_t pll_nid;
203 unsigned int pll_coef_idx, pll_coef_bit;
1bb7e43e 204 unsigned int coef0;
b5bfbc67
TI		 205
206 /* fix-up list */
207 int fixup_id;
208 const struct alc_fixup *fixup_list;
209 const char *fixup_name;
ce764ab2
TI		 210
211 /* multi-io */
212 int multi_ios;
213 struct alc_multi_io multi_io[4];
23c09b00
TI		 214
215 /* bind volumes */
216 struct snd_array bind_ctls;
df694daa
KY		 217};
218
1d045db9 219#define ALC_MODEL_AUTO 0 /* common for all chips */
1da177e4 220
44c02400
TI		 221static bool check_amp_caps(struct hda_codec *codec, hda_nid_t nid,
222 int dir, unsigned int bits)
223{
224 if (!nid)
225 return false;
226 if (get_wcaps(codec, nid) & (1 << (dir + 1)))
227 if (query_amp_caps(codec, nid, dir) & bits)
228 return true;
229 return false;
230}
231
232#define nid_has_mute(codec, nid, dir) \
233 check_amp_caps(codec, nid, dir, AC_AMPCAP_MUTE)
234#define nid_has_volume(codec, nid, dir) \
235 check_amp_caps(codec, nid, dir, AC_AMPCAP_NUM_STEPS)
236
1da177e4
LT		 237/*
238 * input MUX handling
239 */
9c7f852e
TI		 240static int alc_mux_enum_info(struct snd_kcontrol *kcontrol,
241 struct snd_ctl_elem_info *uinfo)
1da177e4
LT		 242{
243 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
244 struct alc_spec *spec = codec->spec;
a1e8d2da
JW		 245 unsigned int mux_idx = snd_ctl_get_ioffidx(kcontrol, &uinfo->id);
246 if (mux_idx >= spec->num_mux_defs)
247 mux_idx = 0;
5311114d
TI		 248 if (!spec->input_mux[mux_idx].num_items && mux_idx > 0)
249 mux_idx = 0;
a1e8d2da 250 return snd_hda_input_mux_info(&spec->input_mux[mux_idx], uinfo);
1da177e4
LT		 251}
252
9c7f852e
TI		 253static int alc_mux_enum_get(struct snd_kcontrol *kcontrol,
254 struct snd_ctl_elem_value *ucontrol)
1da177e4
LT		 255{
256 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
257 struct alc_spec *spec = codec->spec;
258 unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
259
260 ucontrol->value.enumerated.item[0] = spec->cur_mux[adc_idx];
261 return 0;
262}
263
21268961
TI		 264static bool alc_dyn_adc_pcm_resetup(struct hda_codec *codec, int cur)
265{
266 struct alc_spec *spec = codec->spec;
267 hda_nid_t new_adc = spec->adc_nids[spec->dyn_adc_idx[cur]];
268
269 if (spec->cur_adc && spec->cur_adc != new_adc) {
270 /* stream is running, let's swap the current ADC */
271 __snd_hda_codec_cleanup_stream(codec, spec->cur_adc, 1);
272 spec->cur_adc = new_adc;
273 snd_hda_codec_setup_stream(codec, new_adc,
274 spec->cur_adc_stream_tag, 0,
275 spec->cur_adc_format);
276 return true;
277 }
278 return false;
279}
280
61071594
TI		 281static inline hda_nid_t get_capsrc(struct alc_spec *spec, int idx)
282{
283 return spec->capsrc_nids ?
284 spec->capsrc_nids[idx] : spec->adc_nids[idx];
285}
286
24de183e
TI		 287static void call_update_outputs(struct hda_codec *codec);
288
21268961
TI		 289/* select the given imux item; either unmute exclusively or select the route */
290static int alc_mux_select(struct hda_codec *codec, unsigned int adc_idx,
291 unsigned int idx, bool force)
1da177e4 292{
1da177e4 293 struct alc_spec *spec = codec->spec;
cd896c33 294 const struct hda_input_mux *imux;
cd896c33 295 unsigned int mux_idx;
dccc1810 296 int i, type, num_conns;
21268961 297 hda_nid_t nid;
1da177e4 298
cd896c33
TI		 299 mux_idx = adc_idx >= spec->num_mux_defs ? 0 : adc_idx;
300 imux = &spec->input_mux[mux_idx];
5311114d
TI		 301 if (!imux->num_items && mux_idx > 0)
302 imux = &spec->input_mux[0];
cce4aa37
TI		 303 if (!imux->num_items)
304 return 0;
cd896c33 305
21268961
TI		 306 if (idx >= imux->num_items)
307 idx = imux->num_items - 1;
308 if (spec->cur_mux[adc_idx] == idx && !force)
309 return 0;
310 spec->cur_mux[adc_idx] = idx;
311
24de183e
TI		 312 /* for shared I/O, change the pin-control accordingly */
313 if (spec->shared_mic_hp) {
314 /* NOTE: this assumes that there are only two inputs, the
315 * first is the real internal mic and the second is HP jack.
316 */
317 snd_hda_codec_write(codec, spec->autocfg.inputs[1].pin, 0,
318 AC_VERB_SET_PIN_WIDGET_CONTROL,
319 spec->cur_mux[adc_idx] ?
320 PIN_VREF80 : PIN_HP);
321 spec->automute_speaker = !spec->cur_mux[adc_idx];
322 call_update_outputs(codec);
323 }
324
21268961
TI		 325 if (spec->dyn_adc_switch) {
326 alc_dyn_adc_pcm_resetup(codec, idx);
327 adc_idx = spec->dyn_adc_idx[idx];
328 }
329
61071594 330 nid = get_capsrc(spec, adc_idx);
21268961
TI		 331
332 /* no selection? */
dccc1810
TI		 333 num_conns = snd_hda_get_conn_list(codec, nid, NULL);
334 if (num_conns <= 1)
21268961
TI		 335 return 1;
336
a22d543a 337 type = get_wcaps_type(get_wcaps(codec, nid));
0169b6b3 338 if (type == AC_WID_AUD_MIX) {
54cbc9ab 339 /* Matrix-mixer style (e.g. ALC882) */
dccc1810
TI		 340 int active = imux->items[idx].index;
341 for (i = 0; i < num_conns; i++) {
342 unsigned int v = (i == active) ? 0 : HDA_AMP_MUTE;
343 snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT, i,
54cbc9ab
TI		 344 HDA_AMP_MUTE, v);
345 }
54cbc9ab
TI		 346 } else {
347 /* MUX style (e.g. ALC880) */
21268961
TI		 348 snd_hda_codec_write_cache(codec, nid, 0,
349 AC_VERB_SET_CONNECT_SEL,
350 imux->items[idx].index);
54cbc9ab 351 }
21268961
TI		 352 return 1;
353}
354
355static int alc_mux_enum_put(struct snd_kcontrol *kcontrol,
356 struct snd_ctl_elem_value *ucontrol)
357{
358 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
359 unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
360 return alc_mux_select(codec, adc_idx,
361 ucontrol->value.enumerated.item[0], false);
54cbc9ab 362}
e9edcee0 363
23f0c048
TI		 364/*
365 * set up the input pin config (depending on the given auto-pin type)
366 */
367static void alc_set_input_pin(struct hda_codec *codec, hda_nid_t nid,
368 int auto_pin_type)
369{
370 unsigned int val = PIN_IN;
371
86e2959a 372 if (auto_pin_type == AUTO_PIN_MIC) {
23f0c048 373 unsigned int pincap;
954a29c8
TI		 374 unsigned int oldval;
375 oldval = snd_hda_codec_read(codec, nid, 0,
376 AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
1327a32b 377 pincap = snd_hda_query_pin_caps(codec, nid);
23f0c048 378 pincap = (pincap & AC_PINCAP_VREF) >> AC_PINCAP_VREF_SHIFT;
954a29c8
TI		 379 /* if the default pin setup is vref50, we give it priority */
380 if ((pincap & AC_PINCAP_VREF_80) && oldval != PIN_VREF50)
23f0c048 381 val = PIN_VREF80;
461c6c3a
TI		 382 else if (pincap & AC_PINCAP_VREF_50)
383 val = PIN_VREF50;
384 else if (pincap & AC_PINCAP_VREF_100)
385 val = PIN_VREF100;
386 else if (pincap & AC_PINCAP_VREF_GRD)
387 val = PIN_VREFGRD;
23f0c048
TI		 388 }
389 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, val);
390}
391
d88897ea 392/*
1d045db9
TI		 393 * Append the given mixer and verb elements for the later use
394 * The mixer array is referred in build_controls(), and init_verbs are
395 * called in init().
d88897ea 396 */
a9111321 397static void add_mixer(struct alc_spec *spec, const struct snd_kcontrol_new *mix)
d88897ea
TI		 398{
399 if (snd_BUG_ON(spec->num_mixers >= ARRAY_SIZE(spec->mixers)))
400 return;
401 spec->mixers[spec->num_mixers++] = mix;
402}
403
404static void add_verb(struct alc_spec *spec, const struct hda_verb *verb)
405{
406 if (snd_BUG_ON(spec->num_init_verbs >= ARRAY_SIZE(spec->init_verbs)))
407 return;
408 spec->init_verbs[spec->num_init_verbs++] = verb;
409}
410
df694daa 411/*
1d045db9 412 * GPIO setup tables, used in initialization
df694daa 413 */
bc9f98a9 414/* Enable GPIO mask and set output */
a9111321 415static const struct hda_verb alc_gpio1_init_verbs[] = {
bc9f98a9
KY		 416 {0x01, AC_VERB_SET_GPIO_MASK, 0x01},
417 {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
418 {0x01, AC_VERB_SET_GPIO_DATA, 0x01},
419 { }
420};
421
a9111321 422static const struct hda_verb alc_gpio2_init_verbs[] = {
bc9f98a9
KY		 423 {0x01, AC_VERB_SET_GPIO_MASK, 0x02},
424 {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x02},
425 {0x01, AC_VERB_SET_GPIO_DATA, 0x02},
426 { }
427};
428
a9111321 429static const struct hda_verb alc_gpio3_init_verbs[] = {
bdd148a3
KY		 430 {0x01, AC_VERB_SET_GPIO_MASK, 0x03},
431 {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x03},
432 {0x01, AC_VERB_SET_GPIO_DATA, 0x03},
433 { }
434};
435
2c3bf9ab
TI		 436/*
437 * Fix hardware PLL issue
438 * On some codecs, the analog PLL gating control must be off while
439 * the default value is 1.
440 */
441static void alc_fix_pll(struct hda_codec *codec)
442{
443 struct alc_spec *spec = codec->spec;
444 unsigned int val;
445
446 if (!spec->pll_nid)
447 return;
448 snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_COEF_INDEX,
449 spec->pll_coef_idx);
450 val = snd_hda_codec_read(codec, spec->pll_nid, 0,
451 AC_VERB_GET_PROC_COEF, 0);
452 snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_COEF_INDEX,
453 spec->pll_coef_idx);
454 snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_PROC_COEF,
455 val & ~(1 << spec->pll_coef_bit));
456}
457
458static void alc_fix_pll_init(struct hda_codec *codec, hda_nid_t nid,
459 unsigned int coef_idx, unsigned int coef_bit)
460{
461 struct alc_spec *spec = codec->spec;
462 spec->pll_nid = nid;
463 spec->pll_coef_idx = coef_idx;
464 spec->pll_coef_bit = coef_bit;
465 alc_fix_pll(codec);
466}
467
1d045db9
TI		 468/*
469 * Jack-reporting via input-jack layer
470 */
471
472/* initialization of jacks; currently checks only a few known pins */
9ad0e496
KY		 473static int alc_init_jacks(struct hda_codec *codec)
474{
cd372fb3 475#ifdef CONFIG_SND_HDA_INPUT_JACK
9ad0e496
KY		 476 struct alc_spec *spec = codec->spec;
477 int err;
478 unsigned int hp_nid = spec->autocfg.hp_pins[0];
21268961
TI		 479 unsigned int mic_nid = spec->ext_mic_pin;
480 unsigned int dock_nid = spec->dock_mic_pin;
9ad0e496 481
265a0247 482 if (hp_nid) {
cd372fb3
TI		 483 err = snd_hda_input_jack_add(codec, hp_nid,
484 SND_JACK_HEADPHONE, NULL);
265a0247
TI		 485 if (err < 0)
486 return err;
cd372fb3 487 snd_hda_input_jack_report(codec, hp_nid);
265a0247 488 }
9ad0e496 489
265a0247 490 if (mic_nid) {
cd372fb3
TI		 491 err = snd_hda_input_jack_add(codec, mic_nid,
492 SND_JACK_MICROPHONE, NULL);
265a0247
TI		 493 if (err < 0)
494 return err;
cd372fb3 495 snd_hda_input_jack_report(codec, mic_nid);
265a0247 496 }
8ed99d97
TI		 497 if (dock_nid) {
498 err = snd_hda_input_jack_add(codec, dock_nid,
499 SND_JACK_MICROPHONE, NULL);
500 if (err < 0)
501 return err;
502 snd_hda_input_jack_report(codec, dock_nid);
503 }
cd372fb3 504#endif /* CONFIG_SND_HDA_INPUT_JACK */
9ad0e496
KY		 505 return 0;
506}
9ad0e496 507
1d045db9
TI		 508/*
509 * Jack detections for HP auto-mute and mic-switch
510 */
511
512/* check each pin in the given array; returns true if any of them is plugged */
513static bool detect_jacks(struct hda_codec *codec, int num_pins, hda_nid_t *pins)
c9b58006 514{
e6a5e1b7 515 int i, present = 0;
c9b58006 516
e6a5e1b7
TI		 517 for (i = 0; i < num_pins; i++) {
518 hda_nid_t nid = pins[i];
bb35febd
TI		 519 if (!nid)
520 break;
cd372fb3 521 snd_hda_input_jack_report(codec, nid);
e6a5e1b7 522 present |= snd_hda_jack_detect(codec, nid);
bb35febd 523 }
e6a5e1b7
TI		 524 return present;
525}
bb35febd 526
1d045db9 527/* standard HP/line-out auto-mute helper */
e6a5e1b7 528static void do_automute(struct hda_codec *codec, int num_pins, hda_nid_t *pins,
e9427969 529 bool mute, bool hp_out)
e6a5e1b7
TI		 530{
531 struct alc_spec *spec = codec->spec;
532 unsigned int mute_bits = mute ? HDA_AMP_MUTE : 0;
e9427969 533 unsigned int pin_bits = mute ? 0 : (hp_out ? PIN_HP : PIN_OUT);
e6a5e1b7
TI		 534 int i;
535
536 for (i = 0; i < num_pins; i++) {
537 hda_nid_t nid = pins[i];
a9fd4f3f
TI		 538 if (!nid)
539 break;
3b8510ce
TI		 540 switch (spec->automute_mode) {
541 case ALC_AUTOMUTE_PIN:
bb35febd 542 snd_hda_codec_write(codec, nid, 0,
e6a5e1b7
TI		 543 AC_VERB_SET_PIN_WIDGET_CONTROL,
544 pin_bits);
3b8510ce
TI		 545 break;
546 case ALC_AUTOMUTE_AMP:
bb35febd 547 snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
e6a5e1b7 548 HDA_AMP_MUTE, mute_bits);
3b8510ce
TI		 549 break;
550 case ALC_AUTOMUTE_MIXER:
551 nid = spec->automute_mixer_nid[i];
552 if (!nid)
553 break;
554 snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT, 0,
e6a5e1b7 555 HDA_AMP_MUTE, mute_bits);
3b8510ce 556 snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT, 1,
e6a5e1b7 557 HDA_AMP_MUTE, mute_bits);
3b8510ce 558 break;
bb35febd 559 }
a9fd4f3f 560 }
c9b58006
KY		 561}
562
42cf0d01
DH		 563/* Toggle outputs muting */
564static void update_outputs(struct hda_codec *codec)
e6a5e1b7
TI		 565{
566 struct alc_spec *spec = codec->spec;
1a1455de 567 int on;
e6a5e1b7 568
c0a20263
TI		 569 /* Control HP pins/amps depending on master_mute state;
570 * in general, HP pins/amps control should be enabled in all cases,
571 * but currently set only for master_mute, just to be safe
572 */
24de183e
TI		 573 if (!spec->shared_mic_hp) /* don't change HP-pin when shared with mic */
574 do_automute(codec, ARRAY_SIZE(spec->autocfg.hp_pins),
c0a20263
TI		 575 spec->autocfg.hp_pins, spec->master_mute, true);
576
42cf0d01 577 if (!spec->automute_speaker)
1a1455de
TI		 578 on = 0;
579 else
42cf0d01 580 on = spec->hp_jack_present | spec->line_jack_present;
1a1455de 581 on |= spec->master_mute;
e6a5e1b7 582 do_automute(codec, ARRAY_SIZE(spec->autocfg.speaker_pins),
1a1455de 583 spec->autocfg.speaker_pins, on, false);
e6a5e1b7
TI		 584
585 /* toggle line-out mutes if needed, too */
1a1455de
TI		 586 /* if LO is a copy of either HP or Speaker, don't need to handle it */
587 if (spec->autocfg.line_out_pins[0] == spec->autocfg.hp_pins[0] ||
588 spec->autocfg.line_out_pins[0] == spec->autocfg.speaker_pins[0])
e6a5e1b7 589 return;
42cf0d01 590 if (!spec->automute_lo)
1a1455de
TI		 591 on = 0;
592 else
42cf0d01 593 on = spec->hp_jack_present;
1a1455de 594 on |= spec->master_mute;
e6a5e1b7 595 do_automute(codec, ARRAY_SIZE(spec->autocfg.line_out_pins),
1a1455de 596 spec->autocfg.line_out_pins, on, false);
e6a5e1b7
TI		 597}
598
42cf0d01 599static void call_update_outputs(struct hda_codec *codec)
24519911
TI		 600{
601 struct alc_spec *spec = codec->spec;
602 if (spec->automute_hook)
603 spec->automute_hook(codec);
604 else
42cf0d01 605 update_outputs(codec);
24519911
TI		 606}
607
1d045db9 608/* standard HP-automute helper */
e6a5e1b7
TI		 609static void alc_hp_automute(struct hda_codec *codec)
610{
611 struct alc_spec *spec = codec->spec;
612
42cf0d01 613 spec->hp_jack_present =
e6a5e1b7
TI		 614 detect_jacks(codec, ARRAY_SIZE(spec->autocfg.hp_pins),
615 spec->autocfg.hp_pins);
42cf0d01 616 if (!spec->detect_hp || (!spec->automute_speaker && !spec->automute_lo))
3c715a98 617 return;
42cf0d01 618 call_update_outputs(codec);
e6a5e1b7
TI		 619}
620
1d045db9 621/* standard line-out-automute helper */
e6a5e1b7
TI		 622static void alc_line_automute(struct hda_codec *codec)
623{
624 struct alc_spec *spec = codec->spec;
625
e0d32e33
TI		 626 /* check LO jack only when it's different from HP */
627 if (spec->autocfg.line_out_pins[0] == spec->autocfg.hp_pins[0])
628 return;
629
e6a5e1b7
TI		 630 spec->line_jack_present =
631 detect_jacks(codec, ARRAY_SIZE(spec->autocfg.line_out_pins),
632 spec->autocfg.line_out_pins);
42cf0d01 633 if (!spec->automute_speaker || !spec->detect_lo)
3c715a98 634 return;
42cf0d01 635 call_update_outputs(codec);
e6a5e1b7
TI		 636}
637
8d087c76
TI		 638#define get_connection_index(codec, mux, nid) \
639 snd_hda_get_conn_index(codec, mux, nid, 0)
6c819492 640
1d045db9 641/* standard mic auto-switch helper */
7fb0d78f
KY		 642static void alc_mic_automute(struct hda_codec *codec)
643{
644 struct alc_spec *spec = codec->spec;
21268961 645 hda_nid_t *pins = spec->imux_pins;
6c819492 646
21268961 647 if (!spec->auto_mic || !spec->auto_mic_valid_imux)
6c819492
TI		 648 return;
649 if (snd_BUG_ON(!spec->adc_nids))
650 return;
21268961 651 if (snd_BUG_ON(spec->int_mic_idx < 0 || spec->ext_mic_idx < 0))
840b64c0 652 return;
6c819492 653
21268961
TI		 654 if (snd_hda_jack_detect(codec, pins[spec->ext_mic_idx]))
655 alc_mux_select(codec, 0, spec->ext_mic_idx, false);
656 else if (spec->dock_mic_idx >= 0 &&
657 snd_hda_jack_detect(codec, pins[spec->dock_mic_idx]))
658 alc_mux_select(codec, 0, spec->dock_mic_idx, false);
659 else
660 alc_mux_select(codec, 0, spec->int_mic_idx, false);
6c819492 661
21268961
TI		 662 snd_hda_input_jack_report(codec, pins[spec->ext_mic_idx]);
663 if (spec->dock_mic_idx >= 0)
664 snd_hda_input_jack_report(codec, pins[spec->dock_mic_idx]);
7fb0d78f
KY		 665}
666
c9b58006
KY		 667/* unsolicited event for HP jack sensing */
668static void alc_sku_unsol_event(struct hda_codec *codec, unsigned int res)
669{
670 if (codec->vendor_id == 0x10ec0880)
671 res >>= 28;
672 else
673 res >>= 26;
a9fd4f3f 674 switch (res) {
1d045db9 675 case ALC_HP_EVENT:
d922b51d 676 alc_hp_automute(codec);
a9fd4f3f 677 break;
1d045db9 678 case ALC_FRONT_EVENT:
e6a5e1b7
TI		 679 alc_line_automute(codec);
680 break;
1d045db9 681 case ALC_MIC_EVENT:
7fb0d78f 682 alc_mic_automute(codec);
a9fd4f3f
TI		 683 break;
684 }
7fb0d78f
KY		 685}
686
1d045db9 687/* call init functions of standard auto-mute helpers */
7fb0d78f
KY		 688static void alc_inithook(struct hda_codec *codec)
689{
d922b51d 690 alc_hp_automute(codec);
e6a5e1b7 691 alc_line_automute(codec);
7fb0d78f 692 alc_mic_automute(codec);
c9b58006
KY		 693}
694
f9423e7a
KY		 695/* additional initialization for ALC888 variants */
696static void alc888_coef_init(struct hda_codec *codec)
697{
698 unsigned int tmp;
699
700 snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 0);
701 tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0);
702 snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 7);
37db623a 703 if ((tmp & 0xf0) == 0x20)
f9423e7a
KY		 704 /* alc888S-VC */
705 snd_hda_codec_read(codec, 0x20, 0,
706 AC_VERB_SET_PROC_COEF, 0x830);
707 else
708 /* alc888-VB */
709 snd_hda_codec_read(codec, 0x20, 0,
710 AC_VERB_SET_PROC_COEF, 0x3030);
711}
712
1d045db9 713/* additional initialization for ALC889 variants */
87a8c370
JK		 714static void alc889_coef_init(struct hda_codec *codec)
715{
716 unsigned int tmp;
717
718 snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 7);
719 tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0);
720 snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 7);
721 snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_PROC_COEF, tmp|0x2010);
722}
723
3fb4a508
TI		 724/* turn on/off EAPD control (only if available) */
725static void set_eapd(struct hda_codec *codec, hda_nid_t nid, int on)
726{
727 if (get_wcaps_type(get_wcaps(codec, nid)) != AC_WID_PIN)
728 return;
729 if (snd_hda_query_pin_caps(codec, nid) & AC_PINCAP_EAPD)
730 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_EAPD_BTLENABLE,
731 on ? 2 : 0);
732}
733
691f1fcc
TI		 734/* turn on/off EAPD controls of the codec */
735static void alc_auto_setup_eapd(struct hda_codec *codec, bool on)
736{
737 /* We currently only handle front, HP */
39fa84e9
TI		 738 static hda_nid_t pins[] = {
739 0x0f, 0x10, 0x14, 0x15, 0
740 };
741 hda_nid_t *p;
742 for (p = pins; *p; p++)
743 set_eapd(codec, *p, on);
691f1fcc
TI		 744}
745
1c716153
TI		 746/* generic shutup callback;
747 * just turning off EPAD and a little pause for avoiding pop-noise
748 */
749static void alc_eapd_shutup(struct hda_codec *codec)
750{
751 alc_auto_setup_eapd(codec, false);
752 msleep(200);
753}
754
1d045db9 755/* generic EAPD initialization */
4a79ba34 756static void alc_auto_init_amp(struct hda_codec *codec, int type)
bc9f98a9 757{
4a79ba34 758 unsigned int tmp;
bc9f98a9 759
39fa84e9 760 alc_auto_setup_eapd(codec, true);
4a79ba34
TI		 761 switch (type) {
762 case ALC_INIT_GPIO1:
bc9f98a9
KY		 763 snd_hda_sequence_write(codec, alc_gpio1_init_verbs);
764 break;
4a79ba34 765 case ALC_INIT_GPIO2:
bc9f98a9
KY		 766 snd_hda_sequence_write(codec, alc_gpio2_init_verbs);
767 break;
4a79ba34 768 case ALC_INIT_GPIO3:
bdd148a3
KY		 769 snd_hda_sequence_write(codec, alc_gpio3_init_verbs);
770 break;
4a79ba34 771 case ALC_INIT_DEFAULT:
c9b58006
KY		 772 switch (codec->vendor_id) {
773 case 0x10ec0260:
774 snd_hda_codec_write(codec, 0x1a, 0,
775 AC_VERB_SET_COEF_INDEX, 7);
776 tmp = snd_hda_codec_read(codec, 0x1a, 0,
777 AC_VERB_GET_PROC_COEF, 0);
778 snd_hda_codec_write(codec, 0x1a, 0,
779 AC_VERB_SET_COEF_INDEX, 7);
780 snd_hda_codec_write(codec, 0x1a, 0,
781 AC_VERB_SET_PROC_COEF,
782 tmp | 0x2010);
783 break;
784 case 0x10ec0262:
785 case 0x10ec0880:
786 case 0x10ec0882:
787 case 0x10ec0883:
788 case 0x10ec0885:
4a5a4c56 789 case 0x10ec0887:
20b67ddd 790 /*case 0x10ec0889:*/ /* this causes an SPDIF problem */
87a8c370 791 alc889_coef_init(codec);
c9b58006 792 break;
f9423e7a 793 case 0x10ec0888:
4a79ba34 794 alc888_coef_init(codec);
f9423e7a 795 break;
0aea778e 796#if 0 /* XXX: This may cause the silent output on speaker on some machines */
c9b58006
KY		 797 case 0x10ec0267:
798 case 0x10ec0268:
799 snd_hda_codec_write(codec, 0x20, 0,
800 AC_VERB_SET_COEF_INDEX, 7);
801 tmp = snd_hda_codec_read(codec, 0x20, 0,
802 AC_VERB_GET_PROC_COEF, 0);
803 snd_hda_codec_write(codec, 0x20, 0,
ea1fb29a 804 AC_VERB_SET_COEF_INDEX, 7);
c9b58006
KY		 805 snd_hda_codec_write(codec, 0x20, 0,
806 AC_VERB_SET_PROC_COEF,
807 tmp | 0x3000);
808 break;
0aea778e 809#endif /* XXX */
bc9f98a9 810 }
4a79ba34
TI		 811 break;
812 }
813}
814
1d045db9
TI		 815/*
816 * Auto-Mute mode mixer enum support
817 */
1a1455de
TI		 818static int alc_automute_mode_info(struct snd_kcontrol *kcontrol,
819 struct snd_ctl_elem_info *uinfo)
820{
ae8a60a5
TI		 821 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
822 struct alc_spec *spec = codec->spec;
823 static const char * const texts2[] = {
824 "Disabled", "Enabled"
825 };
826 static const char * const texts3[] = {
1a1455de
TI		 827 "Disabled", "Speaker Only", "Line-Out+Speaker"
828 };
ae8a60a5 829 const char * const *texts;
1a1455de
TI		 830
831 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
832 uinfo->count = 1;
42cf0d01 833 if (spec->automute_speaker_possible && spec->automute_lo_possible) {
ae8a60a5
TI		 834 uinfo->value.enumerated.items = 3;
835 texts = texts3;
836 } else {
837 uinfo->value.enumerated.items = 2;
838 texts = texts2;
839 }
840 if (uinfo->value.enumerated.item >= uinfo->value.enumerated.items)
841 uinfo->value.enumerated.item = uinfo->value.enumerated.items - 1;
1a1455de
TI		 842 strcpy(uinfo->value.enumerated.name,
843 texts[uinfo->value.enumerated.item]);
844 return 0;
845}
846
847static int alc_automute_mode_get(struct snd_kcontrol *kcontrol,
848 struct snd_ctl_elem_value *ucontrol)
849{
850 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
851 struct alc_spec *spec = codec->spec;
42cf0d01
DH		 852 unsigned int val = 0;
853 if (spec->automute_speaker)
854 val++;
855 if (spec->automute_lo)
856 val++;
857
1a1455de
TI		 858 ucontrol->value.enumerated.item[0] = val;
859 return 0;
860}
861
862static int alc_automute_mode_put(struct snd_kcontrol *kcontrol,
863 struct snd_ctl_elem_value *ucontrol)
864{
865 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
866 struct alc_spec *spec = codec->spec;
867
868 switch (ucontrol->value.enumerated.item[0]) {
869 case 0:
42cf0d01 870 if (!spec->automute_speaker && !spec->automute_lo)
1a1455de 871 return 0;
42cf0d01
DH		 872 spec->automute_speaker = 0;
873 spec->automute_lo = 0;
1a1455de
TI		 874 break;
875 case 1:
42cf0d01
DH		 876 if (spec->automute_speaker_possible) {
877 if (!spec->automute_lo && spec->automute_speaker)
878 return 0;
879 spec->automute_speaker = 1;
880 spec->automute_lo = 0;
881 } else if (spec->automute_lo_possible) {
882 if (spec->automute_lo)
883 return 0;
884 spec->automute_lo = 1;
885 } else
886 return -EINVAL;
1a1455de
TI		 887 break;
888 case 2:
42cf0d01 889 if (!spec->automute_lo_possible || !spec->automute_speaker_possible)
ae8a60a5 890 return -EINVAL;
42cf0d01 891 if (spec->automute_speaker && spec->automute_lo)
1a1455de 892 return 0;
42cf0d01
DH		 893 spec->automute_speaker = 1;
894 spec->automute_lo = 1;
1a1455de
TI		 895 break;
896 default:
897 return -EINVAL;
898 }
42cf0d01 899 call_update_outputs(codec);
1a1455de
TI		 900 return 1;
901}
902
a9111321 903static const struct snd_kcontrol_new alc_automute_mode_enum = {
1a1455de
TI		 904 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
905 .name = "Auto-Mute Mode",
906 .info = alc_automute_mode_info,
907 .get = alc_automute_mode_get,
908 .put = alc_automute_mode_put,
909};
910
1d045db9
TI		 911static struct snd_kcontrol_new *alc_kcontrol_new(struct alc_spec *spec)
912{
913 snd_array_init(&spec->kctls, sizeof(struct snd_kcontrol_new), 32);
914 return snd_array_new(&spec->kctls);
915}
1a1455de
TI		 916
917static int alc_add_automute_mode_enum(struct hda_codec *codec)
918{
919 struct alc_spec *spec = codec->spec;
920 struct snd_kcontrol_new *knew;
921
922 knew = alc_kcontrol_new(spec);
923 if (!knew)
924 return -ENOMEM;
925 *knew = alc_automute_mode_enum;
926 knew->name = kstrdup("Auto-Mute Mode", GFP_KERNEL);
927 if (!knew->name)
928 return -ENOMEM;
929 return 0;
930}
931
1d045db9
TI		 932/*
933 * Check the availability of HP/line-out auto-mute;
934 * Set up appropriately if really supported
935 */
42cf0d01 936static void alc_init_automute(struct hda_codec *codec)
4a79ba34
TI		 937{
938 struct alc_spec *spec = codec->spec;
bb35febd 939 struct auto_pin_cfg *cfg = &spec->autocfg;
1daf5f46 940 int present = 0;
bb35febd 941 int i;
4a79ba34 942
1daf5f46
TI		 943 if (cfg->hp_pins[0])
944 present++;
945 if (cfg->line_out_pins[0])
946 present++;
947 if (cfg->speaker_pins[0])
948 present++;
949 if (present < 2) /* need two different output types */
950 return;
4a79ba34 951
c48a8fb0
TI		 952 if (!cfg->speaker_pins[0] &&
953 cfg->line_out_type == AUTO_PIN_SPEAKER_OUT) {
bb35febd
TI		 954 memcpy(cfg->speaker_pins, cfg->line_out_pins,
955 sizeof(cfg->speaker_pins));
956 cfg->speaker_outs = cfg->line_outs;
957 }
958
c48a8fb0
TI		 959 if (!cfg->hp_pins[0] &&
960 cfg->line_out_type == AUTO_PIN_HP_OUT) {
bb35febd
TI		 961 memcpy(cfg->hp_pins, cfg->line_out_pins,
962 sizeof(cfg->hp_pins));
963 cfg->hp_outs = cfg->line_outs;
4a79ba34
TI		 964 }
965
42cf0d01
DH		 966 spec->automute_mode = ALC_AUTOMUTE_PIN;
967
bb35febd 968 for (i = 0; i < cfg->hp_outs; i++) {
1a1455de 969 hda_nid_t nid = cfg->hp_pins[i];
06dec228 970 if (!is_jack_detectable(codec, nid))
1a1455de 971 continue;
bb35febd 972 snd_printdd("realtek: Enable HP auto-muting on NID 0x%x\n",
1a1455de
TI		 973 nid);
974 snd_hda_codec_write_cache(codec, nid, 0,
4a79ba34 975 AC_VERB_SET_UNSOLICITED_ENABLE,
1d045db9 976 AC_USRSP_EN | ALC_HP_EVENT);
42cf0d01
DH		 977 spec->detect_hp = 1;
978 }
979
980 if (cfg->line_out_type == AUTO_PIN_LINE_OUT && cfg->line_outs) {
981 if (cfg->speaker_outs)
982 for (i = 0; i < cfg->line_outs; i++) {
983 hda_nid_t nid = cfg->line_out_pins[i];
984 if (!is_jack_detectable(codec, nid))
985 continue;
986 snd_printdd("realtek: Enable Line-Out "
987 "auto-muting on NID 0x%x\n", nid);
988 snd_hda_codec_write_cache(codec, nid, 0,
989 AC_VERB_SET_UNSOLICITED_ENABLE,
990 AC_USRSP_EN | ALC_FRONT_EVENT);
991 spec->detect_lo = 1;
1a1455de 992 }
42cf0d01 993 spec->automute_lo_possible = spec->detect_hp;
ae8a60a5
TI		 994 }
995
42cf0d01
DH		 996 spec->automute_speaker_possible = cfg->speaker_outs &&
997 (spec->detect_hp || spec->detect_lo);
998
999 spec->automute_lo = spec->automute_lo_possible;
1000 spec->automute_speaker = spec->automute_speaker_possible;
1001
1002 if (spec->automute_speaker_possible || spec->automute_lo_possible) {
1a1455de
TI		 1003 /* create a control for automute mode */
1004 alc_add_automute_mode_enum(codec);
ae8a60a5 1005 spec->unsol_event = alc_sku_unsol_event;
1a1455de 1006 }
4a79ba34
TI		 1007}
1008
1d045db9 1009/* return the position of NID in the list, or -1 if not found */
21268961
TI		 1010static int find_idx_in_nid_list(hda_nid_t nid, const hda_nid_t *list, int nums)
1011{
1012 int i;
1013 for (i = 0; i < nums; i++)
1014 if (list[i] == nid)
1015 return i;
1016 return -1;
1017}
1018
1d045db9
TI		 1019/* check whether dynamic ADC-switching is available */
1020static bool alc_check_dyn_adc_switch(struct hda_codec *codec)
1021{
1022 struct alc_spec *spec = codec->spec;
1023 struct hda_input_mux *imux = &spec->private_imux[0];
1024 int i, n, idx;
1025 hda_nid_t cap, pin;
1026
1027 if (imux != spec->input_mux) /* no dynamic imux? */
1028 return false;
1029
1030 for (n = 0; n < spec->num_adc_nids; n++) {
1031 cap = spec->private_capsrc_nids[n];
1032 for (i = 0; i < imux->num_items; i++) {
1033 pin = spec->imux_pins[i];
1034 if (!pin)
1035 return false;
1036 if (get_connection_index(codec, cap, pin) < 0)
1037 break;
1038 }
1039 if (i >= imux->num_items)
268ff6fb 1040 return true; /* no ADC-switch is needed */
1d045db9
TI		 1041 }
1042
1043 for (i = 0; i < imux->num_items; i++) {
1044 pin = spec->imux_pins[i];
1045 for (n = 0; n < spec->num_adc_nids; n++) {
1046 cap = spec->private_capsrc_nids[n];
1047 idx = get_connection_index(codec, cap, pin);
1048 if (idx >= 0) {
1049 imux->items[i].index = idx;
1050 spec->dyn_adc_idx[i] = n;
1051 break;
1052 }
1053 }
1054 }
1055
1056 snd_printdd("realtek: enabling ADC switching\n");
1057 spec->dyn_adc_switch = 1;
1058 return true;
1059}
21268961
TI		 1060
1061/* rebuild imux for matching with the given auto-mic pins (if not yet) */
1062static bool alc_rebuild_imux_for_auto_mic(struct hda_codec *codec)
1063{
1064 struct alc_spec *spec = codec->spec;
1065 struct hda_input_mux *imux;
1066 static char * const texts[3] = {
1067 "Mic", "Internal Mic", "Dock Mic"
1068 };
1069 int i;
1070
1071 if (!spec->auto_mic)
1072 return false;
1073 imux = &spec->private_imux[0];
1074 if (spec->input_mux == imux)
1075 return true;
1076 spec->imux_pins[0] = spec->ext_mic_pin;
1077 spec->imux_pins[1] = spec->int_mic_pin;
1078 spec->imux_pins[2] = spec->dock_mic_pin;
1079 for (i = 0; i < 3; i++) {
1080 strcpy(imux->items[i].label, texts[i]);
6759dc32
TI		 1081 if (spec->imux_pins[i]) {
1082 hda_nid_t pin = spec->imux_pins[i];
1083 int c;
1084 for (c = 0; c < spec->num_adc_nids; c++) {
61071594 1085 hda_nid_t cap = get_capsrc(spec, c);
6759dc32
TI		 1086 int idx = get_connection_index(codec, cap, pin);
1087 if (idx >= 0) {
1088 imux->items[i].index = idx;
1089 break;
1090 }
1091 }
21268961 1092 imux->num_items = i + 1;
6759dc32 1093 }
21268961
TI		 1094 }
1095 spec->num_mux_defs = 1;
1096 spec->input_mux = imux;
1097 return true;
1098}
1099
1100/* check whether all auto-mic pins are valid; setup indices if OK */
1101static bool alc_auto_mic_check_imux(struct hda_codec *codec)
1102{
1103 struct alc_spec *spec = codec->spec;
1104 const struct hda_input_mux *imux;
1105
1106 if (!spec->auto_mic)
1107 return false;
1108 if (spec->auto_mic_valid_imux)
1109 return true; /* already checked */
1110
1111 /* fill up imux indices */
1112 if (!alc_check_dyn_adc_switch(codec)) {
1113 spec->auto_mic = 0;
1114 return false;
1115 }
1116
1117 imux = spec->input_mux;
1118 spec->ext_mic_idx = find_idx_in_nid_list(spec->ext_mic_pin,
1119 spec->imux_pins, imux->num_items);
1120 spec->int_mic_idx = find_idx_in_nid_list(spec->int_mic_pin,
1121 spec->imux_pins, imux->num_items);
1122 spec->dock_mic_idx = find_idx_in_nid_list(spec->dock_mic_pin,
1123 spec->imux_pins, imux->num_items);
1124 if (spec->ext_mic_idx < 0 || spec->int_mic_idx < 0) {
1125 spec->auto_mic = 0;
1126 return false; /* no corresponding imux */
1127 }
1128
1129 snd_hda_codec_write_cache(codec, spec->ext_mic_pin, 0,
1130 AC_VERB_SET_UNSOLICITED_ENABLE,
1d045db9 1131 AC_USRSP_EN | ALC_MIC_EVENT);
21268961
TI		 1132 if (spec->dock_mic_pin)
1133 snd_hda_codec_write_cache(codec, spec->dock_mic_pin, 0,
1134 AC_VERB_SET_UNSOLICITED_ENABLE,
1d045db9 1135 AC_USRSP_EN | ALC_MIC_EVENT);
21268961
TI		 1136
1137 spec->auto_mic_valid_imux = 1;
1138 spec->auto_mic = 1;
1139 return true;
1140}
1141
1d045db9
TI		 1142/*
1143 * Check the availability of auto-mic switch;
1144 * Set up if really supported
1145 */
6c819492
TI		 1146static void alc_init_auto_mic(struct hda_codec *codec)
1147{
1148 struct alc_spec *spec = codec->spec;
1149 struct auto_pin_cfg *cfg = &spec->autocfg;
8ed99d97 1150 hda_nid_t fixed, ext, dock;
6c819492
TI		 1151 int i;
1152
24de183e
TI		 1153 if (spec->shared_mic_hp)
1154 return; /* no auto-mic for the shared I/O */
1155
21268961
TI		 1156 spec->ext_mic_idx = spec->int_mic_idx = spec->dock_mic_idx = -1;
1157
8ed99d97 1158 fixed = ext = dock = 0;
66ceeb6b
TI		 1159 for (i = 0; i < cfg->num_inputs; i++) {
1160 hda_nid_t nid = cfg->inputs[i].pin;
6c819492 1161 unsigned int defcfg;
6c819492 1162 defcfg = snd_hda_codec_get_pincfg(codec, nid);
99ae28be
TI		 1163 switch (snd_hda_get_input_pin_attr(defcfg)) {
1164 case INPUT_PIN_ATTR_INT:
6c819492
TI		 1165 if (fixed)
1166 return; /* already occupied */
8ed99d97
TI		 1167 if (cfg->inputs[i].type != AUTO_PIN_MIC)
1168 return; /* invalid type */
6c819492
TI		 1169 fixed = nid;
1170 break;
99ae28be
TI		 1171 case INPUT_PIN_ATTR_UNUSED:
1172 return; /* invalid entry */
8ed99d97
TI		 1173 case INPUT_PIN_ATTR_DOCK:
1174 if (dock)
1175 return; /* already occupied */
1176 if (cfg->inputs[i].type > AUTO_PIN_LINE_IN)
1177 return; /* invalid type */
1178 dock = nid;
1179 break;
99ae28be 1180 default:
6c819492
TI		 1181 if (ext)
1182 return; /* already occupied */
8ed99d97
TI		 1183 if (cfg->inputs[i].type != AUTO_PIN_MIC)
1184 return; /* invalid type */
6c819492
TI		 1185 ext = nid;
1186 break;
6c819492
TI		 1187 }
1188 }
8ed99d97
TI		 1189 if (!ext && dock) {
1190 ext = dock;
1191 dock = 0;
1192 }
eaa9b3a7
TI		 1193 if (!ext || !fixed)
1194 return;
e35d9d6a 1195 if (!is_jack_detectable(codec, ext))
6c819492 1196 return; /* no unsol support */
8ed99d97
TI		 1197 if (dock && !is_jack_detectable(codec, dock))
1198 return; /* no unsol support */
21268961
TI		 1199
1200 /* check imux indices */
1201 spec->ext_mic_pin = ext;
1202 spec->int_mic_pin = fixed;
1203 spec->dock_mic_pin = dock;
1204
1205 spec->auto_mic = 1;
1206 if (!alc_auto_mic_check_imux(codec))
1207 return;
1208
8ed99d97
TI		 1209 snd_printdd("realtek: Enable auto-mic switch on NID 0x%x/0x%x/0x%x\n",
1210 ext, fixed, dock);
6c819492
TI		 1211 spec->unsol_event = alc_sku_unsol_event;
1212}
1213
1d045db9
TI		 1214/* check the availabilities of auto-mute and auto-mic switches */
1215static void alc_auto_check_switches(struct hda_codec *codec)
1216{
42cf0d01 1217 alc_init_automute(codec);
1d045db9
TI		 1218 alc_init_auto_mic(codec);
1219}
1220
1221/*
1222 * Realtek SSID verification
1223 */
1224
90622917
DH		 1225/* Could be any non-zero and even value. When used as fixup, tells
1226 * the driver to ignore any present sku defines.
1227 */
1228#define ALC_FIXUP_SKU_IGNORE (2)
1229
da00c244
KY		 1230static int alc_auto_parse_customize_define(struct hda_codec *codec)
1231{
1232 unsigned int ass, tmp, i;
7fb56223 1233 unsigned nid = 0;
da00c244
KY		 1234 struct alc_spec *spec = codec->spec;
1235
b6cbe517
TI		 1236 spec->cdefine.enable_pcbeep = 1; /* assume always enabled */
1237
90622917
DH		 1238 if (spec->cdefine.fixup) {
1239 ass = spec->cdefine.sku_cfg;
1240 if (ass == ALC_FIXUP_SKU_IGNORE)
1241 return -1;
1242 goto do_sku;
1243 }
1244
da00c244 1245 ass = codec->subsystem_id & 0xffff;
b6cbe517 1246 if (ass != codec->bus->pci->subsystem_device && (ass & 1))
da00c244
KY		 1247 goto do_sku;
1248
1249 nid = 0x1d;
1250 if (codec->vendor_id == 0x10ec0260)
1251 nid = 0x17;
1252 ass = snd_hda_codec_get_pincfg(codec, nid);
1253
1254 if (!(ass & 1)) {
1255 printk(KERN_INFO "hda_codec: %s: SKU not ready 0x%08x\n",
1256 codec->chip_name, ass);
1257 return -1;
1258 }
1259
1260 /* check sum */
1261 tmp = 0;
1262 for (i = 1; i < 16; i++) {
1263 if ((ass >> i) & 1)
1264 tmp++;
1265 }
1266 if (((ass >> 16) & 0xf) != tmp)
1267 return -1;
1268
1269 spec->cdefine.port_connectivity = ass >> 30;
1270 spec->cdefine.enable_pcbeep = (ass & 0x100000) >> 20;
1271 spec->cdefine.check_sum = (ass >> 16) & 0xf;
1272 spec->cdefine.customization = ass >> 8;
1273do_sku:
1274 spec->cdefine.sku_cfg = ass;
1275 spec->cdefine.external_amp = (ass & 0x38) >> 3;
1276 spec->cdefine.platform_type = (ass & 0x4) >> 2;
1277 spec->cdefine.swap = (ass & 0x2) >> 1;
1278 spec->cdefine.override = ass & 0x1;
1279
1280 snd_printd("SKU: Nid=0x%x sku_cfg=0x%08x\n",
1281 nid, spec->cdefine.sku_cfg);
1282 snd_printd("SKU: port_connectivity=0x%x\n",
1283 spec->cdefine.port_connectivity);
1284 snd_printd("SKU: enable_pcbeep=0x%x\n", spec->cdefine.enable_pcbeep);
1285 snd_printd("SKU: check_sum=0x%08x\n", spec->cdefine.check_sum);
1286 snd_printd("SKU: customization=0x%08x\n", spec->cdefine.customization);
1287 snd_printd("SKU: external_amp=0x%x\n", spec->cdefine.external_amp);
1288 snd_printd("SKU: platform_type=0x%x\n", spec->cdefine.platform_type);
1289 snd_printd("SKU: swap=0x%x\n", spec->cdefine.swap);
1290 snd_printd("SKU: override=0x%x\n", spec->cdefine.override);
1291
1292 return 0;
1293}
1294
1d045db9 1295/* return true if the given NID is found in the list */
3af9ee6b
TI		 1296static bool found_in_nid_list(hda_nid_t nid, const hda_nid_t *list, int nums)
1297{
21268961 1298 return find_idx_in_nid_list(nid, list, nums) >= 0;
3af9ee6b
TI		 1299}
1300
4a79ba34
TI		 1301/* check subsystem ID and set up device-specific initialization;
1302 * return 1 if initialized, 0 if invalid SSID
1303 */
1304/* 32-bit subsystem ID for BIOS loading in HD Audio codec.
1305 * 31 ~ 16 : Manufacture ID
1306 * 15 ~ 8 : SKU ID
1307 * 7 ~ 0 : Assembly ID
1308 * port-A --> pin 39/41, port-E --> pin 14/15, port-D --> pin 35/36
1309 */
1310static int alc_subsystem_id(struct hda_codec *codec,
1311 hda_nid_t porta, hda_nid_t porte,
6227cdce 1312 hda_nid_t portd, hda_nid_t porti)
4a79ba34
TI		 1313{
1314 unsigned int ass, tmp, i;
1315 unsigned nid;
1316 struct alc_spec *spec = codec->spec;
1317
90622917
DH		 1318 if (spec->cdefine.fixup) {
1319 ass = spec->cdefine.sku_cfg;
1320 if (ass == ALC_FIXUP_SKU_IGNORE)
1321 return 0;
1322 goto do_sku;
1323 }
1324
4a79ba34
TI		 1325 ass = codec->subsystem_id & 0xffff;
1326 if ((ass != codec->bus->pci->subsystem_device) && (ass & 1))
1327 goto do_sku;
1328
1329 /* invalid SSID, check the special NID pin defcfg instead */
1330 /*
def319f9 1331 * 31~30 : port connectivity
4a79ba34
TI		 1332 * 29~21 : reserve
1333 * 20 : PCBEEP input
1334 * 19~16 : Check sum (15:1)
1335 * 15~1 : Custom
1336 * 0 : override
1337 */
1338 nid = 0x1d;
1339 if (codec->vendor_id == 0x10ec0260)
1340 nid = 0x17;
1341 ass = snd_hda_codec_get_pincfg(codec, nid);
1342 snd_printd("realtek: No valid SSID, "
1343 "checking pincfg 0x%08x for NID 0x%x\n",
cb6605c1 1344 ass, nid);
6227cdce 1345 if (!(ass & 1))
4a79ba34
TI		 1346 return 0;
1347 if ((ass >> 30) != 1) /* no physical connection */
1348 return 0;
1349
1350 /* check sum */
1351 tmp = 0;
1352 for (i = 1; i < 16; i++) {
1353 if ((ass >> i) & 1)
1354 tmp++;
1355 }
1356 if (((ass >> 16) & 0xf) != tmp)
1357 return 0;
1358do_sku:
1359 snd_printd("realtek: Enabling init ASM_ID=0x%04x CODEC_ID=%08x\n",
1360 ass & 0xffff, codec->vendor_id);
1361 /*
1362 * 0 : override
1363 * 1 : Swap Jack
1364 * 2 : 0 --> Desktop, 1 --> Laptop
1365 * 3~5 : External Amplifier control
1366 * 7~6 : Reserved
1367 */
1368 tmp = (ass & 0x38) >> 3; /* external Amp control */
1369 switch (tmp) {
1370 case 1:
1371 spec->init_amp = ALC_INIT_GPIO1;
1372 break;
1373 case 3:
1374 spec->init_amp = ALC_INIT_GPIO2;
1375 break;
1376 case 7:
1377 spec->init_amp = ALC_INIT_GPIO3;
1378 break;
1379 case 5:
5a8cfb4e 1380 default:
4a79ba34 1381 spec->init_amp = ALC_INIT_DEFAULT;
bc9f98a9
KY		 1382 break;
1383 }
ea1fb29a 1384
8c427226 1385 /* is laptop or Desktop and enable the function "Mute internal speaker
c9b58006
KY		 1386 * when the external headphone out jack is plugged"
1387 */
8c427226 1388 if (!(ass & 0x8000))
4a79ba34 1389 return 1;
c9b58006
KY		 1390 /*
1391 * 10~8 : Jack location
1392 * 12~11: Headphone out -> 00: PortA, 01: PortE, 02: PortD, 03: Resvered
1393 * 14~13: Resvered
1394 * 15 : 1 --> enable the function "Mute internal speaker
1395 * when the external headphone out jack is plugged"
1396 */
5fe6e015
TI		 1397 if (!spec->autocfg.hp_pins[0] &&
1398 !(spec->autocfg.line_out_pins[0] &&
1399 spec->autocfg.line_out_type == AUTO_PIN_HP_OUT)) {
01d4825d 1400 hda_nid_t nid;
c9b58006
KY		 1401 tmp = (ass >> 11) & 0x3; /* HP to chassis */
1402 if (tmp == 0)
01d4825d 1403 nid = porta;
c9b58006 1404 else if (tmp == 1)
01d4825d 1405 nid = porte;
c9b58006 1406 else if (tmp == 2)
01d4825d 1407 nid = portd;
6227cdce
KY		 1408 else if (tmp == 3)
1409 nid = porti;
c9b58006 1410 else
4a79ba34 1411 return 1;
3af9ee6b
TI		 1412 if (found_in_nid_list(nid, spec->autocfg.line_out_pins,
1413 spec->autocfg.line_outs))
1414 return 1;
01d4825d 1415 spec->autocfg.hp_pins[0] = nid;
c9b58006 1416 }
4a79ba34
TI		 1417 return 1;
1418}
ea1fb29a 1419
3e6179b8
TI		 1420/* Check the validity of ALC subsystem-id
1421 * ports contains an array of 4 pin NIDs for port-A, E, D and I */
1422static void alc_ssid_check(struct hda_codec *codec, const hda_nid_t *ports)
4a79ba34 1423{
3e6179b8 1424 if (!alc_subsystem_id(codec, ports[0], ports[1], ports[2], ports[3])) {
4a79ba34
TI		 1425 struct alc_spec *spec = codec->spec;
1426 snd_printd("realtek: "
1427 "Enable default setup for auto mode as fallback\n");
1428 spec->init_amp = ALC_INIT_DEFAULT;
4a79ba34 1429 }
21268961 1430}
1a1455de 1431
f95474ec 1432/*
f8f25ba3 1433 * Fix-up pin default configurations and add default verbs
f95474ec
TI		 1434 */
1435
1436struct alc_pincfg {
1437 hda_nid_t nid;
1438 u32 val;
1439};
1440
e1eb5f10
TB		 1441struct alc_model_fixup {
1442 const int id;
1443 const char *name;
1444};
1445
f8f25ba3 1446struct alc_fixup {
b5bfbc67 1447 int type;
361fe6e9
TI		 1448 bool chained;
1449 int chain_id;
b5bfbc67
TI		 1450 union {
1451 unsigned int sku;
1452 const struct alc_pincfg *pins;
1453 const struct hda_verb *verbs;
1454 void (*func)(struct hda_codec *codec,
1455 const struct alc_fixup *fix,
1456 int action);
1457 } v;
f8f25ba3
TI		 1458};
1459
b5bfbc67
TI		 1460enum {
1461 ALC_FIXUP_INVALID,
1462 ALC_FIXUP_SKU,
1463 ALC_FIXUP_PINS,
1464 ALC_FIXUP_VERBS,
1465 ALC_FIXUP_FUNC,
1466};
1467
1468enum {
1469 ALC_FIXUP_ACT_PRE_PROBE,
1470 ALC_FIXUP_ACT_PROBE,
58701120 1471 ALC_FIXUP_ACT_INIT,
b5bfbc67
TI		 1472};
1473
1474static void alc_apply_fixup(struct hda_codec *codec, int action)
f95474ec 1475{
b5bfbc67
TI		 1476 struct alc_spec *spec = codec->spec;
1477 int id = spec->fixup_id;
aa1d0c52 1478#ifdef CONFIG_SND_DEBUG_VERBOSE
b5bfbc67 1479 const char *modelname = spec->fixup_name;
aa1d0c52 1480#endif
b5bfbc67 1481 int depth = 0;
f95474ec 1482
b5bfbc67
TI		 1483 if (!spec->fixup_list)
1484 return;
1485
1486 while (id >= 0) {
1487 const struct alc_fixup *fix = spec->fixup_list + id;
1488 const struct alc_pincfg *cfg;
1489
1490 switch (fix->type) {
1491 case ALC_FIXUP_SKU:
1492 if (action != ALC_FIXUP_ACT_PRE_PROBE || !fix->v.sku)
e53de8f0 1493 break;
b5bfbc67
TI		 1494 snd_printdd(KERN_INFO "hda_codec: %s: "
1495 "Apply sku override for %s\n",
1496 codec->chip_name, modelname);
1497 spec->cdefine.sku_cfg = fix->v.sku;
1498 spec->cdefine.fixup = 1;
1499 break;
1500 case ALC_FIXUP_PINS:
1501 cfg = fix->v.pins;
1502 if (action != ALC_FIXUP_ACT_PRE_PROBE || !cfg)
1503 break;
1504 snd_printdd(KERN_INFO "hda_codec: %s: "
1505 "Apply pincfg for %s\n",
1506 codec->chip_name, modelname);
1507 for (; cfg->nid; cfg++)
1508 snd_hda_codec_set_pincfg(codec, cfg->nid,
1509 cfg->val);
1510 break;
1511 case ALC_FIXUP_VERBS:
1512 if (action != ALC_FIXUP_ACT_PROBE || !fix->v.verbs)
1513 break;
1514 snd_printdd(KERN_INFO "hda_codec: %s: "
1515 "Apply fix-verbs for %s\n",
1516 codec->chip_name, modelname);
1517 add_verb(codec->spec, fix->v.verbs);
1518 break;
1519 case ALC_FIXUP_FUNC:
1520 if (!fix->v.func)
1521 break;
1522 snd_printdd(KERN_INFO "hda_codec: %s: "
1523 "Apply fix-func for %s\n",
1524 codec->chip_name, modelname);
1525 fix->v.func(codec, fix, action);
1526 break;
1527 default:
1528 snd_printk(KERN_ERR "hda_codec: %s: "
1529 "Invalid fixup type %d\n",
1530 codec->chip_name, fix->type);
1531 break;
1532 }
24af2b1c 1533 if (!fix->chained)
b5bfbc67
TI		 1534 break;
1535 if (++depth > 10)
1536 break;
24af2b1c 1537 id = fix->chain_id;
9d57883f 1538 }
f95474ec
TI		 1539}
1540
e1eb5f10 1541static void alc_pick_fixup(struct hda_codec *codec,
b5bfbc67
TI		 1542 const struct alc_model_fixup *models,
1543 const struct snd_pci_quirk *quirk,
1544 const struct alc_fixup *fixlist)
e1eb5f10 1545{
b5bfbc67 1546 struct alc_spec *spec = codec->spec;
596830ee 1547 const struct snd_pci_quirk *q;
b5bfbc67
TI		 1548 int id = -1;
1549 const char *name = NULL;
e1eb5f10 1550
e1eb5f10
TB		 1551 if (codec->modelname && models) {
1552 while (models->name) {
1553 if (!strcmp(codec->modelname, models->name)) {
b5bfbc67
TI		 1554 id = models->id;
1555 name = models->name;
e1eb5f10
TB		 1556 break;
1557 }
1558 models++;
1559 }
b5bfbc67
TI		 1560 }
1561 if (id < 0) {
596830ee
TI		 1562 q = snd_pci_quirk_lookup(codec->bus->pci, quirk);
1563 if (q) {
1564 id = q->value;
b5bfbc67 1565#ifdef CONFIG_SND_DEBUG_VERBOSE
596830ee 1566 name = q->name;
b5bfbc67
TI		 1567#endif
1568 }
1569 }
596830ee
TI		 1570 if (id < 0) {
1571 for (q = quirk; q->subvendor; q++) {
1572 unsigned int vendorid =
1573 q->subdevice | (q->subvendor << 16);
1574 if (vendorid == codec->subsystem_id) {
1575 id = q->value;
1576#ifdef CONFIG_SND_DEBUG_VERBOSE
1577 name = q->name;
1578#endif
1579 break;
1580 }
1581 }
1582 }
b5bfbc67
TI		 1583
1584 spec->fixup_id = id;
1585 if (id >= 0) {
1586 spec->fixup_list = fixlist;
1587 spec->fixup_name = name;
e1eb5f10 1588 }
f95474ec
TI		 1589}
1590
1d045db9
TI		 1591/*
1592 * COEF access helper functions
1593 */
274693f3
KY		 1594static int alc_read_coef_idx(struct hda_codec *codec,
1595 unsigned int coef_idx)
1596{
1597 unsigned int val;
1598 snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX,
1599 coef_idx);
1600 val = snd_hda_codec_read(codec, 0x20, 0,
1601 AC_VERB_GET_PROC_COEF, 0);
1602 return val;
1603}
1604
977ddd6b
KY		 1605static void alc_write_coef_idx(struct hda_codec *codec, unsigned int coef_idx,
1606 unsigned int coef_val)
1607{
1608 snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX,
1609 coef_idx);
1610 snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_PROC_COEF,
1611 coef_val);
1612}
1613
1bb7e43e
TI		 1614/* a special bypass for COEF 0; read the cached value at the second time */
1615static unsigned int alc_get_coef0(struct hda_codec *codec)
1616{
1617 struct alc_spec *spec = codec->spec;
1618 if (!spec->coef0)
1619 spec->coef0 = alc_read_coef_idx(codec, 0);
1620 return spec->coef0;
1621}
1622
1d045db9
TI		 1623/*
1624 * Digital I/O handling
1625 */
1626
757899ac
TI		 1627/* set right pin controls for digital I/O */
1628static void alc_auto_init_digital(struct hda_codec *codec)
1629{
1630 struct alc_spec *spec = codec->spec;
1631 int i;
1f0f4b80 1632 hda_nid_t pin, dac;
757899ac
TI		 1633
1634 for (i = 0; i < spec->autocfg.dig_outs; i++) {
1635 pin = spec->autocfg.dig_out_pins[i];
1f0f4b80
TI		 1636 if (!pin)
1637 continue;
1638 snd_hda_codec_write(codec, pin, 0,
1639 AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
1640 if (!i)
1641 dac = spec->multiout.dig_out_nid;
1642 else
1643 dac = spec->slave_dig_outs[i - 1];
1644 if (!dac || !(get_wcaps(codec, dac) & AC_WCAP_OUT_AMP))
1645 continue;
1646 snd_hda_codec_write(codec, dac, 0,
1647 AC_VERB_SET_AMP_GAIN_MUTE,
1648 AMP_OUT_UNMUTE);
757899ac
TI		 1649 }
1650 pin = spec->autocfg.dig_in_pin;
1651 if (pin)
1652 snd_hda_codec_write(codec, pin, 0,
1653 AC_VERB_SET_PIN_WIDGET_CONTROL,
1654 PIN_IN);
1655}
1656
1657/* parse digital I/Os and set up NIDs in BIOS auto-parse mode */
1658static void alc_auto_parse_digital(struct hda_codec *codec)
1659{
1660 struct alc_spec *spec = codec->spec;
51e4152a 1661 int i, err, nums;
757899ac
TI		 1662 hda_nid_t dig_nid;
1663
1664 /* support multiple SPDIFs; the secondary is set up as a slave */
51e4152a 1665 nums = 0;
757899ac 1666 for (i = 0; i < spec->autocfg.dig_outs; i++) {
a926757f 1667 hda_nid_t conn[4];
757899ac
TI		 1668 err = snd_hda_get_connections(codec,
1669 spec->autocfg.dig_out_pins[i],
a926757f 1670 conn, ARRAY_SIZE(conn));
51e4152a 1671 if (err <= 0)
757899ac 1672 continue;
a926757f 1673 dig_nid = conn[0]; /* assume the first element is audio-out */
51e4152a 1674 if (!nums) {
757899ac
TI		 1675 spec->multiout.dig_out_nid = dig_nid;
1676 spec->dig_out_type = spec->autocfg.dig_out_type[0];
1677 } else {
1678 spec->multiout.slave_dig_outs = spec->slave_dig_outs;
51e4152a 1679 if (nums >= ARRAY_SIZE(spec->slave_dig_outs) - 1)
757899ac 1680 break;
51e4152a 1681 spec->slave_dig_outs[nums - 1] = dig_nid;
757899ac 1682 }
51e4152a 1683 nums++;
757899ac
TI		 1684 }
1685
1686 if (spec->autocfg.dig_in_pin) {
01fdf180
TI		 1687 dig_nid = codec->start_nid;
1688 for (i = 0; i < codec->num_nodes; i++, dig_nid++) {
1689 unsigned int wcaps = get_wcaps(codec, dig_nid);
1690 if (get_wcaps_type(wcaps) != AC_WID_AUD_IN)
1691 continue;
1692 if (!(wcaps & AC_WCAP_DIGITAL))
1693 continue;
1694 if (!(wcaps & AC_WCAP_CONN_LIST))
1695 continue;
1696 err = get_connection_index(codec, dig_nid,
1697 spec->autocfg.dig_in_pin);
1698 if (err >= 0) {
1699 spec->dig_in_nid = dig_nid;
1700 break;
1701 }
1702 }
757899ac
TI		 1703 }
1704}
1705
ef8ef5fb 1706/*
1d045db9 1707 * capture mixer elements
ef8ef5fb 1708 */
f9e336f6
TI		 1709static int alc_cap_vol_info(struct snd_kcontrol *kcontrol,
1710 struct snd_ctl_elem_info *uinfo)
1711{
1712 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1713 struct alc_spec *spec = codec->spec;
d6cc9fab 1714 unsigned long val;
f9e336f6 1715 int err;
1da177e4 1716
5a9e02e9 1717 mutex_lock(&codec->control_mutex);
d6cc9fab
TI		 1718 if (spec->vol_in_capsrc)
1719 val = HDA_COMPOSE_AMP_VAL(spec->capsrc_nids[0], 3, 0, HDA_OUTPUT);
1720 else
1721 val = HDA_COMPOSE_AMP_VAL(spec->adc_nids[0], 3, 0, HDA_INPUT);
1722 kcontrol->private_value = val;
f9e336f6 1723 err = snd_hda_mixer_amp_volume_info(kcontrol, uinfo);
5a9e02e9 1724 mutex_unlock(&codec->control_mutex);
f9e336f6
TI		 1725 return err;
1726}
1727
1728static int alc_cap_vol_tlv(struct snd_kcontrol *kcontrol, int op_flag,
1729 unsigned int size, unsigned int __user *tlv)
1730{
1731 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1732 struct alc_spec *spec = codec->spec;
d6cc9fab 1733 unsigned long val;
f9e336f6 1734 int err;
1da177e4 1735
5a9e02e9 1736 mutex_lock(&codec->control_mutex);
d6cc9fab
TI		 1737 if (spec->vol_in_capsrc)
1738 val = HDA_COMPOSE_AMP_VAL(spec->capsrc_nids[0], 3, 0, HDA_OUTPUT);
1739 else
1740 val = HDA_COMPOSE_AMP_VAL(spec->adc_nids[0], 3, 0, HDA_INPUT);
1741 kcontrol->private_value = val;
f9e336f6 1742 err = snd_hda_mixer_amp_tlv(kcontrol, op_flag, size, tlv);
5a9e02e9 1743 mutex_unlock(&codec->control_mutex);
f9e336f6
TI		 1744 return err;
1745}
1746
1747typedef int (*getput_call_t)(struct snd_kcontrol *kcontrol,
1748 struct snd_ctl_elem_value *ucontrol);
1749
1750static int alc_cap_getput_caller(struct snd_kcontrol *kcontrol,
1751 struct snd_ctl_elem_value *ucontrol,
9c7a083d 1752 getput_call_t func, bool check_adc_switch)
f9e336f6
TI		 1753{
1754 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1755 struct alc_spec *spec = codec->spec;
21268961 1756 int i, err = 0;
f9e336f6 1757
5a9e02e9 1758 mutex_lock(&codec->control_mutex);
21268961 1759 if (check_adc_switch && spec->dyn_adc_switch) {
9c7a083d
TI		 1760 for (i = 0; i < spec->num_adc_nids; i++) {
1761 kcontrol->private_value =
1762 HDA_COMPOSE_AMP_VAL(spec->adc_nids[i],
1763 3, 0, HDA_INPUT);
1764 err = func(kcontrol, ucontrol);
1765 if (err < 0)
1766 goto error;
1767 }
1768 } else {
1769 i = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
d6cc9fab
TI		 1770 if (spec->vol_in_capsrc)
1771 kcontrol->private_value =
1772 HDA_COMPOSE_AMP_VAL(spec->capsrc_nids[i],
1773 3, 0, HDA_OUTPUT);
1774 else
1775 kcontrol->private_value =
21268961
TI		 1776 HDA_COMPOSE_AMP_VAL(spec->adc_nids[i],
1777 3, 0, HDA_INPUT);
9c7a083d
TI		 1778 err = func(kcontrol, ucontrol);
1779 }
1780 error:
5a9e02e9 1781 mutex_unlock(&codec->control_mutex);
f9e336f6
TI		 1782 return err;
1783}
1784
1785static int alc_cap_vol_get(struct snd_kcontrol *kcontrol,
1786 struct snd_ctl_elem_value *ucontrol)
1787{
1788 return alc_cap_getput_caller(kcontrol, ucontrol,
9c7a083d 1789 snd_hda_mixer_amp_volume_get, false);
f9e336f6
TI		 1790}
1791
1792static int alc_cap_vol_put(struct snd_kcontrol *kcontrol,
1793 struct snd_ctl_elem_value *ucontrol)
1794{
1795 return alc_cap_getput_caller(kcontrol, ucontrol,
9c7a083d 1796 snd_hda_mixer_amp_volume_put, true);
f9e336f6
TI		 1797}
1798
1799/* capture mixer elements */
1800#define alc_cap_sw_info snd_ctl_boolean_stereo_info
1801
1802static int alc_cap_sw_get(struct snd_kcontrol *kcontrol,
1803 struct snd_ctl_elem_value *ucontrol)
1804{
1805 return alc_cap_getput_caller(kcontrol, ucontrol,
9c7a083d 1806 snd_hda_mixer_amp_switch_get, false);
f9e336f6
TI		 1807}
1808
1809static int alc_cap_sw_put(struct snd_kcontrol *kcontrol,
1810 struct snd_ctl_elem_value *ucontrol)
1811{
1812 return alc_cap_getput_caller(kcontrol, ucontrol,
9c7a083d 1813 snd_hda_mixer_amp_switch_put, true);
f9e336f6
TI		 1814}
1815
a23b688f 1816#define _DEFINE_CAPMIX(num) \
f9e336f6
TI		 1817 { \
1818 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
1819 .name = "Capture Switch", \
1820 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE, \
1821 .count = num, \
1822 .info = alc_cap_sw_info, \
1823 .get = alc_cap_sw_get, \
1824 .put = alc_cap_sw_put, \
1825 }, \
1826 { \
1827 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
1828 .name = "Capture Volume", \
1829 .access = (SNDRV_CTL_ELEM_ACCESS_READWRITE | \
1830 SNDRV_CTL_ELEM_ACCESS_TLV_READ | \
1831 SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK), \
1832 .count = num, \
1833 .info = alc_cap_vol_info, \
1834 .get = alc_cap_vol_get, \
1835 .put = alc_cap_vol_put, \
1836 .tlv = { .c = alc_cap_vol_tlv }, \
a23b688f
TI		 1837 }
1838
1839#define _DEFINE_CAPSRC(num) \
3c3e9892
TI		 1840 { \
1841 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
1842 /* .name = "Capture Source", */ \
1843 .name = "Input Source", \
1844 .count = num, \
1845 .info = alc_mux_enum_info, \
1846 .get = alc_mux_enum_get, \
1847 .put = alc_mux_enum_put, \
a23b688f
TI		 1848 }
1849
1850#define DEFINE_CAPMIX(num) \
a9111321 1851static const struct snd_kcontrol_new alc_capture_mixer ## num[] = { \
a23b688f
TI		 1852 _DEFINE_CAPMIX(num), \
1853 _DEFINE_CAPSRC(num), \
1854 { } /* end */ \
1855}
1856
1857#define DEFINE_CAPMIX_NOSRC(num) \
a9111321 1858static const struct snd_kcontrol_new alc_capture_mixer_nosrc ## num[] = { \
a23b688f
TI		 1859 _DEFINE_CAPMIX(num), \
1860 { } /* end */ \
f9e336f6
TI		 1861}
1862
1863/* up to three ADCs */
1864DEFINE_CAPMIX(1);
1865DEFINE_CAPMIX(2);
1866DEFINE_CAPMIX(3);
a23b688f
TI		 1867DEFINE_CAPMIX_NOSRC(1);
1868DEFINE_CAPMIX_NOSRC(2);
1869DEFINE_CAPMIX_NOSRC(3);
e9edcee0
TI		 1870
1871/*
1d045db9 1872 * virtual master controls
e9edcee0
TI		 1873 */
1874
e9edcee0 1875/*
1d045db9 1876 * slave controls for virtual master
e9edcee0 1877 */
1d045db9
TI		 1878static const char * const alc_slave_vols[] = {
1879 "Front Playback Volume",
1880 "Surround Playback Volume",
1881 "Center Playback Volume",
1882 "LFE Playback Volume",
1883 "Side Playback Volume",
1884 "Headphone Playback Volume",
1885 "Speaker Playback Volume",
1886 "Mono Playback Volume",
1887 "Line-Out Playback Volume",
3fe45aea 1888 "PCM Playback Volume",
1d045db9 1889 NULL,
e9edcee0
TI		 1890};
1891
1d045db9
TI		 1892static const char * const alc_slave_sws[] = {
1893 "Front Playback Switch",
1894 "Surround Playback Switch",
1895 "Center Playback Switch",
1896 "LFE Playback Switch",
1897 "Side Playback Switch",
1898 "Headphone Playback Switch",
1899 "Speaker Playback Switch",
1900 "Mono Playback Switch",
1901 "IEC958 Playback Switch",
1902 "Line-Out Playback Switch",
3fe45aea 1903 "PCM Playback Switch",
1d045db9 1904 NULL,
16ded525
TI		 1905};
1906
e9edcee0 1907/*
1d045db9 1908 * build control elements
e9edcee0
TI		 1909 */
1910
1d045db9 1911#define NID_MAPPING (-1)
e9edcee0 1912
1d045db9
TI		 1913#define SUBDEV_SPEAKER_ (0 << 6)
1914#define SUBDEV_HP_ (1 << 6)
1915#define SUBDEV_LINE_ (2 << 6)
1916#define SUBDEV_SPEAKER(x) (SUBDEV_SPEAKER_ | ((x) & 0x3f))
1917#define SUBDEV_HP(x) (SUBDEV_HP_ | ((x) & 0x3f))
1918#define SUBDEV_LINE(x) (SUBDEV_LINE_ | ((x) & 0x3f))
e9edcee0 1919
1d045db9 1920static void alc_free_kctls(struct hda_codec *codec);
e9edcee0 1921
1d045db9
TI		 1922#ifdef CONFIG_SND_HDA_INPUT_BEEP
1923/* additional beep mixers; the actual parameters are overwritten at build */
1924static const struct snd_kcontrol_new alc_beep_mixer[] = {
1925 HDA_CODEC_VOLUME("Beep Playback Volume", 0, 0, HDA_INPUT),
1926 HDA_CODEC_MUTE_BEEP("Beep Playback Switch", 0, 0, HDA_INPUT),
16ded525
TI		 1927 { } /* end */
1928};
1d045db9 1929#endif
16ded525 1930
1d045db9
TI		 1931static int alc_build_controls(struct hda_codec *codec)
1932{
1933 struct alc_spec *spec = codec->spec;
1934 struct snd_kcontrol *kctl = NULL;
1935 const struct snd_kcontrol_new *knew;
1936 int i, j, err;
1937 unsigned int u;
1938 hda_nid_t nid;
1da177e4
LT		 1939
1940 for (i = 0; i < spec->num_mixers; i++) {
1941 err = snd_hda_add_new_ctls(codec, spec->mixers[i]);
1942 if (err < 0)
1943 return err;
1944 }
f9e336f6
TI		 1945 if (spec->cap_mixer) {
1946 err = snd_hda_add_new_ctls(codec, spec->cap_mixer);
1947 if (err < 0)
1948 return err;
1949 }
1da177e4 1950 if (spec->multiout.dig_out_nid) {
9c7f852e 1951 err = snd_hda_create_spdif_out_ctls(codec,
74b654c9 1952 spec->multiout.dig_out_nid,
9c7f852e 1953 spec->multiout.dig_out_nid);
1da177e4
LT		 1954 if (err < 0)
1955 return err;
e64f14f4
TI		 1956 if (!spec->no_analog) {
1957 err = snd_hda_create_spdif_share_sw(codec,
1958 &spec->multiout);
1959 if (err < 0)
1960 return err;
1961 spec->multiout.share_spdif = 1;
1962 }
1da177e4
LT		 1963 }
1964 if (spec->dig_in_nid) {
1965 err = snd_hda_create_spdif_in_ctls(codec, spec->dig_in_nid);
1966 if (err < 0)
1967 return err;
1968 }
2134ea4f 1969
67d634c0 1970#ifdef CONFIG_SND_HDA_INPUT_BEEP
45bdd1c1
TI		 1971 /* create beep controls if needed */
1972 if (spec->beep_amp) {
a9111321 1973 const struct snd_kcontrol_new *knew;
45bdd1c1
TI		 1974 for (knew = alc_beep_mixer; knew->name; knew++) {
1975 struct snd_kcontrol *kctl;
1976 kctl = snd_ctl_new1(knew, codec);
1977 if (!kctl)
1978 return -ENOMEM;
1979 kctl->private_value = spec->beep_amp;
5e26dfd0 1980 err = snd_hda_ctl_add(codec, 0, kctl);
45bdd1c1
TI		 1981 if (err < 0)
1982 return err;
1983 }
1984 }
67d634c0 1985#endif
45bdd1c1 1986
2134ea4f 1987 /* if we have no master control, let's create it */
e64f14f4
TI		 1988 if (!spec->no_analog &&
1989 !snd_hda_find_mixer_ctl(codec, "Master Playback Volume")) {
1c82ed1b 1990 unsigned int vmaster_tlv[4];
2134ea4f 1991 snd_hda_set_vmaster_tlv(codec, spec->vmaster_nid,
1c82ed1b 1992 HDA_OUTPUT, vmaster_tlv);
2134ea4f 1993 err = snd_hda_add_vmaster(codec, "Master Playback Volume",
1c82ed1b 1994 vmaster_tlv, alc_slave_vols);
2134ea4f
TI		 1995 if (err < 0)
1996 return err;
1997 }
e64f14f4
TI		 1998 if (!spec->no_analog &&
1999 !snd_hda_find_mixer_ctl(codec, "Master Playback Switch")) {
2134ea4f
TI		 2000 err = snd_hda_add_vmaster(codec, "Master Playback Switch",
2001 NULL, alc_slave_sws);
2002 if (err < 0)
2003 return err;
2004 }
2005
5b0cb1d8 2006 /* assign Capture Source enums to NID */
fbe618f2
TI		 2007 if (spec->capsrc_nids || spec->adc_nids) {
2008 kctl = snd_hda_find_mixer_ctl(codec, "Capture Source");
2009 if (!kctl)
2010 kctl = snd_hda_find_mixer_ctl(codec, "Input Source");
2011 for (i = 0; kctl && i < kctl->count; i++) {
61071594
TI		 2012 err = snd_hda_add_nid(codec, kctl, i,
2013 get_capsrc(spec, i));
fbe618f2
TI		 2014 if (err < 0)
2015 return err;
2016 }
5b0cb1d8 2017 }
60a6a842 2018 if (spec->cap_mixer && spec->adc_nids) {
5b0cb1d8
JK		 2019 const char *kname = kctl ? kctl->id.name : NULL;
2020 for (knew = spec->cap_mixer; knew->name; knew++) {
2021 if (kname && strcmp(knew->name, kname) == 0)
2022 continue;
2023 kctl = snd_hda_find_mixer_ctl(codec, knew->name);
2024 for (i = 0; kctl && i < kctl->count; i++) {
2025 err = snd_hda_add_nid(codec, kctl, i,
2026 spec->adc_nids[i]);
2027 if (err < 0)
2028 return err;
2029 }
2030 }
2031 }
2032
2033 /* other nid->control mapping */
2034 for (i = 0; i < spec->num_mixers; i++) {
2035 for (knew = spec->mixers[i]; knew->name; knew++) {
2036 if (knew->iface != NID_MAPPING)
2037 continue;
2038 kctl = snd_hda_find_mixer_ctl(codec, knew->name);
2039 if (kctl == NULL)
2040 continue;
2041 u = knew->subdevice;
2042 for (j = 0; j < 4; j++, u >>= 8) {
2043 nid = u & 0x3f;
2044 if (nid == 0)
2045 continue;
2046 switch (u & 0xc0) {
2047 case SUBDEV_SPEAKER_:
2048 nid = spec->autocfg.speaker_pins[nid];
2049 break;
2050 case SUBDEV_LINE_:
2051 nid = spec->autocfg.line_out_pins[nid];
2052 break;
2053 case SUBDEV_HP_:
2054 nid = spec->autocfg.hp_pins[nid];
2055 break;
2056 default:
2057 continue;
2058 }
2059 err = snd_hda_add_nid(codec, kctl, 0, nid);
2060 if (err < 0)
2061 return err;
2062 }
2063 u = knew->private_value;
2064 for (j = 0; j < 4; j++, u >>= 8) {
2065 nid = u & 0xff;
2066 if (nid == 0)
2067 continue;
2068 err = snd_hda_add_nid(codec, kctl, 0, nid);
2069 if (err < 0)
2070 return err;
2071 }
2072 }
2073 }
bae84e70
TI		 2074
2075 alc_free_kctls(codec); /* no longer needed */
2076
1da177e4
LT		 2077 return 0;
2078}
2079
e9edcee0 2080
1da177e4 2081/*
1d045db9 2082 * Common callbacks
e9edcee0 2083 */
1da177e4 2084
1d045db9 2085static void alc_init_special_input_src(struct hda_codec *codec);
1da177e4 2086
1d045db9
TI		 2087static int alc_init(struct hda_codec *codec)
2088{
2089 struct alc_spec *spec = codec->spec;
2090 unsigned int i;
1da177e4 2091
1d045db9
TI		 2092 alc_fix_pll(codec);
2093 alc_auto_init_amp(codec, spec->init_amp);
1da177e4 2094
1d045db9
TI		 2095 for (i = 0; i < spec->num_init_verbs; i++)
2096 snd_hda_sequence_write(codec, spec->init_verbs[i]);
2097 alc_init_special_input_src(codec);
dfc0ff62 2098
1d045db9
TI		 2099 if (spec->init_hook)
2100 spec->init_hook(codec);
16ded525 2101
1d045db9 2102 alc_apply_fixup(codec, ALC_FIXUP_ACT_INIT);
16ded525 2103
1d045db9
TI		 2104 hda_call_check_power_status(codec, 0x01);
2105 return 0;
2106}
ea1fb29a 2107
1d045db9
TI		 2108static void alc_unsol_event(struct hda_codec *codec, unsigned int res)
2109{
2110 struct alc_spec *spec = codec->spec;
e9edcee0 2111
1d045db9
TI		 2112 if (spec->unsol_event)
2113 spec->unsol_event(codec, res);
2114}
ccc656ce 2115
1d045db9
TI		 2116#ifdef CONFIG_SND_HDA_POWER_SAVE
2117static int alc_check_power_status(struct hda_codec *codec, hda_nid_t nid)
2118{
2119 struct alc_spec *spec = codec->spec;
2120 return snd_hda_check_amp_list_power(codec, &spec->loopback, nid);
2121}
2122#endif
ccc656ce
KY		 2123
2124/*
1d045db9 2125 * Analog playback callbacks
ccc656ce 2126 */
1d045db9
TI		 2127static int alc_playback_pcm_open(struct hda_pcm_stream *hinfo,
2128 struct hda_codec *codec,
2129 struct snd_pcm_substream *substream)
458a4fab 2130{
1d045db9
TI		 2131 struct alc_spec *spec = codec->spec;
2132 return snd_hda_multi_out_analog_open(codec, &spec->multiout, substream,
2133 hinfo);
458a4fab
TI		 2134}
2135
1d045db9
TI		 2136static int alc_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
2137 struct hda_codec *codec,
2138 unsigned int stream_tag,
2139 unsigned int format,
2140 struct snd_pcm_substream *substream)
458a4fab 2141{
a9fd4f3f 2142 struct alc_spec *spec = codec->spec;
1d045db9
TI		 2143 return snd_hda_multi_out_analog_prepare(codec, &spec->multiout,
2144 stream_tag, format, substream);
4f5d1706
TI		 2145}
2146
1d045db9
TI		 2147static int alc_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
2148 struct hda_codec *codec,
2149 struct snd_pcm_substream *substream)
4f5d1706 2150{
1d045db9
TI		 2151 struct alc_spec *spec = codec->spec;
2152 return snd_hda_multi_out_analog_cleanup(codec, &spec->multiout);
ccc656ce
KY		 2153}
2154
1d045db9
TI		 2155/*
2156 * Digital out
2157 */
2158static int alc_dig_playback_pcm_open(struct hda_pcm_stream *hinfo,
2159 struct hda_codec *codec,
2160 struct snd_pcm_substream *substream)
ccc656ce 2161{
1d045db9
TI		 2162 struct alc_spec *spec = codec->spec;
2163 return snd_hda_multi_out_dig_open(codec, &spec->multiout);
ccc656ce
KY		 2164}
2165
1d045db9
TI		 2166static int alc_dig_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
2167 struct hda_codec *codec,
2168 unsigned int stream_tag,
2169 unsigned int format,
2170 struct snd_pcm_substream *substream)
ccc656ce 2171{
a9fd4f3f 2172 struct alc_spec *spec = codec->spec;
1d045db9
TI		 2173 return snd_hda_multi_out_dig_prepare(codec, &spec->multiout,
2174 stream_tag, format, substream);
ccc656ce
KY		 2175}
2176
1d045db9
TI		 2177static int alc_dig_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
2178 struct hda_codec *codec,
2179 struct snd_pcm_substream *substream)
ccc656ce 2180{
1d045db9
TI		 2181 struct alc_spec *spec = codec->spec;
2182 return snd_hda_multi_out_dig_cleanup(codec, &spec->multiout);
ccc656ce 2183}
47fd830a 2184
1d045db9
TI		 2185static int alc_dig_playback_pcm_close(struct hda_pcm_stream *hinfo,
2186 struct hda_codec *codec,
2187 struct snd_pcm_substream *substream)
ccc656ce 2188{
1d045db9
TI		 2189 struct alc_spec *spec = codec->spec;
2190 return snd_hda_multi_out_dig_close(codec, &spec->multiout);
ccc656ce
KY		 2191}
2192
e9edcee0 2193/*
1d045db9 2194 * Analog capture
e9edcee0 2195 */
1d045db9
TI		 2196static int alc_alt_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
2197 struct hda_codec *codec,
2198 unsigned int stream_tag,
2199 unsigned int format,
2200 struct snd_pcm_substream *substream)
2201{
2202 struct alc_spec *spec = codec->spec;
1da177e4 2203
6330079f 2204 snd_hda_codec_setup_stream(codec, spec->adc_nids[substream->number + 1],
1da177e4
LT		 2205 stream_tag, 0, format);
2206 return 0;
2207}
2208
c2d986b0 2209static int alc_alt_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
1da177e4 2210 struct hda_codec *codec,
c8b6bf9b 2211 struct snd_pcm_substream *substream)
1da177e4
LT		 2212{
2213 struct alc_spec *spec = codec->spec;
2214
888afa15
TI		 2215 snd_hda_codec_cleanup_stream(codec,
2216 spec->adc_nids[substream->number + 1]);
1da177e4
LT		 2217 return 0;
2218}
2219
840b64c0 2220/* analog capture with dynamic dual-adc changes */
21268961 2221static int dyn_adc_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
840b64c0
TI		 2222 struct hda_codec *codec,
2223 unsigned int stream_tag,
2224 unsigned int format,
2225 struct snd_pcm_substream *substream)
2226{
2227 struct alc_spec *spec = codec->spec;
21268961 2228 spec->cur_adc = spec->adc_nids[spec->dyn_adc_idx[spec->cur_mux[0]]];
840b64c0
TI		 2229 spec->cur_adc_stream_tag = stream_tag;
2230 spec->cur_adc_format = format;
2231 snd_hda_codec_setup_stream(codec, spec->cur_adc, stream_tag, 0, format);
2232 return 0;
2233}
2234
21268961 2235static int dyn_adc_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
840b64c0
TI		 2236 struct hda_codec *codec,
2237 struct snd_pcm_substream *substream)
2238{
2239 struct alc_spec *spec = codec->spec;
2240 snd_hda_codec_cleanup_stream(codec, spec->cur_adc);
2241 spec->cur_adc = 0;
2242 return 0;
2243}
2244
21268961 2245static const struct hda_pcm_stream dyn_adc_pcm_analog_capture = {
840b64c0
TI		 2246 .substreams = 1,
2247 .channels_min = 2,
2248 .channels_max = 2,
2249 .nid = 0, /* fill later */
2250 .ops = {
21268961
TI		 2251 .prepare = dyn_adc_capture_pcm_prepare,
2252 .cleanup = dyn_adc_capture_pcm_cleanup
840b64c0
TI		 2253 },
2254};
1da177e4
LT		 2255
2256/*
2257 */
c2d986b0 2258static const struct hda_pcm_stream alc_pcm_analog_playback = {
1da177e4
LT		 2259 .substreams = 1,
2260 .channels_min = 2,
2261 .channels_max = 8,
e9edcee0 2262 /* NID is set in alc_build_pcms */
1da177e4 2263 .ops = {
c2d986b0
TI		 2264 .open = alc_playback_pcm_open,
2265 .prepare = alc_playback_pcm_prepare,
2266 .cleanup = alc_playback_pcm_cleanup
1da177e4
LT		 2267 },
2268};
2269
c2d986b0 2270static const struct hda_pcm_stream alc_pcm_analog_capture = {
6330079f
TI		 2271 .substreams = 1,
2272 .channels_min = 2,
2273 .channels_max = 2,
2274 /* NID is set in alc_build_pcms */
2275};
2276
c2d986b0 2277static const struct hda_pcm_stream alc_pcm_analog_alt_playback = {
6330079f
TI		 2278 .substreams = 1,
2279 .channels_min = 2,
2280 .channels_max = 2,
2281 /* NID is set in alc_build_pcms */
2282};
2283
c2d986b0 2284static const struct hda_pcm_stream alc_pcm_analog_alt_capture = {
6330079f 2285 .substreams = 2, /* can be overridden */
1da177e4
LT		 2286 .channels_min = 2,
2287 .channels_max = 2,
e9edcee0 2288 /* NID is set in alc_build_pcms */
1da177e4 2289 .ops = {
c2d986b0
TI		 2290 .prepare = alc_alt_capture_pcm_prepare,
2291 .cleanup = alc_alt_capture_pcm_cleanup
1da177e4
LT		 2292 },
2293};
2294
c2d986b0 2295static const struct hda_pcm_stream alc_pcm_digital_playback = {
1da177e4
LT		 2296 .substreams = 1,
2297 .channels_min = 2,
2298 .channels_max = 2,
2299 /* NID is set in alc_build_pcms */
2300 .ops = {
c2d986b0
TI		 2301 .open = alc_dig_playback_pcm_open,
2302 .close = alc_dig_playback_pcm_close,
2303 .prepare = alc_dig_playback_pcm_prepare,
2304 .cleanup = alc_dig_playback_pcm_cleanup
1da177e4
LT		 2305 },
2306};
2307
c2d986b0 2308static const struct hda_pcm_stream alc_pcm_digital_capture = {
1da177e4
LT		 2309 .substreams = 1,
2310 .channels_min = 2,
2311 .channels_max = 2,
2312 /* NID is set in alc_build_pcms */
2313};
2314
4c5186ed 2315/* Used by alc_build_pcms to flag that a PCM has no playback stream */
a9111321 2316static const struct hda_pcm_stream alc_pcm_null_stream = {
4c5186ed
JW		 2317 .substreams = 0,
2318 .channels_min = 0,
2319 .channels_max = 0,
2320};
2321
1da177e4
LT		 2322static int alc_build_pcms(struct hda_codec *codec)
2323{
2324 struct alc_spec *spec = codec->spec;
2325 struct hda_pcm *info = spec->pcm_rec;
c2d986b0 2326 const struct hda_pcm_stream *p;
1fa17573 2327 bool have_multi_adcs;
1da177e4
LT		 2328 int i;
2329
2330 codec->num_pcms = 1;
2331 codec->pcm_info = info;
2332
e64f14f4
TI		 2333 if (spec->no_analog)
2334 goto skip_analog;
2335
812a2cca
TI		 2336 snprintf(spec->stream_name_analog, sizeof(spec->stream_name_analog),
2337 "%s Analog", codec->chip_name);
1da177e4 2338 info->name = spec->stream_name_analog;
274693f3 2339
c2d986b0
TI		 2340 if (spec->multiout.dac_nids > 0) {
2341 p = spec->stream_analog_playback;
2342 if (!p)
2343 p = &alc_pcm_analog_playback;
2344 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *p;
4a471b7d
TI		 2345 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dac_nids[0];
2346 }
c2d986b0
TI		 2347 if (spec->adc_nids) {
2348 p = spec->stream_analog_capture;
21268961
TI		 2349 if (!p) {
2350 if (spec->dyn_adc_switch)
2351 p = &dyn_adc_pcm_analog_capture;
2352 else
2353 p = &alc_pcm_analog_capture;
2354 }
c2d986b0 2355 info->stream[SNDRV_PCM_STREAM_CAPTURE] = *p;
4a471b7d
TI		 2356 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adc_nids[0];
2357 }
2358
2359 if (spec->channel_mode) {
2360 info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max = 0;
2361 for (i = 0; i < spec->num_channel_mode; i++) {
2362 if (spec->channel_mode[i].channels > info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max) {
2363 info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max = spec->channel_mode[i].channels;
2364 }
1da177e4
LT		 2365 }
2366 }
2367
e64f14f4 2368 skip_analog:
e08a007d 2369 /* SPDIF for stream index #1 */
1da177e4 2370 if (spec->multiout.dig_out_nid || spec->dig_in_nid) {
812a2cca
TI		 2371 snprintf(spec->stream_name_digital,
2372 sizeof(spec->stream_name_digital),
2373 "%s Digital", codec->chip_name);
e08a007d 2374 codec->num_pcms = 2;
b25c9da1 2375 codec->slave_dig_outs = spec->multiout.slave_dig_outs;
c06134d7 2376 info = spec->pcm_rec + 1;
1da177e4 2377 info->name = spec->stream_name_digital;
8c441982
TI		 2378 if (spec->dig_out_type)
2379 info->pcm_type = spec->dig_out_type;
2380 else
2381 info->pcm_type = HDA_PCM_TYPE_SPDIF;
c2d986b0
TI		 2382 if (spec->multiout.dig_out_nid) {
2383 p = spec->stream_digital_playback;
2384 if (!p)
2385 p = &alc_pcm_digital_playback;
2386 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *p;
1da177e4
LT		 2387 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dig_out_nid;
2388 }
c2d986b0
TI		 2389 if (spec->dig_in_nid) {
2390 p = spec->stream_digital_capture;
2391 if (!p)
2392 p = &alc_pcm_digital_capture;
2393 info->stream[SNDRV_PCM_STREAM_CAPTURE] = *p;
1da177e4
LT		 2394 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->dig_in_nid;
2395 }
963f803f
TI		 2396 /* FIXME: do we need this for all Realtek codec models? */
2397 codec->spdif_status_reset = 1;
1da177e4
LT		 2398 }
2399
e64f14f4
TI		 2400 if (spec->no_analog)
2401 return 0;
2402
e08a007d
TI		 2403 /* If the use of more than one ADC is requested for the current
2404 * model, configure a second analog capture-only PCM.
2405 */
1fa17573
TI		 2406 have_multi_adcs = (spec->num_adc_nids > 1) &&
2407 !spec->dyn_adc_switch && !spec->auto_mic &&
2408 (!spec->input_mux || spec->input_mux->num_items > 1);
e08a007d 2409 /* Additional Analaog capture for index #2 */
1fa17573 2410 if (spec->alt_dac_nid || have_multi_adcs) {
e08a007d 2411 codec->num_pcms = 3;
c06134d7 2412 info = spec->pcm_rec + 2;
e08a007d 2413 info->name = spec->stream_name_analog;
6330079f 2414 if (spec->alt_dac_nid) {
c2d986b0
TI		 2415 p = spec->stream_analog_alt_playback;
2416 if (!p)
2417 p = &alc_pcm_analog_alt_playback;
2418 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *p;
6330079f
TI		 2419 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid =
2420 spec->alt_dac_nid;
2421 } else {
2422 info->stream[SNDRV_PCM_STREAM_PLAYBACK] =
2423 alc_pcm_null_stream;
2424 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = 0;
2425 }
1fa17573 2426 if (have_multi_adcs) {
c2d986b0
TI		 2427 p = spec->stream_analog_alt_capture;
2428 if (!p)
2429 p = &alc_pcm_analog_alt_capture;
2430 info->stream[SNDRV_PCM_STREAM_CAPTURE] = *p;
6330079f
TI		 2431 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid =
2432 spec->adc_nids[1];
2433 info->stream[SNDRV_PCM_STREAM_CAPTURE].substreams =
2434 spec->num_adc_nids - 1;
2435 } else {
2436 info->stream[SNDRV_PCM_STREAM_CAPTURE] =
2437 alc_pcm_null_stream;
2438 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = 0;
e08a007d
TI		 2439 }
2440 }
2441
1da177e4
LT		 2442 return 0;
2443}
2444
a4e09aa3
TI		 2445static inline void alc_shutup(struct hda_codec *codec)
2446{
1c716153
TI		 2447 struct alc_spec *spec = codec->spec;
2448
2449 if (spec && spec->shutup)
2450 spec->shutup(codec);
a4e09aa3
TI		 2451 snd_hda_shutup_pins(codec);
2452}
2453
603c4019
TI		 2454static void alc_free_kctls(struct hda_codec *codec)
2455{
2456 struct alc_spec *spec = codec->spec;
2457
2458 if (spec->kctls.list) {
2459 struct snd_kcontrol_new *kctl = spec->kctls.list;
2460 int i;
2461 for (i = 0; i < spec->kctls.used; i++)
2462 kfree(kctl[i].name);
2463 }
2464 snd_array_free(&spec->kctls);
2465}
2466
23c09b00
TI		 2467static void alc_free_bind_ctls(struct hda_codec *codec)
2468{
2469 struct alc_spec *spec = codec->spec;
2470 if (spec->bind_ctls.list) {
2471 struct hda_bind_ctls **ctl = spec->bind_ctls.list;
2472 int i;
2473 for (i = 0; i < spec->bind_ctls.used; i++)
2474 kfree(ctl[i]);
2475 }
2476 snd_array_free(&spec->bind_ctls);
2477}
2478
1da177e4
LT		 2479static void alc_free(struct hda_codec *codec)
2480{
e9edcee0 2481 struct alc_spec *spec = codec->spec;
e9edcee0 2482
f12ab1e0 2483 if (!spec)
e9edcee0
TI		 2484 return;
2485
a4e09aa3 2486 alc_shutup(codec);
cd372fb3 2487 snd_hda_input_jack_free(codec);
603c4019 2488 alc_free_kctls(codec);
23c09b00 2489 alc_free_bind_ctls(codec);
e9edcee0 2490 kfree(spec);
680cd536 2491 snd_hda_detach_beep_device(codec);
1da177e4
LT		 2492}
2493
f5de24b0 2494#ifdef CONFIG_SND_HDA_POWER_SAVE
c97259df
DC		 2495static void alc_power_eapd(struct hda_codec *codec)
2496{
691f1fcc 2497 alc_auto_setup_eapd(codec, false);
c97259df
DC		 2498}
2499
f5de24b0
HM		 2500static int alc_suspend(struct hda_codec *codec, pm_message_t state)
2501{
2502 struct alc_spec *spec = codec->spec;
a4e09aa3 2503 alc_shutup(codec);
f5de24b0 2504 if (spec && spec->power_hook)
c97259df 2505 spec->power_hook(codec);
f5de24b0
HM		 2506 return 0;
2507}
2508#endif
2509
2a43952a 2510#ifdef CONFIG_PM
e044c39a
TI		 2511static int alc_resume(struct hda_codec *codec)
2512{
1c716153 2513 msleep(150); /* to avoid pop noise */
e044c39a
TI		 2514 codec->patch_ops.init(codec);
2515 snd_hda_codec_resume_amp(codec);
2516 snd_hda_codec_resume_cache(codec);
9e5341b9 2517 hda_call_check_power_status(codec, 0x01);
e044c39a
TI		 2518 return 0;
2519}
e044c39a
TI		 2520#endif
2521
1da177e4
LT		 2522/*
2523 */
a9111321 2524static const struct hda_codec_ops alc_patch_ops = {
1da177e4
LT		 2525 .build_controls = alc_build_controls,
2526 .build_pcms = alc_build_pcms,
2527 .init = alc_init,
2528 .free = alc_free,
ae6b813a 2529 .unsol_event = alc_unsol_event,
2a43952a 2530#ifdef CONFIG_PM
e044c39a
TI		 2531 .resume = alc_resume,
2532#endif
cb53c626 2533#ifdef CONFIG_SND_HDA_POWER_SAVE
f5de24b0 2534 .suspend = alc_suspend,
cb53c626
TI		 2535 .check_power_status = alc_check_power_status,
2536#endif
c97259df 2537 .reboot_notify = alc_shutup,
1da177e4
LT		 2538};
2539
c027ddcd
KY		 2540/* replace the codec chip_name with the given string */
2541static int alc_codec_rename(struct hda_codec *codec, const char *name)
2542{
2543 kfree(codec->chip_name);
2544 codec->chip_name = kstrdup(name, GFP_KERNEL);
2545 if (!codec->chip_name) {
2546 alc_free(codec);
2547 return -ENOMEM;
2548 }
2549 return 0;
2550}
2551
e16fb6d1
TI		 2552/*
2553 * Rename codecs appropriately from COEF value
2554 */
2555struct alc_codec_rename_table {
2556 unsigned int vendor_id;
2557 unsigned short coef_mask;
2558 unsigned short coef_bits;
2559 const char *name;
2560};
2561
2562static struct alc_codec_rename_table rename_tbl[] = {
2563 { 0x10ec0269, 0xfff0, 0x3010, "ALC277" },
2564 { 0x10ec0269, 0xf0f0, 0x2010, "ALC259" },
2565 { 0x10ec0269, 0xf0f0, 0x3010, "ALC258" },
2566 { 0x10ec0269, 0x00f0, 0x0010, "ALC269VB" },
2567 { 0x10ec0269, 0xffff, 0xa023, "ALC259" },
2568 { 0x10ec0269, 0xffff, 0x6023, "ALC281X" },
2569 { 0x10ec0269, 0x00f0, 0x0020, "ALC269VC" },
2570 { 0x10ec0887, 0x00f0, 0x0030, "ALC887-VD" },
2571 { 0x10ec0888, 0x00f0, 0x0030, "ALC888-VD" },
2572 { 0x10ec0888, 0xf0f0, 0x3020, "ALC886" },
2573 { 0x10ec0899, 0x2000, 0x2000, "ALC899" },
2574 { 0x10ec0892, 0xffff, 0x8020, "ALC661" },
2575 { 0x10ec0892, 0xffff, 0x8011, "ALC661" },
2576 { 0x10ec0892, 0xffff, 0x4011, "ALC656" },
2577 { } /* terminator */
2578};
2579
2580static int alc_codec_rename_from_preset(struct hda_codec *codec)
2581{
2582 const struct alc_codec_rename_table *p;
e16fb6d1
TI		 2583
2584 for (p = rename_tbl; p->vendor_id; p++) {
2585 if (p->vendor_id != codec->vendor_id)
2586 continue;
1bb7e43e 2587 if ((alc_get_coef0(codec) & p->coef_mask) == p->coef_bits)
e16fb6d1
TI		 2588 return alc_codec_rename(codec, p->name);
2589 }
2590 return 0;
2591}
2592
2fa522be 2593/*
1d045db9 2594 * Automatic parse of I/O pins from the BIOS configuration
2fa522be 2595 */
2fa522be 2596
1d045db9
TI		 2597enum {
2598 ALC_CTL_WIDGET_VOL,
2599 ALC_CTL_WIDGET_MUTE,
2600 ALC_CTL_BIND_MUTE,
23c09b00
TI		 2601 ALC_CTL_BIND_VOL,
2602 ALC_CTL_BIND_SW,
2fa522be 2603};
1d045db9
TI		 2604static const struct snd_kcontrol_new alc_control_templates[] = {
2605 HDA_CODEC_VOLUME(NULL, 0, 0, 0),
2606 HDA_CODEC_MUTE(NULL, 0, 0, 0),
2607 HDA_BIND_MUTE(NULL, 0, 0, 0),
23c09b00
TI		 2608 HDA_BIND_VOL(NULL, 0),
2609 HDA_BIND_SW(NULL, 0),
2fa522be
TI		 2610};
2611
1d045db9
TI		 2612/* add dynamic controls */
2613static int add_control(struct alc_spec *spec, int type, const char *name,
2614 int cidx, unsigned long val)
e9edcee0 2615{
c8b6bf9b 2616 struct snd_kcontrol_new *knew;
e9edcee0 2617
ce764ab2 2618 knew = alc_kcontrol_new(spec);
603c4019
TI		 2619 if (!knew)
2620 return -ENOMEM;
1d045db9 2621 *knew = alc_control_templates[type];
543537bd 2622 knew->name = kstrdup(name, GFP_KERNEL);
f12ab1e0 2623 if (!knew->name)
e9edcee0 2624 return -ENOMEM;
66ceeb6b 2625 knew->index = cidx;
4d02d1b6 2626 if (get_amp_nid_(val))
5e26dfd0 2627 knew->subdevice = HDA_SUBDEV_AMP_FLAG;
e9edcee0 2628 knew->private_value = val;
e9edcee0
TI		 2629 return 0;
2630}
2631
0afe5f89
TI		 2632static int add_control_with_pfx(struct alc_spec *spec, int type,
2633 const char *pfx, const char *dir,
66ceeb6b 2634 const char *sfx, int cidx, unsigned long val)
0afe5f89
TI		 2635{
2636 char name[32];
2637 snprintf(name, sizeof(name), "%s %s %s", pfx, dir, sfx);
66ceeb6b 2638 return add_control(spec, type, name, cidx, val);
0afe5f89
TI		 2639}
2640
66ceeb6b
TI		 2641#define add_pb_vol_ctrl(spec, type, pfx, val) \
2642 add_control_with_pfx(spec, type, pfx, "Playback", "Volume", 0, val)
2643#define add_pb_sw_ctrl(spec, type, pfx, val) \
2644 add_control_with_pfx(spec, type, pfx, "Playback", "Switch", 0, val)
2645#define __add_pb_vol_ctrl(spec, type, pfx, cidx, val) \
2646 add_control_with_pfx(spec, type, pfx, "Playback", "Volume", cidx, val)
2647#define __add_pb_sw_ctrl(spec, type, pfx, cidx, val) \
2648 add_control_with_pfx(spec, type, pfx, "Playback", "Switch", cidx, val)
0afe5f89 2649
23c09b00
TI		 2650static const char * const channel_name[4] = {
2651 "Front", "Surround", "CLFE", "Side"
2652};
2653
6843ca16
TI		 2654static const char *alc_get_line_out_pfx(struct alc_spec *spec, int ch,
2655 bool can_be_master, int *index)
bcb2f0f5 2656{
ce764ab2
TI		 2657 struct auto_pin_cfg *cfg = &spec->autocfg;
2658
6843ca16 2659 *index = 0;
ce764ab2
TI		 2660 if (cfg->line_outs == 1 && !spec->multi_ios &&
2661 !cfg->hp_outs && !cfg->speaker_outs && can_be_master)
bcb2f0f5
TI		 2662 return "Master";
2663
2664 switch (cfg->line_out_type) {
2665 case AUTO_PIN_SPEAKER_OUT:
ebbeb3d6
DH		 2666 if (cfg->line_outs == 1)
2667 return "Speaker";
fbabc246
TI		 2668 if (cfg->line_outs == 2)
2669 return ch ? "Bass Speaker" : "Speaker";
ebbeb3d6 2670 break;
bcb2f0f5 2671 case AUTO_PIN_HP_OUT:
6843ca16
TI		 2672 /* for multi-io case, only the primary out */
2673 if (ch && spec->multi_ios)
2674 break;
2675 *index = ch;
bcb2f0f5
TI		 2676 return "Headphone";
2677 default:
ce764ab2 2678 if (cfg->line_outs == 1 && !spec->multi_ios)
bcb2f0f5
TI		 2679 return "PCM";
2680 break;
2681 }
23c09b00
TI		 2682 if (snd_BUG_ON(ch >= ARRAY_SIZE(channel_name)))
2683 return "PCM";
2684
2685 return channel_name[ch];
bcb2f0f5
TI		 2686}
2687
e9edcee0 2688/* create input playback/capture controls for the given pin */
f12ab1e0 2689static int new_analog_input(struct alc_spec *spec, hda_nid_t pin,
66ceeb6b 2690 const char *ctlname, int ctlidx,
df694daa 2691 int idx, hda_nid_t mix_nid)
e9edcee0 2692{
df694daa 2693 int err;
e9edcee0 2694
66ceeb6b 2695 err = __add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, ctlname, ctlidx,
f12ab1e0
TI		 2696 HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT));
2697 if (err < 0)
e9edcee0 2698 return err;
66ceeb6b 2699 err = __add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, ctlname, ctlidx,
f12ab1e0
TI		 2700 HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT));
2701 if (err < 0)
e9edcee0
TI		 2702 return err;
2703 return 0;
2704}
2705
05f5f477
TI		 2706static int alc_is_input_pin(struct hda_codec *codec, hda_nid_t nid)
2707{
2708 unsigned int pincap = snd_hda_query_pin_caps(codec, nid);
2709 return (pincap & AC_PINCAP_IN) != 0;
2710}
2711
1d045db9 2712/* Parse the codec tree and retrieve ADCs and corresponding capsrc MUXs */
d6cc9fab 2713static int alc_auto_fill_adc_caps(struct hda_codec *codec)
b7821709 2714{
d6cc9fab 2715 struct alc_spec *spec = codec->spec;
b7821709 2716 hda_nid_t nid;
d6cc9fab
TI		 2717 hda_nid_t *adc_nids = spec->private_adc_nids;
2718 hda_nid_t *cap_nids = spec->private_capsrc_nids;
2719 int max_nums = ARRAY_SIZE(spec->private_adc_nids);
b7821709
TI		 2720 int i, nums = 0;
2721
24de183e
TI		 2722 if (spec->shared_mic_hp)
2723 max_nums = 1; /* no multi streams with the shared HP/mic */
2724
b7821709
TI		 2725 nid = codec->start_nid;
2726 for (i = 0; i < codec->num_nodes; i++, nid++) {
2727 hda_nid_t src;
2728 const hda_nid_t *list;
2729 unsigned int caps = get_wcaps(codec, nid);
2730 int type = get_wcaps_type(caps);
2731
2732 if (type != AC_WID_AUD_IN || (caps & AC_WCAP_DIGITAL))
2733 continue;
2734 adc_nids[nums] = nid;
2735 cap_nids[nums] = nid;
2736 src = nid;
2737 for (;;) {
2738 int n;
2739 type = get_wcaps_type(get_wcaps(codec, src));
2740 if (type == AC_WID_PIN)
2741 break;
2742 if (type == AC_WID_AUD_SEL) {
2743 cap_nids[nums] = src;
2744 break;
2745 }
2746 n = snd_hda_get_conn_list(codec, src, &list);
2747 if (n > 1) {
2748 cap_nids[nums] = src;
2749 break;
2750 } else if (n != 1)
2751 break;
2752 src = *list;
2753 }
2754 if (++nums >= max_nums)
2755 break;
2756 }
d6cc9fab 2757 spec->adc_nids = spec->private_adc_nids;
21268961 2758 spec->capsrc_nids = spec->private_capsrc_nids;
d6cc9fab 2759 spec->num_adc_nids = nums;
b7821709
TI		 2760 return nums;
2761}
2762
e9edcee0 2763/* create playback/capture controls for input pins */
b7821709 2764static int alc_auto_create_input_ctls(struct hda_codec *codec)
e9edcee0 2765{
05f5f477 2766 struct alc_spec *spec = codec->spec;
b7821709
TI		 2767 const struct auto_pin_cfg *cfg = &spec->autocfg;
2768 hda_nid_t mixer = spec->mixer_nid;
61b9b9b1 2769 struct hda_input_mux *imux = &spec->private_imux[0];
b7821709 2770 int num_adcs;
b7821709 2771 int i, c, err, idx, type_idx = 0;
5322bf27 2772 const char *prev_label = NULL;
e9edcee0 2773
d6cc9fab 2774 num_adcs = alc_auto_fill_adc_caps(codec);
b7821709
TI		 2775 if (num_adcs < 0)
2776 return 0;
2777
66ceeb6b 2778 for (i = 0; i < cfg->num_inputs; i++) {
05f5f477 2779 hda_nid_t pin;
10a20af7 2780 const char *label;
05f5f477 2781
66ceeb6b 2782 pin = cfg->inputs[i].pin;
05f5f477
TI		 2783 if (!alc_is_input_pin(codec, pin))
2784 continue;
2785
5322bf27 2786 label = hda_get_autocfg_input_label(codec, cfg, i);
24de183e
TI		 2787 if (spec->shared_mic_hp && !strcmp(label, "Misc"))
2788 label = "Headphone Mic";
5322bf27 2789 if (prev_label && !strcmp(label, prev_label))
66ceeb6b
TI		 2790 type_idx++;
2791 else
2792 type_idx = 0;
5322bf27
DH		 2793 prev_label = label;
2794
05f5f477
TI		 2795 if (mixer) {
2796 idx = get_connection_index(codec, mixer, pin);
2797 if (idx >= 0) {
2798 err = new_analog_input(spec, pin,
10a20af7
TI		 2799 label, type_idx,
2800 idx, mixer);
05f5f477
TI		 2801 if (err < 0)
2802 return err;
2803 }
2804 }
2805
b7821709 2806 for (c = 0; c < num_adcs; c++) {
61071594 2807 hda_nid_t cap = get_capsrc(spec, c);
d6cc9fab 2808 idx = get_connection_index(codec, cap, pin);
b7821709 2809 if (idx >= 0) {
21268961 2810 spec->imux_pins[imux->num_items] = pin;
b7821709
TI		 2811 snd_hda_add_imux_item(imux, label, idx, NULL);
2812 break;
2813 }
2814 }
e9edcee0 2815 }
21268961
TI		 2816
2817 spec->num_mux_defs = 1;
2818 spec->input_mux = imux;
2819
e9edcee0
TI		 2820 return 0;
2821}
2822
24de183e
TI		 2823/* create a shared input with the headphone out */
2824static int alc_auto_create_shared_input(struct hda_codec *codec)
2825{
2826 struct alc_spec *spec = codec->spec;
2827 struct auto_pin_cfg *cfg = &spec->autocfg;
2828 unsigned int defcfg;
2829 hda_nid_t nid;
2830
2831 /* only one internal input pin? */
2832 if (cfg->num_inputs != 1)
2833 return 0;
2834 defcfg = snd_hda_codec_get_pincfg(codec, cfg->inputs[0].pin);
2835 if (snd_hda_get_input_pin_attr(defcfg) != INPUT_PIN_ATTR_INT)
2836 return 0;
2837
2838 if (cfg->hp_outs == 1 && cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
2839 nid = cfg->hp_pins[0]; /* OK, we have a single HP-out */
2840 else if (cfg->line_outs == 1 && cfg->line_out_type == AUTO_PIN_HP_OUT)
2841 nid = cfg->line_out_pins[0]; /* OK, we have a single line-out */
2842 else
2843 return 0; /* both not available */
2844
2845 if (!(snd_hda_query_pin_caps(codec, nid) & AC_PINCAP_IN))
2846 return 0; /* no input */
2847
2848 cfg->inputs[1].pin = nid;
2849 cfg->inputs[1].type = AUTO_PIN_MIC;
2850 cfg->num_inputs = 2;
2851 spec->shared_mic_hp = 1;
2852 snd_printdd("realtek: Enable shared I/O jack on NID 0x%x\n", nid);
2853 return 0;
2854}
2855
f6c7e546
TI		 2856static void alc_set_pin_output(struct hda_codec *codec, hda_nid_t nid,
2857 unsigned int pin_type)
2858{
2859 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
2860 pin_type);
2861 /* unmute pin */
44c02400
TI		 2862 if (nid_has_mute(codec, nid, HDA_OUTPUT))
2863 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE,
d260cdf6 2864 AMP_OUT_UNMUTE);
f6c7e546
TI		 2865}
2866
baba8ee9
TI		 2867static int get_pin_type(int line_out_type)
2868{
2869 if (line_out_type == AUTO_PIN_HP_OUT)
2870 return PIN_HP;
2871 else
2872 return PIN_OUT;
2873}
2874
0a7f5320 2875static void alc_auto_init_analog_input(struct hda_codec *codec)
e9edcee0
TI		 2876{
2877 struct alc_spec *spec = codec->spec;
66ceeb6b 2878 struct auto_pin_cfg *cfg = &spec->autocfg;
e9edcee0
TI		 2879 int i;
2880
66ceeb6b
TI		 2881 for (i = 0; i < cfg->num_inputs; i++) {
2882 hda_nid_t nid = cfg->inputs[i].pin;
05f5f477 2883 if (alc_is_input_pin(codec, nid)) {
30ea098f 2884 alc_set_input_pin(codec, nid, cfg->inputs[i].type);
1f0f4b80 2885 if (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP)
f12ab1e0
TI		 2886 snd_hda_codec_write(codec, nid, 0,
2887 AC_VERB_SET_AMP_GAIN_MUTE,
e9edcee0
TI		 2888 AMP_OUT_MUTE);
2889 }
2890 }
1f0f4b80
TI		 2891
2892 /* mute all loopback inputs */
2893 if (spec->mixer_nid) {
2894 int nums = snd_hda_get_conn_list(codec, spec->mixer_nid, NULL);
2895 for (i = 0; i < nums; i++)
2896 snd_hda_codec_write(codec, spec->mixer_nid, 0,
2897 AC_VERB_SET_AMP_GAIN_MUTE,
2898 AMP_IN_MUTE(i));
2899 }
e9edcee0
TI		 2900}
2901
1d045db9
TI		 2902/* convert from MIX nid to DAC */
2903static hda_nid_t alc_auto_mix_to_dac(struct hda_codec *codec, hda_nid_t nid)
e9edcee0 2904{
1d045db9
TI		 2905 hda_nid_t list[5];
2906 int i, num;
4a79ba34 2907
afcd5515
TI		 2908 if (get_wcaps_type(get_wcaps(codec, nid)) == AC_WID_AUD_OUT)
2909 return nid;
1d045db9
TI		 2910 num = snd_hda_get_connections(codec, nid, list, ARRAY_SIZE(list));
2911 for (i = 0; i < num; i++) {
2912 if (get_wcaps_type(get_wcaps(codec, list[i])) == AC_WID_AUD_OUT)
2913 return list[i];
2914 }
2915 return 0;
e9edcee0
TI		 2916}
2917
1d045db9
TI		 2918/* go down to the selector widget before the mixer */
2919static hda_nid_t alc_go_down_to_selector(struct hda_codec *codec, hda_nid_t pin)
e9edcee0 2920{
1d045db9
TI		 2921 hda_nid_t srcs[5];
2922 int num = snd_hda_get_connections(codec, pin, srcs,
2923 ARRAY_SIZE(srcs));
2924 if (num != 1 ||
2925 get_wcaps_type(get_wcaps(codec, srcs[0])) != AC_WID_AUD_SEL)
2926 return pin;
2927 return srcs[0];
e9edcee0
TI		 2928}
2929
1d045db9
TI		 2930/* get MIX nid connected to the given pin targeted to DAC */
2931static hda_nid_t alc_auto_dac_to_mix(struct hda_codec *codec, hda_nid_t pin,
2932 hda_nid_t dac)
748cce43 2933{
1d045db9
TI		 2934 hda_nid_t mix[5];
2935 int i, num;
2936
2937 pin = alc_go_down_to_selector(codec, pin);
2938 num = snd_hda_get_connections(codec, pin, mix, ARRAY_SIZE(mix));
2939 for (i = 0; i < num; i++) {
2940 if (alc_auto_mix_to_dac(codec, mix[i]) == dac)
2941 return mix[i];
748cce43 2942 }
1d045db9 2943 return 0;
748cce43
TI		 2944}
2945
1d045db9
TI		 2946/* select the connection from pin to DAC if needed */
2947static int alc_auto_select_dac(struct hda_codec *codec, hda_nid_t pin,
2948 hda_nid_t dac)
eaa9b3a7 2949{
1d045db9
TI		 2950 hda_nid_t mix[5];
2951 int i, num;
eaa9b3a7 2952
1d045db9
TI		 2953 pin = alc_go_down_to_selector(codec, pin);
2954 num = snd_hda_get_connections(codec, pin, mix, ARRAY_SIZE(mix));
2955 if (num < 2)
8ed99d97 2956 return 0;
1d045db9
TI		 2957 for (i = 0; i < num; i++) {
2958 if (alc_auto_mix_to_dac(codec, mix[i]) == dac) {
2959 snd_hda_codec_update_cache(codec, pin, 0,
2960 AC_VERB_SET_CONNECT_SEL, i);
2961 return 0;
2962 }
840b64c0 2963 }
1d045db9 2964 return 0;
840b64c0
TI		 2965}
2966
1d045db9
TI		 2967/* look for an empty DAC slot */
2968static hda_nid_t alc_auto_look_for_dac(struct hda_codec *codec, hda_nid_t pin)
584c0c4c
TI		 2969{
2970 struct alc_spec *spec = codec->spec;
1d045db9
TI		 2971 hda_nid_t srcs[5];
2972 int i, num;
21268961 2973
1d045db9
TI		 2974 pin = alc_go_down_to_selector(codec, pin);
2975 num = snd_hda_get_connections(codec, pin, srcs, ARRAY_SIZE(srcs));
2976 for (i = 0; i < num; i++) {
2977 hda_nid_t nid = alc_auto_mix_to_dac(codec, srcs[i]);
2978 if (!nid)
2979 continue;
2980 if (found_in_nid_list(nid, spec->multiout.dac_nids,
0a34b42b 2981 ARRAY_SIZE(spec->private_dac_nids)))
1d045db9 2982 continue;
c267468e
TI		 2983 if (found_in_nid_list(nid, spec->multiout.hp_out_nid,
2984 ARRAY_SIZE(spec->multiout.hp_out_nid)))
2985 continue;
1d045db9
TI		 2986 if (found_in_nid_list(nid, spec->multiout.extra_out_nid,
2987 ARRAY_SIZE(spec->multiout.extra_out_nid)))
2988 continue;
2989 return nid;
2990 }
2991 return 0;
584c0c4c
TI		 2992}
2993
07b18f69
TI		 2994/* check whether the DAC is reachable from the pin */
2995static bool alc_auto_is_dac_reachable(struct hda_codec *codec,
2996 hda_nid_t pin, hda_nid_t dac)
2997{
2998 hda_nid_t srcs[5];
2999 int i, num;
3000
3001 pin = alc_go_down_to_selector(codec, pin);
3002 num = snd_hda_get_connections(codec, pin, srcs, ARRAY_SIZE(srcs));
3003 for (i = 0; i < num; i++) {
3004 hda_nid_t nid = alc_auto_mix_to_dac(codec, srcs[i]);
3005 if (nid == dac)
3006 return true;
3007 }
3008 return false;
3009}
3010
1d045db9 3011static hda_nid_t get_dac_if_single(struct hda_codec *codec, hda_nid_t pin)
f9e336f6 3012{
1d045db9
TI		 3013 hda_nid_t sel = alc_go_down_to_selector(codec, pin);
3014 if (snd_hda_get_conn_list(codec, sel, NULL) == 1)
3015 return alc_auto_look_for_dac(codec, pin);
3016 return 0;
f9e336f6
TI		 3017}
3018
0a34b42b 3019/* return 0 if no possible DAC is found, 1 if one or more found */
c267468e
TI		 3020static int alc_auto_fill_extra_dacs(struct hda_codec *codec, int num_outs,
3021 const hda_nid_t *pins, hda_nid_t *dacs)
3022{
3023 int i;
3024
3025 if (num_outs && !dacs[0]) {
3026 dacs[0] = alc_auto_look_for_dac(codec, pins[0]);
3027 if (!dacs[0])
3028 return 0;
3029 }
3030
3031 for (i = 1; i < num_outs; i++)
3032 dacs[i] = get_dac_if_single(codec, pins[i]);
3033 for (i = 1; i < num_outs; i++) {
3034 if (!dacs[i])
3035 dacs[i] = alc_auto_look_for_dac(codec, pins[i]);
3036 }
0a34b42b 3037 return 1;
c267468e
TI		 3038}
3039
3040static int alc_auto_fill_multi_ios(struct hda_codec *codec,
07b18f69 3041 unsigned int location, int offset);
c267468e 3042
1d045db9
TI		 3043/* fill in the dac_nids table from the parsed pin configuration */
3044static int alc_auto_fill_dac_nids(struct hda_codec *codec)
21268961
TI		 3045{
3046 struct alc_spec *spec = codec->spec;
0a34b42b 3047 struct auto_pin_cfg *cfg = &spec->autocfg;
07b18f69
TI		 3048 unsigned int location, defcfg;
3049 int num_pins;
1d045db9
TI		 3050 bool redone = false;
3051 int i;
21268961 3052
1d045db9 3053 again:
8f398ae7
TI		 3054 /* set num_dacs once to full for alc_auto_look_for_dac() */
3055 spec->multiout.num_dacs = cfg->line_outs;
e23832ac 3056 spec->multiout.hp_out_nid[0] = 0;
1d045db9
TI		 3057 spec->multiout.extra_out_nid[0] = 0;
3058 memset(spec->private_dac_nids, 0, sizeof(spec->private_dac_nids));
3059 spec->multiout.dac_nids = spec->private_dac_nids;
0a34b42b 3060 spec->multi_ios = 0;
21268961 3061
1d045db9
TI		 3062 /* fill hard-wired DACs first */
3063 if (!redone) {
3064 for (i = 0; i < cfg->line_outs; i++)
3065 spec->private_dac_nids[i] =
3066 get_dac_if_single(codec, cfg->line_out_pins[i]);
3067 if (cfg->hp_outs)
e23832ac 3068 spec->multiout.hp_out_nid[0] =
1d045db9
TI		 3069 get_dac_if_single(codec, cfg->hp_pins[0]);
3070 if (cfg->speaker_outs)
3071 spec->multiout.extra_out_nid[0] =
3072 get_dac_if_single(codec, cfg->speaker_pins[0]);
21268961
TI		 3073 }
3074
1d045db9
TI		 3075 for (i = 0; i < cfg->line_outs; i++) {
3076 hda_nid_t pin = cfg->line_out_pins[i];
3077 if (spec->private_dac_nids[i])
3078 continue;
3079 spec->private_dac_nids[i] = alc_auto_look_for_dac(codec, pin);
3080 if (!spec->private_dac_nids[i] && !redone) {
3081 /* if we can't find primary DACs, re-probe without
3082 * checking the hard-wired DACs
3083 */
3084 redone = true;
3085 goto again;
21268961
TI		 3086 }
3087 }
3088
8f398ae7
TI		 3089 /* re-count num_dacs and squash invalid entries */
3090 spec->multiout.num_dacs = 0;
1d045db9
TI		 3091 for (i = 0; i < cfg->line_outs; i++) {
3092 if (spec->private_dac_nids[i])
3093 spec->multiout.num_dacs++;
0a34b42b 3094 else {
1d045db9
TI		 3095 memmove(spec->private_dac_nids + i,
3096 spec->private_dac_nids + i + 1,
3097 sizeof(hda_nid_t) * (cfg->line_outs - i - 1));
0a34b42b
TI		 3098 spec->private_dac_nids[cfg->line_outs - 1] = 0;
3099 }
1d045db9
TI		 3100 }
3101
c267468e
TI		 3102 if (cfg->line_outs == 1 && cfg->line_out_type != AUTO_PIN_SPEAKER_OUT) {
3103 /* try to fill multi-io first */
c267468e
TI		 3104 defcfg = snd_hda_codec_get_pincfg(codec, cfg->line_out_pins[0]);
3105 location = get_defcfg_location(defcfg);
21268961 3106
07b18f69 3107 num_pins = alc_auto_fill_multi_ios(codec, location, 0);
c267468e
TI		 3108 if (num_pins > 0) {
3109 spec->multi_ios = num_pins;
3110 spec->ext_channel_count = 2;
3111 spec->multiout.num_dacs = num_pins + 1;
3112 }
3113 }
23c09b00 3114
716eef03
TI		 3115 if (cfg->line_out_type != AUTO_PIN_HP_OUT)
3116 alc_auto_fill_extra_dacs(codec, cfg->hp_outs, cfg->hp_pins,
c267468e 3117 spec->multiout.hp_out_nid);
0a34b42b
TI		 3118 if (cfg->line_out_type != AUTO_PIN_SPEAKER_OUT) {
3119 int err = alc_auto_fill_extra_dacs(codec, cfg->speaker_outs,
3120 cfg->speaker_pins,
3121 spec->multiout.extra_out_nid);
3122 /* if no speaker volume is assigned, try again as the primary
3123 * output
3124 */
3125 if (!err && cfg->speaker_outs > 0 &&
3126 cfg->line_out_type == AUTO_PIN_HP_OUT) {
3127 cfg->hp_outs = cfg->line_outs;
3128 memcpy(cfg->hp_pins, cfg->line_out_pins,
3129 sizeof(cfg->hp_pins));
3130 cfg->line_outs = cfg->speaker_outs;
3131 memcpy(cfg->line_out_pins, cfg->speaker_pins,
3132 sizeof(cfg->speaker_pins));
3133 cfg->speaker_outs = 0;
3134 memset(cfg->speaker_pins, 0, sizeof(cfg->speaker_pins));
3135 cfg->line_out_type = AUTO_PIN_SPEAKER_OUT;
3136 redone = false;
3137 goto again;
3138 }
3139 }
23c09b00 3140
07b18f69
TI		 3141 if (!spec->multi_ios &&
3142 cfg->line_out_type == AUTO_PIN_SPEAKER_OUT &&
3143 cfg->hp_outs) {
3144 /* try multi-ios with HP + inputs */
3145 defcfg = snd_hda_codec_get_pincfg(codec, cfg->hp_pins[0]);
3146 location = get_defcfg_location(defcfg);
3147
3148 num_pins = alc_auto_fill_multi_ios(codec, location, 1);
3149 if (num_pins > 0) {
3150 spec->multi_ios = num_pins;
3151 spec->ext_channel_count = 2;
3152 spec->multiout.num_dacs = num_pins + 1;
3153 }
3154 }
3155
23c09b00
TI		 3156 return 0;
3157}
3158
527e4d73
TI		 3159static inline unsigned int get_ctl_pos(unsigned int data)
3160{
3161 hda_nid_t nid = get_amp_nid_(data);
3162 unsigned int dir = get_amp_direction_(data);
3163 return (nid << 1) | dir;
3164}
3165
3166#define is_ctl_used(bits, data) \
3167 test_bit(get_ctl_pos(data), bits)
3168#define mark_ctl_usage(bits, data) \
3169 set_bit(get_ctl_pos(data), bits)
3170
1d045db9
TI		 3171static int alc_auto_add_vol_ctl(struct hda_codec *codec,
3172 const char *pfx, int cidx,
3173 hda_nid_t nid, unsigned int chs)
6694635d 3174{
527e4d73
TI		 3175 struct alc_spec *spec = codec->spec;
3176 unsigned int val;
afcd5515
TI		 3177 if (!nid)
3178 return 0;
527e4d73
TI		 3179 val = HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_OUTPUT);
3180 if (is_ctl_used(spec->vol_ctls, val) && chs != 2) /* exclude LFE */
3181 return 0;
3182 mark_ctl_usage(spec->vol_ctls, val);
1d045db9 3183 return __add_pb_vol_ctrl(codec->spec, ALC_CTL_WIDGET_VOL, pfx, cidx,
527e4d73 3184 val);
1d045db9 3185}
6694635d 3186
e29d3778
TI		 3187static int alc_auto_add_stereo_vol(struct hda_codec *codec,
3188 const char *pfx, int cidx,
3189 hda_nid_t nid)
3190{
3191 int chs = 1;
3192 if (get_wcaps(codec, nid) & AC_WCAP_STEREO)
3193 chs = 3;
3194 return alc_auto_add_vol_ctl(codec, pfx, cidx, nid, chs);
3195}
21268961 3196
1d045db9
TI		 3197/* create a mute-switch for the given mixer widget;
3198 * if it has multiple sources (e.g. DAC and loopback), create a bind-mute
3199 */
3200static int alc_auto_add_sw_ctl(struct hda_codec *codec,
3201 const char *pfx, int cidx,
3202 hda_nid_t nid, unsigned int chs)
3203{
527e4d73 3204 struct alc_spec *spec = codec->spec;
afcd5515 3205 int wid_type;
1d045db9
TI		 3206 int type;
3207 unsigned long val;
afcd5515
TI		 3208 if (!nid)
3209 return 0;
3210 wid_type = get_wcaps_type(get_wcaps(codec, nid));
3211 if (wid_type == AC_WID_PIN || wid_type == AC_WID_AUD_OUT) {
3212 type = ALC_CTL_WIDGET_MUTE;
3213 val = HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_OUTPUT);
3214 } else if (snd_hda_get_conn_list(codec, nid, NULL) == 1) {
1d045db9
TI		 3215 type = ALC_CTL_WIDGET_MUTE;
3216 val = HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_INPUT);
3217 } else {
3218 type = ALC_CTL_BIND_MUTE;
3219 val = HDA_COMPOSE_AMP_VAL(nid, chs, 2, HDA_INPUT);
6694635d 3220 }
527e4d73
TI		 3221 if (is_ctl_used(spec->sw_ctls, val) && chs != 2) /* exclude LFE */
3222 return 0;
3223 mark_ctl_usage(spec->sw_ctls, val);
1d045db9 3224 return __add_pb_sw_ctrl(codec->spec, type, pfx, cidx, val);
6694635d
TI		 3225}
3226
e29d3778
TI		 3227static int alc_auto_add_stereo_sw(struct hda_codec *codec, const char *pfx,
3228 int cidx, hda_nid_t nid)
3229{
3230 int chs = 1;
3231 if (get_wcaps(codec, nid) & AC_WCAP_STEREO)
3232 chs = 3;
3233 return alc_auto_add_sw_ctl(codec, pfx, cidx, nid, chs);
3234}
dc1eae25 3235
afcd5515
TI		 3236static hda_nid_t alc_look_for_out_mute_nid(struct hda_codec *codec,
3237 hda_nid_t pin, hda_nid_t dac)
3238{
3239 hda_nid_t mix = alc_auto_dac_to_mix(codec, pin, dac);
3240 if (nid_has_mute(codec, pin, HDA_OUTPUT))
3241 return pin;
3242 else if (mix && nid_has_mute(codec, mix, HDA_INPUT))
3243 return mix;
3244 else if (nid_has_mute(codec, dac, HDA_OUTPUT))
3245 return dac;
3246 return 0;
3247}
3248
3249static hda_nid_t alc_look_for_out_vol_nid(struct hda_codec *codec,
3250 hda_nid_t pin, hda_nid_t dac)
3251{
3252 hda_nid_t mix = alc_auto_dac_to_mix(codec, pin, dac);
3253 if (nid_has_volume(codec, dac, HDA_OUTPUT))
3254 return dac;
3255 else if (nid_has_volume(codec, mix, HDA_OUTPUT))
3256 return mix;
3257 else if (nid_has_volume(codec, pin, HDA_OUTPUT))
3258 return pin;
3259 return 0;
3260}
3261
1d045db9
TI		 3262/* add playback controls from the parsed DAC table */
3263static int alc_auto_create_multi_out_ctls(struct hda_codec *codec,
3264 const struct auto_pin_cfg *cfg)
dc1eae25
TI		 3265{
3266 struct alc_spec *spec = codec->spec;
1d045db9 3267 int i, err, noutputs;
1f0f4b80 3268
1d045db9
TI		 3269 noutputs = cfg->line_outs;
3270 if (spec->multi_ios > 0)
3271 noutputs += spec->multi_ios;
1da177e4 3272
1d045db9
TI		 3273 for (i = 0; i < noutputs; i++) {
3274 const char *name;
3275 int index;
afcd5515
TI		 3276 hda_nid_t dac, pin;
3277 hda_nid_t sw, vol;
3278
3279 dac = spec->multiout.dac_nids[i];
3280 if (!dac)
1d045db9
TI		 3281 continue;
3282 if (i >= cfg->line_outs)
3283 pin = spec->multi_io[i - 1].pin;
3284 else
3285 pin = cfg->line_out_pins[i];
afcd5515
TI		 3286
3287 sw = alc_look_for_out_mute_nid(codec, pin, dac);
3288 vol = alc_look_for_out_vol_nid(codec, pin, dac);
1d045db9 3289 name = alc_get_line_out_pfx(spec, i, true, &index);
9c4e84d3 3290 if (!name || !strcmp(name, "CLFE")) {
1d045db9 3291 /* Center/LFE */
afcd5515 3292 err = alc_auto_add_vol_ctl(codec, "Center", 0, vol, 1);
1d045db9
TI		 3293 if (err < 0)
3294 return err;
afcd5515 3295 err = alc_auto_add_vol_ctl(codec, "LFE", 0, vol, 2);
1d045db9
TI		 3296 if (err < 0)
3297 return err;
afcd5515 3298 err = alc_auto_add_sw_ctl(codec, "Center", 0, sw, 1);
1d045db9
TI		 3299 if (err < 0)
3300 return err;
afcd5515 3301 err = alc_auto_add_sw_ctl(codec, "LFE", 0, sw, 2);
1d045db9
TI		 3302 if (err < 0)
3303 return err;
3304 } else {
afcd5515 3305 err = alc_auto_add_stereo_vol(codec, name, index, vol);
1d045db9
TI		 3306 if (err < 0)
3307 return err;
afcd5515 3308 err = alc_auto_add_stereo_sw(codec, name, index, sw);
1d045db9
TI		 3309 if (err < 0)
3310 return err;
e9edcee0 3311 }
1da177e4 3312 }
1d045db9
TI		 3313 return 0;
3314}
1da177e4 3315
1d045db9 3316static int alc_auto_create_extra_out(struct hda_codec *codec, hda_nid_t pin,
766ddee6
TI		 3317 hda_nid_t dac, const char *pfx,
3318 int cidx)
1d045db9
TI		 3319{
3320 struct alc_spec *spec = codec->spec;
afcd5515 3321 hda_nid_t sw, vol;
1d045db9 3322 int err;
1da177e4 3323
1d045db9 3324 if (!dac) {
527e4d73 3325 unsigned int val;
1d045db9
TI		 3326 /* the corresponding DAC is already occupied */
3327 if (!(get_wcaps(codec, pin) & AC_WCAP_OUT_AMP))
3328 return 0; /* no way */
3329 /* create a switch only */
527e4d73
TI		 3330 val = HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT);
3331 if (is_ctl_used(spec->sw_ctls, val))
3332 return 0; /* already created */
3333 mark_ctl_usage(spec->sw_ctls, val);
766ddee6 3334 return __add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, pfx, cidx, val);
e9edcee0 3335 }
1da177e4 3336
afcd5515
TI		 3337 sw = alc_look_for_out_mute_nid(codec, pin, dac);
3338 vol = alc_look_for_out_vol_nid(codec, pin, dac);
766ddee6 3339 err = alc_auto_add_stereo_vol(codec, pfx, cidx, vol);
1d045db9
TI		 3340 if (err < 0)
3341 return err;
766ddee6 3342 err = alc_auto_add_stereo_sw(codec, pfx, cidx, sw);
1d045db9
TI		 3343 if (err < 0)
3344 return err;
1da177e4
LT		 3345 return 0;
3346}
3347
23c09b00
TI		 3348static struct hda_bind_ctls *new_bind_ctl(struct hda_codec *codec,
3349 unsigned int nums,
3350 struct hda_ctl_ops *ops)
3351{
3352 struct alc_spec *spec = codec->spec;
3353 struct hda_bind_ctls **ctlp, *ctl;
3354 snd_array_init(&spec->bind_ctls, sizeof(ctl), 8);
3355 ctlp = snd_array_new(&spec->bind_ctls);
3356 if (!ctlp)
3357 return NULL;
3358 ctl = kzalloc(sizeof(*ctl) + sizeof(long) * (nums + 1), GFP_KERNEL);
3359 *ctlp = ctl;
3360 if (ctl)
3361 ctl->ops = ops;
3362 return ctl;
3363}
3364
3365/* add playback controls for speaker and HP outputs */
3366static int alc_auto_create_extra_outs(struct hda_codec *codec, int num_pins,
3367 const hda_nid_t *pins,
3368 const hda_nid_t *dacs,
3369 const char *pfx)
3370{
3371 struct alc_spec *spec = codec->spec;
3372 struct hda_bind_ctls *ctl;
3373 char name[32];
3374 int i, n, err;
3375
3376 if (!num_pins || !pins[0])
3377 return 0;
3378
527e4d73
TI		 3379 if (num_pins == 1) {
3380 hda_nid_t dac = *dacs;
3381 if (!dac)
3382 dac = spec->multiout.dac_nids[0];
766ddee6 3383 return alc_auto_create_extra_out(codec, *pins, dac, pfx, 0);
527e4d73 3384 }
23c09b00
TI		 3385
3386 if (dacs[num_pins - 1]) {
3387 /* OK, we have a multi-output system with individual volumes */
3388 for (i = 0; i < num_pins; i++) {
766ddee6
TI		 3389 if (num_pins >= 3) {
3390 snprintf(name, sizeof(name), "%s %s",
3391 pfx, channel_name[i]);
3392 err = alc_auto_create_extra_out(codec, pins[i], dacs[i],
3393 name, 0);
3394 } else {
3395 err = alc_auto_create_extra_out(codec, pins[i], dacs[i],
3396 pfx, i);
3397 }
23c09b00
TI		 3398 if (err < 0)
3399 return err;
3400 }
3401 return 0;
3402 }
3403
3404 /* Let's create a bind-controls */
3405 ctl = new_bind_ctl(codec, num_pins, &snd_hda_bind_sw);
3406 if (!ctl)
3407 return -ENOMEM;
3408 n = 0;
3409 for (i = 0; i < num_pins; i++) {
3410 if (get_wcaps(codec, pins[i]) & AC_WCAP_OUT_AMP)
3411 ctl->values[n++] =
3412 HDA_COMPOSE_AMP_VAL(pins[i], 3, 0, HDA_OUTPUT);
3413 }
3414 if (n) {
3415 snprintf(name, sizeof(name), "%s Playback Switch", pfx);
3416 err = add_control(spec, ALC_CTL_BIND_SW, name, 0, (long)ctl);
3417 if (err < 0)
3418 return err;
3419 }
3420
3421 ctl = new_bind_ctl(codec, num_pins, &snd_hda_bind_vol);
3422 if (!ctl)
3423 return -ENOMEM;
3424 n = 0;
3425 for (i = 0; i < num_pins; i++) {
3426 hda_nid_t vol;
3427 if (!pins[i] || !dacs[i])
3428 continue;
3429 vol = alc_look_for_out_vol_nid(codec, pins[i], dacs[i]);
3430 if (vol)
3431 ctl->values[n++] =
3432 HDA_COMPOSE_AMP_VAL(vol, 3, 0, HDA_OUTPUT);
3433 }
3434 if (n) {
3435 snprintf(name, sizeof(name), "%s Playback Volume", pfx);
3436 err = add_control(spec, ALC_CTL_BIND_VOL, name, 0, (long)ctl);
3437 if (err < 0)
3438 return err;
3439 }
3440 return 0;
3441}
3442
1d045db9 3443static int alc_auto_create_hp_out(struct hda_codec *codec)
bec15c3a 3444{
1d045db9 3445 struct alc_spec *spec = codec->spec;
e23832ac
TI		 3446 return alc_auto_create_extra_outs(codec, spec->autocfg.hp_outs,
3447 spec->autocfg.hp_pins,
3448 spec->multiout.hp_out_nid,
3449 "Headphone");
bec15c3a
TI		 3450}
3451
1d045db9 3452static int alc_auto_create_speaker_out(struct hda_codec *codec)
bec15c3a 3453{
bec15c3a 3454 struct alc_spec *spec = codec->spec;
23c09b00
TI		 3455 return alc_auto_create_extra_outs(codec, spec->autocfg.speaker_outs,
3456 spec->autocfg.speaker_pins,
3457 spec->multiout.extra_out_nid,
3458 "Speaker");
bec15c3a
TI		 3459}
3460
1d045db9 3461static void alc_auto_set_output_and_unmute(struct hda_codec *codec,
afcd5515 3462 hda_nid_t pin, int pin_type,
1d045db9 3463 hda_nid_t dac)
bec15c3a 3464{
1d045db9 3465 int i, num;
afcd5515 3466 hda_nid_t nid, mix = 0;
1d045db9 3467 hda_nid_t srcs[HDA_MAX_CONNECTIONS];
bec15c3a 3468
afcd5515
TI		 3469 alc_set_pin_output(codec, pin, pin_type);
3470 nid = alc_go_down_to_selector(codec, pin);
1d045db9
TI		 3471 num = snd_hda_get_connections(codec, nid, srcs, ARRAY_SIZE(srcs));
3472 for (i = 0; i < num; i++) {
3473 if (alc_auto_mix_to_dac(codec, srcs[i]) != dac)
3474 continue;
3475 mix = srcs[i];
3476 break;
3477 }
3478 if (!mix)
3479 return;
bec15c3a 3480
1d045db9
TI		 3481 /* need the manual connection? */
3482 if (num > 1)
3483 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CONNECT_SEL, i);
3484 /* unmute mixer widget inputs */
afcd5515
TI		 3485 if (nid_has_mute(codec, mix, HDA_INPUT)) {
3486 snd_hda_codec_write(codec, mix, 0, AC_VERB_SET_AMP_GAIN_MUTE,
1d045db9 3487 AMP_IN_UNMUTE(0));
afcd5515 3488 snd_hda_codec_write(codec, mix, 0, AC_VERB_SET_AMP_GAIN_MUTE,
1d045db9 3489 AMP_IN_UNMUTE(1));
afcd5515 3490 }
1d045db9 3491 /* initialize volume */
afcd5515
TI		 3492 nid = alc_look_for_out_vol_nid(codec, pin, dac);
3493 if (nid)
3494 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE,
3495 AMP_OUT_ZERO);
43dea228
TI		 3496
3497 /* unmute DAC if it's not assigned to a mixer */
3498 nid = alc_look_for_out_mute_nid(codec, pin, dac);
3499 if (nid == mix && nid_has_mute(codec, dac, HDA_OUTPUT))
3500 snd_hda_codec_write(codec, dac, 0, AC_VERB_SET_AMP_GAIN_MUTE,
3501 AMP_OUT_ZERO);
1d045db9 3502}
bec15c3a 3503
1d045db9 3504static void alc_auto_init_multi_out(struct hda_codec *codec)
bec15c3a
TI		 3505{
3506 struct alc_spec *spec = codec->spec;
1d045db9
TI		 3507 int pin_type = get_pin_type(spec->autocfg.line_out_type);
3508 int i;
bec15c3a 3509
1d045db9
TI		 3510 for (i = 0; i <= HDA_SIDE; i++) {
3511 hda_nid_t nid = spec->autocfg.line_out_pins[i];
3512 if (nid)
3513 alc_auto_set_output_and_unmute(codec, nid, pin_type,
3514 spec->multiout.dac_nids[i]);
3515 }
bec15c3a
TI		 3516}
3517
1d045db9 3518static void alc_auto_init_extra_out(struct hda_codec *codec)
e9427969
TI		 3519{
3520 struct alc_spec *spec = codec->spec;
8cd0775d 3521 int i;
675c1aa3 3522 hda_nid_t pin, dac;
e9427969 3523
636030e9 3524 for (i = 0; i < spec->autocfg.hp_outs; i++) {
716eef03
TI		 3525 if (spec->autocfg.line_out_type == AUTO_PIN_HP_OUT)
3526 break;
e23832ac
TI		 3527 pin = spec->autocfg.hp_pins[i];
3528 if (!pin)
3529 break;
3530 dac = spec->multiout.hp_out_nid[i];
3531 if (!dac) {
3532 if (i > 0 && spec->multiout.hp_out_nid[0])
3533 dac = spec->multiout.hp_out_nid[0];
3534 else
3535 dac = spec->multiout.dac_nids[0];
3536 }
675c1aa3
TI		 3537 alc_auto_set_output_and_unmute(codec, pin, PIN_HP, dac);
3538 }
8cd0775d 3539 for (i = 0; i < spec->autocfg.speaker_outs; i++) {
716eef03
TI		 3540 if (spec->autocfg.line_out_type == AUTO_PIN_SPEAKER_OUT)
3541 break;
8cd0775d
TI		 3542 pin = spec->autocfg.speaker_pins[i];
3543 if (!pin)
3544 break;
3545 dac = spec->multiout.extra_out_nid[i];
3546 if (!dac) {
3547 if (i > 0 && spec->multiout.extra_out_nid[0])
3548 dac = spec->multiout.extra_out_nid[0];
3549 else
3550 dac = spec->multiout.dac_nids[0];
3551 }
675c1aa3
TI		 3552 alc_auto_set_output_and_unmute(codec, pin, PIN_OUT, dac);
3553 }
bc9f98a9
KY		 3554}
3555
df694daa 3556/*
1d045db9 3557 * multi-io helper
df694daa 3558 */
1d045db9 3559static int alc_auto_fill_multi_ios(struct hda_codec *codec,
07b18f69
TI		 3560 unsigned int location,
3561 int offset)
df694daa 3562{
1d045db9
TI		 3563 struct alc_spec *spec = codec->spec;
3564 struct auto_pin_cfg *cfg = &spec->autocfg;
c267468e 3565 hda_nid_t prime_dac = spec->private_dac_nids[0];
07b18f69 3566 int type, i, dacs, num_pins = 0;
ea1fb29a 3567
07b18f69 3568 dacs = spec->multiout.num_dacs;
1d045db9
TI		 3569 for (type = AUTO_PIN_LINE_IN; type >= AUTO_PIN_MIC; type--) {
3570 for (i = 0; i < cfg->num_inputs; i++) {
3571 hda_nid_t nid = cfg->inputs[i].pin;
07b18f69 3572 hda_nid_t dac = 0;
1d045db9
TI		 3573 unsigned int defcfg, caps;
3574 if (cfg->inputs[i].type != type)
3575 continue;
3576 defcfg = snd_hda_codec_get_pincfg(codec, nid);
3577 if (get_defcfg_connect(defcfg) != AC_JACK_PORT_COMPLEX)
3578 continue;
3579 if (location && get_defcfg_location(defcfg) != location)
3580 continue;
3581 caps = snd_hda_query_pin_caps(codec, nid);
3582 if (!(caps & AC_PINCAP_OUT))
3583 continue;
07b18f69
TI		 3584 if (offset && offset + num_pins < dacs) {
3585 dac = spec->private_dac_nids[offset + num_pins];
3586 if (!alc_auto_is_dac_reachable(codec, nid, dac))
3587 dac = 0;
3588 }
3589 if (!dac)
3590 dac = alc_auto_look_for_dac(codec, nid);
1d045db9
TI		 3591 if (!dac)
3592 continue;
3593 spec->multi_io[num_pins].pin = nid;
3594 spec->multi_io[num_pins].dac = dac;
3595 num_pins++;
3596 spec->private_dac_nids[spec->multiout.num_dacs++] = dac;
3597 }
863b4518 3598 }
07b18f69 3599 spec->multiout.num_dacs = dacs;
c267468e
TI		 3600 if (num_pins < 2) {
3601 /* clear up again */
07b18f69
TI		 3602 memset(spec->private_dac_nids + dacs, 0,
3603 sizeof(hda_nid_t) * (AUTO_CFG_MAX_OUTS - dacs));
c267468e 3604 spec->private_dac_nids[0] = prime_dac;
1d045db9 3605 return 0;
c267468e 3606 }
1d045db9 3607 return num_pins;
a361d84b
KY		 3608}
3609
1d045db9
TI		 3610static int alc_auto_ch_mode_info(struct snd_kcontrol *kcontrol,
3611 struct snd_ctl_elem_info *uinfo)
a361d84b 3612{
1d045db9 3613 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
a361d84b 3614 struct alc_spec *spec = codec->spec;
a361d84b 3615
1d045db9
TI		 3616 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
3617 uinfo->count = 1;
3618 uinfo->value.enumerated.items = spec->multi_ios + 1;
3619 if (uinfo->value.enumerated.item > spec->multi_ios)
3620 uinfo->value.enumerated.item = spec->multi_ios;
3621 sprintf(uinfo->value.enumerated.name, "%dch",
3622 (uinfo->value.enumerated.item + 1) * 2);
3623 return 0;
3624}
a361d84b 3625
1d045db9
TI		 3626static int alc_auto_ch_mode_get(struct snd_kcontrol *kcontrol,
3627 struct snd_ctl_elem_value *ucontrol)
3628{
3629 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3630 struct alc_spec *spec = codec->spec;
3631 ucontrol->value.enumerated.item[0] = (spec->ext_channel_count - 1) / 2;
3632 return 0;
3633}
a361d84b 3634
1d045db9
TI		 3635static int alc_set_multi_io(struct hda_codec *codec, int idx, bool output)
3636{
3637 struct alc_spec *spec = codec->spec;
3638 hda_nid_t nid = spec->multi_io[idx].pin;
a361d84b 3639
1d045db9
TI		 3640 if (!spec->multi_io[idx].ctl_in)
3641 spec->multi_io[idx].ctl_in =
3642 snd_hda_codec_read(codec, nid, 0,
3643 AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
3644 if (output) {
3645 snd_hda_codec_update_cache(codec, nid, 0,
3646 AC_VERB_SET_PIN_WIDGET_CONTROL,
3647 PIN_OUT);
3648 if (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP)
3649 snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
3650 HDA_AMP_MUTE, 0);
3651 alc_auto_select_dac(codec, nid, spec->multi_io[idx].dac);
3652 } else {
3653 if (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP)
3654 snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
3655 HDA_AMP_MUTE, HDA_AMP_MUTE);
3656 snd_hda_codec_update_cache(codec, nid, 0,
3657 AC_VERB_SET_PIN_WIDGET_CONTROL,
3658 spec->multi_io[idx].ctl_in);
4f574b7b 3659 }
1d045db9 3660 return 0;
a361d84b
KY		 3661}
3662
1d045db9
TI		 3663static int alc_auto_ch_mode_put(struct snd_kcontrol *kcontrol,
3664 struct snd_ctl_elem_value *ucontrol)
a361d84b 3665{
1d045db9 3666 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
f6c7e546 3667 struct alc_spec *spec = codec->spec;
1d045db9 3668 int i, ch;
a361d84b 3669
1d045db9
TI		 3670 ch = ucontrol->value.enumerated.item[0];
3671 if (ch < 0 || ch > spec->multi_ios)
3672 return -EINVAL;
3673 if (ch == (spec->ext_channel_count - 1) / 2)
3674 return 0;
3675 spec->ext_channel_count = (ch + 1) * 2;
3676 for (i = 0; i < spec->multi_ios; i++)
3677 alc_set_multi_io(codec, i, i < ch);
3678 spec->multiout.max_channels = spec->ext_channel_count;
7b1655f5
TI		 3679 if (spec->need_dac_fix && !spec->const_channel_count)
3680 spec->multiout.num_dacs = spec->multiout.max_channels / 2;
1d045db9
TI		 3681 return 1;
3682}
3abf2f36 3683
1d045db9
TI		 3684static const struct snd_kcontrol_new alc_auto_channel_mode_enum = {
3685 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3686 .name = "Channel Mode",
3687 .info = alc_auto_ch_mode_info,
3688 .get = alc_auto_ch_mode_get,
3689 .put = alc_auto_ch_mode_put,
a361d84b
KY		 3690};
3691
23c09b00 3692static int alc_auto_add_multi_channel_mode(struct hda_codec *codec)
a361d84b 3693{
1d045db9 3694 struct alc_spec *spec = codec->spec;
a361d84b 3695
c267468e 3696 if (spec->multi_ios > 0) {
1d045db9 3697 struct snd_kcontrol_new *knew;
a361d84b 3698
1d045db9
TI		 3699 knew = alc_kcontrol_new(spec);
3700 if (!knew)
3701 return -ENOMEM;
3702 *knew = alc_auto_channel_mode_enum;
3703 knew->name = kstrdup("Channel Mode", GFP_KERNEL);
3704 if (!knew->name)
3705 return -ENOMEM;
a361d84b 3706 }
1d045db9
TI		 3707 return 0;
3708}
a361d84b 3709
1d045db9
TI		 3710/* filter out invalid adc_nids (and capsrc_nids) that don't give all
3711 * active input pins
3712 */
3713static void alc_remove_invalid_adc_nids(struct hda_codec *codec)
3714{
3715 struct alc_spec *spec = codec->spec;
3716 const struct hda_input_mux *imux;
3717 hda_nid_t adc_nids[ARRAY_SIZE(spec->private_adc_nids)];
3718 hda_nid_t capsrc_nids[ARRAY_SIZE(spec->private_adc_nids)];
3719 int i, n, nums;
a361d84b 3720
1d045db9
TI		 3721 imux = spec->input_mux;
3722 if (!imux)
3723 return;
3724 if (spec->dyn_adc_switch)
3725 return;
a361d84b 3726
1d045db9
TI		 3727 nums = 0;
3728 for (n = 0; n < spec->num_adc_nids; n++) {
3729 hda_nid_t cap = spec->private_capsrc_nids[n];
3730 int num_conns = snd_hda_get_conn_list(codec, cap, NULL);
3731 for (i = 0; i < imux->num_items; i++) {
3732 hda_nid_t pin = spec->imux_pins[i];
3733 if (pin) {
3734 if (get_connection_index(codec, cap, pin) < 0)
3735 break;
3736 } else if (num_conns <= imux->items[i].index)
3737 break;
3738 }
3739 if (i >= imux->num_items) {
3740 adc_nids[nums] = spec->private_adc_nids[n];
3741 capsrc_nids[nums++] = cap;
22971e3a
TI		 3742 }
3743 }
1d045db9
TI		 3744 if (!nums) {
3745 /* check whether ADC-switch is possible */
3746 if (!alc_check_dyn_adc_switch(codec)) {
3747 printk(KERN_WARNING "hda_codec: %s: no valid ADC found;"
3748 " using fallback 0x%x\n",
3749 codec->chip_name, spec->private_adc_nids[0]);
3750 spec->num_adc_nids = 1;
3751 spec->auto_mic = 0;
3752 return;
22971e3a 3753 }
1d045db9
TI		 3754 } else if (nums != spec->num_adc_nids) {
3755 memcpy(spec->private_adc_nids, adc_nids,
3756 nums * sizeof(hda_nid_t));
3757 memcpy(spec->private_capsrc_nids, capsrc_nids,
3758 nums * sizeof(hda_nid_t));
3759 spec->num_adc_nids = nums;
22971e3a 3760 }
aef9d318 3761
1d045db9
TI		 3762 if (spec->auto_mic)
3763 alc_auto_mic_check_imux(codec); /* check auto-mic setups */
3764 else if (spec->input_mux->num_items == 1)
3765 spec->num_adc_nids = 1; /* reduce to a single ADC */
3766}
3767
3768/*
3769 * initialize ADC paths
3770 */
3771static void alc_auto_init_adc(struct hda_codec *codec, int adc_idx)
3772{
3773 struct alc_spec *spec = codec->spec;
3774 hda_nid_t nid;
3775
3776 nid = spec->adc_nids[adc_idx];
3777 /* mute ADC */
44c02400 3778 if (nid_has_mute(codec, nid, HDA_INPUT)) {
1d045db9
TI		 3779 snd_hda_codec_write(codec, nid, 0,
3780 AC_VERB_SET_AMP_GAIN_MUTE,
3781 AMP_IN_MUTE(0));
3782 return;
a361d84b 3783 }
1d045db9
TI		 3784 if (!spec->capsrc_nids)
3785 return;
3786 nid = spec->capsrc_nids[adc_idx];
44c02400 3787 if (nid_has_mute(codec, nid, HDA_OUTPUT))
1d045db9
TI		 3788 snd_hda_codec_write(codec, nid, 0,
3789 AC_VERB_SET_AMP_GAIN_MUTE,
3790 AMP_OUT_MUTE);
3791}
2134ea4f 3792
1d045db9
TI		 3793static void alc_auto_init_input_src(struct hda_codec *codec)
3794{
3795 struct alc_spec *spec = codec->spec;
3796 int c, nums;
d6cc9fab 3797
1d045db9
TI		 3798 for (c = 0; c < spec->num_adc_nids; c++)
3799 alc_auto_init_adc(codec, c);
3800 if (spec->dyn_adc_switch)
3801 nums = 1;
3802 else
3803 nums = spec->num_adc_nids;
3804 for (c = 0; c < nums; c++)
3805 alc_mux_select(codec, 0, spec->cur_mux[c], true);
3806}
2134ea4f 3807
1d045db9
TI		 3808/* add mic boosts if needed */
3809static int alc_auto_add_mic_boost(struct hda_codec *codec)
3810{
3811 struct alc_spec *spec = codec->spec;
3812 struct auto_pin_cfg *cfg = &spec->autocfg;
3813 int i, err;
3814 int type_idx = 0;
3815 hda_nid_t nid;
3816 const char *prev_label = NULL;
ea1fb29a 3817
1d045db9
TI		 3818 for (i = 0; i < cfg->num_inputs; i++) {
3819 if (cfg->inputs[i].type > AUTO_PIN_MIC)
3820 break;
3821 nid = cfg->inputs[i].pin;
3822 if (get_wcaps(codec, nid) & AC_WCAP_IN_AMP) {
3823 const char *label;
3824 char boost_label[32];
3825
3826 label = hda_get_autocfg_input_label(codec, cfg, i);
24de183e
TI		 3827 if (spec->shared_mic_hp && !strcmp(label, "Misc"))
3828 label = "Headphone Mic";
1d045db9
TI		 3829 if (prev_label && !strcmp(label, prev_label))
3830 type_idx++;
3831 else
3832 type_idx = 0;
3833 prev_label = label;
bf1b0225 3834
1d045db9
TI		 3835 snprintf(boost_label, sizeof(boost_label),
3836 "%s Boost Volume", label);
3837 err = add_control(spec, ALC_CTL_WIDGET_VOL,
3838 boost_label, type_idx,
3839 HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT));
3840 if (err < 0)
3841 return err;
3842 }
3843 }
a361d84b
KY		 3844 return 0;
3845}
3846
1d045db9
TI		 3847/* select or unmute the given capsrc route */
3848static void select_or_unmute_capsrc(struct hda_codec *codec, hda_nid_t cap,
3849 int idx)
3850{
3851 if (get_wcaps_type(get_wcaps(codec, cap)) == AC_WID_AUD_MIX) {
3852 snd_hda_codec_amp_stereo(codec, cap, HDA_INPUT, idx,
3853 HDA_AMP_MUTE, 0);
3854 } else if (snd_hda_get_conn_list(codec, cap, NULL) > 1) {
3855 snd_hda_codec_write_cache(codec, cap, 0,
3856 AC_VERB_SET_CONNECT_SEL, idx);
3857 }
3858}
f6a92248 3859
1d045db9
TI		 3860/* set the default connection to that pin */
3861static int init_capsrc_for_pin(struct hda_codec *codec, hda_nid_t pin)
3862{
3863 struct alc_spec *spec = codec->spec;
3864 int i;
f6a92248 3865
1d045db9
TI		 3866 if (!pin)
3867 return 0;
3868 for (i = 0; i < spec->num_adc_nids; i++) {
61071594 3869 hda_nid_t cap = get_capsrc(spec, i);
1d045db9 3870 int idx;
f53281e6 3871
1d045db9
TI		 3872 idx = get_connection_index(codec, cap, pin);
3873 if (idx < 0)
3874 continue;
3875 select_or_unmute_capsrc(codec, cap, idx);
3876 return i; /* return the found index */
3877 }
3878 return -1; /* not found */
3879}
e01bf509 3880
1d045db9
TI		 3881/* initialize some special cases for input sources */
3882static void alc_init_special_input_src(struct hda_codec *codec)
3883{
3884 struct alc_spec *spec = codec->spec;
3885 int i;
84898e87 3886
1d045db9
TI		 3887 for (i = 0; i < spec->autocfg.num_inputs; i++)
3888 init_capsrc_for_pin(codec, spec->autocfg.inputs[i].pin);
3889}
84898e87 3890
1d045db9
TI		 3891/* assign appropriate capture mixers */
3892static void set_capture_mixer(struct hda_codec *codec)
3893{
3894 struct alc_spec *spec = codec->spec;
3895 static const struct snd_kcontrol_new *caps[2][3] = {
3896 { alc_capture_mixer_nosrc1,
3897 alc_capture_mixer_nosrc2,
3898 alc_capture_mixer_nosrc3 },
3899 { alc_capture_mixer1,
3900 alc_capture_mixer2,
3901 alc_capture_mixer3 },
3902 };
f6a92248 3903
1d045db9 3904 /* check whether either of ADC or MUX has a volume control */
44c02400 3905 if (!nid_has_volume(codec, spec->adc_nids[0], HDA_INPUT)) {
1d045db9
TI		 3906 if (!spec->capsrc_nids)
3907 return; /* no volume */
44c02400 3908 if (!nid_has_volume(codec, spec->capsrc_nids[0], HDA_OUTPUT))
1d045db9
TI		 3909 return; /* no volume in capsrc, too */
3910 spec->vol_in_capsrc = 1;
3911 }
60db6b53 3912
1d045db9
TI		 3913 if (spec->num_adc_nids > 0) {
3914 int mux = 0;
3915 int num_adcs = 0;
64154835 3916
1d045db9
TI		 3917 if (spec->input_mux && spec->input_mux->num_items > 1)
3918 mux = 1;
3919 if (spec->auto_mic) {
3920 num_adcs = 1;
3921 mux = 0;
3922 } else if (spec->dyn_adc_switch)
3923 num_adcs = 1;
3924 if (!num_adcs) {
3925 if (spec->num_adc_nids > 3)
3926 spec->num_adc_nids = 3;
3927 else if (!spec->num_adc_nids)
3928 return;
3929 num_adcs = spec->num_adc_nids;
3930 }
3931 spec->cap_mixer = caps[mux][num_adcs - 1];
3932 }
3933}
f53281e6 3934
e4770629
TI		 3935/*
3936 * standard auto-parser initializations
3937 */
3938static void alc_auto_init_std(struct hda_codec *codec)
3939{
3940 struct alc_spec *spec = codec->spec;
3941 alc_auto_init_multi_out(codec);
3942 alc_auto_init_extra_out(codec);
3943 alc_auto_init_analog_input(codec);
3944 alc_auto_init_input_src(codec);
3945 alc_auto_init_digital(codec);
3946 if (spec->unsol_event)
3947 alc_inithook(codec);
3948}
3949
1d045db9
TI		 3950/*
3951 * Digital-beep handlers
3952 */
3953#ifdef CONFIG_SND_HDA_INPUT_BEEP
3954#define set_beep_amp(spec, nid, idx, dir) \
3955 ((spec)->beep_amp = HDA_COMPOSE_AMP_VAL(nid, 3, idx, dir))
84898e87 3956
1d045db9
TI		 3957static const struct snd_pci_quirk beep_white_list[] = {
3958 SND_PCI_QUIRK(0x1043, 0x829f, "ASUS", 1),
3959 SND_PCI_QUIRK(0x1043, 0x83ce, "EeePC", 1),
3960 SND_PCI_QUIRK(0x1043, 0x831a, "EeePC", 1),
3961 SND_PCI_QUIRK(0x1043, 0x834a, "EeePC", 1),
3962 SND_PCI_QUIRK(0x8086, 0xd613, "Intel", 1),
3963 {}
fe3eb0a7
KY		 3964};
3965
1d045db9
TI		 3966static inline int has_cdefine_beep(struct hda_codec *codec)
3967{
3968 struct alc_spec *spec = codec->spec;
3969 const struct snd_pci_quirk *q;
3970 q = snd_pci_quirk_lookup(codec->bus->pci, beep_white_list);
3971 if (q)
3972 return q->value;
3973 return spec->cdefine.enable_pcbeep;
3974}
3975#else
3976#define set_beep_amp(spec, nid, idx, dir) /* NOP */
3977#define has_cdefine_beep(codec) 0
3978#endif
84898e87 3979
1d045db9
TI		 3980/* parse the BIOS configuration and set up the alc_spec */
3981/* return 1 if successful, 0 if the proper config is not found,
3982 * or a negative error code
3983 */
3e6179b8
TI		 3984static int alc_parse_auto_config(struct hda_codec *codec,
3985 const hda_nid_t *ignore_nids,
3986 const hda_nid_t *ssid_nids)
1d045db9
TI		 3987{
3988 struct alc_spec *spec = codec->spec;
23c09b00 3989 struct auto_pin_cfg *cfg = &spec->autocfg;
1d045db9 3990 int err;
26f5df26 3991
53c334ad
TI		 3992 err = snd_hda_parse_pin_defcfg(codec, cfg, ignore_nids,
3993 spec->parse_flags);
1d045db9
TI		 3994 if (err < 0)
3995 return err;
23c09b00
TI		 3996 if (!cfg->line_outs) {
3997 if (cfg->dig_outs || cfg->dig_in_pin) {
3e6179b8
TI		 3998 spec->multiout.max_channels = 2;
3999 spec->no_analog = 1;
4000 goto dig_only;
4001 }
1d045db9 4002 return 0; /* can't find valid BIOS pin config */
3e6179b8 4003 }
23c09b00 4004
06503670
TI		 4005 if (cfg->line_out_type == AUTO_PIN_SPEAKER_OUT &&
4006 cfg->line_outs <= cfg->hp_outs) {
23c09b00
TI		 4007 /* use HP as primary out */
4008 cfg->speaker_outs = cfg->line_outs;
4009 memcpy(cfg->speaker_pins, cfg->line_out_pins,
4010 sizeof(cfg->speaker_pins));
4011 cfg->line_outs = cfg->hp_outs;
4012 memcpy(cfg->line_out_pins, cfg->hp_pins, sizeof(cfg->hp_pins));
4013 cfg->hp_outs = 0;
4014 memset(cfg->hp_pins, 0, sizeof(cfg->hp_pins));
4015 cfg->line_out_type = AUTO_PIN_HP_OUT;
4016 }
4017
1d045db9 4018 err = alc_auto_fill_dac_nids(codec);
3e6179b8
TI		 4019 if (err < 0)
4020 return err;
23c09b00 4021 err = alc_auto_add_multi_channel_mode(codec);
1d045db9
TI		 4022 if (err < 0)
4023 return err;
23c09b00 4024 err = alc_auto_create_multi_out_ctls(codec, cfg);
1d045db9
TI		 4025 if (err < 0)
4026 return err;
4027 err = alc_auto_create_hp_out(codec);
4028 if (err < 0)
4029 return err;
4030 err = alc_auto_create_speaker_out(codec);
24de183e
TI		 4031 if (err < 0)
4032 return err;
4033 err = alc_auto_create_shared_input(codec);
1d045db9
TI		 4034 if (err < 0)
4035 return err;
4036 err = alc_auto_create_input_ctls(codec);
4037 if (err < 0)
4038 return err;
84898e87 4039
1d045db9 4040 spec->multiout.max_channels = spec->multiout.num_dacs * 2;
f53281e6 4041
3e6179b8 4042 dig_only:
1d045db9 4043 alc_auto_parse_digital(codec);
f6a92248 4044
3e6179b8
TI		 4045 if (!spec->no_analog)
4046 alc_remove_invalid_adc_nids(codec);
4047
4048 if (ssid_nids)
4049 alc_ssid_check(codec, ssid_nids);
64154835 4050
3e6179b8
TI		 4051 if (!spec->no_analog) {
4052 alc_auto_check_switches(codec);
4053 err = alc_auto_add_mic_boost(codec);
4054 if (err < 0)
4055 return err;
4056 }
f6a92248 4057
3e6179b8
TI		 4058 if (spec->kctls.list)
4059 add_mixer(spec, spec->kctls.list);
f6a92248 4060
1d045db9 4061 return 1;
60db6b53 4062}
f6a92248 4063
3e6179b8
TI		 4064static int alc880_parse_auto_config(struct hda_codec *codec)
4065{
4066 static const hda_nid_t alc880_ignore[] = { 0x1d, 0 };
4067 static const hda_nid_t alc880_ssids[] = { 0x15, 0x1b, 0x14, 0 };
4068 return alc_parse_auto_config(codec, alc880_ignore, alc880_ssids);
4069}
4070
1d045db9
TI		 4071#ifdef CONFIG_SND_HDA_POWER_SAVE
4072static const struct hda_amp_list alc880_loopbacks[] = {
4073 { 0x0b, HDA_INPUT, 0 },
4074 { 0x0b, HDA_INPUT, 1 },
4075 { 0x0b, HDA_INPUT, 2 },
4076 { 0x0b, HDA_INPUT, 3 },
4077 { 0x0b, HDA_INPUT, 4 },
4078 { } /* end */
4079};
4080#endif
f6a92248 4081
ee3b2969
TI		 4082/*
4083 * ALC880 fix-ups
4084 */
4085enum {
4086 ALC880_FIXUP_GPIO2,
4087 ALC880_FIXUP_MEDION_RIM,
4088};
4089
4090static const struct alc_fixup alc880_fixups[] = {
4091 [ALC880_FIXUP_GPIO2] = {
4092 .type = ALC_FIXUP_VERBS,
4093 .v.verbs = alc_gpio2_init_verbs,
4094 },
4095 [ALC880_FIXUP_MEDION_RIM] = {
4096 .type = ALC_FIXUP_VERBS,
4097 .v.verbs = (const struct hda_verb[]) {
4098 { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
4099 { 0x20, AC_VERB_SET_PROC_COEF, 0x3060 },
4100 { }
4101 },
4102 .chained = true,
4103 .chain_id = ALC880_FIXUP_GPIO2,
4104 },
4105};
4106
4107static const struct snd_pci_quirk alc880_fixup_tbl[] = {
4108 SND_PCI_QUIRK(0x161f, 0x205d, "Medion Rim 2150", ALC880_FIXUP_MEDION_RIM),
4109 {}
4110};
4111
4112
1d045db9
TI		 4113/*
4114 * board setups
4115 */
4116#ifdef CONFIG_SND_HDA_ENABLE_REALTEK_QUIRKS
4117#define alc_board_config \
4118 snd_hda_check_board_config
4119#define alc_board_codec_sid_config \
4120 snd_hda_check_board_codec_sid_config
4121#include "alc_quirks.c"
4122#else
4123#define alc_board_config(codec, nums, models, tbl) -1
4124#define alc_board_codec_sid_config(codec, nums, models, tbl) -1
4125#define setup_preset(codec, x) /* NOP */
4126#endif
64154835 4127
1d045db9
TI		 4128/*
4129 * OK, here we have finally the patch for ALC880
4130 */
4131#ifdef CONFIG_SND_HDA_ENABLE_REALTEK_QUIRKS
4132#include "alc880_quirks.c"
4133#endif
4f5d1706 4134
1d045db9 4135static int patch_alc880(struct hda_codec *codec)
60db6b53 4136{
1d045db9
TI		 4137 struct alc_spec *spec;
4138 int board_config;
4139 int err;
f6a92248 4140
1d045db9
TI		 4141 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
4142 if (spec == NULL)
4143 return -ENOMEM;
3b8510ce 4144
1d045db9 4145 codec->spec = spec;
64154835 4146
1d045db9 4147 spec->mixer_nid = 0x0b;
7b1655f5 4148 spec->need_dac_fix = 1;
f53281e6 4149
1d045db9
TI		 4150 board_config = alc_board_config(codec, ALC880_MODEL_LAST,
4151 alc880_models, alc880_cfg_tbl);
4152 if (board_config < 0) {
4153 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
4154 codec->chip_name);
4155 board_config = ALC_MODEL_AUTO;
4156 }
f53281e6 4157
ee3b2969
TI		 4158 if (board_config == ALC_MODEL_AUTO) {
4159 alc_pick_fixup(codec, NULL, alc880_fixup_tbl, alc880_fixups);
4160 alc_apply_fixup(codec, ALC_FIXUP_ACT_PRE_PROBE);
4161 }
4162
1d045db9
TI		 4163 if (board_config == ALC_MODEL_AUTO) {
4164 /* automatic parse from the BIOS config */
4165 err = alc880_parse_auto_config(codec);
e16fb6d1
TI		 4166 if (err < 0)
4167 goto error;
1d045db9
TI		 4168#ifdef CONFIG_SND_HDA_ENABLE_REALTEK_QUIRKS
4169 else if (!err) {
4170 printk(KERN_INFO
4171 "hda_codec: Cannot set up configuration "
4172 "from BIOS. Using 3-stack mode...\n");
4173 board_config = ALC880_3ST;
4174 }
4175#endif
4176 }
84898e87 4177
1d045db9
TI		 4178 if (board_config != ALC_MODEL_AUTO)
4179 setup_preset(codec, &alc880_presets[board_config]);
fe3eb0a7 4180
60a6a842 4181 if (!spec->no_analog && !spec->adc_nids) {
1d045db9
TI		 4182 alc_auto_fill_adc_caps(codec);
4183 alc_rebuild_imux_for_auto_mic(codec);
4184 alc_remove_invalid_adc_nids(codec);
4185 }
3e6179b8
TI		 4186
4187 if (!spec->no_analog && !spec->cap_mixer)
4188 set_capture_mixer(codec);
4189
4190 if (!spec->no_analog) {
4191 err = snd_hda_attach_beep_device(codec, 0x1);
e16fb6d1
TI		 4192 if (err < 0)
4193 goto error;
3e6179b8
TI		 4194 set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
4195 }
f53281e6 4196
ee3b2969
TI		 4197 alc_apply_fixup(codec, ALC_FIXUP_ACT_PROBE);
4198
1d045db9 4199 spec->vmaster_nid = 0x0c;
84898e87 4200
1d045db9
TI		 4201 codec->patch_ops = alc_patch_ops;
4202 if (board_config == ALC_MODEL_AUTO)
e4770629 4203 spec->init_hook = alc_auto_init_std;
1d045db9
TI		 4204#ifdef CONFIG_SND_HDA_POWER_SAVE
4205 if (!spec->loopback.amplist)
4206 spec->loopback.amplist = alc880_loopbacks;
4207#endif
f53281e6 4208
1d045db9 4209 return 0;
e16fb6d1
TI		 4210
4211 error:
4212 alc_free(codec);
4213 return err;
226b1ec8
KY		 4214}
4215
1d045db9 4216
60db6b53 4217/*
1d045db9 4218 * ALC260 support
60db6b53 4219 */
1d045db9 4220static int alc260_parse_auto_config(struct hda_codec *codec)
f6a92248 4221{
1d045db9 4222 static const hda_nid_t alc260_ignore[] = { 0x17, 0 };
3e6179b8
TI		 4223 static const hda_nid_t alc260_ssids[] = { 0x10, 0x15, 0x0f, 0 };
4224 return alc_parse_auto_config(codec, alc260_ignore, alc260_ssids);
f6a92248
KY		 4225}
4226
1d045db9
TI		 4227#ifdef CONFIG_SND_HDA_POWER_SAVE
4228static const struct hda_amp_list alc260_loopbacks[] = {
4229 { 0x07, HDA_INPUT, 0 },
4230 { 0x07, HDA_INPUT, 1 },
4231 { 0x07, HDA_INPUT, 2 },
4232 { 0x07, HDA_INPUT, 3 },
4233 { 0x07, HDA_INPUT, 4 },
4234 { } /* end */
4235};
4236#endif
0ec33d1f 4237
1d045db9
TI		 4238/*
4239 * Pin config fixes
4240 */
4241enum {
4242 PINFIX_HP_DC5750,
4243};
4244
4245static const struct alc_fixup alc260_fixups[] = {
4246 [PINFIX_HP_DC5750] = {
4247 .type = ALC_FIXUP_PINS,
4248 .v.pins = (const struct alc_pincfg[]) {
4249 { 0x11, 0x90130110 }, /* speaker */
4250 { }
4251 }
4252 },
4253};
4254
4255static const struct snd_pci_quirk alc260_fixup_tbl[] = {
4256 SND_PCI_QUIRK(0x103c, 0x280a, "HP dc5750", PINFIX_HP_DC5750),
4257 {}
4258};
4259
4260/*
4261 */
4262#ifdef CONFIG_SND_HDA_ENABLE_REALTEK_QUIRKS
4263#include "alc260_quirks.c"
4264#endif
4265
4266static int patch_alc260(struct hda_codec *codec)
977ddd6b 4267{
1d045db9
TI		 4268 struct alc_spec *spec;
4269 int err, board_config;
4270
4271 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
4272 if (spec == NULL)
4273 return -ENOMEM;
4274
4275 codec->spec = spec;
4276
4277 spec->mixer_nid = 0x07;
4278
4279 board_config = alc_board_config(codec, ALC260_MODEL_LAST,
4280 alc260_models, alc260_cfg_tbl);
4281 if (board_config < 0) {
4282 snd_printd(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
4283 codec->chip_name);
4284 board_config = ALC_MODEL_AUTO;
977ddd6b 4285 }
0ec33d1f 4286
1d045db9
TI		 4287 if (board_config == ALC_MODEL_AUTO) {
4288 alc_pick_fixup(codec, NULL, alc260_fixup_tbl, alc260_fixups);
4289 alc_apply_fixup(codec, ALC_FIXUP_ACT_PRE_PROBE);
977ddd6b
KY		 4290 }
4291
1d045db9
TI		 4292 if (board_config == ALC_MODEL_AUTO) {
4293 /* automatic parse from the BIOS config */
4294 err = alc260_parse_auto_config(codec);
e16fb6d1
TI		 4295 if (err < 0)
4296 goto error;
1d045db9
TI		 4297#ifdef CONFIG_SND_HDA_ENABLE_REALTEK_QUIRKS
4298 else if (!err) {
4299 printk(KERN_INFO
4300 "hda_codec: Cannot set up configuration "
4301 "from BIOS. Using base mode...\n");
4302 board_config = ALC260_BASIC;
4303 }
4304#endif
4305 }
977ddd6b 4306
1d045db9
TI		 4307 if (board_config != ALC_MODEL_AUTO)
4308 setup_preset(codec, &alc260_presets[board_config]);
977ddd6b 4309
60a6a842 4310 if (!spec->no_analog && !spec->adc_nids) {
1d045db9
TI		 4311 alc_auto_fill_adc_caps(codec);
4312 alc_rebuild_imux_for_auto_mic(codec);
4313 alc_remove_invalid_adc_nids(codec);
4314 }
3e6179b8
TI		 4315
4316 if (!spec->no_analog && !spec->cap_mixer)
4317 set_capture_mixer(codec);
4318
4319 if (!spec->no_analog) {
4320 err = snd_hda_attach_beep_device(codec, 0x1);
e16fb6d1
TI		 4321 if (err < 0)
4322 goto error;
3e6179b8
TI		 4323 set_beep_amp(spec, 0x07, 0x05, HDA_INPUT);
4324 }
977ddd6b 4325
1d045db9 4326 alc_apply_fixup(codec, ALC_FIXUP_ACT_PROBE);
1a99d4a4 4327
1d045db9 4328 spec->vmaster_nid = 0x08;
1a99d4a4 4329
1d045db9
TI		 4330 codec->patch_ops = alc_patch_ops;
4331 if (board_config == ALC_MODEL_AUTO)
8452a982 4332 spec->init_hook = alc_auto_init_std;
1d045db9
TI		 4333 spec->shutup = alc_eapd_shutup;
4334#ifdef CONFIG_SND_HDA_POWER_SAVE
4335 if (!spec->loopback.amplist)
4336 spec->loopback.amplist = alc260_loopbacks;
4337#endif
6981d184 4338
1d045db9 4339 return 0;
e16fb6d1
TI		 4340
4341 error:
4342 alc_free(codec);
4343 return err;
6981d184
TI		 4344}
4345
1d045db9
TI		 4346
4347/*
4348 * ALC882/883/885/888/889 support
4349 *
4350 * ALC882 is almost identical with ALC880 but has cleaner and more flexible
4351 * configuration. Each pin widget can choose any input DACs and a mixer.
4352 * Each ADC is connected from a mixer of all inputs. This makes possible
4353 * 6-channel independent captures.
4354 *
4355 * In addition, an independent DAC for the multi-playback (not used in this
4356 * driver yet).
4357 */
4358#ifdef CONFIG_SND_HDA_POWER_SAVE
4359#define alc882_loopbacks alc880_loopbacks
4360#endif
4361
4362/*
4363 * Pin config fixes
4364 */
ff818c24 4365enum {
5c0ebfbe
TI		 4366 ALC882_FIXUP_ABIT_AW9D_MAX,
4367 ALC882_FIXUP_LENOVO_Y530,
4368 ALC882_FIXUP_PB_M5210,
4369 ALC882_FIXUP_ACER_ASPIRE_7736,
4370 ALC882_FIXUP_ASUS_W90V,
4371 ALC889_FIXUP_VAIO_TT,
0e7cc2e7 4372 ALC888_FIXUP_EEE1601,
177943a3 4373 ALC882_FIXUP_EAPD,
7a6069bf 4374 ALC883_FIXUP_EAPD,
8812c4f9 4375 ALC883_FIXUP_ACER_EAPD,
eb844d51 4376 ALC882_FIXUP_GPIO3,
68ef0561
TI		 4377 ALC889_FIXUP_COEF,
4378 ALC882_FIXUP_ASUS_W2JC,
c3e837bb
TI		 4379 ALC882_FIXUP_ACER_ASPIRE_4930G,
4380 ALC882_FIXUP_ACER_ASPIRE_8930G,
4381 ALC882_FIXUP_ASPIRE_8930G_VERBS,
5671087f 4382 ALC885_FIXUP_MACPRO_GPIO,
ff818c24
TI		 4383};
4384
68ef0561
TI		 4385static void alc889_fixup_coef(struct hda_codec *codec,
4386 const struct alc_fixup *fix, int action)
4387{
4388 if (action != ALC_FIXUP_ACT_INIT)
4389 return;
4390 alc889_coef_init(codec);
4391}
4392
5671087f
TI		 4393/* toggle speaker-output according to the hp-jack state */
4394static void alc882_gpio_mute(struct hda_codec *codec, int pin, int muted)
4395{
4396 unsigned int gpiostate, gpiomask, gpiodir;
4397
4398 gpiostate = snd_hda_codec_read(codec, codec->afg, 0,
4399 AC_VERB_GET_GPIO_DATA, 0);
4400
4401 if (!muted)
4402 gpiostate |= (1 << pin);
4403 else
4404 gpiostate &= ~(1 << pin);
4405
4406 gpiomask = snd_hda_codec_read(codec, codec->afg, 0,
4407 AC_VERB_GET_GPIO_MASK, 0);
4408 gpiomask |= (1 << pin);
4409
4410 gpiodir = snd_hda_codec_read(codec, codec->afg, 0,
4411 AC_VERB_GET_GPIO_DIRECTION, 0);
4412 gpiodir |= (1 << pin);
4413
4414
4415 snd_hda_codec_write(codec, codec->afg, 0,
4416 AC_VERB_SET_GPIO_MASK, gpiomask);
4417 snd_hda_codec_write(codec, codec->afg, 0,
4418 AC_VERB_SET_GPIO_DIRECTION, gpiodir);
4419
4420 msleep(1);
4421
4422 snd_hda_codec_write(codec, codec->afg, 0,
4423 AC_VERB_SET_GPIO_DATA, gpiostate);
4424}
4425
4426/* set up GPIO at initialization */
4427static void alc885_fixup_macpro_gpio(struct hda_codec *codec,
4428 const struct alc_fixup *fix, int action)
4429{
4430 if (action != ALC_FIXUP_ACT_INIT)
4431 return;
4432 alc882_gpio_mute(codec, 0, 0);
4433 alc882_gpio_mute(codec, 1, 0);
4434}
4435
1d045db9 4436static const struct alc_fixup alc882_fixups[] = {
5c0ebfbe 4437 [ALC882_FIXUP_ABIT_AW9D_MAX] = {
1d045db9
TI		 4438 .type = ALC_FIXUP_PINS,
4439 .v.pins = (const struct alc_pincfg[]) {
4440 { 0x15, 0x01080104 }, /* side */
4441 { 0x16, 0x01011012 }, /* rear */
4442 { 0x17, 0x01016011 }, /* clfe */
2785591a 4443 { }
145a902b
DH		 4444 }
4445 },
5c0ebfbe 4446 [ALC882_FIXUP_LENOVO_Y530] = {
b5bfbc67
TI		 4447 .type = ALC_FIXUP_PINS,
4448 .v.pins = (const struct alc_pincfg[]) {
1d045db9
TI		 4449 { 0x15, 0x99130112 }, /* rear int speakers */
4450 { 0x16, 0x99130111 }, /* subwoofer */
ac612407
DH		 4451 { }
4452 }
4453 },
5c0ebfbe 4454 [ALC882_FIXUP_PB_M5210] = {
b5bfbc67
TI		 4455 .type = ALC_FIXUP_VERBS,
4456 .v.verbs = (const struct hda_verb[]) {
1d045db9 4457 { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50 },
357f915e
KY		 4458 {}
4459 }
4460 },
5c0ebfbe 4461 [ALC882_FIXUP_ACER_ASPIRE_7736] = {
1d045db9
TI		 4462 .type = ALC_FIXUP_SKU,
4463 .v.sku = ALC_FIXUP_SKU_IGNORE,
6981d184 4464 },
5c0ebfbe 4465 [ALC882_FIXUP_ASUS_W90V] = {
5cdf745e
TI		 4466 .type = ALC_FIXUP_PINS,
4467 .v.pins = (const struct alc_pincfg[]) {
4468 { 0x16, 0x99130110 }, /* fix sequence for CLFE */
4469 { }
4470 }
4471 },
5c0ebfbe
TI		 4472 [ALC889_FIXUP_VAIO_TT] = {
4473 .type = ALC_FIXUP_PINS,
4474 .v.pins = (const struct alc_pincfg[]) {
4475 { 0x17, 0x90170111 }, /* hidden surround speaker */
4476 { }
4477 }
4478 },
0e7cc2e7
TI		 4479 [ALC888_FIXUP_EEE1601] = {
4480 .type = ALC_FIXUP_VERBS,
4481 .v.verbs = (const struct hda_verb[]) {
4482 { 0x20, AC_VERB_SET_COEF_INDEX, 0x0b },
4483 { 0x20, AC_VERB_SET_PROC_COEF, 0x0838 },
4484 { }
4485 }
177943a3
TI		 4486 },
4487 [ALC882_FIXUP_EAPD] = {
4488 .type = ALC_FIXUP_VERBS,
4489 .v.verbs = (const struct hda_verb[]) {
4490 /* change to EAPD mode */
4491 { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
4492 { 0x20, AC_VERB_SET_PROC_COEF, 0x3060 },
4493 { }
4494 }
4495 },
7a6069bf
TI		 4496 [ALC883_FIXUP_EAPD] = {
4497 .type = ALC_FIXUP_VERBS,
4498 .v.verbs = (const struct hda_verb[]) {
4499 /* change to EAPD mode */
4500 { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
4501 { 0x20, AC_VERB_SET_PROC_COEF, 0x3070 },
4502 { }
4503 }
4504 },
8812c4f9
TI		 4505 [ALC883_FIXUP_ACER_EAPD] = {
4506 .type = ALC_FIXUP_VERBS,
4507 .v.verbs = (const struct hda_verb[]) {
4508 /* eanable EAPD on Acer laptops */
4509 { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
4510 { 0x20, AC_VERB_SET_PROC_COEF, 0x3050 },
4511 { }
4512 }
4513 },
eb844d51
TI		 4514 [ALC882_FIXUP_GPIO3] = {
4515 .type = ALC_FIXUP_VERBS,
4516 .v.verbs = alc_gpio3_init_verbs,
4517 },
68ef0561
TI		 4518 [ALC882_FIXUP_ASUS_W2JC] = {
4519 .type = ALC_FIXUP_VERBS,
4520 .v.verbs = alc_gpio1_init_verbs,
4521 .chained = true,
4522 .chain_id = ALC882_FIXUP_EAPD,
4523 },
4524 [ALC889_FIXUP_COEF] = {
4525 .type = ALC_FIXUP_FUNC,
4526 .v.func = alc889_fixup_coef,
4527 },
c3e837bb
TI		 4528 [ALC882_FIXUP_ACER_ASPIRE_4930G] = {
4529 .type = ALC_FIXUP_PINS,
4530 .v.pins = (const struct alc_pincfg[]) {
4531 { 0x16, 0x99130111 }, /* CLFE speaker */
4532 { 0x17, 0x99130112 }, /* surround speaker */
4533 { }
4534 }
4535 },
4536 [ALC882_FIXUP_ACER_ASPIRE_8930G] = {
4537 .type = ALC_FIXUP_PINS,
4538 .v.pins = (const struct alc_pincfg[]) {
4539 { 0x16, 0x99130111 }, /* CLFE speaker */
4540 { 0x1b, 0x99130112 }, /* surround speaker */
4541 { }
4542 },
4543 .chained = true,
4544 .chain_id = ALC882_FIXUP_ASPIRE_8930G_VERBS,
4545 },
4546 [ALC882_FIXUP_ASPIRE_8930G_VERBS] = {
4547 /* additional init verbs for Acer Aspire 8930G */
4548 .type = ALC_FIXUP_VERBS,
4549 .v.verbs = (const struct hda_verb[]) {
4550 /* Enable all DACs */
4551 /* DAC DISABLE/MUTE 1? */
4552 /* setting bits 1-5 disables DAC nids 0x02-0x06
4553 * apparently. Init=0x38 */
4554 { 0x20, AC_VERB_SET_COEF_INDEX, 0x03 },
4555 { 0x20, AC_VERB_SET_PROC_COEF, 0x0000 },
4556 /* DAC DISABLE/MUTE 2? */
4557 /* some bit here disables the other DACs.
4558 * Init=0x4900 */
4559 { 0x20, AC_VERB_SET_COEF_INDEX, 0x08 },
4560 { 0x20, AC_VERB_SET_PROC_COEF, 0x0000 },
4561 /* DMIC fix
4562 * This laptop has a stereo digital microphone.
4563 * The mics are only 1cm apart which makes the stereo
4564 * useless. However, either the mic or the ALC889
4565 * makes the signal become a difference/sum signal
4566 * instead of standard stereo, which is annoying.
4567 * So instead we flip this bit which makes the
4568 * codec replicate the sum signal to both channels,
4569 * turning it into a normal mono mic.
4570 */
4571 /* DMIC_CONTROL? Init value = 0x0001 */
4572 { 0x20, AC_VERB_SET_COEF_INDEX, 0x0b },
4573 { 0x20, AC_VERB_SET_PROC_COEF, 0x0003 },
4574 { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
4575 { 0x20, AC_VERB_SET_PROC_COEF, 0x3050 },
4576 { }
4577 }
4578 },
5671087f
TI		 4579 [ALC885_FIXUP_MACPRO_GPIO] = {
4580 .type = ALC_FIXUP_FUNC,
4581 .v.func = alc885_fixup_macpro_gpio,
4582 },
ff818c24
TI		 4583};
4584
1d045db9 4585static const struct snd_pci_quirk alc882_fixup_tbl[] = {
8812c4f9
TI		 4586 SND_PCI_QUIRK(0x1025, 0x006c, "Acer Aspire 9810", ALC883_FIXUP_ACER_EAPD),
4587 SND_PCI_QUIRK(0x1025, 0x0090, "Acer Aspire", ALC883_FIXUP_ACER_EAPD),
4588 SND_PCI_QUIRK(0x1025, 0x010a, "Acer Ferrari 5000", ALC883_FIXUP_ACER_EAPD),
4589 SND_PCI_QUIRK(0x1025, 0x0110, "Acer Aspire", ALC883_FIXUP_ACER_EAPD),
4590 SND_PCI_QUIRK(0x1025, 0x0112, "Acer Aspire 9303", ALC883_FIXUP_ACER_EAPD),
4591 SND_PCI_QUIRK(0x1025, 0x0121, "Acer Aspire 5920G", ALC883_FIXUP_ACER_EAPD),
c3e837bb
TI		 4592 SND_PCI_QUIRK(0x1025, 0x013e, "Acer Aspire 4930G",
4593 ALC882_FIXUP_ACER_ASPIRE_4930G),
4594 SND_PCI_QUIRK(0x1025, 0x013f, "Acer Aspire 5930G",
4595 ALC882_FIXUP_ACER_ASPIRE_4930G),
4596 SND_PCI_QUIRK(0x1025, 0x0145, "Acer Aspire 8930G",
4597 ALC882_FIXUP_ACER_ASPIRE_8930G),
4598 SND_PCI_QUIRK(0x1025, 0x0146, "Acer Aspire 6935G",
4599 ALC882_FIXUP_ACER_ASPIRE_8930G),
4600 SND_PCI_QUIRK(0x1025, 0x015e, "Acer Aspire 6930G",
4601 ALC882_FIXUP_ACER_ASPIRE_4930G),
4602 SND_PCI_QUIRK(0x1025, 0x0166, "Acer Aspire 6530G",
4603 ALC882_FIXUP_ACER_ASPIRE_4930G),
4604 SND_PCI_QUIRK(0x1025, 0x0142, "Acer Aspire 7730G",
4605 ALC882_FIXUP_ACER_ASPIRE_4930G),
5c0ebfbe 4606 SND_PCI_QUIRK(0x1025, 0x0155, "Packard-Bell M5120", ALC882_FIXUP_PB_M5210),
ac9b1cdd 4607 SND_PCI_QUIRK(0x1025, 0x0296, "Acer Aspire 7736z", ALC882_FIXUP_ACER_ASPIRE_7736),
177943a3 4608 SND_PCI_QUIRK(0x1043, 0x13c2, "Asus A7M", ALC882_FIXUP_EAPD),
5c0ebfbe 4609 SND_PCI_QUIRK(0x1043, 0x1873, "ASUS W90V", ALC882_FIXUP_ASUS_W90V),
68ef0561 4610 SND_PCI_QUIRK(0x1043, 0x1971, "Asus W2JC", ALC882_FIXUP_ASUS_W2JC),
0e7cc2e7 4611 SND_PCI_QUIRK(0x1043, 0x835f, "Asus Eee 1601", ALC888_FIXUP_EEE1601),
ac9b1cdd 4612 SND_PCI_QUIRK(0x104d, 0x9047, "Sony Vaio TT", ALC889_FIXUP_VAIO_TT),
5671087f
TI		 4613
4614 /* All Apple entries are in codec SSIDs */
4615 SND_PCI_QUIRK(0x106b, 0x0c00, "Mac Pro", ALC885_FIXUP_MACPRO_GPIO),
4616 SND_PCI_QUIRK(0x106b, 0x1000, "iMac 24", ALC885_FIXUP_MACPRO_GPIO),
4617 SND_PCI_QUIRK(0x106b, 0x2800, "AppleTV", ALC885_FIXUP_MACPRO_GPIO),
4618 SND_PCI_QUIRK(0x106b, 0x3200, "iMac 7,1 Aluminum", ALC882_FIXUP_EAPD),
4619 SND_PCI_QUIRK(0x106b, 0x3e00, "iMac 24 Aluminum", ALC885_FIXUP_MACPRO_GPIO),
4620
7a6069bf 4621 SND_PCI_QUIRK(0x1071, 0x8258, "Evesham Voyaeger", ALC882_FIXUP_EAPD),
eb844d51 4622 SND_PCI_QUIRK_VENDOR(0x1462, "MSI", ALC882_FIXUP_GPIO3),
5c0ebfbe 4623 SND_PCI_QUIRK(0x147b, 0x107a, "Abit AW9D-MAX", ALC882_FIXUP_ABIT_AW9D_MAX),
7a6069bf
TI		 4624 SND_PCI_QUIRK_VENDOR(0x1558, "Clevo laptop", ALC882_FIXUP_EAPD),
4625 SND_PCI_QUIRK(0x161f, 0x2054, "Medion laptop", ALC883_FIXUP_EAPD),
ac9b1cdd 4626 SND_PCI_QUIRK(0x17aa, 0x3a0d, "Lenovo Y530", ALC882_FIXUP_LENOVO_Y530),
68ef0561 4627 SND_PCI_QUIRK(0x8086, 0x0022, "DX58SO", ALC889_FIXUP_COEF),
ff818c24
TI		 4628 {}
4629};
4630
f6a92248 4631/*
1d045db9 4632 * BIOS auto configuration
f6a92248 4633 */
1d045db9
TI		 4634/* almost identical with ALC880 parser... */
4635static int alc882_parse_auto_config(struct hda_codec *codec)
4636{
1d045db9 4637 static const hda_nid_t alc882_ignore[] = { 0x1d, 0 };
3e6179b8
TI		 4638 static const hda_nid_t alc882_ssids[] = { 0x15, 0x1b, 0x14, 0 };
4639 return alc_parse_auto_config(codec, alc882_ignore, alc882_ssids);
1d045db9 4640}
b896b4eb 4641
1d045db9
TI		 4642/*
4643 */
4644#ifdef CONFIG_SND_HDA_ENABLE_REALTEK_QUIRKS
4645#include "alc882_quirks.c"
4646#endif
4647
4648static int patch_alc882(struct hda_codec *codec)
f6a92248
KY		 4649{
4650 struct alc_spec *spec;
1d045db9 4651 int err, board_config;
f6a92248
KY		 4652
4653 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
4654 if (spec == NULL)
4655 return -ENOMEM;
4656
4657 codec->spec = spec;
4658
1f0f4b80
TI		 4659 spec->mixer_nid = 0x0b;
4660
1d045db9
TI		 4661 switch (codec->vendor_id) {
4662 case 0x10ec0882:
4663 case 0x10ec0885:
4664 break;
4665 default:
4666 /* ALC883 and variants */
4667 alc_fix_pll_init(codec, 0x20, 0x0a, 10);
4668 break;
c793bec5 4669 }
977ddd6b 4670
e16fb6d1
TI		 4671 err = alc_codec_rename_from_preset(codec);
4672 if (err < 0)
4673 goto error;
4674
b2539699
TI		 4675 board_config = alc_board_config(codec, ALC882_MODEL_LAST,
4676 alc882_models, NULL);
4677 if (board_config < 0)
4678 board_config = alc_board_codec_sid_config(codec,
1d045db9 4679 ALC882_MODEL_LAST, alc882_models, alc882_ssid_cfg_tbl);
f6a92248
KY		 4680
4681 if (board_config < 0) {
9a11f1aa
TI		 4682 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
4683 codec->chip_name);
1d045db9 4684 board_config = ALC_MODEL_AUTO;
f6a92248
KY		 4685 }
4686
1d045db9
TI		 4687 if (board_config == ALC_MODEL_AUTO) {
4688 alc_pick_fixup(codec, NULL, alc882_fixup_tbl, alc882_fixups);
b5bfbc67
TI		 4689 alc_apply_fixup(codec, ALC_FIXUP_ACT_PRE_PROBE);
4690 }
ff818c24 4691
1d045db9
TI		 4692 alc_auto_parse_customize_define(codec);
4693
4694 if (board_config == ALC_MODEL_AUTO) {
f6a92248 4695 /* automatic parse from the BIOS config */
1d045db9 4696 err = alc882_parse_auto_config(codec);
e16fb6d1
TI		 4697 if (err < 0)
4698 goto error;
f6a92248
KY		 4699 }
4700
1d045db9
TI		 4701 if (board_config != ALC_MODEL_AUTO)
4702 setup_preset(codec, &alc882_presets[board_config]);
f6a92248 4703
60a6a842 4704 if (!spec->no_analog && !spec->adc_nids) {
d6cc9fab 4705 alc_auto_fill_adc_caps(codec);
21268961 4706 alc_rebuild_imux_for_auto_mic(codec);
d6cc9fab 4707 alc_remove_invalid_adc_nids(codec);
84898e87
KY		 4708 }
4709
3e6179b8
TI		 4710 if (!spec->no_analog && !spec->cap_mixer)
4711 set_capture_mixer(codec);
1d045db9 4712
3e6179b8
TI		 4713 if (!spec->no_analog && has_cdefine_beep(codec)) {
4714 err = snd_hda_attach_beep_device(codec, 0x1);
e16fb6d1
TI		 4715 if (err < 0)
4716 goto error;
1d045db9 4717 set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
3e6179b8 4718 }
f6a92248 4719
b5bfbc67 4720 alc_apply_fixup(codec, ALC_FIXUP_ACT_PROBE);
ff818c24 4721
1d045db9 4722 spec->vmaster_nid = 0x0c;
100d5eb3 4723
f6a92248 4724 codec->patch_ops = alc_patch_ops;
1d045db9 4725 if (board_config == ALC_MODEL_AUTO)
e4770629 4726 spec->init_hook = alc_auto_init_std;
bf1b0225
KY		 4727
4728 alc_init_jacks(codec);
f6a92248
KY		 4729#ifdef CONFIG_SND_HDA_POWER_SAVE
4730 if (!spec->loopback.amplist)
1d045db9 4731 spec->loopback.amplist = alc882_loopbacks;
f6a92248
KY		 4732#endif
4733
4734 return 0;
e16fb6d1
TI		 4735
4736 error:
4737 alc_free(codec);
4738 return err;
f6a92248
KY		 4739}
4740
df694daa 4741
df694daa 4742/*
1d045db9 4743 * ALC262 support
df694daa 4744 */
1d045db9 4745static int alc262_parse_auto_config(struct hda_codec *codec)
df694daa 4746{
1d045db9 4747 static const hda_nid_t alc262_ignore[] = { 0x1d, 0 };
3e6179b8
TI		 4748 static const hda_nid_t alc262_ssids[] = { 0x15, 0x1b, 0x14, 0 };
4749 return alc_parse_auto_config(codec, alc262_ignore, alc262_ssids);
df694daa
KY		 4750}
4751
df694daa 4752/*
1d045db9 4753 * Pin config fixes
df694daa 4754 */
cfc9b06f 4755enum {
ea4e7af1
TI		 4756 ALC262_FIXUP_FSC_H270,
4757 ALC262_FIXUP_HP_Z200,
4758 ALC262_FIXUP_TYAN,
12837c98 4759 ALC262_FIXUP_TOSHIBA_RX1,
c470150c 4760 ALC262_FIXUP_LENOVO_3000,
b42590b8
TI		 4761 ALC262_FIXUP_BENQ,
4762 ALC262_FIXUP_BENQ_T31,
cfc9b06f
TI		 4763};
4764
1d045db9 4765static const struct alc_fixup alc262_fixups[] = {
ea4e7af1 4766 [ALC262_FIXUP_FSC_H270] = {
b5bfbc67
TI		 4767 .type = ALC_FIXUP_PINS,
4768 .v.pins = (const struct alc_pincfg[]) {
1d045db9
TI		 4769 { 0x14, 0x99130110 }, /* speaker */
4770 { 0x15, 0x0221142f }, /* front HP */
4771 { 0x1b, 0x0121141f }, /* rear HP */
4772 { }
4773 }
4774 },
ea4e7af1 4775 [ALC262_FIXUP_HP_Z200] = {
1d045db9
TI		 4776 .type = ALC_FIXUP_PINS,
4777 .v.pins = (const struct alc_pincfg[]) {
4778 { 0x16, 0x99130120 }, /* internal speaker */
73413b12
TI		 4779 { }
4780 }
cfc9b06f 4781 },
ea4e7af1
TI		 4782 [ALC262_FIXUP_TYAN] = {
4783 .type = ALC_FIXUP_PINS,
4784 .v.pins = (const struct alc_pincfg[]) {
4785 { 0x14, 0x1993e1f0 }, /* int AUX */
4786 { }
4787 }
4788 },
12837c98
TI		 4789 [ALC262_FIXUP_TOSHIBA_RX1] = {
4790 .type = ALC_FIXUP_PINS,
4791 .v.pins = (const struct alc_pincfg[]) {
4792 { 0x14, 0x90170110 }, /* speaker */
4793 { 0x15, 0x0421101f }, /* HP */
4794 { 0x1a, 0x40f000f0 }, /* N/A */
4795 { 0x1b, 0x40f000f0 }, /* N/A */
4796 { 0x1e, 0x40f000f0 }, /* N/A */
4797 }
4798 },
c470150c
TI		 4799 [ALC262_FIXUP_LENOVO_3000] = {
4800 .type = ALC_FIXUP_VERBS,
4801 .v.verbs = (const struct hda_verb[]) {
4802 { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50 },
b42590b8
TI		 4803 {}
4804 },
4805 .chained = true,
4806 .chain_id = ALC262_FIXUP_BENQ,
4807 },
4808 [ALC262_FIXUP_BENQ] = {
4809 .type = ALC_FIXUP_VERBS,
4810 .v.verbs = (const struct hda_verb[]) {
c470150c
TI		 4811 { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
4812 { 0x20, AC_VERB_SET_PROC_COEF, 0x3070 },
4813 {}
4814 }
4815 },
b42590b8
TI		 4816 [ALC262_FIXUP_BENQ_T31] = {
4817 .type = ALC_FIXUP_VERBS,
4818 .v.verbs = (const struct hda_verb[]) {
4819 { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
4820 { 0x20, AC_VERB_SET_PROC_COEF, 0x3050 },
4821 {}
4822 }
4823 },
cfc9b06f
TI		 4824};
4825
1d045db9 4826static const struct snd_pci_quirk alc262_fixup_tbl[] = {
ea4e7af1 4827 SND_PCI_QUIRK(0x103c, 0x170b, "HP Z200", ALC262_FIXUP_HP_Z200),
3dcd3be3
TI		 4828 SND_PCI_QUIRK(0x10cf, 0x1397, "Fujitsu", ALC262_FIXUP_BENQ),
4829 SND_PCI_QUIRK(0x10cf, 0x142d, "Fujitsu Lifebook E8410", ALC262_FIXUP_BENQ),
ea4e7af1 4830 SND_PCI_QUIRK(0x10f1, 0x2915, "Tyan Thunder n6650W", ALC262_FIXUP_TYAN),
12837c98
TI		 4831 SND_PCI_QUIRK(0x1179, 0x0001, "Toshiba dynabook SS RX1",
4832 ALC262_FIXUP_TOSHIBA_RX1),
ea4e7af1 4833 SND_PCI_QUIRK(0x1734, 0x1147, "FSC Celsius H270", ALC262_FIXUP_FSC_H270),
c470150c 4834 SND_PCI_QUIRK(0x17aa, 0x384e, "Lenovo 3000", ALC262_FIXUP_LENOVO_3000),
b42590b8
TI		 4835 SND_PCI_QUIRK(0x17ff, 0x0560, "Benq ED8", ALC262_FIXUP_BENQ),
4836 SND_PCI_QUIRK(0x17ff, 0x058d, "Benq T31-16", ALC262_FIXUP_BENQ_T31),
cfc9b06f
TI		 4837 {}
4838};
df694daa 4839
1d045db9
TI		 4840
4841#ifdef CONFIG_SND_HDA_POWER_SAVE
4842#define alc262_loopbacks alc880_loopbacks
4843#endif
4844
1d045db9
TI		 4845/*
4846 */
1d045db9 4847static int patch_alc262(struct hda_codec *codec)
df694daa
KY		 4848{
4849 struct alc_spec *spec;
df694daa
KY		 4850 int err;
4851
dc041e0b 4852 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
df694daa
KY		 4853 if (spec == NULL)
4854 return -ENOMEM;
4855
f12ab1e0 4856 codec->spec = spec;
df694daa 4857
1d045db9
TI		 4858 spec->mixer_nid = 0x0b;
4859
4860#if 0
4861 /* pshou 07/11/05 set a zero PCM sample to DAC when FIFO is
4862 * under-run
4863 */
4864 {
4865 int tmp;
4866 snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_COEF_INDEX, 7);
4867 tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0);
4868 snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_COEF_INDEX, 7);
4869 snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_PROC_COEF, tmp | 0x80);
4870 }
4871#endif
4872 alc_auto_parse_customize_define(codec);
1f0f4b80 4873
1d045db9
TI		 4874 alc_fix_pll_init(codec, 0x20, 0x0a, 10);
4875
42399f7a
TI		 4876 alc_pick_fixup(codec, NULL, alc262_fixup_tbl, alc262_fixups);
4877 alc_apply_fixup(codec, ALC_FIXUP_ACT_PRE_PROBE);
9c7f852e 4878
42399f7a
TI		 4879 /* automatic parse from the BIOS config */
4880 err = alc262_parse_auto_config(codec);
4881 if (err < 0)
4882 goto error;
df694daa 4883
60a6a842 4884 if (!spec->no_analog && !spec->adc_nids) {
21268961
TI		 4885 alc_auto_fill_adc_caps(codec);
4886 alc_rebuild_imux_for_auto_mic(codec);
4887 alc_remove_invalid_adc_nids(codec);
4888 }
3e6179b8
TI		 4889
4890 if (!spec->no_analog && !spec->cap_mixer)
c7a8eb10 4891 set_capture_mixer(codec);
3e6179b8
TI		 4892
4893 if (!spec->no_analog && has_cdefine_beep(codec)) {
4894 err = snd_hda_attach_beep_device(codec, 0x1);
e16fb6d1
TI		 4895 if (err < 0)
4896 goto error;
1d045db9 4897 set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
3e6179b8 4898 }
2134ea4f 4899
b5bfbc67 4900 alc_apply_fixup(codec, ALC_FIXUP_ACT_PROBE);
7fa90e87 4901
1d045db9
TI		 4902 spec->vmaster_nid = 0x0c;
4903
df694daa 4904 codec->patch_ops = alc_patch_ops;
42399f7a 4905 spec->init_hook = alc_auto_init_std;
1d045db9
TI		 4906 spec->shutup = alc_eapd_shutup;
4907
4908 alc_init_jacks(codec);
cb53c626
TI		 4909#ifdef CONFIG_SND_HDA_POWER_SAVE
4910 if (!spec->loopback.amplist)
1d045db9 4911 spec->loopback.amplist = alc262_loopbacks;
cb53c626 4912#endif
ea1fb29a 4913
1da177e4 4914 return 0;
e16fb6d1
TI		 4915
4916 error:
4917 alc_free(codec);
4918 return err;
1da177e4
LT		 4919}
4920
f32610ed 4921/*
1d045db9 4922 * ALC268
f32610ed 4923 */
1d045db9
TI		 4924/* bind Beep switches of both NID 0x0f and 0x10 */
4925static const struct hda_bind_ctls alc268_bind_beep_sw = {
4926 .ops = &snd_hda_bind_sw,
4927 .values = {
4928 HDA_COMPOSE_AMP_VAL(0x0f, 3, 1, HDA_INPUT),
4929 HDA_COMPOSE_AMP_VAL(0x10, 3, 1, HDA_INPUT),
4930 0
4931 },
f32610ed
JS		 4932};
4933
1d045db9
TI		 4934static const struct snd_kcontrol_new alc268_beep_mixer[] = {
4935 HDA_CODEC_VOLUME("Beep Playback Volume", 0x1d, 0x0, HDA_INPUT),
4936 HDA_BIND_SW("Beep Playback Switch", &alc268_bind_beep_sw),
4937 { }
f32610ed
JS		 4938};
4939
1d045db9
TI		 4940/* set PCBEEP vol = 0, mute connections */
4941static const struct hda_verb alc268_beep_init_verbs[] = {
4942 {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4943 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4944 {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4945 { }
f32610ed
JS		 4946};
4947
4948/*
4949 * BIOS auto configuration
4950 */
1d045db9 4951static int alc268_parse_auto_config(struct hda_codec *codec)
f32610ed 4952{
3e6179b8 4953 static const hda_nid_t alc268_ssids[] = { 0x15, 0x1b, 0x14, 0 };
f32610ed 4954 struct alc_spec *spec = codec->spec;
3e6179b8
TI		 4955 int err = alc_parse_auto_config(codec, NULL, alc268_ssids);
4956 if (err > 0) {
4957 if (!spec->no_analog && spec->autocfg.speaker_pins[0] != 0x1d) {
4958 add_mixer(spec, alc268_beep_mixer);
4959 add_verb(spec, alc268_beep_init_verbs);
1d045db9 4960 }
1d045db9 4961 }
3e6179b8 4962 return err;
f32610ed
JS		 4963}
4964
1d045db9
TI		 4965/*
4966 */
1d045db9 4967static int patch_alc268(struct hda_codec *codec)
f32610ed
JS		 4968{
4969 struct alc_spec *spec;
1d045db9 4970 int i, has_beep, err;
f32610ed
JS		 4971
4972 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
4973 if (spec == NULL)
4974 return -ENOMEM;
4975
4976 codec->spec = spec;
4977
1d045db9 4978 /* ALC268 has no aa-loopback mixer */
1f0f4b80 4979
6ebb8053
TI		 4980 /* automatic parse from the BIOS config */
4981 err = alc268_parse_auto_config(codec);
e16fb6d1
TI		 4982 if (err < 0)
4983 goto error;
f32610ed 4984
1d045db9
TI		 4985 has_beep = 0;
4986 for (i = 0; i < spec->num_mixers; i++) {
4987 if (spec->mixers[i] == alc268_beep_mixer) {
4988 has_beep = 1;
4989 break;
4990 }
4991 }
f32610ed 4992
1d045db9
TI		 4993 if (has_beep) {
4994 err = snd_hda_attach_beep_device(codec, 0x1);
e16fb6d1
TI		 4995 if (err < 0)
4996 goto error;
1d045db9
TI		 4997 if (!query_amp_caps(codec, 0x1d, HDA_INPUT))
4998 /* override the amp caps for beep generator */
4999 snd_hda_override_amp_caps(codec, 0x1d, HDA_INPUT,
5000 (0x0c << AC_AMPCAP_OFFSET_SHIFT) |
5001 (0x0c << AC_AMPCAP_NUM_STEPS_SHIFT) |
5002 (0x07 << AC_AMPCAP_STEP_SIZE_SHIFT) |
5003 (0 << AC_AMPCAP_MUTE_SHIFT));
2f893286
KY		 5004 }
5005
60a6a842 5006 if (!spec->no_analog && !spec->adc_nids) {
d6cc9fab 5007 alc_auto_fill_adc_caps(codec);
21268961 5008 alc_rebuild_imux_for_auto_mic(codec);
d6cc9fab 5009 alc_remove_invalid_adc_nids(codec);
dd704698 5010 }
f32610ed 5011
3e6179b8 5012 if (!spec->no_analog && !spec->cap_mixer)
1d045db9 5013 set_capture_mixer(codec);
f32610ed 5014
2134ea4f
TI		 5015 spec->vmaster_nid = 0x02;
5016
f32610ed 5017 codec->patch_ops = alc_patch_ops;
6ebb8053 5018 spec->init_hook = alc_auto_init_std;
1c716153 5019 spec->shutup = alc_eapd_shutup;
1d045db9
TI		 5020
5021 alc_init_jacks(codec);
f32610ed
JS		 5022
5023 return 0;
e16fb6d1
TI		 5024
5025 error:
5026 alc_free(codec);
5027 return err;
f32610ed
JS		 5028}
5029
bc9f98a9 5030/*
1d045db9 5031 * ALC269
bc9f98a9 5032 */
1d045db9
TI		 5033#ifdef CONFIG_SND_HDA_POWER_SAVE
5034#define alc269_loopbacks alc880_loopbacks
5035#endif
e1406348 5036
1d045db9
TI		 5037static const struct hda_pcm_stream alc269_44k_pcm_analog_playback = {
5038 .substreams = 1,
5039 .channels_min = 2,
5040 .channels_max = 8,
5041 .rates = SNDRV_PCM_RATE_44100, /* fixed rate */
5042 /* NID is set in alc_build_pcms */
5043 .ops = {
5044 .open = alc_playback_pcm_open,
5045 .prepare = alc_playback_pcm_prepare,
5046 .cleanup = alc_playback_pcm_cleanup
bc9f98a9
KY		 5047 },
5048};
5049
1d045db9
TI		 5050static const struct hda_pcm_stream alc269_44k_pcm_analog_capture = {
5051 .substreams = 1,
5052 .channels_min = 2,
5053 .channels_max = 2,
5054 .rates = SNDRV_PCM_RATE_44100, /* fixed rate */
5055 /* NID is set in alc_build_pcms */
bc9f98a9 5056};
291702f0 5057
1d045db9
TI		 5058#ifdef CONFIG_SND_HDA_POWER_SAVE
5059static int alc269_mic2_for_mute_led(struct hda_codec *codec)
5060{
5061 switch (codec->subsystem_id) {
5062 case 0x103c1586:
5063 return 1;
5064 }
5065 return 0;
5066}
6dda9f4a 5067
1d045db9
TI		 5068static int alc269_mic2_mute_check_ps(struct hda_codec *codec, hda_nid_t nid)
5069{
5070 /* update mute-LED according to the speaker mute state */
5071 if (nid == 0x01 || nid == 0x14) {
5072 int pinval;
5073 if (snd_hda_codec_amp_read(codec, 0x14, 0, HDA_OUTPUT, 0) &
5074 HDA_AMP_MUTE)
5075 pinval = 0x24;
5076 else
5077 pinval = 0x20;
5078 /* mic2 vref pin is used for mute LED control */
5079 snd_hda_codec_update_cache(codec, 0x19, 0,
5080 AC_VERB_SET_PIN_WIDGET_CONTROL,
5081 pinval);
5082 }
5083 return alc_check_power_status(codec, nid);
5084}
5085#endif /* CONFIG_SND_HDA_POWER_SAVE */
9541ba1d 5086
1d045db9
TI		 5087/* different alc269-variants */
5088enum {
5089 ALC269_TYPE_ALC269VA,
5090 ALC269_TYPE_ALC269VB,
5091 ALC269_TYPE_ALC269VC,
bc9f98a9
KY		 5092};
5093
5094/*
1d045db9 5095 * BIOS auto configuration
bc9f98a9 5096 */
1d045db9
TI		 5097static int alc269_parse_auto_config(struct hda_codec *codec)
5098{
1d045db9 5099 static const hda_nid_t alc269_ignore[] = { 0x1d, 0 };
3e6179b8
TI		 5100 static const hda_nid_t alc269_ssids[] = { 0, 0x1b, 0x14, 0x21 };
5101 static const hda_nid_t alc269va_ssids[] = { 0x15, 0x1b, 0x14, 0 };
5102 struct alc_spec *spec = codec->spec;
5103 const hda_nid_t *ssids = spec->codec_variant == ALC269_TYPE_ALC269VA ?
5104 alc269va_ssids : alc269_ssids;
bc9f98a9 5105
3e6179b8 5106 return alc_parse_auto_config(codec, alc269_ignore, ssids);
1d045db9 5107}
bc9f98a9 5108
1d045db9
TI		 5109static void alc269_toggle_power_output(struct hda_codec *codec, int power_up)
5110{
5111 int val = alc_read_coef_idx(codec, 0x04);
5112 if (power_up)
5113 val |= 1 << 11;
5114 else
5115 val &= ~(1 << 11);
5116 alc_write_coef_idx(codec, 0x04, val);
5117}
291702f0 5118
1d045db9
TI		 5119static void alc269_shutup(struct hda_codec *codec)
5120{
1bb7e43e 5121 if ((alc_get_coef0(codec) & 0x00ff) == 0x017)
1d045db9 5122 alc269_toggle_power_output(codec, 0);
1bb7e43e 5123 if ((alc_get_coef0(codec) & 0x00ff) == 0x018) {
1d045db9
TI		 5124 alc269_toggle_power_output(codec, 0);
5125 msleep(150);
5126 }
5127}
291702f0 5128
2a43952a 5129#ifdef CONFIG_PM
1d045db9
TI		 5130static int alc269_resume(struct hda_codec *codec)
5131{
1bb7e43e 5132 if ((alc_get_coef0(codec) & 0x00ff) == 0x018) {
1d045db9
TI		 5133 alc269_toggle_power_output(codec, 0);
5134 msleep(150);
5135 }
8c427226 5136
1d045db9 5137 codec->patch_ops.init(codec);
f1d4e28b 5138
1bb7e43e 5139 if ((alc_get_coef0(codec) & 0x00ff) == 0x017) {
1d045db9
TI		 5140 alc269_toggle_power_output(codec, 1);
5141 msleep(200);
5142 }
f1d4e28b 5143
1bb7e43e 5144 if ((alc_get_coef0(codec) & 0x00ff) == 0x018)
1d045db9 5145 alc269_toggle_power_output(codec, 1);
f1d4e28b 5146
1d045db9
TI		 5147 snd_hda_codec_resume_amp(codec);
5148 snd_hda_codec_resume_cache(codec);
5149 hda_call_check_power_status(codec, 0x01);
5150 return 0;
5151}
2a43952a 5152#endif /* CONFIG_PM */
f1d4e28b 5153
1d045db9
TI		 5154static void alc269_fixup_hweq(struct hda_codec *codec,
5155 const struct alc_fixup *fix, int action)
5156{
5157 int coef;
f1d4e28b 5158
1d045db9
TI		 5159 if (action != ALC_FIXUP_ACT_INIT)
5160 return;
5161 coef = alc_read_coef_idx(codec, 0x1e);
5162 alc_write_coef_idx(codec, 0x1e, coef | 0x80);
5163}
f1d4e28b 5164
1d045db9
TI		 5165static void alc271_fixup_dmic(struct hda_codec *codec,
5166 const struct alc_fixup *fix, int action)
5167{
5168 static const struct hda_verb verbs[] = {
5169 {0x20, AC_VERB_SET_COEF_INDEX, 0x0d},
5170 {0x20, AC_VERB_SET_PROC_COEF, 0x4000},
5171 {}
5172 };
5173 unsigned int cfg;
f1d4e28b 5174
1d045db9
TI		 5175 if (strcmp(codec->chip_name, "ALC271X"))
5176 return;
5177 cfg = snd_hda_codec_get_pincfg(codec, 0x12);
5178 if (get_defcfg_connect(cfg) == AC_JACK_PORT_FIXED)
5179 snd_hda_sequence_write(codec, verbs);
5180}
f1d4e28b 5181
017f2a10
TI		 5182static void alc269_fixup_pcm_44k(struct hda_codec *codec,
5183 const struct alc_fixup *fix, int action)
5184{
5185 struct alc_spec *spec = codec->spec;
5186
5187 if (action != ALC_FIXUP_ACT_PROBE)
5188 return;
5189
5190 /* Due to a hardware problem on Lenovo Ideadpad, we need to
5191 * fix the sample rate of analog I/O to 44.1kHz
5192 */
5193 spec->stream_analog_playback = &alc269_44k_pcm_analog_playback;
5194 spec->stream_analog_capture = &alc269_44k_pcm_analog_capture;
5195}
5196
adabb3ec
TI		 5197static void alc269_fixup_stereo_dmic(struct hda_codec *codec,
5198 const struct alc_fixup *fix, int action)
5199{
5200 int coef;
5201
5202 if (action != ALC_FIXUP_ACT_INIT)
5203 return;
5204 /* The digital-mic unit sends PDM (differential signal) instead of
5205 * the standard PCM, thus you can't record a valid mono stream as is.
5206 * Below is a workaround specific to ALC269 to control the dmic
5207 * signal source as mono.
5208 */
5209 coef = alc_read_coef_idx(codec, 0x07);
5210 alc_write_coef_idx(codec, 0x07, coef | 0x80);
5211}
5212
24519911
TI		 5213static void alc269_quanta_automute(struct hda_codec *codec)
5214{
42cf0d01 5215 update_outputs(codec);
24519911
TI		 5216
5217 snd_hda_codec_write(codec, 0x20, 0,
5218 AC_VERB_SET_COEF_INDEX, 0x0c);
5219 snd_hda_codec_write(codec, 0x20, 0,
5220 AC_VERB_SET_PROC_COEF, 0x680);
5221
5222 snd_hda_codec_write(codec, 0x20, 0,
5223 AC_VERB_SET_COEF_INDEX, 0x0c);
5224 snd_hda_codec_write(codec, 0x20, 0,
5225 AC_VERB_SET_PROC_COEF, 0x480);
5226}
5227
5228static void alc269_fixup_quanta_mute(struct hda_codec *codec,
5229 const struct alc_fixup *fix, int action)
5230{
5231 struct alc_spec *spec = codec->spec;
5232 if (action != ALC_FIXUP_ACT_PROBE)
5233 return;
5234 spec->automute_hook = alc269_quanta_automute;
5235}
5236
1d045db9
TI		 5237enum {
5238 ALC269_FIXUP_SONY_VAIO,
5239 ALC275_FIXUP_SONY_VAIO_GPIO2,
5240 ALC269_FIXUP_DELL_M101Z,
5241 ALC269_FIXUP_SKU_IGNORE,
5242 ALC269_FIXUP_ASUS_G73JW,
5243 ALC269_FIXUP_LENOVO_EAPD,
5244 ALC275_FIXUP_SONY_HWEQ,
5245 ALC271_FIXUP_DMIC,
017f2a10 5246 ALC269_FIXUP_PCM_44K,
adabb3ec 5247 ALC269_FIXUP_STEREO_DMIC,
24519911
TI		 5248 ALC269_FIXUP_QUANTA_MUTE,
5249 ALC269_FIXUP_LIFEBOOK,
a4297b5d
TI		 5250 ALC269_FIXUP_AMIC,
5251 ALC269_FIXUP_DMIC,
5252 ALC269VB_FIXUP_AMIC,
5253 ALC269VB_FIXUP_DMIC,
f1d4e28b
KY		 5254};
5255
1d045db9
TI		 5256static const struct alc_fixup alc269_fixups[] = {
5257 [ALC269_FIXUP_SONY_VAIO] = {
5258 .type = ALC_FIXUP_VERBS,
5259 .v.verbs = (const struct hda_verb[]) {
5260 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREFGRD},
5261 {}
5262 }
f1d4e28b 5263 },
1d045db9
TI		 5264 [ALC275_FIXUP_SONY_VAIO_GPIO2] = {
5265 .type = ALC_FIXUP_VERBS,
5266 .v.verbs = (const struct hda_verb[]) {
5267 {0x01, AC_VERB_SET_GPIO_MASK, 0x04},
5268 {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x04},
5269 {0x01, AC_VERB_SET_GPIO_DATA, 0x00},
5270 { }
5271 },
5272 .chained = true,
5273 .chain_id = ALC269_FIXUP_SONY_VAIO
5274 },
5275 [ALC269_FIXUP_DELL_M101Z] = {
5276 .type = ALC_FIXUP_VERBS,
5277 .v.verbs = (const struct hda_verb[]) {
5278 /* Enables internal speaker */
5279 {0x20, AC_VERB_SET_COEF_INDEX, 13},
5280 {0x20, AC_VERB_SET_PROC_COEF, 0x4040},
5281 {}
5282 }
5283 },
5284 [ALC269_FIXUP_SKU_IGNORE] = {
5285 .type = ALC_FIXUP_SKU,
5286 .v.sku = ALC_FIXUP_SKU_IGNORE,
5287 },
5288 [ALC269_FIXUP_ASUS_G73JW] = {
5289 .type = ALC_FIXUP_PINS,
5290 .v.pins = (const struct alc_pincfg[]) {
5291 { 0x17, 0x99130111 }, /* subwoofer */
5292 { }
5293 }
5294 },
5295 [ALC269_FIXUP_LENOVO_EAPD] = {
5296 .type = ALC_FIXUP_VERBS,
5297 .v.verbs = (const struct hda_verb[]) {
5298 {0x14, AC_VERB_SET_EAPD_BTLENABLE, 0},
5299 {}
5300 }
5301 },
5302 [ALC275_FIXUP_SONY_HWEQ] = {
5303 .type = ALC_FIXUP_FUNC,
5304 .v.func = alc269_fixup_hweq,
5305 .chained = true,
5306 .chain_id = ALC275_FIXUP_SONY_VAIO_GPIO2
5307 },
5308 [ALC271_FIXUP_DMIC] = {
5309 .type = ALC_FIXUP_FUNC,
5310 .v.func = alc271_fixup_dmic,
f1d4e28b 5311 },
017f2a10
TI		 5312 [ALC269_FIXUP_PCM_44K] = {
5313 .type = ALC_FIXUP_FUNC,
5314 .v.func = alc269_fixup_pcm_44k,
5315 },
adabb3ec
TI		 5316 [ALC269_FIXUP_STEREO_DMIC] = {
5317 .type = ALC_FIXUP_FUNC,
5318 .v.func = alc269_fixup_stereo_dmic,
5319 },
24519911
TI		 5320 [ALC269_FIXUP_QUANTA_MUTE] = {
5321 .type = ALC_FIXUP_FUNC,
5322 .v.func = alc269_fixup_quanta_mute,
5323 },
5324 [ALC269_FIXUP_LIFEBOOK] = {
5325 .type = ALC_FIXUP_PINS,
5326 .v.pins = (const struct alc_pincfg[]) {
5327 { 0x1a, 0x2101103f }, /* dock line-out */
5328 { 0x1b, 0x23a11040 }, /* dock mic-in */
5329 { }
5330 },
5331 .chained = true,
5332 .chain_id = ALC269_FIXUP_QUANTA_MUTE
5333 },
a4297b5d
TI		 5334 [ALC269_FIXUP_AMIC] = {
5335 .type = ALC_FIXUP_PINS,
5336 .v.pins = (const struct alc_pincfg[]) {
5337 { 0x14, 0x99130110 }, /* speaker */
5338 { 0x15, 0x0121401f }, /* HP out */
5339 { 0x18, 0x01a19c20 }, /* mic */
5340 { 0x19, 0x99a3092f }, /* int-mic */
5341 { }
5342 },
5343 },
5344 [ALC269_FIXUP_DMIC] = {
5345 .type = ALC_FIXUP_PINS,
5346 .v.pins = (const struct alc_pincfg[]) {
5347 { 0x12, 0x99a3092f }, /* int-mic */
5348 { 0x14, 0x99130110 }, /* speaker */
5349 { 0x15, 0x0121401f }, /* HP out */
5350 { 0x18, 0x01a19c20 }, /* mic */
5351 { }
5352 },
5353 },
5354 [ALC269VB_FIXUP_AMIC] = {
5355 .type = ALC_FIXUP_PINS,
5356 .v.pins = (const struct alc_pincfg[]) {
5357 { 0x14, 0x99130110 }, /* speaker */
5358 { 0x18, 0x01a19c20 }, /* mic */
5359 { 0x19, 0x99a3092f }, /* int-mic */
5360 { 0x21, 0x0121401f }, /* HP out */
5361 { }
5362 },
5363 },
5364 [ALC269_FIXUP_DMIC] = {
5365 .type = ALC_FIXUP_PINS,
5366 .v.pins = (const struct alc_pincfg[]) {
5367 { 0x12, 0x99a3092f }, /* int-mic */
5368 { 0x14, 0x99130110 }, /* speaker */
5369 { 0x18, 0x01a19c20 }, /* mic */
5370 { 0x21, 0x0121401f }, /* HP out */
5371 { }
5372 },
5373 },
f1d4e28b
KY		 5374};
5375
1d045db9 5376static const struct snd_pci_quirk alc269_fixup_tbl[] = {
017f2a10 5377 SND_PCI_QUIRK(0x1043, 0x1a13, "Asus G73Jw", ALC269_FIXUP_ASUS_G73JW),
adabb3ec
TI		 5378 SND_PCI_QUIRK(0x1043, 0x16e3, "ASUS UX50", ALC269_FIXUP_STEREO_DMIC),
5379 SND_PCI_QUIRK(0x1043, 0x831a, "ASUS P901", ALC269_FIXUP_STEREO_DMIC),
5380 SND_PCI_QUIRK(0x1043, 0x834a, "ASUS S101", ALC269_FIXUP_STEREO_DMIC),
5381 SND_PCI_QUIRK(0x1043, 0x8398, "ASUS P1005", ALC269_FIXUP_STEREO_DMIC),
5382 SND_PCI_QUIRK(0x1043, 0x83ce, "ASUS P1005", ALC269_FIXUP_STEREO_DMIC),
1d045db9
TI		 5383 SND_PCI_QUIRK(0x104d, 0x9073, "Sony VAIO", ALC275_FIXUP_SONY_VAIO_GPIO2),
5384 SND_PCI_QUIRK(0x104d, 0x907b, "Sony VAIO", ALC275_FIXUP_SONY_HWEQ),
5385 SND_PCI_QUIRK(0x104d, 0x9084, "Sony VAIO", ALC275_FIXUP_SONY_HWEQ),
5386 SND_PCI_QUIRK_VENDOR(0x104d, "Sony VAIO", ALC269_FIXUP_SONY_VAIO),
5387 SND_PCI_QUIRK(0x1028, 0x0470, "Dell M101z", ALC269_FIXUP_DELL_M101Z),
5388 SND_PCI_QUIRK_VENDOR(0x1025, "Acer Aspire", ALC271_FIXUP_DMIC),
24519911 5389 SND_PCI_QUIRK(0x10cf, 0x1475, "Lifebook", ALC269_FIXUP_LIFEBOOK),
1d045db9
TI		 5390 SND_PCI_QUIRK(0x17aa, 0x20f2, "Thinkpad SL410/510", ALC269_FIXUP_SKU_IGNORE),
5391 SND_PCI_QUIRK(0x17aa, 0x215e, "Thinkpad L512", ALC269_FIXUP_SKU_IGNORE),
5392 SND_PCI_QUIRK(0x17aa, 0x21b8, "Thinkpad Edge 14", ALC269_FIXUP_SKU_IGNORE),
5393 SND_PCI_QUIRK(0x17aa, 0x21ca, "Thinkpad L412", ALC269_FIXUP_SKU_IGNORE),
5394 SND_PCI_QUIRK(0x17aa, 0x21e9, "Thinkpad Edge 15", ALC269_FIXUP_SKU_IGNORE),
24519911 5395 SND_PCI_QUIRK(0x17aa, 0x3bf8, "Quanta FL1", ALC269_FIXUP_QUANTA_MUTE),
017f2a10 5396 SND_PCI_QUIRK(0x17aa, 0x3bf8, "Lenovo Ideapd", ALC269_FIXUP_PCM_44K),
1d045db9 5397 SND_PCI_QUIRK(0x17aa, 0x9e54, "LENOVO NB", ALC269_FIXUP_LENOVO_EAPD),
a4297b5d
TI		 5398
5399#if 1
5400 /* Below is a quirk table taken from the old code.
5401 * Basically the device should work as is without the fixup table.
5402 * If BIOS doesn't give a proper info, enable the corresponding
5403 * fixup entry.
5404 */
5405 SND_PCI_QUIRK(0x1043, 0x8330, "ASUS Eeepc P703 P900A",
5406 ALC269_FIXUP_AMIC),
5407 SND_PCI_QUIRK(0x1043, 0x1013, "ASUS N61Da", ALC269_FIXUP_AMIC),
5408 SND_PCI_QUIRK(0x1043, 0x1113, "ASUS N63Jn", ALC269_FIXUP_AMIC),
5409 SND_PCI_QUIRK(0x1043, 0x1143, "ASUS B53f", ALC269_FIXUP_AMIC),
5410 SND_PCI_QUIRK(0x1043, 0x1133, "ASUS UJ20ft", ALC269_FIXUP_AMIC),
5411 SND_PCI_QUIRK(0x1043, 0x1183, "ASUS K72DR", ALC269_FIXUP_AMIC),
5412 SND_PCI_QUIRK(0x1043, 0x11b3, "ASUS K52DR", ALC269_FIXUP_AMIC),
5413 SND_PCI_QUIRK(0x1043, 0x11e3, "ASUS U33Jc", ALC269_FIXUP_AMIC),
5414 SND_PCI_QUIRK(0x1043, 0x1273, "ASUS UL80Jt", ALC269_FIXUP_AMIC),
5415 SND_PCI_QUIRK(0x1043, 0x1283, "ASUS U53Jc", ALC269_FIXUP_AMIC),
5416 SND_PCI_QUIRK(0x1043, 0x12b3, "ASUS N82JV", ALC269_FIXUP_AMIC),
5417 SND_PCI_QUIRK(0x1043, 0x12d3, "ASUS N61Jv", ALC269_FIXUP_AMIC),
5418 SND_PCI_QUIRK(0x1043, 0x13a3, "ASUS UL30Vt", ALC269_FIXUP_AMIC),
5419 SND_PCI_QUIRK(0x1043, 0x1373, "ASUS G73JX", ALC269_FIXUP_AMIC),
5420 SND_PCI_QUIRK(0x1043, 0x1383, "ASUS UJ30Jc", ALC269_FIXUP_AMIC),
5421 SND_PCI_QUIRK(0x1043, 0x13d3, "ASUS N61JA", ALC269_FIXUP_AMIC),
5422 SND_PCI_QUIRK(0x1043, 0x1413, "ASUS UL50", ALC269_FIXUP_AMIC),
5423 SND_PCI_QUIRK(0x1043, 0x1443, "ASUS UL30", ALC269_FIXUP_AMIC),
5424 SND_PCI_QUIRK(0x1043, 0x1453, "ASUS M60Jv", ALC269_FIXUP_AMIC),
5425 SND_PCI_QUIRK(0x1043, 0x1483, "ASUS UL80", ALC269_FIXUP_AMIC),
5426 SND_PCI_QUIRK(0x1043, 0x14f3, "ASUS F83Vf", ALC269_FIXUP_AMIC),
5427 SND_PCI_QUIRK(0x1043, 0x14e3, "ASUS UL20", ALC269_FIXUP_AMIC),
5428 SND_PCI_QUIRK(0x1043, 0x1513, "ASUS UX30", ALC269_FIXUP_AMIC),
5429 SND_PCI_QUIRK(0x1043, 0x1593, "ASUS N51Vn", ALC269_FIXUP_AMIC),
5430 SND_PCI_QUIRK(0x1043, 0x15a3, "ASUS N60Jv", ALC269_FIXUP_AMIC),
5431 SND_PCI_QUIRK(0x1043, 0x15b3, "ASUS N60Dp", ALC269_FIXUP_AMIC),
5432 SND_PCI_QUIRK(0x1043, 0x15c3, "ASUS N70De", ALC269_FIXUP_AMIC),
5433 SND_PCI_QUIRK(0x1043, 0x15e3, "ASUS F83T", ALC269_FIXUP_AMIC),
5434 SND_PCI_QUIRK(0x1043, 0x1643, "ASUS M60J", ALC269_FIXUP_AMIC),
5435 SND_PCI_QUIRK(0x1043, 0x1653, "ASUS U50", ALC269_FIXUP_AMIC),
5436 SND_PCI_QUIRK(0x1043, 0x1693, "ASUS F50N", ALC269_FIXUP_AMIC),
5437 SND_PCI_QUIRK(0x1043, 0x16a3, "ASUS F5Q", ALC269_FIXUP_AMIC),
5438 SND_PCI_QUIRK(0x1043, 0x1723, "ASUS P80", ALC269_FIXUP_AMIC),
5439 SND_PCI_QUIRK(0x1043, 0x1743, "ASUS U80", ALC269_FIXUP_AMIC),
5440 SND_PCI_QUIRK(0x1043, 0x1773, "ASUS U20A", ALC269_FIXUP_AMIC),
5441 SND_PCI_QUIRK(0x1043, 0x1883, "ASUS F81Se", ALC269_FIXUP_AMIC),
5442 SND_PCI_QUIRK(0x152d, 0x1778, "Quanta ON1", ALC269_FIXUP_DMIC),
5443 SND_PCI_QUIRK(0x17aa, 0x3be9, "Quanta Wistron", ALC269_FIXUP_AMIC),
5444 SND_PCI_QUIRK(0x17aa, 0x3bf8, "Quanta FL1", ALC269_FIXUP_AMIC),
5445 SND_PCI_QUIRK(0x17ff, 0x059a, "Quanta EL3", ALC269_FIXUP_DMIC),
5446 SND_PCI_QUIRK(0x17ff, 0x059b, "Quanta JR1", ALC269_FIXUP_DMIC),
5447#endif
5448 {}
5449};
5450
5451static const struct alc_model_fixup alc269_fixup_models[] = {
5452 {.id = ALC269_FIXUP_AMIC, .name = "laptop-amic"},
5453 {.id = ALC269_FIXUP_DMIC, .name = "laptop-dmic"},
1d045db9 5454 {}
6dda9f4a
KY		 5455};
5456
6dda9f4a 5457
1d045db9
TI		 5458static int alc269_fill_coef(struct hda_codec *codec)
5459{
5460 int val;
ebb83eeb 5461
1bb7e43e 5462 if ((alc_get_coef0(codec) & 0x00ff) < 0x015) {
1d045db9
TI		 5463 alc_write_coef_idx(codec, 0xf, 0x960b);
5464 alc_write_coef_idx(codec, 0xe, 0x8817);
5465 }
ebb83eeb 5466
1bb7e43e 5467 if ((alc_get_coef0(codec) & 0x00ff) == 0x016) {
1d045db9
TI		 5468 alc_write_coef_idx(codec, 0xf, 0x960b);
5469 alc_write_coef_idx(codec, 0xe, 0x8814);
5470 }
ebb83eeb 5471
1bb7e43e 5472 if ((alc_get_coef0(codec) & 0x00ff) == 0x017) {
1d045db9
TI		 5473 val = alc_read_coef_idx(codec, 0x04);
5474 /* Power up output pin */
5475 alc_write_coef_idx(codec, 0x04, val | (1<<11));
5476 }
ebb83eeb 5477
1bb7e43e 5478 if ((alc_get_coef0(codec) & 0x00ff) == 0x018) {
1d045db9
TI		 5479 val = alc_read_coef_idx(codec, 0xd);
5480 if ((val & 0x0c00) >> 10 != 0x1) {
5481 /* Capless ramp up clock control */
5482 alc_write_coef_idx(codec, 0xd, val | (1<<10));
5483 }
5484 val = alc_read_coef_idx(codec, 0x17);
5485 if ((val & 0x01c0) >> 6 != 0x4) {
5486 /* Class D power on reset */
5487 alc_write_coef_idx(codec, 0x17, val | (1<<7));
5488 }
5489 }
ebb83eeb 5490
1d045db9
TI		 5491 val = alc_read_coef_idx(codec, 0xd); /* Class D */
5492 alc_write_coef_idx(codec, 0xd, val | (1<<14));
bc9f98a9 5493
1d045db9
TI		 5494 val = alc_read_coef_idx(codec, 0x4); /* HP */
5495 alc_write_coef_idx(codec, 0x4, val | (1<<11));
6dda9f4a 5496
1d045db9
TI		 5497 return 0;
5498}
a7f2371f 5499
1d045db9
TI		 5500/*
5501 */
1d045db9
TI		 5502static int patch_alc269(struct hda_codec *codec)
5503{
5504 struct alc_spec *spec;
20ca0c35 5505 int err = 0;
291702f0 5506
1d045db9
TI		 5507 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
5508 if (spec == NULL)
5509 return -ENOMEM;
bc9f98a9 5510
1d045db9 5511 codec->spec = spec;
8c427226 5512
1d045db9 5513 spec->mixer_nid = 0x0b;
f1d4e28b 5514
1d045db9 5515 alc_auto_parse_customize_define(codec);
f1d4e28b 5516
e16fb6d1
TI		 5517 err = alc_codec_rename_from_preset(codec);
5518 if (err < 0)
5519 goto error;
5520
1d045db9
TI		 5521 if (codec->vendor_id == 0x10ec0269) {
5522 spec->codec_variant = ALC269_TYPE_ALC269VA;
1bb7e43e
TI		 5523 switch (alc_get_coef0(codec) & 0x00f0) {
5524 case 0x0010:
1d045db9 5525 if (codec->bus->pci->subsystem_vendor == 0x1025 &&
e16fb6d1 5526 spec->cdefine.platform_type == 1)
20ca0c35 5527 err = alc_codec_rename(codec, "ALC271X");
1d045db9 5528 spec->codec_variant = ALC269_TYPE_ALC269VB;
1bb7e43e
TI		 5529 break;
5530 case 0x0020:
e16fb6d1
TI		 5531 if (codec->bus->pci->subsystem_vendor == 0x17aa &&
5532 codec->bus->pci->subsystem_device == 0x21f3)
20ca0c35 5533 err = alc_codec_rename(codec, "ALC3202");
1d045db9 5534 spec->codec_variant = ALC269_TYPE_ALC269VC;
1bb7e43e
TI		 5535 break;
5536 default:
1d045db9 5537 alc_fix_pll_init(codec, 0x20, 0x04, 15);
1bb7e43e 5538 }
e16fb6d1
TI		 5539 if (err < 0)
5540 goto error;
1d045db9
TI		 5541 alc269_fill_coef(codec);
5542 }
6dda9f4a 5543
a4297b5d
TI		 5544 alc_pick_fixup(codec, alc269_fixup_models,
5545 alc269_fixup_tbl, alc269_fixups);
5546 alc_apply_fixup(codec, ALC_FIXUP_ACT_PRE_PROBE);
6dda9f4a 5547
a4297b5d
TI		 5548 /* automatic parse from the BIOS config */
5549 err = alc269_parse_auto_config(codec);
e16fb6d1
TI		 5550 if (err < 0)
5551 goto error;
6dda9f4a 5552
60a6a842 5553 if (!spec->no_analog && !spec->adc_nids) {
1d045db9
TI		 5554 alc_auto_fill_adc_caps(codec);
5555 alc_rebuild_imux_for_auto_mic(codec);
5556 alc_remove_invalid_adc_nids(codec);
5557 }
6dda9f4a 5558
3e6179b8 5559 if (!spec->no_analog && !spec->cap_mixer)
1d045db9 5560 set_capture_mixer(codec);
3e6179b8
TI		 5561
5562 if (!spec->no_analog && has_cdefine_beep(codec)) {
5563 err = snd_hda_attach_beep_device(codec, 0x1);
e16fb6d1
TI		 5564 if (err < 0)
5565 goto error;
1d045db9 5566 set_beep_amp(spec, 0x0b, 0x04, HDA_INPUT);
3e6179b8 5567 }
f1d4e28b 5568
1d045db9 5569 alc_apply_fixup(codec, ALC_FIXUP_ACT_PROBE);
622e84cd 5570
1d045db9 5571 spec->vmaster_nid = 0x02;
622e84cd 5572
1d045db9 5573 codec->patch_ops = alc_patch_ops;
2a43952a 5574#ifdef CONFIG_PM
1d045db9
TI		 5575 codec->patch_ops.resume = alc269_resume;
5576#endif
a4297b5d 5577 spec->init_hook = alc_auto_init_std;
1d045db9 5578 spec->shutup = alc269_shutup;
ebb83eeb 5579
1d045db9
TI		 5580 alc_init_jacks(codec);
5581#ifdef CONFIG_SND_HDA_POWER_SAVE
5582 if (!spec->loopback.amplist)
5583 spec->loopback.amplist = alc269_loopbacks;
5584 if (alc269_mic2_for_mute_led(codec))
5585 codec->patch_ops.check_power_status = alc269_mic2_mute_check_ps;
5586#endif
ebb83eeb 5587
1d045db9 5588 return 0;
e16fb6d1
TI		 5589
5590 error:
5591 alc_free(codec);
5592 return err;
1d045db9 5593}
f1d4e28b 5594
1d045db9
TI		 5595/*
5596 * ALC861
5597 */
622e84cd 5598
1d045db9 5599static int alc861_parse_auto_config(struct hda_codec *codec)
6dda9f4a 5600{
1d045db9 5601 static const hda_nid_t alc861_ignore[] = { 0x1d, 0 };
3e6179b8
TI		 5602 static const hda_nid_t alc861_ssids[] = { 0x0e, 0x0f, 0x0b, 0 };
5603 return alc_parse_auto_config(codec, alc861_ignore, alc861_ssids);
604401a9
TI		 5604}
5605
1d045db9
TI		 5606#ifdef CONFIG_SND_HDA_POWER_SAVE
5607static const struct hda_amp_list alc861_loopbacks[] = {
5608 { 0x15, HDA_INPUT, 0 },
5609 { 0x15, HDA_INPUT, 1 },
5610 { 0x15, HDA_INPUT, 2 },
5611 { 0x15, HDA_INPUT, 3 },
5612 { } /* end */
5613};
5614#endif
ce764ab2 5615
ce764ab2 5616
1d045db9
TI		 5617/* Pin config fixes */
5618enum {
5619 PINFIX_FSC_AMILO_PI1505,
5620};
7085ec12 5621
1d045db9
TI		 5622static const struct alc_fixup alc861_fixups[] = {
5623 [PINFIX_FSC_AMILO_PI1505] = {
5624 .type = ALC_FIXUP_PINS,
5625 .v.pins = (const struct alc_pincfg[]) {
5626 { 0x0b, 0x0221101f }, /* HP */
5627 { 0x0f, 0x90170310 }, /* speaker */
5628 { }
5629 }
5630 },
5631};
7085ec12 5632
1d045db9
TI		 5633static const struct snd_pci_quirk alc861_fixup_tbl[] = {
5634 SND_PCI_QUIRK(0x1734, 0x10c7, "FSC Amilo Pi1505", PINFIX_FSC_AMILO_PI1505),
5635 {}
5636};
3af9ee6b 5637
1d045db9
TI		 5638/*
5639 */
1d045db9 5640static int patch_alc861(struct hda_codec *codec)
7085ec12 5641{
1d045db9 5642 struct alc_spec *spec;
1d045db9 5643 int err;
7085ec12 5644
1d045db9
TI		 5645 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
5646 if (spec == NULL)
5647 return -ENOMEM;
3af9ee6b 5648
1d045db9
TI		 5649 codec->spec = spec;
5650
5651 spec->mixer_nid = 0x15;
5652
cb4e4824
TI		 5653 alc_pick_fixup(codec, NULL, alc861_fixup_tbl, alc861_fixups);
5654 alc_apply_fixup(codec, ALC_FIXUP_ACT_PRE_PROBE);
3af9ee6b 5655
cb4e4824
TI		 5656 /* automatic parse from the BIOS config */
5657 err = alc861_parse_auto_config(codec);
e16fb6d1
TI		 5658 if (err < 0)
5659 goto error;
3af9ee6b 5660
60a6a842 5661 if (!spec->no_analog && !spec->adc_nids) {
1d045db9
TI		 5662 alc_auto_fill_adc_caps(codec);
5663 alc_rebuild_imux_for_auto_mic(codec);
5664 alc_remove_invalid_adc_nids(codec);
5665 }
7085ec12 5666
3e6179b8 5667 if (!spec->no_analog && !spec->cap_mixer)
1d045db9 5668 set_capture_mixer(codec);
3e6179b8
TI		 5669
5670 if (!spec->no_analog) {
5671 err = snd_hda_attach_beep_device(codec, 0x23);
e16fb6d1
TI		 5672 if (err < 0)
5673 goto error;
3e6179b8
TI		 5674 set_beep_amp(spec, 0x23, 0, HDA_OUTPUT);
5675 }
7085ec12 5676
1d045db9 5677 spec->vmaster_nid = 0x03;
97aaab7b 5678
1d045db9
TI		 5679 alc_apply_fixup(codec, ALC_FIXUP_ACT_PROBE);
5680
5681 codec->patch_ops = alc_patch_ops;
cb4e4824 5682 spec->init_hook = alc_auto_init_std;
1d045db9 5683#ifdef CONFIG_SND_HDA_POWER_SAVE
cb4e4824 5684 spec->power_hook = alc_power_eapd;
1d045db9
TI		 5685 if (!spec->loopback.amplist)
5686 spec->loopback.amplist = alc861_loopbacks;
5687#endif
5688
5689 return 0;
e16fb6d1
TI		 5690
5691 error:
5692 alc_free(codec);
5693 return err;
7085ec12
TI		 5694}
5695
1d045db9
TI		 5696/*
5697 * ALC861-VD support
5698 *
5699 * Based on ALC882
5700 *
5701 * In addition, an independent DAC
5702 */
5703#ifdef CONFIG_SND_HDA_POWER_SAVE
5704#define alc861vd_loopbacks alc880_loopbacks
5705#endif
5706
1d045db9 5707static int alc861vd_parse_auto_config(struct hda_codec *codec)
bc9f98a9 5708{
1d045db9 5709 static const hda_nid_t alc861vd_ignore[] = { 0x1d, 0 };
3e6179b8
TI		 5710 static const hda_nid_t alc861vd_ssids[] = { 0x15, 0x1b, 0x14, 0 };
5711 return alc_parse_auto_config(codec, alc861vd_ignore, alc861vd_ssids);
ce764ab2
TI		 5712}
5713
1d045db9 5714enum {
8fdcb6fe
TI		 5715 ALC660VD_FIX_ASUS_GPIO1,
5716 ALC861VD_FIX_DALLAS,
1d045db9 5717};
ce764ab2 5718
8fdcb6fe
TI		 5719/* exclude VREF80 */
5720static void alc861vd_fixup_dallas(struct hda_codec *codec,
5721 const struct alc_fixup *fix, int action)
5722{
5723 if (action == ALC_FIXUP_ACT_PRE_PROBE) {
5724 snd_hda_override_pin_caps(codec, 0x18, 0x00001714);
5725 snd_hda_override_pin_caps(codec, 0x19, 0x0000171c);
5726 }
5727}
5728
1d045db9
TI		 5729static const struct alc_fixup alc861vd_fixups[] = {
5730 [ALC660VD_FIX_ASUS_GPIO1] = {
5731 .type = ALC_FIXUP_VERBS,
5732 .v.verbs = (const struct hda_verb[]) {
8fdcb6fe 5733 /* reset GPIO1 */
1d045db9
TI		 5734 {0x01, AC_VERB_SET_GPIO_MASK, 0x03},
5735 {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
5736 {0x01, AC_VERB_SET_GPIO_DATA, 0x01},
5737 { }
5738 }
5739 },
8fdcb6fe
TI		 5740 [ALC861VD_FIX_DALLAS] = {
5741 .type = ALC_FIXUP_FUNC,
5742 .v.func = alc861vd_fixup_dallas,
5743 },
1d045db9 5744};
ce764ab2 5745
1d045db9 5746static const struct snd_pci_quirk alc861vd_fixup_tbl[] = {
8fdcb6fe 5747 SND_PCI_QUIRK(0x103c, 0x30bf, "HP TX1000", ALC861VD_FIX_DALLAS),
1d045db9 5748 SND_PCI_QUIRK(0x1043, 0x1339, "ASUS A7-K", ALC660VD_FIX_ASUS_GPIO1),
8fdcb6fe 5749 SND_PCI_QUIRK(0x1179, 0xff31, "Toshiba L30-149", ALC861VD_FIX_DALLAS),
1d045db9
TI		 5750 {}
5751};
ce764ab2 5752
1d045db9
TI		 5753static const struct hda_verb alc660vd_eapd_verbs[] = {
5754 {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
5755 {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
5756 { }
ce764ab2
TI		 5757};
5758
1d045db9
TI		 5759/*
5760 */
1d045db9 5761static int patch_alc861vd(struct hda_codec *codec)
ce764ab2 5762{
1d045db9 5763 struct alc_spec *spec;
cb4e4824 5764 int err;
ce764ab2 5765
1d045db9
TI		 5766 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
5767 if (spec == NULL)
5768 return -ENOMEM;
5769
5770 codec->spec = spec;
5771
5772 spec->mixer_nid = 0x0b;
5773
cb4e4824
TI		 5774 alc_pick_fixup(codec, NULL, alc861vd_fixup_tbl, alc861vd_fixups);
5775 alc_apply_fixup(codec, ALC_FIXUP_ACT_PRE_PROBE);
1d045db9 5776
cb4e4824
TI		 5777 /* automatic parse from the BIOS config */
5778 err = alc861vd_parse_auto_config(codec);
e16fb6d1
TI		 5779 if (err < 0)
5780 goto error;
ce764ab2 5781
1d045db9
TI		 5782 if (codec->vendor_id == 0x10ec0660) {
5783 /* always turn on EAPD */
5784 add_verb(spec, alc660vd_eapd_verbs);
5785 }
5786
60a6a842 5787 if (!spec->no_analog && !spec->adc_nids) {
1d045db9
TI		 5788 alc_auto_fill_adc_caps(codec);
5789 alc_rebuild_imux_for_auto_mic(codec);
5790 alc_remove_invalid_adc_nids(codec);
ce764ab2 5791 }
1d045db9 5792
3e6179b8
TI		 5793 if (!spec->no_analog && !spec->cap_mixer)
5794 set_capture_mixer(codec);
5795
5796 if (!spec->no_analog) {
5797 err = snd_hda_attach_beep_device(codec, 0x23);
e16fb6d1
TI		 5798 if (err < 0)
5799 goto error;
3e6179b8
TI		 5800 set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
5801 }
1d045db9
TI		 5802
5803 spec->vmaster_nid = 0x02;
5804
5805 alc_apply_fixup(codec, ALC_FIXUP_ACT_PROBE);
5806
5807 codec->patch_ops = alc_patch_ops;
5808
cb4e4824 5809 spec->init_hook = alc_auto_init_std;
1d045db9
TI		 5810 spec->shutup = alc_eapd_shutup;
5811#ifdef CONFIG_SND_HDA_POWER_SAVE
5812 if (!spec->loopback.amplist)
5813 spec->loopback.amplist = alc861vd_loopbacks;
5814#endif
5815
ce764ab2 5816 return 0;
e16fb6d1
TI		 5817
5818 error:
5819 alc_free(codec);
5820 return err;
ce764ab2
TI		 5821}
5822
1d045db9
TI		 5823/*
5824 * ALC662 support
5825 *
5826 * ALC662 is almost identical with ALC880 but has cleaner and more flexible
5827 * configuration. Each pin widget can choose any input DACs and a mixer.
5828 * Each ADC is connected from a mixer of all inputs. This makes possible
5829 * 6-channel independent captures.
5830 *
5831 * In addition, an independent DAC for the multi-playback (not used in this
5832 * driver yet).
5833 */
5834#ifdef CONFIG_SND_HDA_POWER_SAVE
5835#define alc662_loopbacks alc880_loopbacks
5836#endif
5837
5838/*
5839 * BIOS auto configuration
5840 */
5841
bc9f98a9
KY		 5842static int alc662_parse_auto_config(struct hda_codec *codec)
5843{
4c6d72d1 5844 static const hda_nid_t alc662_ignore[] = { 0x1d, 0 };
3e6179b8
TI		 5845 static const hda_nid_t alc663_ssids[] = { 0x15, 0x1b, 0x14, 0x21 };
5846 static const hda_nid_t alc662_ssids[] = { 0x15, 0x1b, 0x14, 0 };
5847 const hda_nid_t *ssids;
ee979a14 5848
6227cdce
KY		 5849 if (codec->vendor_id == 0x10ec0272 || codec->vendor_id == 0x10ec0663 ||
5850 codec->vendor_id == 0x10ec0665 || codec->vendor_id == 0x10ec0670)
3e6179b8 5851 ssids = alc663_ssids;
6227cdce 5852 else
3e6179b8
TI		 5853 ssids = alc662_ssids;
5854 return alc_parse_auto_config(codec, alc662_ignore, ssids);
bc9f98a9
KY		 5855}
5856
6be7948f 5857static void alc272_fixup_mario(struct hda_codec *codec,
b5bfbc67 5858 const struct alc_fixup *fix, int action)
6fc398cb 5859{
b5bfbc67 5860 if (action != ALC_FIXUP_ACT_PROBE)
6fc398cb 5861 return;
6be7948f
TB		 5862 if (snd_hda_override_amp_caps(codec, 0x2, HDA_OUTPUT,
5863 (0x3b << AC_AMPCAP_OFFSET_SHIFT) |
5864 (0x3b << AC_AMPCAP_NUM_STEPS_SHIFT) |
5865 (0x03 << AC_AMPCAP_STEP_SIZE_SHIFT) |
5866 (0 << AC_AMPCAP_MUTE_SHIFT)))
5867 printk(KERN_WARNING
5868 "hda_codec: failed to override amp caps for NID 0x2\n");
5869}
5870
6cb3b707 5871enum {
2df03514 5872 ALC662_FIXUP_ASPIRE,
6cb3b707 5873 ALC662_FIXUP_IDEAPAD,
6be7948f 5874 ALC272_FIXUP_MARIO,
d2ebd479 5875 ALC662_FIXUP_CZC_P10T,
94024cd1 5876 ALC662_FIXUP_SKU_IGNORE,
e59ea3ed 5877 ALC662_FIXUP_HP_RP5800,
53c334ad
TI		 5878 ALC662_FIXUP_ASUS_MODE1,
5879 ALC662_FIXUP_ASUS_MODE2,
5880 ALC662_FIXUP_ASUS_MODE3,
5881 ALC662_FIXUP_ASUS_MODE4,
5882 ALC662_FIXUP_ASUS_MODE5,
5883 ALC662_FIXUP_ASUS_MODE6,
5884 ALC662_FIXUP_ASUS_MODE7,
5885 ALC662_FIXUP_ASUS_MODE8,
6cb3b707
DH		 5886};
5887
5888static const struct alc_fixup alc662_fixups[] = {
2df03514 5889 [ALC662_FIXUP_ASPIRE] = {
b5bfbc67
TI		 5890 .type = ALC_FIXUP_PINS,
5891 .v.pins = (const struct alc_pincfg[]) {
2df03514
DC		 5892 { 0x15, 0x99130112 }, /* subwoofer */
5893 { }
5894 }
5895 },
6cb3b707 5896 [ALC662_FIXUP_IDEAPAD] = {
b5bfbc67
TI		 5897 .type = ALC_FIXUP_PINS,
5898 .v.pins = (const struct alc_pincfg[]) {
6cb3b707
DH		 5899 { 0x17, 0x99130112 }, /* subwoofer */
5900 { }
5901 }
5902 },
6be7948f 5903 [ALC272_FIXUP_MARIO] = {
b5bfbc67
TI		 5904 .type = ALC_FIXUP_FUNC,
5905 .v.func = alc272_fixup_mario,
d2ebd479
AA		 5906 },
5907 [ALC662_FIXUP_CZC_P10T] = {
5908 .type = ALC_FIXUP_VERBS,
5909 .v.verbs = (const struct hda_verb[]) {
5910 {0x14, AC_VERB_SET_EAPD_BTLENABLE, 0},
5911 {}
5912 }
5913 },
94024cd1
DH		 5914 [ALC662_FIXUP_SKU_IGNORE] = {
5915 .type = ALC_FIXUP_SKU,
5916 .v.sku = ALC_FIXUP_SKU_IGNORE,
c6b35874 5917 },
e59ea3ed
TI		 5918 [ALC662_FIXUP_HP_RP5800] = {
5919 .type = ALC_FIXUP_PINS,
5920 .v.pins = (const struct alc_pincfg[]) {
5921 { 0x14, 0x0221201f }, /* HP out */
5922 { }
5923 },
5924 .chained = true,
5925 .chain_id = ALC662_FIXUP_SKU_IGNORE
5926 },
53c334ad
TI		 5927 [ALC662_FIXUP_ASUS_MODE1] = {
5928 .type = ALC_FIXUP_PINS,
5929 .v.pins = (const struct alc_pincfg[]) {
5930 { 0x14, 0x99130110 }, /* speaker */
5931 { 0x18, 0x01a19c20 }, /* mic */
5932 { 0x19, 0x99a3092f }, /* int-mic */
5933 { 0x21, 0x0121401f }, /* HP out */
5934 { }
5935 },
5936 .chained = true,
5937 .chain_id = ALC662_FIXUP_SKU_IGNORE
5938 },
5939 [ALC662_FIXUP_ASUS_MODE2] = {
2996bdba
TI		 5940 .type = ALC_FIXUP_PINS,
5941 .v.pins = (const struct alc_pincfg[]) {
5942 { 0x14, 0x99130110 }, /* speaker */
5943 { 0x18, 0x01a19820 }, /* mic */
5944 { 0x19, 0x99a3092f }, /* int-mic */
5945 { 0x1b, 0x0121401f }, /* HP out */
5946 { }
5947 },
53c334ad
TI		 5948 .chained = true,
5949 .chain_id = ALC662_FIXUP_SKU_IGNORE
5950 },
5951 [ALC662_FIXUP_ASUS_MODE3] = {
5952 .type = ALC_FIXUP_PINS,
5953 .v.pins = (const struct alc_pincfg[]) {
5954 { 0x14, 0x99130110 }, /* speaker */
5955 { 0x15, 0x0121441f }, /* HP */
5956 { 0x18, 0x01a19840 }, /* mic */
5957 { 0x19, 0x99a3094f }, /* int-mic */
5958 { 0x21, 0x01211420 }, /* HP2 */
5959 { }
5960 },
5961 .chained = true,
5962 .chain_id = ALC662_FIXUP_SKU_IGNORE
5963 },
5964 [ALC662_FIXUP_ASUS_MODE4] = {
5965 .type = ALC_FIXUP_PINS,
5966 .v.pins = (const struct alc_pincfg[]) {
5967 { 0x14, 0x99130110 }, /* speaker */
5968 { 0x16, 0x99130111 }, /* speaker */
5969 { 0x18, 0x01a19840 }, /* mic */
5970 { 0x19, 0x99a3094f }, /* int-mic */
5971 { 0x21, 0x0121441f }, /* HP */
5972 { }
5973 },
5974 .chained = true,
5975 .chain_id = ALC662_FIXUP_SKU_IGNORE
5976 },
5977 [ALC662_FIXUP_ASUS_MODE5] = {
5978 .type = ALC_FIXUP_PINS,
5979 .v.pins = (const struct alc_pincfg[]) {
5980 { 0x14, 0x99130110 }, /* speaker */
5981 { 0x15, 0x0121441f }, /* HP */
5982 { 0x16, 0x99130111 }, /* speaker */
5983 { 0x18, 0x01a19840 }, /* mic */
5984 { 0x19, 0x99a3094f }, /* int-mic */
5985 { }
5986 },
5987 .chained = true,
5988 .chain_id = ALC662_FIXUP_SKU_IGNORE
5989 },
5990 [ALC662_FIXUP_ASUS_MODE6] = {
5991 .type = ALC_FIXUP_PINS,
5992 .v.pins = (const struct alc_pincfg[]) {
5993 { 0x14, 0x99130110 }, /* speaker */
5994 { 0x15, 0x01211420 }, /* HP2 */
5995 { 0x18, 0x01a19840 }, /* mic */
5996 { 0x19, 0x99a3094f }, /* int-mic */
5997 { 0x1b, 0x0121441f }, /* HP */
5998 { }
5999 },
6000 .chained = true,
6001 .chain_id = ALC662_FIXUP_SKU_IGNORE
6002 },
6003 [ALC662_FIXUP_ASUS_MODE7] = {
6004 .type = ALC_FIXUP_PINS,
6005 .v.pins = (const struct alc_pincfg[]) {
6006 { 0x14, 0x99130110 }, /* speaker */
6007 { 0x17, 0x99130111 }, /* speaker */
6008 { 0x18, 0x01a19840 }, /* mic */
6009 { 0x19, 0x99a3094f }, /* int-mic */
6010 { 0x1b, 0x01214020 }, /* HP */
6011 { 0x21, 0x0121401f }, /* HP */
6012 { }
6013 },
6014 .chained = true,
6015 .chain_id = ALC662_FIXUP_SKU_IGNORE
6016 },
6017 [ALC662_FIXUP_ASUS_MODE8] = {
6018 .type = ALC_FIXUP_PINS,
6019 .v.pins = (const struct alc_pincfg[]) {
6020 { 0x14, 0x99130110 }, /* speaker */
6021 { 0x12, 0x99a30970 }, /* int-mic */
6022 { 0x15, 0x01214020 }, /* HP */
6023 { 0x17, 0x99130111 }, /* speaker */
6024 { 0x18, 0x01a19840 }, /* mic */
6025 { 0x21, 0x0121401f }, /* HP */
6026 { }
6027 },
6028 .chained = true,
6029 .chain_id = ALC662_FIXUP_SKU_IGNORE
2996bdba 6030 },
6cb3b707
DH		 6031};
6032
a9111321 6033static const struct snd_pci_quirk alc662_fixup_tbl[] = {
53c334ad 6034 SND_PCI_QUIRK(0x1019, 0x9087, "ECS", ALC662_FIXUP_ASUS_MODE2),
a6c47a85 6035 SND_PCI_QUIRK(0x1025, 0x0308, "Acer Aspire 8942G", ALC662_FIXUP_ASPIRE),
94024cd1 6036 SND_PCI_QUIRK(0x1025, 0x031c, "Gateway NV79", ALC662_FIXUP_SKU_IGNORE),
2df03514 6037 SND_PCI_QUIRK(0x1025, 0x038b, "Acer Aspire 8943G", ALC662_FIXUP_ASPIRE),
e59ea3ed 6038 SND_PCI_QUIRK(0x103c, 0x1632, "HP RP5800", ALC662_FIXUP_HP_RP5800),
53c334ad 6039 SND_PCI_QUIRK(0x105b, 0x0cd6, "Foxconn", ALC662_FIXUP_ASUS_MODE2),
a0e90acc 6040 SND_PCI_QUIRK(0x144d, 0xc051, "Samsung R720", ALC662_FIXUP_IDEAPAD),
d4118588 6041 SND_PCI_QUIRK(0x17aa, 0x38af, "Lenovo Ideapad Y550P", ALC662_FIXUP_IDEAPAD),
6cb3b707 6042 SND_PCI_QUIRK(0x17aa, 0x3a0d, "Lenovo Ideapad Y550", ALC662_FIXUP_IDEAPAD),
d2ebd479 6043 SND_PCI_QUIRK(0x1b35, 0x2206, "CZC P10T", ALC662_FIXUP_CZC_P10T),
53c334ad
TI		 6044
6045#if 0
6046 /* Below is a quirk table taken from the old code.
6047 * Basically the device should work as is without the fixup table.
6048 * If BIOS doesn't give a proper info, enable the corresponding
6049 * fixup entry.
6050 */
6051 SND_PCI_QUIRK(0x1043, 0x1000, "ASUS N50Vm", ALC662_FIXUP_ASUS_MODE1),
6052 SND_PCI_QUIRK(0x1043, 0x1092, "ASUS NB", ALC662_FIXUP_ASUS_MODE3),
6053 SND_PCI_QUIRK(0x1043, 0x1173, "ASUS K73Jn", ALC662_FIXUP_ASUS_MODE1),
6054 SND_PCI_QUIRK(0x1043, 0x11c3, "ASUS M70V", ALC662_FIXUP_ASUS_MODE3),
6055 SND_PCI_QUIRK(0x1043, 0x11d3, "ASUS NB", ALC662_FIXUP_ASUS_MODE1),
6056 SND_PCI_QUIRK(0x1043, 0x11f3, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
6057 SND_PCI_QUIRK(0x1043, 0x1203, "ASUS NB", ALC662_FIXUP_ASUS_MODE1),
6058 SND_PCI_QUIRK(0x1043, 0x1303, "ASUS G60J", ALC662_FIXUP_ASUS_MODE1),
6059 SND_PCI_QUIRK(0x1043, 0x1333, "ASUS G60Jx", ALC662_FIXUP_ASUS_MODE1),
6060 SND_PCI_QUIRK(0x1043, 0x1339, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
6061 SND_PCI_QUIRK(0x1043, 0x13e3, "ASUS N71JA", ALC662_FIXUP_ASUS_MODE7),
6062 SND_PCI_QUIRK(0x1043, 0x1463, "ASUS N71", ALC662_FIXUP_ASUS_MODE7),
6063 SND_PCI_QUIRK(0x1043, 0x14d3, "ASUS G72", ALC662_FIXUP_ASUS_MODE8),
6064 SND_PCI_QUIRK(0x1043, 0x1563, "ASUS N90", ALC662_FIXUP_ASUS_MODE3),
6065 SND_PCI_QUIRK(0x1043, 0x15d3, "ASUS N50SF F50SF", ALC662_FIXUP_ASUS_MODE1),
6066 SND_PCI_QUIRK(0x1043, 0x16c3, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
6067 SND_PCI_QUIRK(0x1043, 0x16f3, "ASUS K40C K50C", ALC662_FIXUP_ASUS_MODE2),
6068 SND_PCI_QUIRK(0x1043, 0x1733, "ASUS N81De", ALC662_FIXUP_ASUS_MODE1),
6069 SND_PCI_QUIRK(0x1043, 0x1753, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
6070 SND_PCI_QUIRK(0x1043, 0x1763, "ASUS NB", ALC662_FIXUP_ASUS_MODE6),
6071 SND_PCI_QUIRK(0x1043, 0x1765, "ASUS NB", ALC662_FIXUP_ASUS_MODE6),
6072 SND_PCI_QUIRK(0x1043, 0x1783, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
6073 SND_PCI_QUIRK(0x1043, 0x1793, "ASUS F50GX", ALC662_FIXUP_ASUS_MODE1),
6074 SND_PCI_QUIRK(0x1043, 0x17b3, "ASUS F70SL", ALC662_FIXUP_ASUS_MODE3),
6075 SND_PCI_QUIRK(0x1043, 0x17f3, "ASUS X58LE", ALC662_FIXUP_ASUS_MODE2),
6076 SND_PCI_QUIRK(0x1043, 0x1813, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
6077 SND_PCI_QUIRK(0x1043, 0x1823, "ASUS NB", ALC662_FIXUP_ASUS_MODE5),
6078 SND_PCI_QUIRK(0x1043, 0x1833, "ASUS NB", ALC662_FIXUP_ASUS_MODE6),
6079 SND_PCI_QUIRK(0x1043, 0x1843, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
6080 SND_PCI_QUIRK(0x1043, 0x1853, "ASUS F50Z", ALC662_FIXUP_ASUS_MODE1),
6081 SND_PCI_QUIRK(0x1043, 0x1864, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
6082 SND_PCI_QUIRK(0x1043, 0x1876, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
6083 SND_PCI_QUIRK(0x1043, 0x1893, "ASUS M50Vm", ALC662_FIXUP_ASUS_MODE3),
6084 SND_PCI_QUIRK(0x1043, 0x1894, "ASUS X55", ALC662_FIXUP_ASUS_MODE3),
6085 SND_PCI_QUIRK(0x1043, 0x18b3, "ASUS N80Vc", ALC662_FIXUP_ASUS_MODE1),
6086 SND_PCI_QUIRK(0x1043, 0x18c3, "ASUS VX5", ALC662_FIXUP_ASUS_MODE1),
6087 SND_PCI_QUIRK(0x1043, 0x18d3, "ASUS N81Te", ALC662_FIXUP_ASUS_MODE1),
6088 SND_PCI_QUIRK(0x1043, 0x18f3, "ASUS N505Tp", ALC662_FIXUP_ASUS_MODE1),
6089 SND_PCI_QUIRK(0x1043, 0x1903, "ASUS F5GL", ALC662_FIXUP_ASUS_MODE1),
6090 SND_PCI_QUIRK(0x1043, 0x1913, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
6091 SND_PCI_QUIRK(0x1043, 0x1933, "ASUS F80Q", ALC662_FIXUP_ASUS_MODE2),
6092 SND_PCI_QUIRK(0x1043, 0x1943, "ASUS Vx3V", ALC662_FIXUP_ASUS_MODE1),
6093 SND_PCI_QUIRK(0x1043, 0x1953, "ASUS NB", ALC662_FIXUP_ASUS_MODE1),
6094 SND_PCI_QUIRK(0x1043, 0x1963, "ASUS X71C", ALC662_FIXUP_ASUS_MODE3),
6095 SND_PCI_QUIRK(0x1043, 0x1983, "ASUS N5051A", ALC662_FIXUP_ASUS_MODE1),
6096 SND_PCI_QUIRK(0x1043, 0x1993, "ASUS N20", ALC662_FIXUP_ASUS_MODE1),
6097 SND_PCI_QUIRK(0x1043, 0x19b3, "ASUS F7Z", ALC662_FIXUP_ASUS_MODE1),
6098 SND_PCI_QUIRK(0x1043, 0x19c3, "ASUS F5Z/F6x", ALC662_FIXUP_ASUS_MODE2),
6099 SND_PCI_QUIRK(0x1043, 0x19e3, "ASUS NB", ALC662_FIXUP_ASUS_MODE1),
6100 SND_PCI_QUIRK(0x1043, 0x19f3, "ASUS NB", ALC662_FIXUP_ASUS_MODE4),
6101#endif
6cb3b707
DH		 6102 {}
6103};
6104
6be7948f
TB		 6105static const struct alc_model_fixup alc662_fixup_models[] = {
6106 {.id = ALC272_FIXUP_MARIO, .name = "mario"},
53c334ad
TI		 6107 {.id = ALC662_FIXUP_ASUS_MODE1, .name = "asus-mode1"},
6108 {.id = ALC662_FIXUP_ASUS_MODE2, .name = "asus-mode2"},
6109 {.id = ALC662_FIXUP_ASUS_MODE3, .name = "asus-mode3"},
6110 {.id = ALC662_FIXUP_ASUS_MODE4, .name = "asus-mode4"},
6111 {.id = ALC662_FIXUP_ASUS_MODE5, .name = "asus-mode5"},
6112 {.id = ALC662_FIXUP_ASUS_MODE6, .name = "asus-mode6"},
6113 {.id = ALC662_FIXUP_ASUS_MODE7, .name = "asus-mode7"},
6114 {.id = ALC662_FIXUP_ASUS_MODE8, .name = "asus-mode8"},
6be7948f
TB		 6115 {}
6116};
6cb3b707
DH		 6117
6118
1d045db9
TI		 6119/*
6120 */
bc9f98a9
KY		 6121static int patch_alc662(struct hda_codec *codec)
6122{
6123 struct alc_spec *spec;
20ca0c35 6124 int err = 0;
bc9f98a9
KY		 6125
6126 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
6127 if (!spec)
6128 return -ENOMEM;
6129
6130 codec->spec = spec;
6131
1f0f4b80
TI		 6132 spec->mixer_nid = 0x0b;
6133
53c334ad
TI		 6134 /* handle multiple HPs as is */
6135 spec->parse_flags = HDA_PINCFG_NO_HP_FIXUP;
6136
da00c244
KY		 6137 alc_auto_parse_customize_define(codec);
6138
2c3bf9ab
TI		 6139 alc_fix_pll_init(codec, 0x20, 0x04, 15);
6140
e16fb6d1
TI		 6141 err = alc_codec_rename_from_preset(codec);
6142 if (err < 0)
6143 goto error;
6144
1bb7e43e 6145 if ((alc_get_coef0(codec) & (1 << 14)) &&
e16fb6d1
TI		 6146 codec->bus->pci->subsystem_vendor == 0x1025 &&
6147 spec->cdefine.platform_type == 1) {
6148 if (alc_codec_rename(codec, "ALC272X") < 0)
6149 goto error;
20ca0c35 6150 }
274693f3 6151
b9c5106c
TI		 6152 alc_pick_fixup(codec, alc662_fixup_models,
6153 alc662_fixup_tbl, alc662_fixups);
6154 alc_apply_fixup(codec, ALC_FIXUP_ACT_PRE_PROBE);
6155 /* automatic parse from the BIOS config */
6156 err = alc662_parse_auto_config(codec);
e16fb6d1
TI		 6157 if (err < 0)
6158 goto error;
bc9f98a9 6159
60a6a842 6160 if (!spec->no_analog && !spec->adc_nids) {
d6cc9fab 6161 alc_auto_fill_adc_caps(codec);
21268961 6162 alc_rebuild_imux_for_auto_mic(codec);
d6cc9fab 6163 alc_remove_invalid_adc_nids(codec);
dd704698 6164 }
bc9f98a9 6165
3e6179b8 6166 if (!spec->no_analog && !spec->cap_mixer)
b59bdf3b 6167 set_capture_mixer(codec);
cec27c89 6168
3e6179b8
TI		 6169 if (!spec->no_analog && has_cdefine_beep(codec)) {
6170 err = snd_hda_attach_beep_device(codec, 0x1);
e16fb6d1
TI		 6171 if (err < 0)
6172 goto error;
da00c244
KY		 6173 switch (codec->vendor_id) {
6174 case 0x10ec0662:
6175 set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
6176 break;
6177 case 0x10ec0272:
6178 case 0x10ec0663:
6179 case 0x10ec0665:
6180 set_beep_amp(spec, 0x0b, 0x04, HDA_INPUT);
6181 break;
6182 case 0x10ec0273:
6183 set_beep_amp(spec, 0x0b, 0x03, HDA_INPUT);
6184 break;
6185 }
cec27c89 6186 }
2134ea4f
TI		 6187 spec->vmaster_nid = 0x02;
6188
b5bfbc67
TI		 6189 alc_apply_fixup(codec, ALC_FIXUP_ACT_PROBE);
6190
bc9f98a9 6191 codec->patch_ops = alc_patch_ops;
b9c5106c 6192 spec->init_hook = alc_auto_init_std;
1c716153 6193 spec->shutup = alc_eapd_shutup;
6cb3b707 6194
bf1b0225
KY		 6195 alc_init_jacks(codec);
6196
cb53c626
TI		 6197#ifdef CONFIG_SND_HDA_POWER_SAVE
6198 if (!spec->loopback.amplist)
6199 spec->loopback.amplist = alc662_loopbacks;
6200#endif
bc9f98a9
KY		 6201
6202 return 0;
801f49d3 6203
e16fb6d1
TI		 6204 error:
6205 alc_free(codec);
6206 return err;
b478b998
KY		 6207}
6208
d1eb57f4
KY		 6209/*
6210 * ALC680 support
6211 */
d1eb57f4 6212
d1eb57f4
KY		 6213static int alc680_parse_auto_config(struct hda_codec *codec)
6214{
3e6179b8 6215 return alc_parse_auto_config(codec, NULL, NULL);
d1eb57f4
KY		 6216}
6217
d1eb57f4 6218/*
d1eb57f4 6219 */
d1eb57f4
KY		 6220static int patch_alc680(struct hda_codec *codec)
6221{
6222 struct alc_spec *spec;
d1eb57f4
KY		 6223 int err;
6224
6225 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
6226 if (spec == NULL)
6227 return -ENOMEM;
6228
6229 codec->spec = spec;
6230
1f0f4b80
TI		 6231 /* ALC680 has no aa-loopback mixer */
6232
1ebec5f2
TI		 6233 /* automatic parse from the BIOS config */
6234 err = alc680_parse_auto_config(codec);
6235 if (err < 0) {
6236 alc_free(codec);
6237 return err;
d1eb57f4
KY		 6238 }
6239
3e6179b8 6240 if (!spec->no_analog && !spec->cap_mixer)
d1eb57f4
KY		 6241 set_capture_mixer(codec);
6242
6243 spec->vmaster_nid = 0x02;
6244
6245 codec->patch_ops = alc_patch_ops;
1ebec5f2 6246 spec->init_hook = alc_auto_init_std;
d1eb57f4
KY		 6247
6248 return 0;
6249}
6250
1da177e4
LT		 6251/*
6252 * patch entries
6253 */
a9111321 6254static const struct hda_codec_preset snd_hda_preset_realtek[] = {
296f0338 6255 { .id = 0x10ec0221, .name = "ALC221", .patch = patch_alc269 },
1da177e4 6256 { .id = 0x10ec0260, .name = "ALC260", .patch = patch_alc260 },
df694daa 6257 { .id = 0x10ec0262, .name = "ALC262", .patch = patch_alc262 },
f6a92248 6258 { .id = 0x10ec0267, .name = "ALC267", .patch = patch_alc268 },
a361d84b 6259 { .id = 0x10ec0268, .name = "ALC268", .patch = patch_alc268 },
f6a92248 6260 { .id = 0x10ec0269, .name = "ALC269", .patch = patch_alc269 },
ebb83eeb 6261 { .id = 0x10ec0270, .name = "ALC270", .patch = patch_alc269 },
01afd41f 6262 { .id = 0x10ec0272, .name = "ALC272", .patch = patch_alc662 },
ebb83eeb 6263 { .id = 0x10ec0275, .name = "ALC275", .patch = patch_alc269 },
296f0338 6264 { .id = 0x10ec0276, .name = "ALC276", .patch = patch_alc269 },
f32610ed 6265 { .id = 0x10ec0861, .rev = 0x100340, .name = "ALC660",
bc9f98a9 6266 .patch = patch_alc861 },
f32610ed
JS		 6267 { .id = 0x10ec0660, .name = "ALC660-VD", .patch = patch_alc861vd },
6268 { .id = 0x10ec0861, .name = "ALC861", .patch = patch_alc861 },
6269 { .id = 0x10ec0862, .name = "ALC861-VD", .patch = patch_alc861vd },
bc9f98a9 6270 { .id = 0x10ec0662, .rev = 0x100002, .name = "ALC662 rev2",
4953550a 6271 .patch = patch_alc882 },
bc9f98a9
KY		 6272 { .id = 0x10ec0662, .rev = 0x100101, .name = "ALC662 rev1",
6273 .patch = patch_alc662 },
cc667a72
DH		 6274 { .id = 0x10ec0662, .rev = 0x100300, .name = "ALC662 rev3",
6275 .patch = patch_alc662 },
6dda9f4a 6276 { .id = 0x10ec0663, .name = "ALC663", .patch = patch_alc662 },
cec27c89 6277 { .id = 0x10ec0665, .name = "ALC665", .patch = patch_alc662 },
6227cdce 6278 { .id = 0x10ec0670, .name = "ALC670", .patch = patch_alc662 },
d1eb57f4 6279 { .id = 0x10ec0680, .name = "ALC680", .patch = patch_alc680 },
f32610ed 6280 { .id = 0x10ec0880, .name = "ALC880", .patch = patch_alc880 },
1da177e4 6281 { .id = 0x10ec0882, .name = "ALC882", .patch = patch_alc882 },
4953550a 6282 { .id = 0x10ec0883, .name = "ALC883", .patch = patch_alc882 },
669faba2 6283 { .id = 0x10ec0885, .rev = 0x100101, .name = "ALC889A",
4953550a 6284 .patch = patch_alc882 },
cb308f97 6285 { .id = 0x10ec0885, .rev = 0x100103, .name = "ALC889A",
4953550a 6286 .patch = patch_alc882 },
df694daa 6287 { .id = 0x10ec0885, .name = "ALC885", .patch = patch_alc882 },
e16fb6d1 6288 { .id = 0x10ec0887, .name = "ALC887", .patch = patch_alc882 },
4442608d 6289 { .id = 0x10ec0888, .rev = 0x100101, .name = "ALC1200",
4953550a 6290 .patch = patch_alc882 },
e16fb6d1 6291 { .id = 0x10ec0888, .name = "ALC888", .patch = patch_alc882 },
4953550a 6292 { .id = 0x10ec0889, .name = "ALC889", .patch = patch_alc882 },
274693f3 6293 { .id = 0x10ec0892, .name = "ALC892", .patch = patch_alc662 },
e16fb6d1 6294 { .id = 0x10ec0899, .name = "ALC898", .patch = patch_alc882 },
1da177e4
LT		 6295 {} /* terminator */
6296};
1289e9e8
TI		 6297
6298MODULE_ALIAS("snd-hda-codec-id:10ec*");
6299
6300MODULE_LICENSE("GPL");
6301MODULE_DESCRIPTION("Realtek HD-audio codec");
6302
6303static struct hda_codec_preset_list realtek_list = {
6304 .preset = snd_hda_preset_realtek,
6305 .owner = THIS_MODULE,
6306};
6307
6308static int __init patch_realtek_init(void)
6309{
6310 return snd_hda_add_codec_preset(&realtek_list);
6311}
6312
6313static void __exit patch_realtek_exit(void)
6314{
6315 snd_hda_delete_codec_preset(&realtek_list);
6316}
6317
6318module_init(patch_realtek_init)
6319module_exit(patch_realtek_exit)
A mirror of Linus' kernel repository