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