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