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