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