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