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