]> 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/realtek - Fix overflow of vol/sw check bitmap
[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[] = {
1a1455de
TI		 805 "Disabled", "Speaker Only", "Line-Out+Speaker"
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",
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",
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++)
3800 alc_mux_select(codec, 0, spec->cur_mux[c], true);
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,
4370 ALC889_FIXUP_VAIO_TT,
0e7cc2e7 4371 ALC888_FIXUP_EEE1601,
177943a3 4372 ALC882_FIXUP_EAPD,
7a6069bf 4373 ALC883_FIXUP_EAPD,
8812c4f9 4374 ALC883_FIXUP_ACER_EAPD,
eb844d51 4375 ALC882_FIXUP_GPIO3,
68ef0561
TI		 4376 ALC889_FIXUP_COEF,
4377 ALC882_FIXUP_ASUS_W2JC,
c3e837bb
TI		 4378 ALC882_FIXUP_ACER_ASPIRE_4930G,
4379 ALC882_FIXUP_ACER_ASPIRE_8930G,
4380 ALC882_FIXUP_ASPIRE_8930G_VERBS,
5671087f 4381 ALC885_FIXUP_MACPRO_GPIO,
02a237b2 4382 ALC889_FIXUP_DAC_ROUTE,
ff818c24
TI		 4383};
4384
68ef0561
TI		 4385static void alc889_fixup_coef(struct hda_codec *codec,
4386 const struct alc_fixup *fix, int action)
4387{
4388 if (action != ALC_FIXUP_ACT_INIT)
4389 return;
4390 alc889_coef_init(codec);
4391}
4392
5671087f
TI		 4393/* toggle speaker-output according to the hp-jack state */
4394static void alc882_gpio_mute(struct hda_codec *codec, int pin, int muted)
4395{
4396 unsigned int gpiostate, gpiomask, gpiodir;
4397
4398 gpiostate = snd_hda_codec_read(codec, codec->afg, 0,
4399 AC_VERB_GET_GPIO_DATA, 0);
4400
4401 if (!muted)
4402 gpiostate |= (1 << pin);
4403 else
4404 gpiostate &= ~(1 << pin);
4405
4406 gpiomask = snd_hda_codec_read(codec, codec->afg, 0,
4407 AC_VERB_GET_GPIO_MASK, 0);
4408 gpiomask |= (1 << pin);
4409
4410 gpiodir = snd_hda_codec_read(codec, codec->afg, 0,
4411 AC_VERB_GET_GPIO_DIRECTION, 0);
4412 gpiodir |= (1 << pin);
4413
4414
4415 snd_hda_codec_write(codec, codec->afg, 0,
4416 AC_VERB_SET_GPIO_MASK, gpiomask);
4417 snd_hda_codec_write(codec, codec->afg, 0,
4418 AC_VERB_SET_GPIO_DIRECTION, gpiodir);
4419
4420 msleep(1);
4421
4422 snd_hda_codec_write(codec, codec->afg, 0,
4423 AC_VERB_SET_GPIO_DATA, gpiostate);
4424}
4425
4426/* set up GPIO at initialization */
4427static void alc885_fixup_macpro_gpio(struct hda_codec *codec,
4428 const struct alc_fixup *fix, int action)
4429{
4430 if (action != ALC_FIXUP_ACT_INIT)
4431 return;
4432 alc882_gpio_mute(codec, 0, 0);
4433 alc882_gpio_mute(codec, 1, 0);
4434}
4435
02a237b2
TI		 4436/* Fix the connection of some pins for ALC889:
4437 * At least, Acer Aspire 5935 shows the connections to DAC3/4 don't
4438 * work correctly (bko#42740)
4439 */
4440static void alc889_fixup_dac_route(struct hda_codec *codec,
4441 const struct alc_fixup *fix, int action)
4442{
4443 if (action == ALC_FIXUP_ACT_PRE_PROBE) {
4444 hda_nid_t conn1[2] = { 0x0c, 0x0d };
4445 hda_nid_t conn2[2] = { 0x0e, 0x0f };
4446 snd_hda_override_conn_list(codec, 0x14, 2, conn1);
4447 snd_hda_override_conn_list(codec, 0x15, 2, conn1);
4448 snd_hda_override_conn_list(codec, 0x18, 2, conn2);
4449 snd_hda_override_conn_list(codec, 0x1a, 2, conn2);
4450 }
4451}
4452
1d045db9 4453static const struct alc_fixup alc882_fixups[] = {
5c0ebfbe 4454 [ALC882_FIXUP_ABIT_AW9D_MAX] = {
1d045db9
TI		 4455 .type = ALC_FIXUP_PINS,
4456 .v.pins = (const struct alc_pincfg[]) {
4457 { 0x15, 0x01080104 }, /* side */
4458 { 0x16, 0x01011012 }, /* rear */
4459 { 0x17, 0x01016011 }, /* clfe */
2785591a 4460 { }
145a902b
DH		 4461 }
4462 },
5c0ebfbe 4463 [ALC882_FIXUP_LENOVO_Y530] = {
b5bfbc67
TI		 4464 .type = ALC_FIXUP_PINS,
4465 .v.pins = (const struct alc_pincfg[]) {
1d045db9
TI		 4466 { 0x15, 0x99130112 }, /* rear int speakers */
4467 { 0x16, 0x99130111 }, /* subwoofer */
ac612407
DH		 4468 { }
4469 }
4470 },
5c0ebfbe 4471 [ALC882_FIXUP_PB_M5210] = {
b5bfbc67
TI		 4472 .type = ALC_FIXUP_VERBS,
4473 .v.verbs = (const struct hda_verb[]) {
1d045db9 4474 { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50 },
357f915e
KY		 4475 {}
4476 }
4477 },
5c0ebfbe 4478 [ALC882_FIXUP_ACER_ASPIRE_7736] = {
1d045db9
TI		 4479 .type = ALC_FIXUP_SKU,
4480 .v.sku = ALC_FIXUP_SKU_IGNORE,
6981d184 4481 },
5c0ebfbe 4482 [ALC882_FIXUP_ASUS_W90V] = {
5cdf745e
TI		 4483 .type = ALC_FIXUP_PINS,
4484 .v.pins = (const struct alc_pincfg[]) {
4485 { 0x16, 0x99130110 }, /* fix sequence for CLFE */
4486 { }
4487 }
4488 },
5c0ebfbe
TI		 4489 [ALC889_FIXUP_VAIO_TT] = {
4490 .type = ALC_FIXUP_PINS,
4491 .v.pins = (const struct alc_pincfg[]) {
4492 { 0x17, 0x90170111 }, /* hidden surround speaker */
4493 { }
4494 }
4495 },
0e7cc2e7
TI		 4496 [ALC888_FIXUP_EEE1601] = {
4497 .type = ALC_FIXUP_VERBS,
4498 .v.verbs = (const struct hda_verb[]) {
4499 { 0x20, AC_VERB_SET_COEF_INDEX, 0x0b },
4500 { 0x20, AC_VERB_SET_PROC_COEF, 0x0838 },
4501 { }
4502 }
177943a3
TI		 4503 },
4504 [ALC882_FIXUP_EAPD] = {
4505 .type = ALC_FIXUP_VERBS,
4506 .v.verbs = (const struct hda_verb[]) {
4507 /* change to EAPD mode */
4508 { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
4509 { 0x20, AC_VERB_SET_PROC_COEF, 0x3060 },
4510 { }
4511 }
4512 },
7a6069bf
TI		 4513 [ALC883_FIXUP_EAPD] = {
4514 .type = ALC_FIXUP_VERBS,
4515 .v.verbs = (const struct hda_verb[]) {
4516 /* change to EAPD mode */
4517 { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
4518 { 0x20, AC_VERB_SET_PROC_COEF, 0x3070 },
4519 { }
4520 }
4521 },
8812c4f9
TI		 4522 [ALC883_FIXUP_ACER_EAPD] = {
4523 .type = ALC_FIXUP_VERBS,
4524 .v.verbs = (const struct hda_verb[]) {
4525 /* eanable EAPD on Acer laptops */
4526 { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
4527 { 0x20, AC_VERB_SET_PROC_COEF, 0x3050 },
4528 { }
4529 }
4530 },
eb844d51
TI		 4531 [ALC882_FIXUP_GPIO3] = {
4532 .type = ALC_FIXUP_VERBS,
4533 .v.verbs = alc_gpio3_init_verbs,
4534 },
68ef0561
TI		 4535 [ALC882_FIXUP_ASUS_W2JC] = {
4536 .type = ALC_FIXUP_VERBS,
4537 .v.verbs = alc_gpio1_init_verbs,
4538 .chained = true,
4539 .chain_id = ALC882_FIXUP_EAPD,
4540 },
4541 [ALC889_FIXUP_COEF] = {
4542 .type = ALC_FIXUP_FUNC,
4543 .v.func = alc889_fixup_coef,
4544 },
c3e837bb
TI		 4545 [ALC882_FIXUP_ACER_ASPIRE_4930G] = {
4546 .type = ALC_FIXUP_PINS,
4547 .v.pins = (const struct alc_pincfg[]) {
4548 { 0x16, 0x99130111 }, /* CLFE speaker */
4549 { 0x17, 0x99130112 }, /* surround speaker */
4550 { }
4551 }
4552 },
4553 [ALC882_FIXUP_ACER_ASPIRE_8930G] = {
4554 .type = ALC_FIXUP_PINS,
4555 .v.pins = (const struct alc_pincfg[]) {
4556 { 0x16, 0x99130111 }, /* CLFE speaker */
4557 { 0x1b, 0x99130112 }, /* surround speaker */
4558 { }
4559 },
4560 .chained = true,
4561 .chain_id = ALC882_FIXUP_ASPIRE_8930G_VERBS,
4562 },
4563 [ALC882_FIXUP_ASPIRE_8930G_VERBS] = {
4564 /* additional init verbs for Acer Aspire 8930G */
4565 .type = ALC_FIXUP_VERBS,
4566 .v.verbs = (const struct hda_verb[]) {
4567 /* Enable all DACs */
4568 /* DAC DISABLE/MUTE 1? */
4569 /* setting bits 1-5 disables DAC nids 0x02-0x06
4570 * apparently. Init=0x38 */
4571 { 0x20, AC_VERB_SET_COEF_INDEX, 0x03 },
4572 { 0x20, AC_VERB_SET_PROC_COEF, 0x0000 },
4573 /* DAC DISABLE/MUTE 2? */
4574 /* some bit here disables the other DACs.
4575 * Init=0x4900 */
4576 { 0x20, AC_VERB_SET_COEF_INDEX, 0x08 },
4577 { 0x20, AC_VERB_SET_PROC_COEF, 0x0000 },
4578 /* DMIC fix
4579 * This laptop has a stereo digital microphone.
4580 * The mics are only 1cm apart which makes the stereo
4581 * useless. However, either the mic or the ALC889
4582 * makes the signal become a difference/sum signal
4583 * instead of standard stereo, which is annoying.
4584 * So instead we flip this bit which makes the
4585 * codec replicate the sum signal to both channels,
4586 * turning it into a normal mono mic.
4587 */
4588 /* DMIC_CONTROL? Init value = 0x0001 */
4589 { 0x20, AC_VERB_SET_COEF_INDEX, 0x0b },
4590 { 0x20, AC_VERB_SET_PROC_COEF, 0x0003 },
4591 { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
4592 { 0x20, AC_VERB_SET_PROC_COEF, 0x3050 },
4593 { }
4594 }
4595 },
5671087f
TI		 4596 [ALC885_FIXUP_MACPRO_GPIO] = {
4597 .type = ALC_FIXUP_FUNC,
4598 .v.func = alc885_fixup_macpro_gpio,
4599 },
02a237b2
TI		 4600 [ALC889_FIXUP_DAC_ROUTE] = {
4601 .type = ALC_FIXUP_FUNC,
4602 .v.func = alc889_fixup_dac_route,
4603 },
ff818c24
TI		 4604};
4605
1d045db9 4606static const struct snd_pci_quirk alc882_fixup_tbl[] = {
8812c4f9
TI		 4607 SND_PCI_QUIRK(0x1025, 0x006c, "Acer Aspire 9810", ALC883_FIXUP_ACER_EAPD),
4608 SND_PCI_QUIRK(0x1025, 0x0090, "Acer Aspire", ALC883_FIXUP_ACER_EAPD),
4609 SND_PCI_QUIRK(0x1025, 0x010a, "Acer Ferrari 5000", ALC883_FIXUP_ACER_EAPD),
4610 SND_PCI_QUIRK(0x1025, 0x0110, "Acer Aspire", ALC883_FIXUP_ACER_EAPD),
4611 SND_PCI_QUIRK(0x1025, 0x0112, "Acer Aspire 9303", ALC883_FIXUP_ACER_EAPD),
4612 SND_PCI_QUIRK(0x1025, 0x0121, "Acer Aspire 5920G", ALC883_FIXUP_ACER_EAPD),
c3e837bb
TI		 4613 SND_PCI_QUIRK(0x1025, 0x013e, "Acer Aspire 4930G",
4614 ALC882_FIXUP_ACER_ASPIRE_4930G),
4615 SND_PCI_QUIRK(0x1025, 0x013f, "Acer Aspire 5930G",
4616 ALC882_FIXUP_ACER_ASPIRE_4930G),
4617 SND_PCI_QUIRK(0x1025, 0x0145, "Acer Aspire 8930G",
4618 ALC882_FIXUP_ACER_ASPIRE_8930G),
4619 SND_PCI_QUIRK(0x1025, 0x0146, "Acer Aspire 6935G",
4620 ALC882_FIXUP_ACER_ASPIRE_8930G),
4621 SND_PCI_QUIRK(0x1025, 0x015e, "Acer Aspire 6930G",
4622 ALC882_FIXUP_ACER_ASPIRE_4930G),
4623 SND_PCI_QUIRK(0x1025, 0x0166, "Acer Aspire 6530G",
4624 ALC882_FIXUP_ACER_ASPIRE_4930G),
4625 SND_PCI_QUIRK(0x1025, 0x0142, "Acer Aspire 7730G",
4626 ALC882_FIXUP_ACER_ASPIRE_4930G),
5c0ebfbe 4627 SND_PCI_QUIRK(0x1025, 0x0155, "Packard-Bell M5120", ALC882_FIXUP_PB_M5210),
02a237b2 4628 SND_PCI_QUIRK(0x1025, 0x0259, "Acer Aspire 5935", ALC889_FIXUP_DAC_ROUTE),
ac9b1cdd 4629 SND_PCI_QUIRK(0x1025, 0x0296, "Acer Aspire 7736z", ALC882_FIXUP_ACER_ASPIRE_7736),
177943a3 4630 SND_PCI_QUIRK(0x1043, 0x13c2, "Asus A7M", ALC882_FIXUP_EAPD),
5c0ebfbe 4631 SND_PCI_QUIRK(0x1043, 0x1873, "ASUS W90V", ALC882_FIXUP_ASUS_W90V),
68ef0561 4632 SND_PCI_QUIRK(0x1043, 0x1971, "Asus W2JC", ALC882_FIXUP_ASUS_W2JC),
0e7cc2e7 4633 SND_PCI_QUIRK(0x1043, 0x835f, "Asus Eee 1601", ALC888_FIXUP_EEE1601),
ac9b1cdd 4634 SND_PCI_QUIRK(0x104d, 0x9047, "Sony Vaio TT", ALC889_FIXUP_VAIO_TT),
5671087f
TI		 4635
4636 /* All Apple entries are in codec SSIDs */
4637 SND_PCI_QUIRK(0x106b, 0x0c00, "Mac Pro", ALC885_FIXUP_MACPRO_GPIO),
4638 SND_PCI_QUIRK(0x106b, 0x1000, "iMac 24", ALC885_FIXUP_MACPRO_GPIO),
4639 SND_PCI_QUIRK(0x106b, 0x2800, "AppleTV", ALC885_FIXUP_MACPRO_GPIO),
4640 SND_PCI_QUIRK(0x106b, 0x3200, "iMac 7,1 Aluminum", ALC882_FIXUP_EAPD),
4641 SND_PCI_QUIRK(0x106b, 0x3e00, "iMac 24 Aluminum", ALC885_FIXUP_MACPRO_GPIO),
4642
7a6069bf 4643 SND_PCI_QUIRK(0x1071, 0x8258, "Evesham Voyaeger", ALC882_FIXUP_EAPD),
eb844d51 4644 SND_PCI_QUIRK_VENDOR(0x1462, "MSI", ALC882_FIXUP_GPIO3),
5c0ebfbe 4645 SND_PCI_QUIRK(0x147b, 0x107a, "Abit AW9D-MAX", ALC882_FIXUP_ABIT_AW9D_MAX),
7a6069bf
TI		 4646 SND_PCI_QUIRK_VENDOR(0x1558, "Clevo laptop", ALC882_FIXUP_EAPD),
4647 SND_PCI_QUIRK(0x161f, 0x2054, "Medion laptop", ALC883_FIXUP_EAPD),
ac9b1cdd 4648 SND_PCI_QUIRK(0x17aa, 0x3a0d, "Lenovo Y530", ALC882_FIXUP_LENOVO_Y530),
68ef0561 4649 SND_PCI_QUIRK(0x8086, 0x0022, "DX58SO", ALC889_FIXUP_COEF),
ff818c24
TI		 4650 {}
4651};
4652
f6a92248 4653/*
1d045db9 4654 * BIOS auto configuration
f6a92248 4655 */
1d045db9
TI		 4656/* almost identical with ALC880 parser... */
4657static int alc882_parse_auto_config(struct hda_codec *codec)
4658{
1d045db9 4659 static const hda_nid_t alc882_ignore[] = { 0x1d, 0 };
3e6179b8
TI		 4660 static const hda_nid_t alc882_ssids[] = { 0x15, 0x1b, 0x14, 0 };
4661 return alc_parse_auto_config(codec, alc882_ignore, alc882_ssids);
1d045db9 4662}
b896b4eb 4663
1d045db9
TI		 4664/*
4665 */
4666#ifdef CONFIG_SND_HDA_ENABLE_REALTEK_QUIRKS
4667#include "alc882_quirks.c"
4668#endif
4669
4670static int patch_alc882(struct hda_codec *codec)
f6a92248
KY		 4671{
4672 struct alc_spec *spec;
1d045db9 4673 int err, board_config;
f6a92248
KY		 4674
4675 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
4676 if (spec == NULL)
4677 return -ENOMEM;
4678
4679 codec->spec = spec;
4680
1f0f4b80
TI		 4681 spec->mixer_nid = 0x0b;
4682
1d045db9
TI		 4683 switch (codec->vendor_id) {
4684 case 0x10ec0882:
4685 case 0x10ec0885:
4686 break;
4687 default:
4688 /* ALC883 and variants */
4689 alc_fix_pll_init(codec, 0x20, 0x0a, 10);
4690 break;
c793bec5 4691 }
977ddd6b 4692
e16fb6d1
TI		 4693 err = alc_codec_rename_from_preset(codec);
4694 if (err < 0)
4695 goto error;
4696
b2539699
TI		 4697 board_config = alc_board_config(codec, ALC882_MODEL_LAST,
4698 alc882_models, NULL);
4699 if (board_config < 0)
4700 board_config = alc_board_codec_sid_config(codec,
1d045db9 4701 ALC882_MODEL_LAST, alc882_models, alc882_ssid_cfg_tbl);
f6a92248
KY		 4702
4703 if (board_config < 0) {
9a11f1aa
TI		 4704 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
4705 codec->chip_name);
1d045db9 4706 board_config = ALC_MODEL_AUTO;
f6a92248
KY		 4707 }
4708
1d045db9
TI		 4709 if (board_config == ALC_MODEL_AUTO) {
4710 alc_pick_fixup(codec, NULL, alc882_fixup_tbl, alc882_fixups);
b5bfbc67
TI		 4711 alc_apply_fixup(codec, ALC_FIXUP_ACT_PRE_PROBE);
4712 }
ff818c24 4713
1d045db9
TI		 4714 alc_auto_parse_customize_define(codec);
4715
4716 if (board_config == ALC_MODEL_AUTO) {
f6a92248 4717 /* automatic parse from the BIOS config */
1d045db9 4718 err = alc882_parse_auto_config(codec);
e16fb6d1
TI		 4719 if (err < 0)
4720 goto error;
f6a92248
KY		 4721 }
4722
fde48a1f 4723 if (board_config != ALC_MODEL_AUTO) {
1d045db9 4724 setup_preset(codec, &alc882_presets[board_config]);
fde48a1f
DH		 4725 spec->vmaster_nid = 0x0c;
4726 }
f6a92248 4727
60a6a842 4728 if (!spec->no_analog && !spec->adc_nids) {
d6cc9fab 4729 alc_auto_fill_adc_caps(codec);
21268961 4730 alc_rebuild_imux_for_auto_mic(codec);
d6cc9fab 4731 alc_remove_invalid_adc_nids(codec);
84898e87
KY		 4732 }
4733
3e6179b8
TI		 4734 if (!spec->no_analog && !spec->cap_mixer)
4735 set_capture_mixer(codec);
1d045db9 4736
3e6179b8
TI		 4737 if (!spec->no_analog && has_cdefine_beep(codec)) {
4738 err = snd_hda_attach_beep_device(codec, 0x1);
e16fb6d1
TI		 4739 if (err < 0)
4740 goto error;
1d045db9 4741 set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
3e6179b8 4742 }
f6a92248 4743
b5bfbc67 4744 alc_apply_fixup(codec, ALC_FIXUP_ACT_PROBE);
ff818c24 4745
f6a92248 4746 codec->patch_ops = alc_patch_ops;
1d045db9 4747 if (board_config == ALC_MODEL_AUTO)
e4770629 4748 spec->init_hook = alc_auto_init_std;
f21d78e2
TI		 4749 else
4750 codec->patch_ops.build_controls = __alc_build_controls;
bf1b0225 4751
f6a92248
KY		 4752#ifdef CONFIG_SND_HDA_POWER_SAVE
4753 if (!spec->loopback.amplist)
1d045db9 4754 spec->loopback.amplist = alc882_loopbacks;
f6a92248
KY		 4755#endif
4756
4757 return 0;
e16fb6d1
TI		 4758
4759 error:
4760 alc_free(codec);
4761 return err;
f6a92248
KY		 4762}
4763
df694daa 4764
df694daa 4765/*
1d045db9 4766 * ALC262 support
df694daa 4767 */
1d045db9 4768static int alc262_parse_auto_config(struct hda_codec *codec)
df694daa 4769{
1d045db9 4770 static const hda_nid_t alc262_ignore[] = { 0x1d, 0 };
3e6179b8
TI		 4771 static const hda_nid_t alc262_ssids[] = { 0x15, 0x1b, 0x14, 0 };
4772 return alc_parse_auto_config(codec, alc262_ignore, alc262_ssids);
df694daa
KY		 4773}
4774
df694daa 4775/*
1d045db9 4776 * Pin config fixes
df694daa 4777 */
cfc9b06f 4778enum {
ea4e7af1
TI		 4779 ALC262_FIXUP_FSC_H270,
4780 ALC262_FIXUP_HP_Z200,
4781 ALC262_FIXUP_TYAN,
c470150c 4782 ALC262_FIXUP_LENOVO_3000,
b42590b8
TI		 4783 ALC262_FIXUP_BENQ,
4784 ALC262_FIXUP_BENQ_T31,
cfc9b06f
TI		 4785};
4786
1d045db9 4787static const struct alc_fixup alc262_fixups[] = {
ea4e7af1 4788 [ALC262_FIXUP_FSC_H270] = {
b5bfbc67
TI		 4789 .type = ALC_FIXUP_PINS,
4790 .v.pins = (const struct alc_pincfg[]) {
1d045db9
TI		 4791 { 0x14, 0x99130110 }, /* speaker */
4792 { 0x15, 0x0221142f }, /* front HP */
4793 { 0x1b, 0x0121141f }, /* rear HP */
4794 { }
4795 }
4796 },
ea4e7af1 4797 [ALC262_FIXUP_HP_Z200] = {
1d045db9
TI		 4798 .type = ALC_FIXUP_PINS,
4799 .v.pins = (const struct alc_pincfg[]) {
4800 { 0x16, 0x99130120 }, /* internal speaker */
73413b12
TI		 4801 { }
4802 }
cfc9b06f 4803 },
ea4e7af1
TI		 4804 [ALC262_FIXUP_TYAN] = {
4805 .type = ALC_FIXUP_PINS,
4806 .v.pins = (const struct alc_pincfg[]) {
4807 { 0x14, 0x1993e1f0 }, /* int AUX */
4808 { }
4809 }
4810 },
c470150c
TI		 4811 [ALC262_FIXUP_LENOVO_3000] = {
4812 .type = ALC_FIXUP_VERBS,
4813 .v.verbs = (const struct hda_verb[]) {
4814 { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50 },
b42590b8
TI		 4815 {}
4816 },
4817 .chained = true,
4818 .chain_id = ALC262_FIXUP_BENQ,
4819 },
4820 [ALC262_FIXUP_BENQ] = {
4821 .type = ALC_FIXUP_VERBS,
4822 .v.verbs = (const struct hda_verb[]) {
c470150c
TI		 4823 { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
4824 { 0x20, AC_VERB_SET_PROC_COEF, 0x3070 },
4825 {}
4826 }
4827 },
b42590b8
TI		 4828 [ALC262_FIXUP_BENQ_T31] = {
4829 .type = ALC_FIXUP_VERBS,
4830 .v.verbs = (const struct hda_verb[]) {
4831 { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
4832 { 0x20, AC_VERB_SET_PROC_COEF, 0x3050 },
4833 {}
4834 }
4835 },
cfc9b06f
TI		 4836};
4837
1d045db9 4838static const struct snd_pci_quirk alc262_fixup_tbl[] = {
ea4e7af1 4839 SND_PCI_QUIRK(0x103c, 0x170b, "HP Z200", ALC262_FIXUP_HP_Z200),
3dcd3be3
TI		 4840 SND_PCI_QUIRK(0x10cf, 0x1397, "Fujitsu", ALC262_FIXUP_BENQ),
4841 SND_PCI_QUIRK(0x10cf, 0x142d, "Fujitsu Lifebook E8410", ALC262_FIXUP_BENQ),
ea4e7af1
TI		 4842 SND_PCI_QUIRK(0x10f1, 0x2915, "Tyan Thunder n6650W", ALC262_FIXUP_TYAN),
4843 SND_PCI_QUIRK(0x1734, 0x1147, "FSC Celsius H270", ALC262_FIXUP_FSC_H270),
c470150c 4844 SND_PCI_QUIRK(0x17aa, 0x384e, "Lenovo 3000", ALC262_FIXUP_LENOVO_3000),
b42590b8
TI		 4845 SND_PCI_QUIRK(0x17ff, 0x0560, "Benq ED8", ALC262_FIXUP_BENQ),
4846 SND_PCI_QUIRK(0x17ff, 0x058d, "Benq T31-16", ALC262_FIXUP_BENQ_T31),
cfc9b06f
TI		 4847 {}
4848};
df694daa 4849
1d045db9
TI		 4850
4851#ifdef CONFIG_SND_HDA_POWER_SAVE
4852#define alc262_loopbacks alc880_loopbacks
4853#endif
4854
1d045db9
TI		 4855/*
4856 */
1d045db9 4857static int patch_alc262(struct hda_codec *codec)
df694daa
KY		 4858{
4859 struct alc_spec *spec;
df694daa
KY		 4860 int err;
4861
dc041e0b 4862 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
df694daa
KY		 4863 if (spec == NULL)
4864 return -ENOMEM;
4865
f12ab1e0 4866 codec->spec = spec;
df694daa 4867
1d045db9
TI		 4868 spec->mixer_nid = 0x0b;
4869
4870#if 0
4871 /* pshou 07/11/05 set a zero PCM sample to DAC when FIFO is
4872 * under-run
4873 */
4874 {
4875 int tmp;
4876 snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_COEF_INDEX, 7);
4877 tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0);
4878 snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_COEF_INDEX, 7);
4879 snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_PROC_COEF, tmp | 0x80);
4880 }
4881#endif
4882 alc_auto_parse_customize_define(codec);
1f0f4b80 4883
1d045db9
TI		 4884 alc_fix_pll_init(codec, 0x20, 0x0a, 10);
4885
42399f7a
TI		 4886 alc_pick_fixup(codec, NULL, alc262_fixup_tbl, alc262_fixups);
4887 alc_apply_fixup(codec, ALC_FIXUP_ACT_PRE_PROBE);
9c7f852e 4888
42399f7a
TI		 4889 /* automatic parse from the BIOS config */
4890 err = alc262_parse_auto_config(codec);
4891 if (err < 0)
4892 goto error;
df694daa 4893
60a6a842 4894 if (!spec->no_analog && !spec->adc_nids) {
21268961
TI		 4895 alc_auto_fill_adc_caps(codec);
4896 alc_rebuild_imux_for_auto_mic(codec);
4897 alc_remove_invalid_adc_nids(codec);
4898 }
3e6179b8
TI		 4899
4900 if (!spec->no_analog && !spec->cap_mixer)
c7a8eb10 4901 set_capture_mixer(codec);
3e6179b8
TI		 4902
4903 if (!spec->no_analog && has_cdefine_beep(codec)) {
4904 err = snd_hda_attach_beep_device(codec, 0x1);
e16fb6d1
TI		 4905 if (err < 0)
4906 goto error;
1d045db9 4907 set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
3e6179b8 4908 }
2134ea4f 4909
b5bfbc67 4910 alc_apply_fixup(codec, ALC_FIXUP_ACT_PROBE);
7fa90e87 4911
df694daa 4912 codec->patch_ops = alc_patch_ops;
42399f7a 4913 spec->init_hook = alc_auto_init_std;
1d045db9
TI		 4914 spec->shutup = alc_eapd_shutup;
4915
cb53c626
TI		 4916#ifdef CONFIG_SND_HDA_POWER_SAVE
4917 if (!spec->loopback.amplist)
1d045db9 4918 spec->loopback.amplist = alc262_loopbacks;
cb53c626 4919#endif
ea1fb29a 4920
1da177e4 4921 return 0;
e16fb6d1
TI		 4922
4923 error:
4924 alc_free(codec);
4925 return err;
1da177e4
LT		 4926}
4927
f32610ed 4928/*
1d045db9 4929 * ALC268
f32610ed 4930 */
1d045db9
TI		 4931/* bind Beep switches of both NID 0x0f and 0x10 */
4932static const struct hda_bind_ctls alc268_bind_beep_sw = {
4933 .ops = &snd_hda_bind_sw,
4934 .values = {
4935 HDA_COMPOSE_AMP_VAL(0x0f, 3, 1, HDA_INPUT),
4936 HDA_COMPOSE_AMP_VAL(0x10, 3, 1, HDA_INPUT),
4937 0
4938 },
f32610ed
JS		 4939};
4940
1d045db9
TI		 4941static const struct snd_kcontrol_new alc268_beep_mixer[] = {
4942 HDA_CODEC_VOLUME("Beep Playback Volume", 0x1d, 0x0, HDA_INPUT),
4943 HDA_BIND_SW("Beep Playback Switch", &alc268_bind_beep_sw),
4944 { }
f32610ed
JS		 4945};
4946
1d045db9
TI		 4947/* set PCBEEP vol = 0, mute connections */
4948static const struct hda_verb alc268_beep_init_verbs[] = {
4949 {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4950 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4951 {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4952 { }
f32610ed
JS		 4953};
4954
4955/*
4956 * BIOS auto configuration
4957 */
1d045db9 4958static int alc268_parse_auto_config(struct hda_codec *codec)
f32610ed 4959{
3e6179b8 4960 static const hda_nid_t alc268_ssids[] = { 0x15, 0x1b, 0x14, 0 };
f32610ed 4961 struct alc_spec *spec = codec->spec;
3e6179b8
TI		 4962 int err = alc_parse_auto_config(codec, NULL, alc268_ssids);
4963 if (err > 0) {
4964 if (!spec->no_analog && spec->autocfg.speaker_pins[0] != 0x1d) {
4965 add_mixer(spec, alc268_beep_mixer);
4966 add_verb(spec, alc268_beep_init_verbs);
1d045db9 4967 }
1d045db9 4968 }
3e6179b8 4969 return err;
f32610ed
JS		 4970}
4971
1d045db9
TI		 4972/*
4973 */
1d045db9 4974static int patch_alc268(struct hda_codec *codec)
f32610ed
JS		 4975{
4976 struct alc_spec *spec;
1d045db9 4977 int i, has_beep, err;
f32610ed
JS		 4978
4979 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
4980 if (spec == NULL)
4981 return -ENOMEM;
4982
4983 codec->spec = spec;
4984
1d045db9 4985 /* ALC268 has no aa-loopback mixer */
1f0f4b80 4986
6ebb8053
TI		 4987 /* automatic parse from the BIOS config */
4988 err = alc268_parse_auto_config(codec);
e16fb6d1
TI		 4989 if (err < 0)
4990 goto error;
f32610ed 4991
1d045db9
TI		 4992 has_beep = 0;
4993 for (i = 0; i < spec->num_mixers; i++) {
4994 if (spec->mixers[i] == alc268_beep_mixer) {
4995 has_beep = 1;
4996 break;
4997 }
4998 }
f32610ed 4999
1d045db9
TI		 5000 if (has_beep) {
5001 err = snd_hda_attach_beep_device(codec, 0x1);
e16fb6d1
TI		 5002 if (err < 0)
5003 goto error;
1d045db9
TI		 5004 if (!query_amp_caps(codec, 0x1d, HDA_INPUT))
5005 /* override the amp caps for beep generator */
5006 snd_hda_override_amp_caps(codec, 0x1d, HDA_INPUT,
5007 (0x0c << AC_AMPCAP_OFFSET_SHIFT) |
5008 (0x0c << AC_AMPCAP_NUM_STEPS_SHIFT) |
5009 (0x07 << AC_AMPCAP_STEP_SIZE_SHIFT) |
5010 (0 << AC_AMPCAP_MUTE_SHIFT));
2f893286
KY		 5011 }
5012
60a6a842 5013 if (!spec->no_analog && !spec->adc_nids) {
d6cc9fab 5014 alc_auto_fill_adc_caps(codec);
21268961 5015 alc_rebuild_imux_for_auto_mic(codec);
d6cc9fab 5016 alc_remove_invalid_adc_nids(codec);
dd704698 5017 }
f32610ed 5018
3e6179b8 5019 if (!spec->no_analog && !spec->cap_mixer)
1d045db9 5020 set_capture_mixer(codec);
f32610ed
JS		 5021
5022 codec->patch_ops = alc_patch_ops;
6ebb8053 5023 spec->init_hook = alc_auto_init_std;
1c716153 5024 spec->shutup = alc_eapd_shutup;
1d045db9 5025
f32610ed 5026 return 0;
e16fb6d1
TI		 5027
5028 error:
5029 alc_free(codec);
5030 return err;
f32610ed
JS		 5031}
5032
bc9f98a9 5033/*
1d045db9 5034 * ALC269
bc9f98a9 5035 */
1d045db9
TI		 5036#ifdef CONFIG_SND_HDA_POWER_SAVE
5037#define alc269_loopbacks alc880_loopbacks
5038#endif
e1406348 5039
1d045db9
TI		 5040static const struct hda_pcm_stream alc269_44k_pcm_analog_playback = {
5041 .substreams = 1,
5042 .channels_min = 2,
5043 .channels_max = 8,
5044 .rates = SNDRV_PCM_RATE_44100, /* fixed rate */
5045 /* NID is set in alc_build_pcms */
5046 .ops = {
5047 .open = alc_playback_pcm_open,
5048 .prepare = alc_playback_pcm_prepare,
5049 .cleanup = alc_playback_pcm_cleanup
bc9f98a9
KY		 5050 },
5051};
5052
1d045db9
TI		 5053static const struct hda_pcm_stream alc269_44k_pcm_analog_capture = {
5054 .substreams = 1,
5055 .channels_min = 2,
5056 .channels_max = 2,
5057 .rates = SNDRV_PCM_RATE_44100, /* fixed rate */
5058 /* NID is set in alc_build_pcms */
bc9f98a9 5059};
291702f0 5060
1d045db9
TI		 5061#ifdef CONFIG_SND_HDA_POWER_SAVE
5062static int alc269_mic2_for_mute_led(struct hda_codec *codec)
5063{
5064 switch (codec->subsystem_id) {
5065 case 0x103c1586:
5066 return 1;
5067 }
5068 return 0;
5069}
6dda9f4a 5070
1d045db9
TI		 5071static int alc269_mic2_mute_check_ps(struct hda_codec *codec, hda_nid_t nid)
5072{
5073 /* update mute-LED according to the speaker mute state */
5074 if (nid == 0x01 || nid == 0x14) {
5075 int pinval;
5076 if (snd_hda_codec_amp_read(codec, 0x14, 0, HDA_OUTPUT, 0) &
5077 HDA_AMP_MUTE)
5078 pinval = 0x24;
5079 else
5080 pinval = 0x20;
5081 /* mic2 vref pin is used for mute LED control */
5082 snd_hda_codec_update_cache(codec, 0x19, 0,
5083 AC_VERB_SET_PIN_WIDGET_CONTROL,
5084 pinval);
5085 }
5086 return alc_check_power_status(codec, nid);
5087}
5088#endif /* CONFIG_SND_HDA_POWER_SAVE */
9541ba1d 5089
1d045db9
TI		 5090/* different alc269-variants */
5091enum {
5092 ALC269_TYPE_ALC269VA,
5093 ALC269_TYPE_ALC269VB,
5094 ALC269_TYPE_ALC269VC,
bc9f98a9
KY		 5095};
5096
5097/*
1d045db9 5098 * BIOS auto configuration
bc9f98a9 5099 */
1d045db9
TI		 5100static int alc269_parse_auto_config(struct hda_codec *codec)
5101{
1d045db9 5102 static const hda_nid_t alc269_ignore[] = { 0x1d, 0 };
3e6179b8
TI		 5103 static const hda_nid_t alc269_ssids[] = { 0, 0x1b, 0x14, 0x21 };
5104 static const hda_nid_t alc269va_ssids[] = { 0x15, 0x1b, 0x14, 0 };
5105 struct alc_spec *spec = codec->spec;
5106 const hda_nid_t *ssids = spec->codec_variant == ALC269_TYPE_ALC269VA ?
5107 alc269va_ssids : alc269_ssids;
bc9f98a9 5108
3e6179b8 5109 return alc_parse_auto_config(codec, alc269_ignore, ssids);
1d045db9 5110}
bc9f98a9 5111
1d045db9
TI		 5112static void alc269_toggle_power_output(struct hda_codec *codec, int power_up)
5113{
5114 int val = alc_read_coef_idx(codec, 0x04);
5115 if (power_up)
5116 val |= 1 << 11;
5117 else
5118 val &= ~(1 << 11);
5119 alc_write_coef_idx(codec, 0x04, val);
5120}
291702f0 5121
1d045db9
TI		 5122static void alc269_shutup(struct hda_codec *codec)
5123{
1bb7e43e 5124 if ((alc_get_coef0(codec) & 0x00ff) == 0x017)
1d045db9 5125 alc269_toggle_power_output(codec, 0);
1bb7e43e 5126 if ((alc_get_coef0(codec) & 0x00ff) == 0x018) {
1d045db9
TI		 5127 alc269_toggle_power_output(codec, 0);
5128 msleep(150);
5129 }
5130}
291702f0 5131
2a43952a 5132#ifdef CONFIG_PM
1d045db9
TI		 5133static int alc269_resume(struct hda_codec *codec)
5134{
1bb7e43e 5135 if ((alc_get_coef0(codec) & 0x00ff) == 0x018) {
1d045db9
TI		 5136 alc269_toggle_power_output(codec, 0);
5137 msleep(150);
5138 }
8c427226 5139
1d045db9 5140 codec->patch_ops.init(codec);
f1d4e28b 5141
1bb7e43e 5142 if ((alc_get_coef0(codec) & 0x00ff) == 0x017) {
1d045db9
TI		 5143 alc269_toggle_power_output(codec, 1);
5144 msleep(200);
5145 }
f1d4e28b 5146
1bb7e43e 5147 if ((alc_get_coef0(codec) & 0x00ff) == 0x018)
1d045db9 5148 alc269_toggle_power_output(codec, 1);
f1d4e28b 5149
1d045db9
TI		 5150 snd_hda_codec_resume_amp(codec);
5151 snd_hda_codec_resume_cache(codec);
5152 hda_call_check_power_status(codec, 0x01);
5153 return 0;
5154}
2a43952a 5155#endif /* CONFIG_PM */
f1d4e28b 5156
1d045db9
TI		 5157static void alc269_fixup_hweq(struct hda_codec *codec,
5158 const struct alc_fixup *fix, int action)
5159{
5160 int coef;
f1d4e28b 5161
1d045db9
TI		 5162 if (action != ALC_FIXUP_ACT_INIT)
5163 return;
5164 coef = alc_read_coef_idx(codec, 0x1e);
5165 alc_write_coef_idx(codec, 0x1e, coef | 0x80);
5166}
f1d4e28b 5167
1d045db9
TI		 5168static void alc271_fixup_dmic(struct hda_codec *codec,
5169 const struct alc_fixup *fix, int action)
5170{
5171 static const struct hda_verb verbs[] = {
5172 {0x20, AC_VERB_SET_COEF_INDEX, 0x0d},
5173 {0x20, AC_VERB_SET_PROC_COEF, 0x4000},
5174 {}
5175 };
5176 unsigned int cfg;
f1d4e28b 5177
1d045db9
TI		 5178 if (strcmp(codec->chip_name, "ALC271X"))
5179 return;
5180 cfg = snd_hda_codec_get_pincfg(codec, 0x12);
5181 if (get_defcfg_connect(cfg) == AC_JACK_PORT_FIXED)
5182 snd_hda_sequence_write(codec, verbs);
5183}
f1d4e28b 5184
017f2a10
TI		 5185static void alc269_fixup_pcm_44k(struct hda_codec *codec,
5186 const struct alc_fixup *fix, int action)
5187{
5188 struct alc_spec *spec = codec->spec;
5189
5190 if (action != ALC_FIXUP_ACT_PROBE)
5191 return;
5192
5193 /* Due to a hardware problem on Lenovo Ideadpad, we need to
5194 * fix the sample rate of analog I/O to 44.1kHz
5195 */
5196 spec->stream_analog_playback = &alc269_44k_pcm_analog_playback;
5197 spec->stream_analog_capture = &alc269_44k_pcm_analog_capture;
5198}
5199
adabb3ec
TI		 5200static void alc269_fixup_stereo_dmic(struct hda_codec *codec,
5201 const struct alc_fixup *fix, int action)
5202{
5203 int coef;
5204
5205 if (action != ALC_FIXUP_ACT_INIT)
5206 return;
5207 /* The digital-mic unit sends PDM (differential signal) instead of
5208 * the standard PCM, thus you can't record a valid mono stream as is.
5209 * Below is a workaround specific to ALC269 to control the dmic
5210 * signal source as mono.
5211 */
5212 coef = alc_read_coef_idx(codec, 0x07);
5213 alc_write_coef_idx(codec, 0x07, coef | 0x80);
5214}
5215
24519911
TI		 5216static void alc269_quanta_automute(struct hda_codec *codec)
5217{
42cf0d01 5218 update_outputs(codec);
24519911
TI		 5219
5220 snd_hda_codec_write(codec, 0x20, 0,
5221 AC_VERB_SET_COEF_INDEX, 0x0c);
5222 snd_hda_codec_write(codec, 0x20, 0,
5223 AC_VERB_SET_PROC_COEF, 0x680);
5224
5225 snd_hda_codec_write(codec, 0x20, 0,
5226 AC_VERB_SET_COEF_INDEX, 0x0c);
5227 snd_hda_codec_write(codec, 0x20, 0,
5228 AC_VERB_SET_PROC_COEF, 0x480);
5229}
5230
5231static void alc269_fixup_quanta_mute(struct hda_codec *codec,
5232 const struct alc_fixup *fix, int action)
5233{
5234 struct alc_spec *spec = codec->spec;
5235 if (action != ALC_FIXUP_ACT_PROBE)
5236 return;
5237 spec->automute_hook = alc269_quanta_automute;
5238}
5239
1d045db9
TI		 5240enum {
5241 ALC269_FIXUP_SONY_VAIO,
5242 ALC275_FIXUP_SONY_VAIO_GPIO2,
5243 ALC269_FIXUP_DELL_M101Z,
5244 ALC269_FIXUP_SKU_IGNORE,
5245 ALC269_FIXUP_ASUS_G73JW,
5246 ALC269_FIXUP_LENOVO_EAPD,
5247 ALC275_FIXUP_SONY_HWEQ,
5248 ALC271_FIXUP_DMIC,
017f2a10 5249 ALC269_FIXUP_PCM_44K,
adabb3ec 5250 ALC269_FIXUP_STEREO_DMIC,
24519911
TI		 5251 ALC269_FIXUP_QUANTA_MUTE,
5252 ALC269_FIXUP_LIFEBOOK,
a4297b5d
TI		 5253 ALC269_FIXUP_AMIC,
5254 ALC269_FIXUP_DMIC,
5255 ALC269VB_FIXUP_AMIC,
5256 ALC269VB_FIXUP_DMIC,
f1d4e28b
KY		 5257};
5258
1d045db9
TI		 5259static const struct alc_fixup alc269_fixups[] = {
5260 [ALC269_FIXUP_SONY_VAIO] = {
5261 .type = ALC_FIXUP_VERBS,
5262 .v.verbs = (const struct hda_verb[]) {
5263 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREFGRD},
5264 {}
5265 }
f1d4e28b 5266 },
1d045db9
TI		 5267 [ALC275_FIXUP_SONY_VAIO_GPIO2] = {
5268 .type = ALC_FIXUP_VERBS,
5269 .v.verbs = (const struct hda_verb[]) {
5270 {0x01, AC_VERB_SET_GPIO_MASK, 0x04},
5271 {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x04},
5272 {0x01, AC_VERB_SET_GPIO_DATA, 0x00},
5273 { }
5274 },
5275 .chained = true,
5276 .chain_id = ALC269_FIXUP_SONY_VAIO
5277 },
5278 [ALC269_FIXUP_DELL_M101Z] = {
5279 .type = ALC_FIXUP_VERBS,
5280 .v.verbs = (const struct hda_verb[]) {
5281 /* Enables internal speaker */
5282 {0x20, AC_VERB_SET_COEF_INDEX, 13},
5283 {0x20, AC_VERB_SET_PROC_COEF, 0x4040},
5284 {}
5285 }
5286 },
5287 [ALC269_FIXUP_SKU_IGNORE] = {
5288 .type = ALC_FIXUP_SKU,
5289 .v.sku = ALC_FIXUP_SKU_IGNORE,
5290 },
5291 [ALC269_FIXUP_ASUS_G73JW] = {
5292 .type = ALC_FIXUP_PINS,
5293 .v.pins = (const struct alc_pincfg[]) {
5294 { 0x17, 0x99130111 }, /* subwoofer */
5295 { }
5296 }
5297 },
5298 [ALC269_FIXUP_LENOVO_EAPD] = {
5299 .type = ALC_FIXUP_VERBS,
5300 .v.verbs = (const struct hda_verb[]) {
5301 {0x14, AC_VERB_SET_EAPD_BTLENABLE, 0},
5302 {}
5303 }
5304 },
5305 [ALC275_FIXUP_SONY_HWEQ] = {
5306 .type = ALC_FIXUP_FUNC,
5307 .v.func = alc269_fixup_hweq,
5308 .chained = true,
5309 .chain_id = ALC275_FIXUP_SONY_VAIO_GPIO2
5310 },
5311 [ALC271_FIXUP_DMIC] = {
5312 .type = ALC_FIXUP_FUNC,
5313 .v.func = alc271_fixup_dmic,
f1d4e28b 5314 },
017f2a10
TI		 5315 [ALC269_FIXUP_PCM_44K] = {
5316 .type = ALC_FIXUP_FUNC,
5317 .v.func = alc269_fixup_pcm_44k,
5318 },
adabb3ec
TI		 5319 [ALC269_FIXUP_STEREO_DMIC] = {
5320 .type = ALC_FIXUP_FUNC,
5321 .v.func = alc269_fixup_stereo_dmic,
5322 },
24519911
TI		 5323 [ALC269_FIXUP_QUANTA_MUTE] = {
5324 .type = ALC_FIXUP_FUNC,
5325 .v.func = alc269_fixup_quanta_mute,
5326 },
5327 [ALC269_FIXUP_LIFEBOOK] = {
5328 .type = ALC_FIXUP_PINS,
5329 .v.pins = (const struct alc_pincfg[]) {
5330 { 0x1a, 0x2101103f }, /* dock line-out */
5331 { 0x1b, 0x23a11040 }, /* dock mic-in */
5332 { }
5333 },
5334 .chained = true,
5335 .chain_id = ALC269_FIXUP_QUANTA_MUTE
5336 },
a4297b5d
TI		 5337 [ALC269_FIXUP_AMIC] = {
5338 .type = ALC_FIXUP_PINS,
5339 .v.pins = (const struct alc_pincfg[]) {
5340 { 0x14, 0x99130110 }, /* speaker */
5341 { 0x15, 0x0121401f }, /* HP out */
5342 { 0x18, 0x01a19c20 }, /* mic */
5343 { 0x19, 0x99a3092f }, /* int-mic */
5344 { }
5345 },
5346 },
5347 [ALC269_FIXUP_DMIC] = {
5348 .type = ALC_FIXUP_PINS,
5349 .v.pins = (const struct alc_pincfg[]) {
5350 { 0x12, 0x99a3092f }, /* int-mic */
5351 { 0x14, 0x99130110 }, /* speaker */
5352 { 0x15, 0x0121401f }, /* HP out */
5353 { 0x18, 0x01a19c20 }, /* mic */
5354 { }
5355 },
5356 },
5357 [ALC269VB_FIXUP_AMIC] = {
5358 .type = ALC_FIXUP_PINS,
5359 .v.pins = (const struct alc_pincfg[]) {
5360 { 0x14, 0x99130110 }, /* speaker */
5361 { 0x18, 0x01a19c20 }, /* mic */
5362 { 0x19, 0x99a3092f }, /* int-mic */
5363 { 0x21, 0x0121401f }, /* HP out */
5364 { }
5365 },
5366 },
2267ea97 5367 [ALC269VB_FIXUP_DMIC] = {
a4297b5d
TI		 5368 .type = ALC_FIXUP_PINS,
5369 .v.pins = (const struct alc_pincfg[]) {
5370 { 0x12, 0x99a3092f }, /* int-mic */
5371 { 0x14, 0x99130110 }, /* speaker */
5372 { 0x18, 0x01a19c20 }, /* mic */
5373 { 0x21, 0x0121401f }, /* HP out */
5374 { }
5375 },
5376 },
f1d4e28b
KY		 5377};
5378
1d045db9 5379static const struct snd_pci_quirk alc269_fixup_tbl[] = {
017f2a10 5380 SND_PCI_QUIRK(0x1043, 0x1a13, "Asus G73Jw", ALC269_FIXUP_ASUS_G73JW),
adabb3ec
TI		 5381 SND_PCI_QUIRK(0x1043, 0x16e3, "ASUS UX50", ALC269_FIXUP_STEREO_DMIC),
5382 SND_PCI_QUIRK(0x1043, 0x831a, "ASUS P901", ALC269_FIXUP_STEREO_DMIC),
5383 SND_PCI_QUIRK(0x1043, 0x834a, "ASUS S101", ALC269_FIXUP_STEREO_DMIC),
5384 SND_PCI_QUIRK(0x1043, 0x8398, "ASUS P1005", ALC269_FIXUP_STEREO_DMIC),
5385 SND_PCI_QUIRK(0x1043, 0x83ce, "ASUS P1005", ALC269_FIXUP_STEREO_DMIC),
1d045db9
TI		 5386 SND_PCI_QUIRK(0x104d, 0x9073, "Sony VAIO", ALC275_FIXUP_SONY_VAIO_GPIO2),
5387 SND_PCI_QUIRK(0x104d, 0x907b, "Sony VAIO", ALC275_FIXUP_SONY_HWEQ),
5388 SND_PCI_QUIRK(0x104d, 0x9084, "Sony VAIO", ALC275_FIXUP_SONY_HWEQ),
5389 SND_PCI_QUIRK_VENDOR(0x104d, "Sony VAIO", ALC269_FIXUP_SONY_VAIO),
5390 SND_PCI_QUIRK(0x1028, 0x0470, "Dell M101z", ALC269_FIXUP_DELL_M101Z),
5391 SND_PCI_QUIRK_VENDOR(0x1025, "Acer Aspire", ALC271_FIXUP_DMIC),
24519911 5392 SND_PCI_QUIRK(0x10cf, 0x1475, "Lifebook", ALC269_FIXUP_LIFEBOOK),
1d045db9
TI		 5393 SND_PCI_QUIRK(0x17aa, 0x20f2, "Thinkpad SL410/510", ALC269_FIXUP_SKU_IGNORE),
5394 SND_PCI_QUIRK(0x17aa, 0x215e, "Thinkpad L512", ALC269_FIXUP_SKU_IGNORE),
5395 SND_PCI_QUIRK(0x17aa, 0x21b8, "Thinkpad Edge 14", ALC269_FIXUP_SKU_IGNORE),
5396 SND_PCI_QUIRK(0x17aa, 0x21ca, "Thinkpad L412", ALC269_FIXUP_SKU_IGNORE),
5397 SND_PCI_QUIRK(0x17aa, 0x21e9, "Thinkpad Edge 15", ALC269_FIXUP_SKU_IGNORE),
24519911 5398 SND_PCI_QUIRK(0x17aa, 0x3bf8, "Quanta FL1", ALC269_FIXUP_QUANTA_MUTE),
017f2a10 5399 SND_PCI_QUIRK(0x17aa, 0x3bf8, "Lenovo Ideapd", ALC269_FIXUP_PCM_44K),
1d045db9 5400 SND_PCI_QUIRK(0x17aa, 0x9e54, "LENOVO NB", ALC269_FIXUP_LENOVO_EAPD),
a4297b5d
TI		 5401
5402#if 1
5403 /* Below is a quirk table taken from the old code.
5404 * Basically the device should work as is without the fixup table.
5405 * If BIOS doesn't give a proper info, enable the corresponding
5406 * fixup entry.
5407 */
5408 SND_PCI_QUIRK(0x1043, 0x8330, "ASUS Eeepc P703 P900A",
5409 ALC269_FIXUP_AMIC),
5410 SND_PCI_QUIRK(0x1043, 0x1013, "ASUS N61Da", ALC269_FIXUP_AMIC),
a4297b5d
TI		 5411 SND_PCI_QUIRK(0x1043, 0x1143, "ASUS B53f", ALC269_FIXUP_AMIC),
5412 SND_PCI_QUIRK(0x1043, 0x1133, "ASUS UJ20ft", ALC269_FIXUP_AMIC),
5413 SND_PCI_QUIRK(0x1043, 0x1183, "ASUS K72DR", ALC269_FIXUP_AMIC),
5414 SND_PCI_QUIRK(0x1043, 0x11b3, "ASUS K52DR", ALC269_FIXUP_AMIC),
5415 SND_PCI_QUIRK(0x1043, 0x11e3, "ASUS U33Jc", ALC269_FIXUP_AMIC),
5416 SND_PCI_QUIRK(0x1043, 0x1273, "ASUS UL80Jt", ALC269_FIXUP_AMIC),
5417 SND_PCI_QUIRK(0x1043, 0x1283, "ASUS U53Jc", ALC269_FIXUP_AMIC),
5418 SND_PCI_QUIRK(0x1043, 0x12b3, "ASUS N82JV", ALC269_FIXUP_AMIC),
5419 SND_PCI_QUIRK(0x1043, 0x12d3, "ASUS N61Jv", ALC269_FIXUP_AMIC),
5420 SND_PCI_QUIRK(0x1043, 0x13a3, "ASUS UL30Vt", ALC269_FIXUP_AMIC),
5421 SND_PCI_QUIRK(0x1043, 0x1373, "ASUS G73JX", ALC269_FIXUP_AMIC),
5422 SND_PCI_QUIRK(0x1043, 0x1383, "ASUS UJ30Jc", ALC269_FIXUP_AMIC),
5423 SND_PCI_QUIRK(0x1043, 0x13d3, "ASUS N61JA", ALC269_FIXUP_AMIC),
5424 SND_PCI_QUIRK(0x1043, 0x1413, "ASUS UL50", ALC269_FIXUP_AMIC),
5425 SND_PCI_QUIRK(0x1043, 0x1443, "ASUS UL30", ALC269_FIXUP_AMIC),
5426 SND_PCI_QUIRK(0x1043, 0x1453, "ASUS M60Jv", ALC269_FIXUP_AMIC),
5427 SND_PCI_QUIRK(0x1043, 0x1483, "ASUS UL80", ALC269_FIXUP_AMIC),
5428 SND_PCI_QUIRK(0x1043, 0x14f3, "ASUS F83Vf", ALC269_FIXUP_AMIC),
5429 SND_PCI_QUIRK(0x1043, 0x14e3, "ASUS UL20", ALC269_FIXUP_AMIC),
5430 SND_PCI_QUIRK(0x1043, 0x1513, "ASUS UX30", ALC269_FIXUP_AMIC),
5431 SND_PCI_QUIRK(0x1043, 0x1593, "ASUS N51Vn", ALC269_FIXUP_AMIC),
5432 SND_PCI_QUIRK(0x1043, 0x15a3, "ASUS N60Jv", ALC269_FIXUP_AMIC),
5433 SND_PCI_QUIRK(0x1043, 0x15b3, "ASUS N60Dp", ALC269_FIXUP_AMIC),
5434 SND_PCI_QUIRK(0x1043, 0x15c3, "ASUS N70De", ALC269_FIXUP_AMIC),
5435 SND_PCI_QUIRK(0x1043, 0x15e3, "ASUS F83T", ALC269_FIXUP_AMIC),
5436 SND_PCI_QUIRK(0x1043, 0x1643, "ASUS M60J", ALC269_FIXUP_AMIC),
5437 SND_PCI_QUIRK(0x1043, 0x1653, "ASUS U50", ALC269_FIXUP_AMIC),
5438 SND_PCI_QUIRK(0x1043, 0x1693, "ASUS F50N", ALC269_FIXUP_AMIC),
5439 SND_PCI_QUIRK(0x1043, 0x16a3, "ASUS F5Q", ALC269_FIXUP_AMIC),
5440 SND_PCI_QUIRK(0x1043, 0x1723, "ASUS P80", ALC269_FIXUP_AMIC),
5441 SND_PCI_QUIRK(0x1043, 0x1743, "ASUS U80", ALC269_FIXUP_AMIC),
5442 SND_PCI_QUIRK(0x1043, 0x1773, "ASUS U20A", ALC269_FIXUP_AMIC),
5443 SND_PCI_QUIRK(0x1043, 0x1883, "ASUS F81Se", ALC269_FIXUP_AMIC),
5444 SND_PCI_QUIRK(0x152d, 0x1778, "Quanta ON1", ALC269_FIXUP_DMIC),
5445 SND_PCI_QUIRK(0x17aa, 0x3be9, "Quanta Wistron", ALC269_FIXUP_AMIC),
5446 SND_PCI_QUIRK(0x17aa, 0x3bf8, "Quanta FL1", ALC269_FIXUP_AMIC),
5447 SND_PCI_QUIRK(0x17ff, 0x059a, "Quanta EL3", ALC269_FIXUP_DMIC),
5448 SND_PCI_QUIRK(0x17ff, 0x059b, "Quanta JR1", ALC269_FIXUP_DMIC),
5449#endif
5450 {}
5451};
5452
5453static const struct alc_model_fixup alc269_fixup_models[] = {
5454 {.id = ALC269_FIXUP_AMIC, .name = "laptop-amic"},
5455 {.id = ALC269_FIXUP_DMIC, .name = "laptop-dmic"},
1d045db9 5456 {}
6dda9f4a
KY		 5457};
5458
6dda9f4a 5459
1d045db9
TI		 5460static int alc269_fill_coef(struct hda_codec *codec)
5461{
5462 int val;
ebb83eeb 5463
1bb7e43e 5464 if ((alc_get_coef0(codec) & 0x00ff) < 0x015) {
1d045db9
TI		 5465 alc_write_coef_idx(codec, 0xf, 0x960b);
5466 alc_write_coef_idx(codec, 0xe, 0x8817);
5467 }
ebb83eeb 5468
1bb7e43e 5469 if ((alc_get_coef0(codec) & 0x00ff) == 0x016) {
1d045db9
TI		 5470 alc_write_coef_idx(codec, 0xf, 0x960b);
5471 alc_write_coef_idx(codec, 0xe, 0x8814);
5472 }
ebb83eeb 5473
1bb7e43e 5474 if ((alc_get_coef0(codec) & 0x00ff) == 0x017) {
1d045db9
TI		 5475 val = alc_read_coef_idx(codec, 0x04);
5476 /* Power up output pin */
5477 alc_write_coef_idx(codec, 0x04, val | (1<<11));
5478 }
ebb83eeb 5479
1bb7e43e 5480 if ((alc_get_coef0(codec) & 0x00ff) == 0x018) {
1d045db9
TI		 5481 val = alc_read_coef_idx(codec, 0xd);
5482 if ((val & 0x0c00) >> 10 != 0x1) {
5483 /* Capless ramp up clock control */
5484 alc_write_coef_idx(codec, 0xd, val | (1<<10));
5485 }
5486 val = alc_read_coef_idx(codec, 0x17);
5487 if ((val & 0x01c0) >> 6 != 0x4) {
5488 /* Class D power on reset */
5489 alc_write_coef_idx(codec, 0x17, val | (1<<7));
5490 }
5491 }
ebb83eeb 5492
1d045db9
TI		 5493 val = alc_read_coef_idx(codec, 0xd); /* Class D */
5494 alc_write_coef_idx(codec, 0xd, val | (1<<14));
bc9f98a9 5495
1d045db9
TI		 5496 val = alc_read_coef_idx(codec, 0x4); /* HP */
5497 alc_write_coef_idx(codec, 0x4, val | (1<<11));
6dda9f4a 5498
1d045db9
TI		 5499 return 0;
5500}
a7f2371f 5501
1d045db9
TI		 5502/*
5503 */
1d045db9
TI		 5504static int patch_alc269(struct hda_codec *codec)
5505{
5506 struct alc_spec *spec;
20ca0c35 5507 int err = 0;
291702f0 5508
1d045db9
TI		 5509 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
5510 if (spec == NULL)
5511 return -ENOMEM;
bc9f98a9 5512
1d045db9 5513 codec->spec = spec;
8c427226 5514
1d045db9 5515 spec->mixer_nid = 0x0b;
f1d4e28b 5516
1d045db9 5517 alc_auto_parse_customize_define(codec);
f1d4e28b 5518
e16fb6d1
TI		 5519 err = alc_codec_rename_from_preset(codec);
5520 if (err < 0)
5521 goto error;
5522
1d045db9
TI		 5523 if (codec->vendor_id == 0x10ec0269) {
5524 spec->codec_variant = ALC269_TYPE_ALC269VA;
1bb7e43e
TI		 5525 switch (alc_get_coef0(codec) & 0x00f0) {
5526 case 0x0010:
1d045db9 5527 if (codec->bus->pci->subsystem_vendor == 0x1025 &&
e16fb6d1 5528 spec->cdefine.platform_type == 1)
20ca0c35 5529 err = alc_codec_rename(codec, "ALC271X");
1d045db9 5530 spec->codec_variant = ALC269_TYPE_ALC269VB;
1bb7e43e
TI		 5531 break;
5532 case 0x0020:
e16fb6d1
TI		 5533 if (codec->bus->pci->subsystem_vendor == 0x17aa &&
5534 codec->bus->pci->subsystem_device == 0x21f3)
20ca0c35 5535 err = alc_codec_rename(codec, "ALC3202");
1d045db9 5536 spec->codec_variant = ALC269_TYPE_ALC269VC;
1bb7e43e
TI		 5537 break;
5538 default:
1d045db9 5539 alc_fix_pll_init(codec, 0x20, 0x04, 15);
1bb7e43e 5540 }
e16fb6d1
TI		 5541 if (err < 0)
5542 goto error;
1d045db9
TI		 5543 alc269_fill_coef(codec);
5544 }
6dda9f4a 5545
a4297b5d
TI		 5546 alc_pick_fixup(codec, alc269_fixup_models,
5547 alc269_fixup_tbl, alc269_fixups);
5548 alc_apply_fixup(codec, ALC_FIXUP_ACT_PRE_PROBE);
6dda9f4a 5549
a4297b5d
TI		 5550 /* automatic parse from the BIOS config */
5551 err = alc269_parse_auto_config(codec);
e16fb6d1
TI		 5552 if (err < 0)
5553 goto error;
6dda9f4a 5554
60a6a842 5555 if (!spec->no_analog && !spec->adc_nids) {
1d045db9
TI		 5556 alc_auto_fill_adc_caps(codec);
5557 alc_rebuild_imux_for_auto_mic(codec);
5558 alc_remove_invalid_adc_nids(codec);
5559 }
6dda9f4a 5560
3e6179b8 5561 if (!spec->no_analog && !spec->cap_mixer)
1d045db9 5562 set_capture_mixer(codec);
3e6179b8
TI		 5563
5564 if (!spec->no_analog && has_cdefine_beep(codec)) {
5565 err = snd_hda_attach_beep_device(codec, 0x1);
e16fb6d1
TI		 5566 if (err < 0)
5567 goto error;
1d045db9 5568 set_beep_amp(spec, 0x0b, 0x04, HDA_INPUT);
3e6179b8 5569 }
f1d4e28b 5570
1d045db9 5571 alc_apply_fixup(codec, ALC_FIXUP_ACT_PROBE);
622e84cd 5572
1d045db9 5573 codec->patch_ops = alc_patch_ops;
2a43952a 5574#ifdef CONFIG_PM
1d045db9
TI		 5575 codec->patch_ops.resume = alc269_resume;
5576#endif
a4297b5d 5577 spec->init_hook = alc_auto_init_std;
1d045db9 5578 spec->shutup = alc269_shutup;
ebb83eeb 5579
1d045db9
TI		 5580#ifdef CONFIG_SND_HDA_POWER_SAVE
5581 if (!spec->loopback.amplist)
5582 spec->loopback.amplist = alc269_loopbacks;
5583 if (alc269_mic2_for_mute_led(codec))
5584 codec->patch_ops.check_power_status = alc269_mic2_mute_check_ps;
5585#endif
ebb83eeb 5586
1d045db9 5587 return 0;
e16fb6d1
TI		 5588
5589 error:
5590 alc_free(codec);
5591 return err;
1d045db9 5592}
f1d4e28b 5593
1d045db9
TI		 5594/*
5595 * ALC861
5596 */
622e84cd 5597
1d045db9 5598static int alc861_parse_auto_config(struct hda_codec *codec)
6dda9f4a 5599{
1d045db9 5600 static const hda_nid_t alc861_ignore[] = { 0x1d, 0 };
3e6179b8
TI		 5601 static const hda_nid_t alc861_ssids[] = { 0x0e, 0x0f, 0x0b, 0 };
5602 return alc_parse_auto_config(codec, alc861_ignore, alc861_ssids);
604401a9
TI		 5603}
5604
1d045db9
TI		 5605#ifdef CONFIG_SND_HDA_POWER_SAVE
5606static const struct hda_amp_list alc861_loopbacks[] = {
5607 { 0x15, HDA_INPUT, 0 },
5608 { 0x15, HDA_INPUT, 1 },
5609 { 0x15, HDA_INPUT, 2 },
5610 { 0x15, HDA_INPUT, 3 },
5611 { } /* end */
5612};
5613#endif
ce764ab2 5614
ce764ab2 5615
1d045db9
TI		 5616/* Pin config fixes */
5617enum {
5618 PINFIX_FSC_AMILO_PI1505,
3b25eb69 5619 PINFIX_ASUS_A6RP,
1d045db9 5620};
7085ec12 5621
31150f23
TI		 5622/* On some laptops, VREF of pin 0x0f is abused for controlling the main amp */
5623static void alc861_fixup_asus_amp_vref_0f(struct hda_codec *codec,
5624 const struct alc_fixup *fix, int action)
5625{
5626 struct alc_spec *spec = codec->spec;
5627 unsigned int val;
5628
5629 if (action != ALC_FIXUP_ACT_INIT)
5630 return;
5631 val = snd_hda_codec_read(codec, 0x0f, 0,
5632 AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
5633 if (!(val & (AC_PINCTL_IN_EN | AC_PINCTL_OUT_EN)))
5634 val |= AC_PINCTL_IN_EN;
5635 val |= AC_PINCTL_VREF_50;
5636 snd_hda_codec_write(codec, 0x0f, 0,
5637 AC_VERB_SET_PIN_WIDGET_CONTROL, val);
5638 spec->keep_vref_in_automute = 1;
5639}
5640
1d045db9
TI		 5641static const struct alc_fixup alc861_fixups[] = {
5642 [PINFIX_FSC_AMILO_PI1505] = {
5643 .type = ALC_FIXUP_PINS,
5644 .v.pins = (const struct alc_pincfg[]) {
5645 { 0x0b, 0x0221101f }, /* HP */
5646 { 0x0f, 0x90170310 }, /* speaker */
5647 { }
5648 }
5649 },
3b25eb69 5650 [PINFIX_ASUS_A6RP] = {
31150f23
TI		 5651 .type = ALC_FIXUP_FUNC,
5652 .v.func = alc861_fixup_asus_amp_vref_0f,
3b25eb69 5653 },
1d045db9 5654};
7085ec12 5655
1d045db9 5656static const struct snd_pci_quirk alc861_fixup_tbl[] = {
31150f23 5657 SND_PCI_QUIRK_VENDOR(0x1043, "ASUS laptop", PINFIX_ASUS_A6RP),
416846d2 5658 SND_PCI_QUIRK(0x1584, 0x0000, "Uniwill ECS M31EI", PINFIX_ASUS_A6RP),
b3a81520 5659 SND_PCI_QUIRK(0x1584, 0x2b01, "Haier W18", PINFIX_ASUS_A6RP),
1d045db9
TI		 5660 SND_PCI_QUIRK(0x1734, 0x10c7, "FSC Amilo Pi1505", PINFIX_FSC_AMILO_PI1505),
5661 {}
5662};
3af9ee6b 5663
1d045db9
TI		 5664/*
5665 */
1d045db9 5666static int patch_alc861(struct hda_codec *codec)
7085ec12 5667{
1d045db9 5668 struct alc_spec *spec;
1d045db9 5669 int err;
7085ec12 5670
1d045db9
TI		 5671 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
5672 if (spec == NULL)
5673 return -ENOMEM;
3af9ee6b 5674
1d045db9
TI		 5675 codec->spec = spec;
5676
5677 spec->mixer_nid = 0x15;
5678
cb4e4824
TI		 5679 alc_pick_fixup(codec, NULL, alc861_fixup_tbl, alc861_fixups);
5680 alc_apply_fixup(codec, ALC_FIXUP_ACT_PRE_PROBE);
3af9ee6b 5681
cb4e4824
TI		 5682 /* automatic parse from the BIOS config */
5683 err = alc861_parse_auto_config(codec);
e16fb6d1
TI		 5684 if (err < 0)
5685 goto error;
3af9ee6b 5686
60a6a842 5687 if (!spec->no_analog && !spec->adc_nids) {
1d045db9
TI		 5688 alc_auto_fill_adc_caps(codec);
5689 alc_rebuild_imux_for_auto_mic(codec);
5690 alc_remove_invalid_adc_nids(codec);
5691 }
7085ec12 5692
3e6179b8 5693 if (!spec->no_analog && !spec->cap_mixer)
1d045db9 5694 set_capture_mixer(codec);
3e6179b8
TI		 5695
5696 if (!spec->no_analog) {
5697 err = snd_hda_attach_beep_device(codec, 0x23);
e16fb6d1
TI		 5698 if (err < 0)
5699 goto error;
3e6179b8
TI		 5700 set_beep_amp(spec, 0x23, 0, HDA_OUTPUT);
5701 }
7085ec12 5702
1d045db9
TI		 5703 alc_apply_fixup(codec, ALC_FIXUP_ACT_PROBE);
5704
5705 codec->patch_ops = alc_patch_ops;
cb4e4824 5706 spec->init_hook = alc_auto_init_std;
1d045db9 5707#ifdef CONFIG_SND_HDA_POWER_SAVE
cb4e4824 5708 spec->power_hook = alc_power_eapd;
1d045db9
TI		 5709 if (!spec->loopback.amplist)
5710 spec->loopback.amplist = alc861_loopbacks;
5711#endif
5712
5713 return 0;
e16fb6d1
TI		 5714
5715 error:
5716 alc_free(codec);
5717 return err;
7085ec12
TI		 5718}
5719
1d045db9
TI		 5720/*
5721 * ALC861-VD support
5722 *
5723 * Based on ALC882
5724 *
5725 * In addition, an independent DAC
5726 */
5727#ifdef CONFIG_SND_HDA_POWER_SAVE
5728#define alc861vd_loopbacks alc880_loopbacks
5729#endif
5730
1d045db9 5731static int alc861vd_parse_auto_config(struct hda_codec *codec)
bc9f98a9 5732{
1d045db9 5733 static const hda_nid_t alc861vd_ignore[] = { 0x1d, 0 };
3e6179b8
TI		 5734 static const hda_nid_t alc861vd_ssids[] = { 0x15, 0x1b, 0x14, 0 };
5735 return alc_parse_auto_config(codec, alc861vd_ignore, alc861vd_ssids);
ce764ab2
TI		 5736}
5737
1d045db9 5738enum {
8fdcb6fe
TI		 5739 ALC660VD_FIX_ASUS_GPIO1,
5740 ALC861VD_FIX_DALLAS,
1d045db9 5741};
ce764ab2 5742
8fdcb6fe
TI		 5743/* exclude VREF80 */
5744static void alc861vd_fixup_dallas(struct hda_codec *codec,
5745 const struct alc_fixup *fix, int action)
5746{
5747 if (action == ALC_FIXUP_ACT_PRE_PROBE) {
5748 snd_hda_override_pin_caps(codec, 0x18, 0x00001714);
5749 snd_hda_override_pin_caps(codec, 0x19, 0x0000171c);
5750 }
5751}
5752
1d045db9
TI		 5753static const struct alc_fixup alc861vd_fixups[] = {
5754 [ALC660VD_FIX_ASUS_GPIO1] = {
5755 .type = ALC_FIXUP_VERBS,
5756 .v.verbs = (const struct hda_verb[]) {
8fdcb6fe 5757 /* reset GPIO1 */
1d045db9
TI		 5758 {0x01, AC_VERB_SET_GPIO_MASK, 0x03},
5759 {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
5760 {0x01, AC_VERB_SET_GPIO_DATA, 0x01},
5761 { }
5762 }
5763 },
8fdcb6fe
TI		 5764 [ALC861VD_FIX_DALLAS] = {
5765 .type = ALC_FIXUP_FUNC,
5766 .v.func = alc861vd_fixup_dallas,
5767 },
1d045db9 5768};
ce764ab2 5769
1d045db9 5770static const struct snd_pci_quirk alc861vd_fixup_tbl[] = {
8fdcb6fe 5771 SND_PCI_QUIRK(0x103c, 0x30bf, "HP TX1000", ALC861VD_FIX_DALLAS),
1d045db9 5772 SND_PCI_QUIRK(0x1043, 0x1339, "ASUS A7-K", ALC660VD_FIX_ASUS_GPIO1),
8fdcb6fe 5773 SND_PCI_QUIRK(0x1179, 0xff31, "Toshiba L30-149", ALC861VD_FIX_DALLAS),
1d045db9
TI		 5774 {}
5775};
ce764ab2 5776
1d045db9
TI		 5777static const struct hda_verb alc660vd_eapd_verbs[] = {
5778 {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
5779 {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
5780 { }
ce764ab2
TI		 5781};
5782
1d045db9
TI		 5783/*
5784 */
1d045db9 5785static int patch_alc861vd(struct hda_codec *codec)
ce764ab2 5786{
1d045db9 5787 struct alc_spec *spec;
cb4e4824 5788 int err;
ce764ab2 5789
1d045db9
TI		 5790 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
5791 if (spec == NULL)
5792 return -ENOMEM;
5793
5794 codec->spec = spec;
5795
5796 spec->mixer_nid = 0x0b;
5797
cb4e4824
TI		 5798 alc_pick_fixup(codec, NULL, alc861vd_fixup_tbl, alc861vd_fixups);
5799 alc_apply_fixup(codec, ALC_FIXUP_ACT_PRE_PROBE);
1d045db9 5800
cb4e4824
TI		 5801 /* automatic parse from the BIOS config */
5802 err = alc861vd_parse_auto_config(codec);
e16fb6d1
TI		 5803 if (err < 0)
5804 goto error;
ce764ab2 5805
1d045db9
TI		 5806 if (codec->vendor_id == 0x10ec0660) {
5807 /* always turn on EAPD */
5808 add_verb(spec, alc660vd_eapd_verbs);
5809 }
5810
60a6a842 5811 if (!spec->no_analog && !spec->adc_nids) {
1d045db9
TI		 5812 alc_auto_fill_adc_caps(codec);
5813 alc_rebuild_imux_for_auto_mic(codec);
5814 alc_remove_invalid_adc_nids(codec);
ce764ab2 5815 }
1d045db9 5816
3e6179b8
TI		 5817 if (!spec->no_analog && !spec->cap_mixer)
5818 set_capture_mixer(codec);
5819
5820 if (!spec->no_analog) {
5821 err = snd_hda_attach_beep_device(codec, 0x23);
e16fb6d1
TI		 5822 if (err < 0)
5823 goto error;
3e6179b8
TI		 5824 set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
5825 }
1d045db9 5826
1d045db9
TI		 5827 alc_apply_fixup(codec, ALC_FIXUP_ACT_PROBE);
5828
5829 codec->patch_ops = alc_patch_ops;
5830
cb4e4824 5831 spec->init_hook = alc_auto_init_std;
1d045db9
TI		 5832 spec->shutup = alc_eapd_shutup;
5833#ifdef CONFIG_SND_HDA_POWER_SAVE
5834 if (!spec->loopback.amplist)
5835 spec->loopback.amplist = alc861vd_loopbacks;
5836#endif
5837
ce764ab2 5838 return 0;
e16fb6d1
TI		 5839
5840 error:
5841 alc_free(codec);
5842 return err;
ce764ab2
TI		 5843}
5844
1d045db9
TI		 5845/*
5846 * ALC662 support
5847 *
5848 * ALC662 is almost identical with ALC880 but has cleaner and more flexible
5849 * configuration. Each pin widget can choose any input DACs and a mixer.
5850 * Each ADC is connected from a mixer of all inputs. This makes possible
5851 * 6-channel independent captures.
5852 *
5853 * In addition, an independent DAC for the multi-playback (not used in this
5854 * driver yet).
5855 */
5856#ifdef CONFIG_SND_HDA_POWER_SAVE
5857#define alc662_loopbacks alc880_loopbacks
5858#endif
5859
5860/*
5861 * BIOS auto configuration
5862 */
5863
bc9f98a9
KY		 5864static int alc662_parse_auto_config(struct hda_codec *codec)
5865{
4c6d72d1 5866 static const hda_nid_t alc662_ignore[] = { 0x1d, 0 };
3e6179b8
TI		 5867 static const hda_nid_t alc663_ssids[] = { 0x15, 0x1b, 0x14, 0x21 };
5868 static const hda_nid_t alc662_ssids[] = { 0x15, 0x1b, 0x14, 0 };
5869 const hda_nid_t *ssids;
ee979a14 5870
6227cdce
KY		 5871 if (codec->vendor_id == 0x10ec0272 || codec->vendor_id == 0x10ec0663 ||
5872 codec->vendor_id == 0x10ec0665 || codec->vendor_id == 0x10ec0670)
3e6179b8 5873 ssids = alc663_ssids;
6227cdce 5874 else
3e6179b8
TI		 5875 ssids = alc662_ssids;
5876 return alc_parse_auto_config(codec, alc662_ignore, ssids);
bc9f98a9
KY		 5877}
5878
6be7948f 5879static void alc272_fixup_mario(struct hda_codec *codec,
b5bfbc67 5880 const struct alc_fixup *fix, int action)
6fc398cb 5881{
b5bfbc67 5882 if (action != ALC_FIXUP_ACT_PROBE)
6fc398cb 5883 return;
6be7948f
TB		 5884 if (snd_hda_override_amp_caps(codec, 0x2, HDA_OUTPUT,
5885 (0x3b << AC_AMPCAP_OFFSET_SHIFT) |
5886 (0x3b << AC_AMPCAP_NUM_STEPS_SHIFT) |
5887 (0x03 << AC_AMPCAP_STEP_SIZE_SHIFT) |
5888 (0 << AC_AMPCAP_MUTE_SHIFT)))
5889 printk(KERN_WARNING
5890 "hda_codec: failed to override amp caps for NID 0x2\n");
5891}
5892
6cb3b707 5893enum {
2df03514 5894 ALC662_FIXUP_ASPIRE,
6cb3b707 5895 ALC662_FIXUP_IDEAPAD,
6be7948f 5896 ALC272_FIXUP_MARIO,
d2ebd479 5897 ALC662_FIXUP_CZC_P10T,
94024cd1 5898 ALC662_FIXUP_SKU_IGNORE,
e59ea3ed 5899 ALC662_FIXUP_HP_RP5800,
53c334ad
TI		 5900 ALC662_FIXUP_ASUS_MODE1,
5901 ALC662_FIXUP_ASUS_MODE2,
5902 ALC662_FIXUP_ASUS_MODE3,
5903 ALC662_FIXUP_ASUS_MODE4,
5904 ALC662_FIXUP_ASUS_MODE5,
5905 ALC662_FIXUP_ASUS_MODE6,
5906 ALC662_FIXUP_ASUS_MODE7,
5907 ALC662_FIXUP_ASUS_MODE8,
6cb3b707
DH		 5908};
5909
5910static const struct alc_fixup alc662_fixups[] = {
2df03514 5911 [ALC662_FIXUP_ASPIRE] = {
b5bfbc67
TI		 5912 .type = ALC_FIXUP_PINS,
5913 .v.pins = (const struct alc_pincfg[]) {
2df03514
DC		 5914 { 0x15, 0x99130112 }, /* subwoofer */
5915 { }
5916 }
5917 },
6cb3b707 5918 [ALC662_FIXUP_IDEAPAD] = {
b5bfbc67
TI		 5919 .type = ALC_FIXUP_PINS,
5920 .v.pins = (const struct alc_pincfg[]) {
6cb3b707
DH		 5921 { 0x17, 0x99130112 }, /* subwoofer */
5922 { }
5923 }
5924 },
6be7948f 5925 [ALC272_FIXUP_MARIO] = {
b5bfbc67
TI		 5926 .type = ALC_FIXUP_FUNC,
5927 .v.func = alc272_fixup_mario,
d2ebd479
AA		 5928 },
5929 [ALC662_FIXUP_CZC_P10T] = {
5930 .type = ALC_FIXUP_VERBS,
5931 .v.verbs = (const struct hda_verb[]) {
5932 {0x14, AC_VERB_SET_EAPD_BTLENABLE, 0},
5933 {}
5934 }
5935 },
94024cd1
DH		 5936 [ALC662_FIXUP_SKU_IGNORE] = {
5937 .type = ALC_FIXUP_SKU,
5938 .v.sku = ALC_FIXUP_SKU_IGNORE,
c6b35874 5939 },
e59ea3ed
TI		 5940 [ALC662_FIXUP_HP_RP5800] = {
5941 .type = ALC_FIXUP_PINS,
5942 .v.pins = (const struct alc_pincfg[]) {
5943 { 0x14, 0x0221201f }, /* HP out */
5944 { }
5945 },
5946 .chained = true,
5947 .chain_id = ALC662_FIXUP_SKU_IGNORE
5948 },
53c334ad
TI		 5949 [ALC662_FIXUP_ASUS_MODE1] = {
5950 .type = ALC_FIXUP_PINS,
5951 .v.pins = (const struct alc_pincfg[]) {
5952 { 0x14, 0x99130110 }, /* speaker */
5953 { 0x18, 0x01a19c20 }, /* mic */
5954 { 0x19, 0x99a3092f }, /* int-mic */
5955 { 0x21, 0x0121401f }, /* HP out */
5956 { }
5957 },
5958 .chained = true,
5959 .chain_id = ALC662_FIXUP_SKU_IGNORE
5960 },
5961 [ALC662_FIXUP_ASUS_MODE2] = {
2996bdba
TI		 5962 .type = ALC_FIXUP_PINS,
5963 .v.pins = (const struct alc_pincfg[]) {
5964 { 0x14, 0x99130110 }, /* speaker */
5965 { 0x18, 0x01a19820 }, /* mic */
5966 { 0x19, 0x99a3092f }, /* int-mic */
5967 { 0x1b, 0x0121401f }, /* HP out */
5968 { }
5969 },
53c334ad
TI		 5970 .chained = true,
5971 .chain_id = ALC662_FIXUP_SKU_IGNORE
5972 },
5973 [ALC662_FIXUP_ASUS_MODE3] = {
5974 .type = ALC_FIXUP_PINS,
5975 .v.pins = (const struct alc_pincfg[]) {
5976 { 0x14, 0x99130110 }, /* speaker */
5977 { 0x15, 0x0121441f }, /* HP */
5978 { 0x18, 0x01a19840 }, /* mic */
5979 { 0x19, 0x99a3094f }, /* int-mic */
5980 { 0x21, 0x01211420 }, /* HP2 */
5981 { }
5982 },
5983 .chained = true,
5984 .chain_id = ALC662_FIXUP_SKU_IGNORE
5985 },
5986 [ALC662_FIXUP_ASUS_MODE4] = {
5987 .type = ALC_FIXUP_PINS,
5988 .v.pins = (const struct alc_pincfg[]) {
5989 { 0x14, 0x99130110 }, /* speaker */
5990 { 0x16, 0x99130111 }, /* speaker */
5991 { 0x18, 0x01a19840 }, /* mic */
5992 { 0x19, 0x99a3094f }, /* int-mic */
5993 { 0x21, 0x0121441f }, /* HP */
5994 { }
5995 },
5996 .chained = true,
5997 .chain_id = ALC662_FIXUP_SKU_IGNORE
5998 },
5999 [ALC662_FIXUP_ASUS_MODE5] = {
6000 .type = ALC_FIXUP_PINS,
6001 .v.pins = (const struct alc_pincfg[]) {
6002 { 0x14, 0x99130110 }, /* speaker */
6003 { 0x15, 0x0121441f }, /* HP */
6004 { 0x16, 0x99130111 }, /* speaker */
6005 { 0x18, 0x01a19840 }, /* mic */
6006 { 0x19, 0x99a3094f }, /* int-mic */
6007 { }
6008 },
6009 .chained = true,
6010 .chain_id = ALC662_FIXUP_SKU_IGNORE
6011 },
6012 [ALC662_FIXUP_ASUS_MODE6] = {
6013 .type = ALC_FIXUP_PINS,
6014 .v.pins = (const struct alc_pincfg[]) {
6015 { 0x14, 0x99130110 }, /* speaker */
6016 { 0x15, 0x01211420 }, /* HP2 */
6017 { 0x18, 0x01a19840 }, /* mic */
6018 { 0x19, 0x99a3094f }, /* int-mic */
6019 { 0x1b, 0x0121441f }, /* HP */
6020 { }
6021 },
6022 .chained = true,
6023 .chain_id = ALC662_FIXUP_SKU_IGNORE
6024 },
6025 [ALC662_FIXUP_ASUS_MODE7] = {
6026 .type = ALC_FIXUP_PINS,
6027 .v.pins = (const struct alc_pincfg[]) {
6028 { 0x14, 0x99130110 }, /* speaker */
6029 { 0x17, 0x99130111 }, /* speaker */
6030 { 0x18, 0x01a19840 }, /* mic */
6031 { 0x19, 0x99a3094f }, /* int-mic */
6032 { 0x1b, 0x01214020 }, /* HP */
6033 { 0x21, 0x0121401f }, /* HP */
6034 { }
6035 },
6036 .chained = true,
6037 .chain_id = ALC662_FIXUP_SKU_IGNORE
6038 },
6039 [ALC662_FIXUP_ASUS_MODE8] = {
6040 .type = ALC_FIXUP_PINS,
6041 .v.pins = (const struct alc_pincfg[]) {
6042 { 0x14, 0x99130110 }, /* speaker */
6043 { 0x12, 0x99a30970 }, /* int-mic */
6044 { 0x15, 0x01214020 }, /* HP */
6045 { 0x17, 0x99130111 }, /* speaker */
6046 { 0x18, 0x01a19840 }, /* mic */
6047 { 0x21, 0x0121401f }, /* HP */
6048 { }
6049 },
6050 .chained = true,
6051 .chain_id = ALC662_FIXUP_SKU_IGNORE
2996bdba 6052 },
6cb3b707
DH		 6053};
6054
a9111321 6055static const struct snd_pci_quirk alc662_fixup_tbl[] = {
53c334ad 6056 SND_PCI_QUIRK(0x1019, 0x9087, "ECS", ALC662_FIXUP_ASUS_MODE2),
a6c47a85 6057 SND_PCI_QUIRK(0x1025, 0x0308, "Acer Aspire 8942G", ALC662_FIXUP_ASPIRE),
94024cd1 6058 SND_PCI_QUIRK(0x1025, 0x031c, "Gateway NV79", ALC662_FIXUP_SKU_IGNORE),
2df03514 6059 SND_PCI_QUIRK(0x1025, 0x038b, "Acer Aspire 8943G", ALC662_FIXUP_ASPIRE),
e59ea3ed 6060 SND_PCI_QUIRK(0x103c, 0x1632, "HP RP5800", ALC662_FIXUP_HP_RP5800),
53c334ad 6061 SND_PCI_QUIRK(0x105b, 0x0cd6, "Foxconn", ALC662_FIXUP_ASUS_MODE2),
a0e90acc 6062 SND_PCI_QUIRK(0x144d, 0xc051, "Samsung R720", ALC662_FIXUP_IDEAPAD),
d4118588 6063 SND_PCI_QUIRK(0x17aa, 0x38af, "Lenovo Ideapad Y550P", ALC662_FIXUP_IDEAPAD),
6cb3b707 6064 SND_PCI_QUIRK(0x17aa, 0x3a0d, "Lenovo Ideapad Y550", ALC662_FIXUP_IDEAPAD),
d2ebd479 6065 SND_PCI_QUIRK(0x1b35, 0x2206, "CZC P10T", ALC662_FIXUP_CZC_P10T),
53c334ad
TI		 6066
6067#if 0
6068 /* Below is a quirk table taken from the old code.
6069 * Basically the device should work as is without the fixup table.
6070 * If BIOS doesn't give a proper info, enable the corresponding
6071 * fixup entry.
6072 */
6073 SND_PCI_QUIRK(0x1043, 0x1000, "ASUS N50Vm", ALC662_FIXUP_ASUS_MODE1),
6074 SND_PCI_QUIRK(0x1043, 0x1092, "ASUS NB", ALC662_FIXUP_ASUS_MODE3),
6075 SND_PCI_QUIRK(0x1043, 0x1173, "ASUS K73Jn", ALC662_FIXUP_ASUS_MODE1),
6076 SND_PCI_QUIRK(0x1043, 0x11c3, "ASUS M70V", ALC662_FIXUP_ASUS_MODE3),
6077 SND_PCI_QUIRK(0x1043, 0x11d3, "ASUS NB", ALC662_FIXUP_ASUS_MODE1),
6078 SND_PCI_QUIRK(0x1043, 0x11f3, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
6079 SND_PCI_QUIRK(0x1043, 0x1203, "ASUS NB", ALC662_FIXUP_ASUS_MODE1),
6080 SND_PCI_QUIRK(0x1043, 0x1303, "ASUS G60J", ALC662_FIXUP_ASUS_MODE1),
6081 SND_PCI_QUIRK(0x1043, 0x1333, "ASUS G60Jx", ALC662_FIXUP_ASUS_MODE1),
6082 SND_PCI_QUIRK(0x1043, 0x1339, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
6083 SND_PCI_QUIRK(0x1043, 0x13e3, "ASUS N71JA", ALC662_FIXUP_ASUS_MODE7),
6084 SND_PCI_QUIRK(0x1043, 0x1463, "ASUS N71", ALC662_FIXUP_ASUS_MODE7),
6085 SND_PCI_QUIRK(0x1043, 0x14d3, "ASUS G72", ALC662_FIXUP_ASUS_MODE8),
6086 SND_PCI_QUIRK(0x1043, 0x1563, "ASUS N90", ALC662_FIXUP_ASUS_MODE3),
6087 SND_PCI_QUIRK(0x1043, 0x15d3, "ASUS N50SF F50SF", ALC662_FIXUP_ASUS_MODE1),
6088 SND_PCI_QUIRK(0x1043, 0x16c3, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
6089 SND_PCI_QUIRK(0x1043, 0x16f3, "ASUS K40C K50C", ALC662_FIXUP_ASUS_MODE2),
6090 SND_PCI_QUIRK(0x1043, 0x1733, "ASUS N81De", ALC662_FIXUP_ASUS_MODE1),
6091 SND_PCI_QUIRK(0x1043, 0x1753, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
6092 SND_PCI_QUIRK(0x1043, 0x1763, "ASUS NB", ALC662_FIXUP_ASUS_MODE6),
6093 SND_PCI_QUIRK(0x1043, 0x1765, "ASUS NB", ALC662_FIXUP_ASUS_MODE6),
6094 SND_PCI_QUIRK(0x1043, 0x1783, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
6095 SND_PCI_QUIRK(0x1043, 0x1793, "ASUS F50GX", ALC662_FIXUP_ASUS_MODE1),
6096 SND_PCI_QUIRK(0x1043, 0x17b3, "ASUS F70SL", ALC662_FIXUP_ASUS_MODE3),
6097 SND_PCI_QUIRK(0x1043, 0x17f3, "ASUS X58LE", ALC662_FIXUP_ASUS_MODE2),
6098 SND_PCI_QUIRK(0x1043, 0x1813, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
6099 SND_PCI_QUIRK(0x1043, 0x1823, "ASUS NB", ALC662_FIXUP_ASUS_MODE5),
6100 SND_PCI_QUIRK(0x1043, 0x1833, "ASUS NB", ALC662_FIXUP_ASUS_MODE6),
6101 SND_PCI_QUIRK(0x1043, 0x1843, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
6102 SND_PCI_QUIRK(0x1043, 0x1853, "ASUS F50Z", ALC662_FIXUP_ASUS_MODE1),
6103 SND_PCI_QUIRK(0x1043, 0x1864, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
6104 SND_PCI_QUIRK(0x1043, 0x1876, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
6105 SND_PCI_QUIRK(0x1043, 0x1893, "ASUS M50Vm", ALC662_FIXUP_ASUS_MODE3),
6106 SND_PCI_QUIRK(0x1043, 0x1894, "ASUS X55", ALC662_FIXUP_ASUS_MODE3),
6107 SND_PCI_QUIRK(0x1043, 0x18b3, "ASUS N80Vc", ALC662_FIXUP_ASUS_MODE1),
6108 SND_PCI_QUIRK(0x1043, 0x18c3, "ASUS VX5", ALC662_FIXUP_ASUS_MODE1),
6109 SND_PCI_QUIRK(0x1043, 0x18d3, "ASUS N81Te", ALC662_FIXUP_ASUS_MODE1),
6110 SND_PCI_QUIRK(0x1043, 0x18f3, "ASUS N505Tp", ALC662_FIXUP_ASUS_MODE1),
6111 SND_PCI_QUIRK(0x1043, 0x1903, "ASUS F5GL", ALC662_FIXUP_ASUS_MODE1),
6112 SND_PCI_QUIRK(0x1043, 0x1913, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
6113 SND_PCI_QUIRK(0x1043, 0x1933, "ASUS F80Q", ALC662_FIXUP_ASUS_MODE2),
6114 SND_PCI_QUIRK(0x1043, 0x1943, "ASUS Vx3V", ALC662_FIXUP_ASUS_MODE1),
6115 SND_PCI_QUIRK(0x1043, 0x1953, "ASUS NB", ALC662_FIXUP_ASUS_MODE1),
6116 SND_PCI_QUIRK(0x1043, 0x1963, "ASUS X71C", ALC662_FIXUP_ASUS_MODE3),
6117 SND_PCI_QUIRK(0x1043, 0x1983, "ASUS N5051A", ALC662_FIXUP_ASUS_MODE1),
6118 SND_PCI_QUIRK(0x1043, 0x1993, "ASUS N20", ALC662_FIXUP_ASUS_MODE1),
6119 SND_PCI_QUIRK(0x1043, 0x19b3, "ASUS F7Z", ALC662_FIXUP_ASUS_MODE1),
6120 SND_PCI_QUIRK(0x1043, 0x19c3, "ASUS F5Z/F6x", ALC662_FIXUP_ASUS_MODE2),
6121 SND_PCI_QUIRK(0x1043, 0x19e3, "ASUS NB", ALC662_FIXUP_ASUS_MODE1),
6122 SND_PCI_QUIRK(0x1043, 0x19f3, "ASUS NB", ALC662_FIXUP_ASUS_MODE4),
6123#endif
6cb3b707
DH		 6124 {}
6125};
6126
6be7948f
TB		 6127static const struct alc_model_fixup alc662_fixup_models[] = {
6128 {.id = ALC272_FIXUP_MARIO, .name = "mario"},
53c334ad
TI		 6129 {.id = ALC662_FIXUP_ASUS_MODE1, .name = "asus-mode1"},
6130 {.id = ALC662_FIXUP_ASUS_MODE2, .name = "asus-mode2"},
6131 {.id = ALC662_FIXUP_ASUS_MODE3, .name = "asus-mode3"},
6132 {.id = ALC662_FIXUP_ASUS_MODE4, .name = "asus-mode4"},
6133 {.id = ALC662_FIXUP_ASUS_MODE5, .name = "asus-mode5"},
6134 {.id = ALC662_FIXUP_ASUS_MODE6, .name = "asus-mode6"},
6135 {.id = ALC662_FIXUP_ASUS_MODE7, .name = "asus-mode7"},
6136 {.id = ALC662_FIXUP_ASUS_MODE8, .name = "asus-mode8"},
6be7948f
TB		 6137 {}
6138};
6cb3b707
DH		 6139
6140
1d045db9
TI		 6141/*
6142 */
bc9f98a9
KY		 6143static int patch_alc662(struct hda_codec *codec)
6144{
6145 struct alc_spec *spec;
20ca0c35 6146 int err = 0;
bc9f98a9
KY		 6147
6148 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
6149 if (!spec)
6150 return -ENOMEM;
6151
6152 codec->spec = spec;
6153
1f0f4b80
TI		 6154 spec->mixer_nid = 0x0b;
6155
53c334ad
TI		 6156 /* handle multiple HPs as is */
6157 spec->parse_flags = HDA_PINCFG_NO_HP_FIXUP;
6158
da00c244
KY		 6159 alc_auto_parse_customize_define(codec);
6160
2c3bf9ab
TI		 6161 alc_fix_pll_init(codec, 0x20, 0x04, 15);
6162
e16fb6d1
TI		 6163 err = alc_codec_rename_from_preset(codec);
6164 if (err < 0)
6165 goto error;
6166
1bb7e43e 6167 if ((alc_get_coef0(codec) & (1 << 14)) &&
e16fb6d1
TI		 6168 codec->bus->pci->subsystem_vendor == 0x1025 &&
6169 spec->cdefine.platform_type == 1) {
6170 if (alc_codec_rename(codec, "ALC272X") < 0)
6171 goto error;
20ca0c35 6172 }
274693f3 6173
b9c5106c
TI		 6174 alc_pick_fixup(codec, alc662_fixup_models,
6175 alc662_fixup_tbl, alc662_fixups);
6176 alc_apply_fixup(codec, ALC_FIXUP_ACT_PRE_PROBE);
6177 /* automatic parse from the BIOS config */
6178 err = alc662_parse_auto_config(codec);
e16fb6d1
TI		 6179 if (err < 0)
6180 goto error;
bc9f98a9 6181
60a6a842 6182 if (!spec->no_analog && !spec->adc_nids) {
d6cc9fab 6183 alc_auto_fill_adc_caps(codec);
21268961 6184 alc_rebuild_imux_for_auto_mic(codec);
d6cc9fab 6185 alc_remove_invalid_adc_nids(codec);
dd704698 6186 }
bc9f98a9 6187
3e6179b8 6188 if (!spec->no_analog && !spec->cap_mixer)
b59bdf3b 6189 set_capture_mixer(codec);
cec27c89 6190
3e6179b8
TI		 6191 if (!spec->no_analog && has_cdefine_beep(codec)) {
6192 err = snd_hda_attach_beep_device(codec, 0x1);
e16fb6d1
TI		 6193 if (err < 0)
6194 goto error;
da00c244
KY		 6195 switch (codec->vendor_id) {
6196 case 0x10ec0662:
6197 set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
6198 break;
6199 case 0x10ec0272:
6200 case 0x10ec0663:
6201 case 0x10ec0665:
6202 set_beep_amp(spec, 0x0b, 0x04, HDA_INPUT);
6203 break;
6204 case 0x10ec0273:
6205 set_beep_amp(spec, 0x0b, 0x03, HDA_INPUT);
6206 break;
6207 }
cec27c89 6208 }
2134ea4f 6209
b5bfbc67
TI		 6210 alc_apply_fixup(codec, ALC_FIXUP_ACT_PROBE);
6211
bc9f98a9 6212 codec->patch_ops = alc_patch_ops;
b9c5106c 6213 spec->init_hook = alc_auto_init_std;
1c716153 6214 spec->shutup = alc_eapd_shutup;
6cb3b707 6215
cb53c626
TI		 6216#ifdef CONFIG_SND_HDA_POWER_SAVE
6217 if (!spec->loopback.amplist)
6218 spec->loopback.amplist = alc662_loopbacks;
6219#endif
bc9f98a9
KY		 6220
6221 return 0;
801f49d3 6222
e16fb6d1
TI		 6223 error:
6224 alc_free(codec);
6225 return err;
b478b998
KY		 6226}
6227
d1eb57f4
KY		 6228/*
6229 * ALC680 support
6230 */
d1eb57f4 6231
d1eb57f4
KY		 6232static int alc680_parse_auto_config(struct hda_codec *codec)
6233{
3e6179b8 6234 return alc_parse_auto_config(codec, NULL, NULL);
d1eb57f4
KY		 6235}
6236
d1eb57f4 6237/*
d1eb57f4 6238 */
d1eb57f4
KY		 6239static int patch_alc680(struct hda_codec *codec)
6240{
6241 struct alc_spec *spec;
d1eb57f4
KY		 6242 int err;
6243
6244 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
6245 if (spec == NULL)
6246 return -ENOMEM;
6247
6248 codec->spec = spec;
6249
1f0f4b80
TI		 6250 /* ALC680 has no aa-loopback mixer */
6251
1ebec5f2
TI		 6252 /* automatic parse from the BIOS config */
6253 err = alc680_parse_auto_config(codec);
6254 if (err < 0) {
6255 alc_free(codec);
6256 return err;
d1eb57f4
KY		 6257 }
6258
3e6179b8 6259 if (!spec->no_analog && !spec->cap_mixer)
d1eb57f4
KY		 6260 set_capture_mixer(codec);
6261
d1eb57f4 6262 codec->patch_ops = alc_patch_ops;
1ebec5f2 6263 spec->init_hook = alc_auto_init_std;
d1eb57f4
KY		 6264
6265 return 0;
6266}
6267
1da177e4
LT		 6268/*
6269 * patch entries
6270 */
a9111321 6271static const struct hda_codec_preset snd_hda_preset_realtek[] = {
296f0338 6272 { .id = 0x10ec0221, .name = "ALC221", .patch = patch_alc269 },
1da177e4 6273 { .id = 0x10ec0260, .name = "ALC260", .patch = patch_alc260 },
df694daa 6274 { .id = 0x10ec0262, .name = "ALC262", .patch = patch_alc262 },
f6a92248 6275 { .id = 0x10ec0267, .name = "ALC267", .patch = patch_alc268 },
a361d84b 6276 { .id = 0x10ec0268, .name = "ALC268", .patch = patch_alc268 },
f6a92248 6277 { .id = 0x10ec0269, .name = "ALC269", .patch = patch_alc269 },
ebb83eeb 6278 { .id = 0x10ec0270, .name = "ALC270", .patch = patch_alc269 },
01afd41f 6279 { .id = 0x10ec0272, .name = "ALC272", .patch = patch_alc662 },
ebb83eeb 6280 { .id = 0x10ec0275, .name = "ALC275", .patch = patch_alc269 },
296f0338 6281 { .id = 0x10ec0276, .name = "ALC276", .patch = patch_alc269 },
f32610ed 6282 { .id = 0x10ec0861, .rev = 0x100340, .name = "ALC660",
bc9f98a9 6283 .patch = patch_alc861 },
f32610ed
JS		 6284 { .id = 0x10ec0660, .name = "ALC660-VD", .patch = patch_alc861vd },
6285 { .id = 0x10ec0861, .name = "ALC861", .patch = patch_alc861 },
6286 { .id = 0x10ec0862, .name = "ALC861-VD", .patch = patch_alc861vd },
bc9f98a9 6287 { .id = 0x10ec0662, .rev = 0x100002, .name = "ALC662 rev2",
4953550a 6288 .patch = patch_alc882 },
bc9f98a9
KY		 6289 { .id = 0x10ec0662, .rev = 0x100101, .name = "ALC662 rev1",
6290 .patch = patch_alc662 },
cc667a72
DH		 6291 { .id = 0x10ec0662, .rev = 0x100300, .name = "ALC662 rev3",
6292 .patch = patch_alc662 },
6dda9f4a 6293 { .id = 0x10ec0663, .name = "ALC663", .patch = patch_alc662 },
cec27c89 6294 { .id = 0x10ec0665, .name = "ALC665", .patch = patch_alc662 },
6227cdce 6295 { .id = 0x10ec0670, .name = "ALC670", .patch = patch_alc662 },
d1eb57f4 6296 { .id = 0x10ec0680, .name = "ALC680", .patch = patch_alc680 },
f32610ed 6297 { .id = 0x10ec0880, .name = "ALC880", .patch = patch_alc880 },
1da177e4 6298 { .id = 0x10ec0882, .name = "ALC882", .patch = patch_alc882 },
4953550a 6299 { .id = 0x10ec0883, .name = "ALC883", .patch = patch_alc882 },
669faba2 6300 { .id = 0x10ec0885, .rev = 0x100101, .name = "ALC889A",
4953550a 6301 .patch = patch_alc882 },
cb308f97 6302 { .id = 0x10ec0885, .rev = 0x100103, .name = "ALC889A",
4953550a 6303 .patch = patch_alc882 },
df694daa 6304 { .id = 0x10ec0885, .name = "ALC885", .patch = patch_alc882 },
e16fb6d1 6305 { .id = 0x10ec0887, .name = "ALC887", .patch = patch_alc882 },
4442608d 6306 { .id = 0x10ec0888, .rev = 0x100101, .name = "ALC1200",
4953550a 6307 .patch = patch_alc882 },
e16fb6d1 6308 { .id = 0x10ec0888, .name = "ALC888", .patch = patch_alc882 },
4953550a 6309 { .id = 0x10ec0889, .name = "ALC889", .patch = patch_alc882 },
274693f3 6310 { .id = 0x10ec0892, .name = "ALC892", .patch = patch_alc662 },
e16fb6d1 6311 { .id = 0x10ec0899, .name = "ALC898", .patch = patch_alc882 },
1da177e4
LT		 6312 {} /* terminator */
6313};
1289e9e8
TI		 6314
6315MODULE_ALIAS("snd-hda-codec-id:10ec*");
6316
6317MODULE_LICENSE("GPL");
6318MODULE_DESCRIPTION("Realtek HD-audio codec");
6319
6320static struct hda_codec_preset_list realtek_list = {
6321 .preset = snd_hda_preset_realtek,
6322 .owner = THIS_MODULE,
6323};
6324
6325static int __init patch_realtek_init(void)
6326{
6327 return snd_hda_add_codec_preset(&realtek_list);
6328}
6329
6330static void __exit patch_realtek_exit(void)
6331{
6332 snd_hda_delete_codec_preset(&realtek_list);
6333}
6334
6335module_init(patch_realtek_init)
6336module_exit(patch_realtek_exit)
ubuntu-bionic-kernel mirror