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