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