]> git.proxmox.com Git - mirror_ubuntu-bionic-kernel.git/blob - sound/pci/hda/patch_realtek.c
projects / mirror_ubuntu-bionic-kernel.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
ALSA: hda - add quirk to detect CD input on Gigabyte EP45-DS3
[mirror_ubuntu-bionic-kernel.git] / sound / pci / hda / patch_realtek.c
1 /*
2 * Universal Interface for Intel High Definition Audio Codec
3 *
4 * HD audio interface patch for Realtek ALC codecs
5 *
6 * Copyright (c) 2004 Kailang Yang <kailang@realtek.com.tw>
7 * PeiSen Hou <pshou@realtek.com.tw>
8 * Takashi Iwai <tiwai@suse.de>
9 * Jonathan Woithe <jwoithe@physics.adelaide.edu.au>
10 *
11 * This driver is free software; you can redistribute it and/or modify
12 * it under the terms of the GNU General Public License as published by
13 * the Free Software Foundation; either version 2 of the License, or
14 * (at your option) any later version.
15 *
16 * This driver is distributed in the hope that it will be useful,
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 * GNU General Public License for more details.
20 *
21 * You should have received a copy of the GNU General Public License
22 * along with this program; if not, write to the Free Software
23 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
24 */
25
26 #include <linux/init.h>
27 #include <linux/delay.h>
28 #include <linux/slab.h>
29 #include <linux/pci.h>
30 #include <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
2072 static int alc_init(struct hda_codec *codec)
2073 {
2074 struct alc_spec *spec = codec->spec;
2075 unsigned int i;
2076
2077 alc_fix_pll(codec);
2078 alc_auto_init_amp(codec, spec->init_amp);
2079
2080 for (i = 0; i < spec->num_init_verbs; i++)
2081 snd_hda_sequence_write(codec, spec->init_verbs[i]);
2082 alc_init_special_input_src(codec);
2083
2084 if (spec->init_hook)
2085 spec->init_hook(codec);
2086
2087 alc_apply_fixup(codec, ALC_FIXUP_ACT_INIT);
2088
2089 snd_hda_jack_report_sync(codec);
2090
2091 hda_call_check_power_status(codec, 0x01);
2092 return 0;
2093 }
2094
2095 static void alc_unsol_event(struct hda_codec *codec, unsigned int res)
2096 {
2097 struct alc_spec *spec = codec->spec;
2098
2099 if (spec->unsol_event)
2100 spec->unsol_event(codec, res);
2101 }
2102
2103 #ifdef CONFIG_SND_HDA_POWER_SAVE
2104 static int alc_check_power_status(struct hda_codec *codec, hda_nid_t nid)
2105 {
2106 struct alc_spec *spec = codec->spec;
2107 return snd_hda_check_amp_list_power(codec, &spec->loopback, nid);
2108 }
2109 #endif
2110
2111 /*
2112 * Analog playback callbacks
2113 */
2114 static int alc_playback_pcm_open(struct hda_pcm_stream *hinfo,
2115 struct hda_codec *codec,
2116 struct snd_pcm_substream *substream)
2117 {
2118 struct alc_spec *spec = codec->spec;
2119 return snd_hda_multi_out_analog_open(codec, &spec->multiout, substream,
2120 hinfo);
2121 }
2122
2123 static int alc_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
2124 struct hda_codec *codec,
2125 unsigned int stream_tag,
2126 unsigned int format,
2127 struct snd_pcm_substream *substream)
2128 {
2129 struct alc_spec *spec = codec->spec;
2130 return snd_hda_multi_out_analog_prepare(codec, &spec->multiout,
2131 stream_tag, format, substream);
2132 }
2133
2134 static int alc_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
2135 struct hda_codec *codec,
2136 struct snd_pcm_substream *substream)
2137 {
2138 struct alc_spec *spec = codec->spec;
2139 return snd_hda_multi_out_analog_cleanup(codec, &spec->multiout);
2140 }
2141
2142 /*
2143 * Digital out
2144 */
2145 static int alc_dig_playback_pcm_open(struct hda_pcm_stream *hinfo,
2146 struct hda_codec *codec,
2147 struct snd_pcm_substream *substream)
2148 {
2149 struct alc_spec *spec = codec->spec;
2150 return snd_hda_multi_out_dig_open(codec, &spec->multiout);
2151 }
2152
2153 static int alc_dig_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
2154 struct hda_codec *codec,
2155 unsigned int stream_tag,
2156 unsigned int format,
2157 struct snd_pcm_substream *substream)
2158 {
2159 struct alc_spec *spec = codec->spec;
2160 return snd_hda_multi_out_dig_prepare(codec, &spec->multiout,
2161 stream_tag, format, substream);
2162 }
2163
2164 static int alc_dig_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
2165 struct hda_codec *codec,
2166 struct snd_pcm_substream *substream)
2167 {
2168 struct alc_spec *spec = codec->spec;
2169 return snd_hda_multi_out_dig_cleanup(codec, &spec->multiout);
2170 }
2171
2172 static int alc_dig_playback_pcm_close(struct hda_pcm_stream *hinfo,
2173 struct hda_codec *codec,
2174 struct snd_pcm_substream *substream)
2175 {
2176 struct alc_spec *spec = codec->spec;
2177 return snd_hda_multi_out_dig_close(codec, &spec->multiout);
2178 }
2179
2180 /*
2181 * Analog capture
2182 */
2183 static int alc_alt_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
2184 struct hda_codec *codec,
2185 unsigned int stream_tag,
2186 unsigned int format,
2187 struct snd_pcm_substream *substream)
2188 {
2189 struct alc_spec *spec = codec->spec;
2190
2191 snd_hda_codec_setup_stream(codec, spec->adc_nids[substream->number + 1],
2192 stream_tag, 0, format);
2193 return 0;
2194 }
2195
2196 static int alc_alt_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
2197 struct hda_codec *codec,
2198 struct snd_pcm_substream *substream)
2199 {
2200 struct alc_spec *spec = codec->spec;
2201
2202 snd_hda_codec_cleanup_stream(codec,
2203 spec->adc_nids[substream->number + 1]);
2204 return 0;
2205 }
2206
2207 /* analog capture with dynamic dual-adc changes */
2208 static int dyn_adc_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
2209 struct hda_codec *codec,
2210 unsigned int stream_tag,
2211 unsigned int format,
2212 struct snd_pcm_substream *substream)
2213 {
2214 struct alc_spec *spec = codec->spec;
2215 spec->cur_adc = spec->adc_nids[spec->dyn_adc_idx[spec->cur_mux[0]]];
2216 spec->cur_adc_stream_tag = stream_tag;
2217 spec->cur_adc_format = format;
2218 snd_hda_codec_setup_stream(codec, spec->cur_adc, stream_tag, 0, format);
2219 return 0;
2220 }
2221
2222 static int dyn_adc_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
2223 struct hda_codec *codec,
2224 struct snd_pcm_substream *substream)
2225 {
2226 struct alc_spec *spec = codec->spec;
2227 snd_hda_codec_cleanup_stream(codec, spec->cur_adc);
2228 spec->cur_adc = 0;
2229 return 0;
2230 }
2231
2232 static const struct hda_pcm_stream dyn_adc_pcm_analog_capture = {
2233 .substreams = 1,
2234 .channels_min = 2,
2235 .channels_max = 2,
2236 .nid = 0, /* fill later */
2237 .ops = {
2238 .prepare = dyn_adc_capture_pcm_prepare,
2239 .cleanup = dyn_adc_capture_pcm_cleanup
2240 },
2241 };
2242
2243 /*
2244 */
2245 static const struct hda_pcm_stream alc_pcm_analog_playback = {
2246 .substreams = 1,
2247 .channels_min = 2,
2248 .channels_max = 8,
2249 /* NID is set in alc_build_pcms */
2250 .ops = {
2251 .open = alc_playback_pcm_open,
2252 .prepare = alc_playback_pcm_prepare,
2253 .cleanup = alc_playback_pcm_cleanup
2254 },
2255 };
2256
2257 static const struct hda_pcm_stream alc_pcm_analog_capture = {
2258 .substreams = 1,
2259 .channels_min = 2,
2260 .channels_max = 2,
2261 /* NID is set in alc_build_pcms */
2262 };
2263
2264 static const struct hda_pcm_stream alc_pcm_analog_alt_playback = {
2265 .substreams = 1,
2266 .channels_min = 2,
2267 .channels_max = 2,
2268 /* NID is set in alc_build_pcms */
2269 };
2270
2271 static const struct hda_pcm_stream alc_pcm_analog_alt_capture = {
2272 .substreams = 2, /* can be overridden */
2273 .channels_min = 2,
2274 .channels_max = 2,
2275 /* NID is set in alc_build_pcms */
2276 .ops = {
2277 .prepare = alc_alt_capture_pcm_prepare,
2278 .cleanup = alc_alt_capture_pcm_cleanup
2279 },
2280 };
2281
2282 static const struct hda_pcm_stream alc_pcm_digital_playback = {
2283 .substreams = 1,
2284 .channels_min = 2,
2285 .channels_max = 2,
2286 /* NID is set in alc_build_pcms */
2287 .ops = {
2288 .open = alc_dig_playback_pcm_open,
2289 .close = alc_dig_playback_pcm_close,
2290 .prepare = alc_dig_playback_pcm_prepare,
2291 .cleanup = alc_dig_playback_pcm_cleanup
2292 },
2293 };
2294
2295 static const struct hda_pcm_stream alc_pcm_digital_capture = {
2296 .substreams = 1,
2297 .channels_min = 2,
2298 .channels_max = 2,
2299 /* NID is set in alc_build_pcms */
2300 };
2301
2302 /* Used by alc_build_pcms to flag that a PCM has no playback stream */
2303 static const struct hda_pcm_stream alc_pcm_null_stream = {
2304 .substreams = 0,
2305 .channels_min = 0,
2306 .channels_max = 0,
2307 };
2308
2309 static int alc_build_pcms(struct hda_codec *codec)
2310 {
2311 struct alc_spec *spec = codec->spec;
2312 struct hda_pcm *info = spec->pcm_rec;
2313 const struct hda_pcm_stream *p;
2314 bool have_multi_adcs;
2315 int i;
2316
2317 codec->num_pcms = 1;
2318 codec->pcm_info = info;
2319
2320 if (spec->no_analog)
2321 goto skip_analog;
2322
2323 snprintf(spec->stream_name_analog, sizeof(spec->stream_name_analog),
2324 "%s Analog", codec->chip_name);
2325 info->name = spec->stream_name_analog;
2326
2327 if (spec->multiout.num_dacs > 0) {
2328 p = spec->stream_analog_playback;
2329 if (!p)
2330 p = &alc_pcm_analog_playback;
2331 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *p;
2332 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dac_nids[0];
2333 }
2334 if (spec->adc_nids) {
2335 p = spec->stream_analog_capture;
2336 if (!p) {
2337 if (spec->dyn_adc_switch)
2338 p = &dyn_adc_pcm_analog_capture;
2339 else
2340 p = &alc_pcm_analog_capture;
2341 }
2342 info->stream[SNDRV_PCM_STREAM_CAPTURE] = *p;
2343 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adc_nids[0];
2344 }
2345
2346 if (spec->channel_mode) {
2347 info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max = 0;
2348 for (i = 0; i < spec->num_channel_mode; i++) {
2349 if (spec->channel_mode[i].channels > info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max) {
2350 info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max = spec->channel_mode[i].channels;
2351 }
2352 }
2353 }
2354
2355 skip_analog:
2356 /* SPDIF for stream index #1 */
2357 if (spec->multiout.dig_out_nid || spec->dig_in_nid) {
2358 snprintf(spec->stream_name_digital,
2359 sizeof(spec->stream_name_digital),
2360 "%s Digital", codec->chip_name);
2361 codec->num_pcms = 2;
2362 codec->slave_dig_outs = spec->multiout.slave_dig_outs;
2363 info = spec->pcm_rec + 1;
2364 info->name = spec->stream_name_digital;
2365 if (spec->dig_out_type)
2366 info->pcm_type = spec->dig_out_type;
2367 else
2368 info->pcm_type = HDA_PCM_TYPE_SPDIF;
2369 if (spec->multiout.dig_out_nid) {
2370 p = spec->stream_digital_playback;
2371 if (!p)
2372 p = &alc_pcm_digital_playback;
2373 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *p;
2374 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dig_out_nid;
2375 }
2376 if (spec->dig_in_nid) {
2377 p = spec->stream_digital_capture;
2378 if (!p)
2379 p = &alc_pcm_digital_capture;
2380 info->stream[SNDRV_PCM_STREAM_CAPTURE] = *p;
2381 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->dig_in_nid;
2382 }
2383 /* FIXME: do we need this for all Realtek codec models? */
2384 codec->spdif_status_reset = 1;
2385 }
2386
2387 if (spec->no_analog)
2388 return 0;
2389
2390 /* If the use of more than one ADC is requested for the current
2391 * model, configure a second analog capture-only PCM.
2392 */
2393 have_multi_adcs = (spec->num_adc_nids > 1) &&
2394 !spec->dyn_adc_switch && !spec->auto_mic &&
2395 (!spec->input_mux || spec->input_mux->num_items > 1);
2396 /* Additional Analaog capture for index #2 */
2397 if (spec->alt_dac_nid || have_multi_adcs) {
2398 codec->num_pcms = 3;
2399 info = spec->pcm_rec + 2;
2400 info->name = spec->stream_name_analog;
2401 if (spec->alt_dac_nid) {
2402 p = spec->stream_analog_alt_playback;
2403 if (!p)
2404 p = &alc_pcm_analog_alt_playback;
2405 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *p;
2406 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid =
2407 spec->alt_dac_nid;
2408 } else {
2409 info->stream[SNDRV_PCM_STREAM_PLAYBACK] =
2410 alc_pcm_null_stream;
2411 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = 0;
2412 }
2413 if (have_multi_adcs) {
2414 p = spec->stream_analog_alt_capture;
2415 if (!p)
2416 p = &alc_pcm_analog_alt_capture;
2417 info->stream[SNDRV_PCM_STREAM_CAPTURE] = *p;
2418 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid =
2419 spec->adc_nids[1];
2420 info->stream[SNDRV_PCM_STREAM_CAPTURE].substreams =
2421 spec->num_adc_nids - 1;
2422 } else {
2423 info->stream[SNDRV_PCM_STREAM_CAPTURE] =
2424 alc_pcm_null_stream;
2425 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = 0;
2426 }
2427 }
2428
2429 return 0;
2430 }
2431
2432 static inline void alc_shutup(struct hda_codec *codec)
2433 {
2434 struct alc_spec *spec = codec->spec;
2435
2436 if (spec && spec->shutup)
2437 spec->shutup(codec);
2438 snd_hda_shutup_pins(codec);
2439 }
2440
2441 static void alc_free_kctls(struct hda_codec *codec)
2442 {
2443 struct alc_spec *spec = codec->spec;
2444
2445 if (spec->kctls.list) {
2446 struct snd_kcontrol_new *kctl = spec->kctls.list;
2447 int i;
2448 for (i = 0; i < spec->kctls.used; i++)
2449 kfree(kctl[i].name);
2450 }
2451 snd_array_free(&spec->kctls);
2452 }
2453
2454 static void alc_free_bind_ctls(struct hda_codec *codec)
2455 {
2456 struct alc_spec *spec = codec->spec;
2457 if (spec->bind_ctls.list) {
2458 struct hda_bind_ctls **ctl = spec->bind_ctls.list;
2459 int i;
2460 for (i = 0; i < spec->bind_ctls.used; i++)
2461 kfree(ctl[i]);
2462 }
2463 snd_array_free(&spec->bind_ctls);
2464 }
2465
2466 static void alc_free(struct hda_codec *codec)
2467 {
2468 struct alc_spec *spec = codec->spec;
2469
2470 if (!spec)
2471 return;
2472
2473 alc_shutup(codec);
2474 alc_free_kctls(codec);
2475 alc_free_bind_ctls(codec);
2476 kfree(spec);
2477 snd_hda_detach_beep_device(codec);
2478 }
2479
2480 #ifdef CONFIG_SND_HDA_POWER_SAVE
2481 static void alc_power_eapd(struct hda_codec *codec)
2482 {
2483 alc_auto_setup_eapd(codec, false);
2484 }
2485
2486 static int alc_suspend(struct hda_codec *codec, pm_message_t state)
2487 {
2488 struct alc_spec *spec = codec->spec;
2489 alc_shutup(codec);
2490 if (spec && spec->power_hook)
2491 spec->power_hook(codec);
2492 return 0;
2493 }
2494 #endif
2495
2496 #ifdef CONFIG_PM
2497 static int alc_resume(struct hda_codec *codec)
2498 {
2499 msleep(150); /* to avoid pop noise */
2500 codec->patch_ops.init(codec);
2501 snd_hda_codec_resume_amp(codec);
2502 snd_hda_codec_resume_cache(codec);
2503 hda_call_check_power_status(codec, 0x01);
2504 return 0;
2505 }
2506 #endif
2507
2508 /*
2509 */
2510 static const struct hda_codec_ops alc_patch_ops = {
2511 .build_controls = alc_build_controls,
2512 .build_pcms = alc_build_pcms,
2513 .init = alc_init,
2514 .free = alc_free,
2515 .unsol_event = alc_unsol_event,
2516 #ifdef CONFIG_PM
2517 .resume = alc_resume,
2518 #endif
2519 #ifdef CONFIG_SND_HDA_POWER_SAVE
2520 .suspend = alc_suspend,
2521 .check_power_status = alc_check_power_status,
2522 #endif
2523 .reboot_notify = alc_shutup,
2524 };
2525
2526 /* replace the codec chip_name with the given string */
2527 static int alc_codec_rename(struct hda_codec *codec, const char *name)
2528 {
2529 kfree(codec->chip_name);
2530 codec->chip_name = kstrdup(name, GFP_KERNEL);
2531 if (!codec->chip_name) {
2532 alc_free(codec);
2533 return -ENOMEM;
2534 }
2535 return 0;
2536 }
2537
2538 /*
2539 * Rename codecs appropriately from COEF value
2540 */
2541 struct alc_codec_rename_table {
2542 unsigned int vendor_id;
2543 unsigned short coef_mask;
2544 unsigned short coef_bits;
2545 const char *name;
2546 };
2547
2548 static struct alc_codec_rename_table rename_tbl[] = {
2549 { 0x10ec0269, 0xfff0, 0x3010, "ALC277" },
2550 { 0x10ec0269, 0xf0f0, 0x2010, "ALC259" },
2551 { 0x10ec0269, 0xf0f0, 0x3010, "ALC258" },
2552 { 0x10ec0269, 0x00f0, 0x0010, "ALC269VB" },
2553 { 0x10ec0269, 0xffff, 0xa023, "ALC259" },
2554 { 0x10ec0269, 0xffff, 0x6023, "ALC281X" },
2555 { 0x10ec0269, 0x00f0, 0x0020, "ALC269VC" },
2556 { 0x10ec0887, 0x00f0, 0x0030, "ALC887-VD" },
2557 { 0x10ec0888, 0x00f0, 0x0030, "ALC888-VD" },
2558 { 0x10ec0888, 0xf0f0, 0x3020, "ALC886" },
2559 { 0x10ec0899, 0x2000, 0x2000, "ALC899" },
2560 { 0x10ec0892, 0xffff, 0x8020, "ALC661" },
2561 { 0x10ec0892, 0xffff, 0x8011, "ALC661" },
2562 { 0x10ec0892, 0xffff, 0x4011, "ALC656" },
2563 { } /* terminator */
2564 };
2565
2566 static int alc_codec_rename_from_preset(struct hda_codec *codec)
2567 {
2568 const struct alc_codec_rename_table *p;
2569
2570 for (p = rename_tbl; p->vendor_id; p++) {
2571 if (p->vendor_id != codec->vendor_id)
2572 continue;
2573 if ((alc_get_coef0(codec) & p->coef_mask) == p->coef_bits)
2574 return alc_codec_rename(codec, p->name);
2575 }
2576 return 0;
2577 }
2578
2579 /*
2580 * Automatic parse of I/O pins from the BIOS configuration
2581 */
2582
2583 enum {
2584 ALC_CTL_WIDGET_VOL,
2585 ALC_CTL_WIDGET_MUTE,
2586 ALC_CTL_BIND_MUTE,
2587 ALC_CTL_BIND_VOL,
2588 ALC_CTL_BIND_SW,
2589 };
2590 static const struct snd_kcontrol_new alc_control_templates[] = {
2591 HDA_CODEC_VOLUME(NULL, 0, 0, 0),
2592 HDA_CODEC_MUTE(NULL, 0, 0, 0),
2593 HDA_BIND_MUTE(NULL, 0, 0, 0),
2594 HDA_BIND_VOL(NULL, 0),
2595 HDA_BIND_SW(NULL, 0),
2596 };
2597
2598 /* add dynamic controls */
2599 static int add_control(struct alc_spec *spec, int type, const char *name,
2600 int cidx, unsigned long val)
2601 {
2602 struct snd_kcontrol_new *knew;
2603
2604 knew = alc_kcontrol_new(spec);
2605 if (!knew)
2606 return -ENOMEM;
2607 *knew = alc_control_templates[type];
2608 knew->name = kstrdup(name, GFP_KERNEL);
2609 if (!knew->name)
2610 return -ENOMEM;
2611 knew->index = cidx;
2612 if (get_amp_nid_(val))
2613 knew->subdevice = HDA_SUBDEV_AMP_FLAG;
2614 knew->private_value = val;
2615 return 0;
2616 }
2617
2618 static int add_control_with_pfx(struct alc_spec *spec, int type,
2619 const char *pfx, const char *dir,
2620 const char *sfx, int cidx, unsigned long val)
2621 {
2622 char name[32];
2623 snprintf(name, sizeof(name), "%s %s %s", pfx, dir, sfx);
2624 return add_control(spec, type, name, cidx, val);
2625 }
2626
2627 #define add_pb_vol_ctrl(spec, type, pfx, val) \
2628 add_control_with_pfx(spec, type, pfx, "Playback", "Volume", 0, val)
2629 #define add_pb_sw_ctrl(spec, type, pfx, val) \
2630 add_control_with_pfx(spec, type, pfx, "Playback", "Switch", 0, val)
2631 #define __add_pb_vol_ctrl(spec, type, pfx, cidx, val) \
2632 add_control_with_pfx(spec, type, pfx, "Playback", "Volume", cidx, val)
2633 #define __add_pb_sw_ctrl(spec, type, pfx, cidx, val) \
2634 add_control_with_pfx(spec, type, pfx, "Playback", "Switch", cidx, val)
2635
2636 static const char * const channel_name[4] = {
2637 "Front", "Surround", "CLFE", "Side"
2638 };
2639
2640 static const char *alc_get_line_out_pfx(struct alc_spec *spec, int ch,
2641 bool can_be_master, int *index)
2642 {
2643 struct auto_pin_cfg *cfg = &spec->autocfg;
2644
2645 *index = 0;
2646 if (cfg->line_outs == 1 && !spec->multi_ios &&
2647 !cfg->hp_outs && !cfg->speaker_outs && can_be_master)
2648 return "Master";
2649
2650 switch (cfg->line_out_type) {
2651 case AUTO_PIN_SPEAKER_OUT:
2652 if (cfg->line_outs == 1)
2653 return "Speaker";
2654 if (cfg->line_outs == 2)
2655 return ch ? "Bass Speaker" : "Speaker";
2656 break;
2657 case AUTO_PIN_HP_OUT:
2658 /* for multi-io case, only the primary out */
2659 if (ch && spec->multi_ios)
2660 break;
2661 *index = ch;
2662 return "Headphone";
2663 default:
2664 if (cfg->line_outs == 1 && !spec->multi_ios)
2665 return "PCM";
2666 break;
2667 }
2668 if (snd_BUG_ON(ch >= ARRAY_SIZE(channel_name)))
2669 return "PCM";
2670
2671 return channel_name[ch];
2672 }
2673
2674 /* create input playback/capture controls for the given pin */
2675 static int new_analog_input(struct alc_spec *spec, hda_nid_t pin,
2676 const char *ctlname, int ctlidx,
2677 int idx, hda_nid_t mix_nid)
2678 {
2679 int err;
2680
2681 err = __add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, ctlname, ctlidx,
2682 HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT));
2683 if (err < 0)
2684 return err;
2685 err = __add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, ctlname, ctlidx,
2686 HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT));
2687 if (err < 0)
2688 return err;
2689 return 0;
2690 }
2691
2692 static int alc_is_input_pin(struct hda_codec *codec, hda_nid_t nid)
2693 {
2694 unsigned int pincap = snd_hda_query_pin_caps(codec, nid);
2695 return (pincap & AC_PINCAP_IN) != 0;
2696 }
2697
2698 /* Parse the codec tree and retrieve ADCs and corresponding capsrc MUXs */
2699 static int alc_auto_fill_adc_caps(struct hda_codec *codec)
2700 {
2701 struct alc_spec *spec = codec->spec;
2702 hda_nid_t nid;
2703 hda_nid_t *adc_nids = spec->private_adc_nids;
2704 hda_nid_t *cap_nids = spec->private_capsrc_nids;
2705 int max_nums = ARRAY_SIZE(spec->private_adc_nids);
2706 int i, nums = 0;
2707
2708 if (spec->shared_mic_hp)
2709 max_nums = 1; /* no multi streams with the shared HP/mic */
2710
2711 nid = codec->start_nid;
2712 for (i = 0; i < codec->num_nodes; i++, nid++) {
2713 hda_nid_t src;
2714 const hda_nid_t *list;
2715 unsigned int caps = get_wcaps(codec, nid);
2716 int type = get_wcaps_type(caps);
2717
2718 if (type != AC_WID_AUD_IN || (caps & AC_WCAP_DIGITAL))
2719 continue;
2720 adc_nids[nums] = nid;
2721 cap_nids[nums] = nid;
2722 src = nid;
2723 for (;;) {
2724 int n;
2725 type = get_wcaps_type(get_wcaps(codec, src));
2726 if (type == AC_WID_PIN)
2727 break;
2728 if (type == AC_WID_AUD_SEL) {
2729 cap_nids[nums] = src;
2730 break;
2731 }
2732 n = snd_hda_get_conn_list(codec, src, &list);
2733 if (n > 1) {
2734 cap_nids[nums] = src;
2735 break;
2736 } else if (n != 1)
2737 break;
2738 src = *list;
2739 }
2740 if (++nums >= max_nums)
2741 break;
2742 }
2743 spec->adc_nids = spec->private_adc_nids;
2744 spec->capsrc_nids = spec->private_capsrc_nids;
2745 spec->num_adc_nids = nums;
2746 return nums;
2747 }
2748
2749 /* create playback/capture controls for input pins */
2750 static int alc_auto_create_input_ctls(struct hda_codec *codec)
2751 {
2752 struct alc_spec *spec = codec->spec;
2753 const struct auto_pin_cfg *cfg = &spec->autocfg;
2754 hda_nid_t mixer = spec->mixer_nid;
2755 struct hda_input_mux *imux = &spec->private_imux[0];
2756 int num_adcs;
2757 int i, c, err, idx, type_idx = 0;
2758 const char *prev_label = NULL;
2759
2760 num_adcs = alc_auto_fill_adc_caps(codec);
2761 if (num_adcs < 0)
2762 return 0;
2763
2764 for (i = 0; i < cfg->num_inputs; i++) {
2765 hda_nid_t pin;
2766 const char *label;
2767
2768 pin = cfg->inputs[i].pin;
2769 if (!alc_is_input_pin(codec, pin))
2770 continue;
2771
2772 label = hda_get_autocfg_input_label(codec, cfg, i);
2773 if (spec->shared_mic_hp && !strcmp(label, "Misc"))
2774 label = "Headphone Mic";
2775 if (prev_label && !strcmp(label, prev_label))
2776 type_idx++;
2777 else
2778 type_idx = 0;
2779 prev_label = label;
2780
2781 if (mixer) {
2782 idx = get_connection_index(codec, mixer, pin);
2783 if (idx >= 0) {
2784 err = new_analog_input(spec, pin,
2785 label, type_idx,
2786 idx, mixer);
2787 if (err < 0)
2788 return err;
2789 }
2790 }
2791
2792 for (c = 0; c < num_adcs; c++) {
2793 hda_nid_t cap = get_capsrc(spec, c);
2794 idx = get_connection_index(codec, cap, pin);
2795 if (idx >= 0) {
2796 spec->imux_pins[imux->num_items] = pin;
2797 snd_hda_add_imux_item(imux, label, idx, NULL);
2798 break;
2799 }
2800 }
2801 }
2802
2803 spec->num_mux_defs = 1;
2804 spec->input_mux = imux;
2805
2806 return 0;
2807 }
2808
2809 /* create a shared input with the headphone out */
2810 static int alc_auto_create_shared_input(struct hda_codec *codec)
2811 {
2812 struct alc_spec *spec = codec->spec;
2813 struct auto_pin_cfg *cfg = &spec->autocfg;
2814 unsigned int defcfg;
2815 hda_nid_t nid;
2816
2817 /* only one internal input pin? */
2818 if (cfg->num_inputs != 1)
2819 return 0;
2820 defcfg = snd_hda_codec_get_pincfg(codec, cfg->inputs[0].pin);
2821 if (snd_hda_get_input_pin_attr(defcfg) != INPUT_PIN_ATTR_INT)
2822 return 0;
2823
2824 if (cfg->hp_outs == 1 && cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
2825 nid = cfg->hp_pins[0]; /* OK, we have a single HP-out */
2826 else if (cfg->line_outs == 1 && cfg->line_out_type == AUTO_PIN_HP_OUT)
2827 nid = cfg->line_out_pins[0]; /* OK, we have a single line-out */
2828 else
2829 return 0; /* both not available */
2830
2831 if (!(snd_hda_query_pin_caps(codec, nid) & AC_PINCAP_IN))
2832 return 0; /* no input */
2833
2834 cfg->inputs[1].pin = nid;
2835 cfg->inputs[1].type = AUTO_PIN_MIC;
2836 cfg->num_inputs = 2;
2837 spec->shared_mic_hp = 1;
2838 snd_printdd("realtek: Enable shared I/O jack on NID 0x%x\n", nid);
2839 return 0;
2840 }
2841
2842 static void alc_set_pin_output(struct hda_codec *codec, hda_nid_t nid,
2843 unsigned int pin_type)
2844 {
2845 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
2846 pin_type);
2847 /* unmute pin */
2848 if (nid_has_mute(codec, nid, HDA_OUTPUT))
2849 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE,
2850 AMP_OUT_UNMUTE);
2851 }
2852
2853 static int get_pin_type(int line_out_type)
2854 {
2855 if (line_out_type == AUTO_PIN_HP_OUT)
2856 return PIN_HP;
2857 else
2858 return PIN_OUT;
2859 }
2860
2861 static void alc_auto_init_analog_input(struct hda_codec *codec)
2862 {
2863 struct alc_spec *spec = codec->spec;
2864 struct auto_pin_cfg *cfg = &spec->autocfg;
2865 int i;
2866
2867 for (i = 0; i < cfg->num_inputs; i++) {
2868 hda_nid_t nid = cfg->inputs[i].pin;
2869 if (alc_is_input_pin(codec, nid)) {
2870 alc_set_input_pin(codec, nid, cfg->inputs[i].type);
2871 if (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP)
2872 snd_hda_codec_write(codec, nid, 0,
2873 AC_VERB_SET_AMP_GAIN_MUTE,
2874 AMP_OUT_MUTE);
2875 }
2876 }
2877
2878 /* mute all loopback inputs */
2879 if (spec->mixer_nid) {
2880 int nums = snd_hda_get_conn_list(codec, spec->mixer_nid, NULL);
2881 for (i = 0; i < nums; i++)
2882 snd_hda_codec_write(codec, spec->mixer_nid, 0,
2883 AC_VERB_SET_AMP_GAIN_MUTE,
2884 AMP_IN_MUTE(i));
2885 }
2886 }
2887
2888 /* convert from MIX nid to DAC */
2889 static hda_nid_t alc_auto_mix_to_dac(struct hda_codec *codec, hda_nid_t nid)
2890 {
2891 hda_nid_t list[5];
2892 int i, num;
2893
2894 if (get_wcaps_type(get_wcaps(codec, nid)) == AC_WID_AUD_OUT)
2895 return nid;
2896 num = snd_hda_get_connections(codec, nid, list, ARRAY_SIZE(list));
2897 for (i = 0; i < num; i++) {
2898 if (get_wcaps_type(get_wcaps(codec, list[i])) == AC_WID_AUD_OUT)
2899 return list[i];
2900 }
2901 return 0;
2902 }
2903
2904 /* go down to the selector widget before the mixer */
2905 static hda_nid_t alc_go_down_to_selector(struct hda_codec *codec, hda_nid_t pin)
2906 {
2907 hda_nid_t srcs[5];
2908 int num = snd_hda_get_connections(codec, pin, srcs,
2909 ARRAY_SIZE(srcs));
2910 if (num != 1 ||
2911 get_wcaps_type(get_wcaps(codec, srcs[0])) != AC_WID_AUD_SEL)
2912 return pin;
2913 return srcs[0];
2914 }
2915
2916 /* get MIX nid connected to the given pin targeted to DAC */
2917 static hda_nid_t alc_auto_dac_to_mix(struct hda_codec *codec, hda_nid_t pin,
2918 hda_nid_t dac)
2919 {
2920 hda_nid_t mix[5];
2921 int i, num;
2922
2923 pin = alc_go_down_to_selector(codec, pin);
2924 num = snd_hda_get_connections(codec, pin, mix, ARRAY_SIZE(mix));
2925 for (i = 0; i < num; i++) {
2926 if (alc_auto_mix_to_dac(codec, mix[i]) == dac)
2927 return mix[i];
2928 }
2929 return 0;
2930 }
2931
2932 /* select the connection from pin to DAC if needed */
2933 static int alc_auto_select_dac(struct hda_codec *codec, hda_nid_t pin,
2934 hda_nid_t dac)
2935 {
2936 hda_nid_t mix[5];
2937 int i, num;
2938
2939 pin = alc_go_down_to_selector(codec, pin);
2940 num = snd_hda_get_connections(codec, pin, mix, ARRAY_SIZE(mix));
2941 if (num < 2)
2942 return 0;
2943 for (i = 0; i < num; i++) {
2944 if (alc_auto_mix_to_dac(codec, mix[i]) == dac) {
2945 snd_hda_codec_update_cache(codec, pin, 0,
2946 AC_VERB_SET_CONNECT_SEL, i);
2947 return 0;
2948 }
2949 }
2950 return 0;
2951 }
2952
2953 /* look for an empty DAC slot */
2954 static hda_nid_t alc_auto_look_for_dac(struct hda_codec *codec, hda_nid_t pin)
2955 {
2956 struct alc_spec *spec = codec->spec;
2957 hda_nid_t srcs[5];
2958 int i, num;
2959
2960 pin = alc_go_down_to_selector(codec, pin);
2961 num = snd_hda_get_connections(codec, pin, srcs, ARRAY_SIZE(srcs));
2962 for (i = 0; i < num; i++) {
2963 hda_nid_t nid = alc_auto_mix_to_dac(codec, srcs[i]);
2964 if (!nid)
2965 continue;
2966 if (found_in_nid_list(nid, spec->multiout.dac_nids,
2967 ARRAY_SIZE(spec->private_dac_nids)))
2968 continue;
2969 if (found_in_nid_list(nid, spec->multiout.hp_out_nid,
2970 ARRAY_SIZE(spec->multiout.hp_out_nid)))
2971 continue;
2972 if (found_in_nid_list(nid, spec->multiout.extra_out_nid,
2973 ARRAY_SIZE(spec->multiout.extra_out_nid)))
2974 continue;
2975 return nid;
2976 }
2977 return 0;
2978 }
2979
2980 /* check whether the DAC is reachable from the pin */
2981 static bool alc_auto_is_dac_reachable(struct hda_codec *codec,
2982 hda_nid_t pin, hda_nid_t dac)
2983 {
2984 hda_nid_t srcs[5];
2985 int i, num;
2986
2987 pin = alc_go_down_to_selector(codec, pin);
2988 num = snd_hda_get_connections(codec, pin, srcs, ARRAY_SIZE(srcs));
2989 for (i = 0; i < num; i++) {
2990 hda_nid_t nid = alc_auto_mix_to_dac(codec, srcs[i]);
2991 if (nid == dac)
2992 return true;
2993 }
2994 return false;
2995 }
2996
2997 static hda_nid_t get_dac_if_single(struct hda_codec *codec, hda_nid_t pin)
2998 {
2999 hda_nid_t sel = alc_go_down_to_selector(codec, pin);
3000 if (snd_hda_get_conn_list(codec, sel, NULL) == 1)
3001 return alc_auto_look_for_dac(codec, pin);
3002 return 0;
3003 }
3004
3005 /* return 0 if no possible DAC is found, 1 if one or more found */
3006 static int alc_auto_fill_extra_dacs(struct hda_codec *codec, int num_outs,
3007 const hda_nid_t *pins, hda_nid_t *dacs)
3008 {
3009 int i;
3010
3011 if (num_outs && !dacs[0]) {
3012 dacs[0] = alc_auto_look_for_dac(codec, pins[0]);
3013 if (!dacs[0])
3014 return 0;
3015 }
3016
3017 for (i = 1; i < num_outs; i++)
3018 dacs[i] = get_dac_if_single(codec, pins[i]);
3019 for (i = 1; i < num_outs; i++) {
3020 if (!dacs[i])
3021 dacs[i] = alc_auto_look_for_dac(codec, pins[i]);
3022 }
3023 return 1;
3024 }
3025
3026 static int alc_auto_fill_multi_ios(struct hda_codec *codec,
3027 unsigned int location, int offset);
3028 static hda_nid_t alc_look_for_out_vol_nid(struct hda_codec *codec,
3029 hda_nid_t pin, hda_nid_t dac);
3030
3031 /* fill in the dac_nids table from the parsed pin configuration */
3032 static int alc_auto_fill_dac_nids(struct hda_codec *codec)
3033 {
3034 struct alc_spec *spec = codec->spec;
3035 struct auto_pin_cfg *cfg = &spec->autocfg;
3036 unsigned int location, defcfg;
3037 int num_pins;
3038 bool redone = false;
3039 int i;
3040
3041 again:
3042 /* set num_dacs once to full for alc_auto_look_for_dac() */
3043 spec->multiout.num_dacs = cfg->line_outs;
3044 spec->multiout.hp_out_nid[0] = 0;
3045 spec->multiout.extra_out_nid[0] = 0;
3046 memset(spec->private_dac_nids, 0, sizeof(spec->private_dac_nids));
3047 spec->multiout.dac_nids = spec->private_dac_nids;
3048 spec->multi_ios = 0;
3049
3050 /* fill hard-wired DACs first */
3051 if (!redone) {
3052 for (i = 0; i < cfg->line_outs; i++)
3053 spec->private_dac_nids[i] =
3054 get_dac_if_single(codec, cfg->line_out_pins[i]);
3055 if (cfg->hp_outs)
3056 spec->multiout.hp_out_nid[0] =
3057 get_dac_if_single(codec, cfg->hp_pins[0]);
3058 if (cfg->speaker_outs)
3059 spec->multiout.extra_out_nid[0] =
3060 get_dac_if_single(codec, cfg->speaker_pins[0]);
3061 }
3062
3063 for (i = 0; i < cfg->line_outs; i++) {
3064 hda_nid_t pin = cfg->line_out_pins[i];
3065 if (spec->private_dac_nids[i])
3066 continue;
3067 spec->private_dac_nids[i] = alc_auto_look_for_dac(codec, pin);
3068 if (!spec->private_dac_nids[i] && !redone) {
3069 /* if we can't find primary DACs, re-probe without
3070 * checking the hard-wired DACs
3071 */
3072 redone = true;
3073 goto again;
3074 }
3075 }
3076
3077 /* re-count num_dacs and squash invalid entries */
3078 spec->multiout.num_dacs = 0;
3079 for (i = 0; i < cfg->line_outs; i++) {
3080 if (spec->private_dac_nids[i])
3081 spec->multiout.num_dacs++;
3082 else {
3083 memmove(spec->private_dac_nids + i,
3084 spec->private_dac_nids + i + 1,
3085 sizeof(hda_nid_t) * (cfg->line_outs - i - 1));
3086 spec->private_dac_nids[cfg->line_outs - 1] = 0;
3087 }
3088 }
3089
3090 if (cfg->line_outs == 1 && cfg->line_out_type != AUTO_PIN_SPEAKER_OUT) {
3091 /* try to fill multi-io first */
3092 defcfg = snd_hda_codec_get_pincfg(codec, cfg->line_out_pins[0]);
3093 location = get_defcfg_location(defcfg);
3094
3095 num_pins = alc_auto_fill_multi_ios(codec, location, 0);
3096 if (num_pins > 0) {
3097 spec->multi_ios = num_pins;
3098 spec->ext_channel_count = 2;
3099 spec->multiout.num_dacs = num_pins + 1;
3100 }
3101 }
3102
3103 if (cfg->line_out_type != AUTO_PIN_HP_OUT)
3104 alc_auto_fill_extra_dacs(codec, cfg->hp_outs, cfg->hp_pins,
3105 spec->multiout.hp_out_nid);
3106 if (cfg->line_out_type != AUTO_PIN_SPEAKER_OUT) {
3107 int err = alc_auto_fill_extra_dacs(codec, cfg->speaker_outs,
3108 cfg->speaker_pins,
3109 spec->multiout.extra_out_nid);
3110 /* if no speaker volume is assigned, try again as the primary
3111 * output
3112 */
3113 if (!err && cfg->speaker_outs > 0 &&
3114 cfg->line_out_type == AUTO_PIN_HP_OUT) {
3115 cfg->hp_outs = cfg->line_outs;
3116 memcpy(cfg->hp_pins, cfg->line_out_pins,
3117 sizeof(cfg->hp_pins));
3118 cfg->line_outs = cfg->speaker_outs;
3119 memcpy(cfg->line_out_pins, cfg->speaker_pins,
3120 sizeof(cfg->speaker_pins));
3121 cfg->speaker_outs = 0;
3122 memset(cfg->speaker_pins, 0, sizeof(cfg->speaker_pins));
3123 cfg->line_out_type = AUTO_PIN_SPEAKER_OUT;
3124 redone = false;
3125 goto again;
3126 }
3127 }
3128
3129 if (!spec->multi_ios &&
3130 cfg->line_out_type == AUTO_PIN_SPEAKER_OUT &&
3131 cfg->hp_outs) {
3132 /* try multi-ios with HP + inputs */
3133 defcfg = snd_hda_codec_get_pincfg(codec, cfg->hp_pins[0]);
3134 location = get_defcfg_location(defcfg);
3135
3136 num_pins = alc_auto_fill_multi_ios(codec, location, 1);
3137 if (num_pins > 0) {
3138 spec->multi_ios = num_pins;
3139 spec->ext_channel_count = 2;
3140 spec->multiout.num_dacs = num_pins + 1;
3141 }
3142 }
3143
3144 if (cfg->line_out_pins[0])
3145 spec->vmaster_nid =
3146 alc_look_for_out_vol_nid(codec, cfg->line_out_pins[0],
3147 spec->multiout.dac_nids[0]);
3148 return 0;
3149 }
3150
3151 static inline unsigned int get_ctl_pos(unsigned int data)
3152 {
3153 hda_nid_t nid = get_amp_nid_(data);
3154 unsigned int dir;
3155 if (snd_BUG_ON(nid >= MAX_VOL_NIDS))
3156 return 0;
3157 dir = get_amp_direction_(data);
3158 return (nid << 1) | dir;
3159 }
3160
3161 #define is_ctl_used(bits, data) \
3162 test_bit(get_ctl_pos(data), bits)
3163 #define mark_ctl_usage(bits, data) \
3164 set_bit(get_ctl_pos(data), bits)
3165
3166 static int alc_auto_add_vol_ctl(struct hda_codec *codec,
3167 const char *pfx, int cidx,
3168 hda_nid_t nid, unsigned int chs)
3169 {
3170 struct alc_spec *spec = codec->spec;
3171 unsigned int val;
3172 if (!nid)
3173 return 0;
3174 val = HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_OUTPUT);
3175 if (is_ctl_used(spec->vol_ctls, val) && chs != 2) /* exclude LFE */
3176 return 0;
3177 mark_ctl_usage(spec->vol_ctls, val);
3178 return __add_pb_vol_ctrl(codec->spec, ALC_CTL_WIDGET_VOL, pfx, cidx,
3179 val);
3180 }
3181
3182 static int alc_auto_add_stereo_vol(struct hda_codec *codec,
3183 const char *pfx, int cidx,
3184 hda_nid_t nid)
3185 {
3186 int chs = 1;
3187 if (get_wcaps(codec, nid) & AC_WCAP_STEREO)
3188 chs = 3;
3189 return alc_auto_add_vol_ctl(codec, pfx, cidx, nid, chs);
3190 }
3191
3192 /* create a mute-switch for the given mixer widget;
3193 * if it has multiple sources (e.g. DAC and loopback), create a bind-mute
3194 */
3195 static int alc_auto_add_sw_ctl(struct hda_codec *codec,
3196 const char *pfx, int cidx,
3197 hda_nid_t nid, unsigned int chs)
3198 {
3199 struct alc_spec *spec = codec->spec;
3200 int wid_type;
3201 int type;
3202 unsigned long val;
3203 if (!nid)
3204 return 0;
3205 wid_type = get_wcaps_type(get_wcaps(codec, nid));
3206 if (wid_type == AC_WID_PIN || wid_type == AC_WID_AUD_OUT) {
3207 type = ALC_CTL_WIDGET_MUTE;
3208 val = HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_OUTPUT);
3209 } else if (snd_hda_get_conn_list(codec, nid, NULL) == 1) {
3210 type = ALC_CTL_WIDGET_MUTE;
3211 val = HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_INPUT);
3212 } else {
3213 type = ALC_CTL_BIND_MUTE;
3214 val = HDA_COMPOSE_AMP_VAL(nid, chs, 2, HDA_INPUT);
3215 }
3216 if (is_ctl_used(spec->sw_ctls, val) && chs != 2) /* exclude LFE */
3217 return 0;
3218 mark_ctl_usage(spec->sw_ctls, val);
3219 return __add_pb_sw_ctrl(codec->spec, type, pfx, cidx, val);
3220 }
3221
3222 static int alc_auto_add_stereo_sw(struct hda_codec *codec, const char *pfx,
3223 int cidx, hda_nid_t nid)
3224 {
3225 int chs = 1;
3226 if (get_wcaps(codec, nid) & AC_WCAP_STEREO)
3227 chs = 3;
3228 return alc_auto_add_sw_ctl(codec, pfx, cidx, nid, chs);
3229 }
3230
3231 static hda_nid_t alc_look_for_out_mute_nid(struct hda_codec *codec,
3232 hda_nid_t pin, hda_nid_t dac)
3233 {
3234 hda_nid_t mix = alc_auto_dac_to_mix(codec, pin, dac);
3235 if (nid_has_mute(codec, pin, HDA_OUTPUT))
3236 return pin;
3237 else if (mix && nid_has_mute(codec, mix, HDA_INPUT))
3238 return mix;
3239 else if (nid_has_mute(codec, dac, HDA_OUTPUT))
3240 return dac;
3241 return 0;
3242 }
3243
3244 static hda_nid_t alc_look_for_out_vol_nid(struct hda_codec *codec,
3245 hda_nid_t pin, hda_nid_t dac)
3246 {
3247 hda_nid_t mix = alc_auto_dac_to_mix(codec, pin, dac);
3248 if (nid_has_volume(codec, dac, HDA_OUTPUT))
3249 return dac;
3250 else if (nid_has_volume(codec, mix, HDA_OUTPUT))
3251 return mix;
3252 else if (nid_has_volume(codec, pin, HDA_OUTPUT))
3253 return pin;
3254 return 0;
3255 }
3256
3257 /* add playback controls from the parsed DAC table */
3258 static int alc_auto_create_multi_out_ctls(struct hda_codec *codec,
3259 const struct auto_pin_cfg *cfg)
3260 {
3261 struct alc_spec *spec = codec->spec;
3262 int i, err, noutputs;
3263
3264 noutputs = cfg->line_outs;
3265 if (spec->multi_ios > 0 && cfg->line_outs < 3)
3266 noutputs += spec->multi_ios;
3267
3268 for (i = 0; i < noutputs; i++) {
3269 const char *name;
3270 int index;
3271 hda_nid_t dac, pin;
3272 hda_nid_t sw, vol;
3273
3274 dac = spec->multiout.dac_nids[i];
3275 if (!dac)
3276 continue;
3277 if (i >= cfg->line_outs)
3278 pin = spec->multi_io[i - 1].pin;
3279 else
3280 pin = cfg->line_out_pins[i];
3281
3282 sw = alc_look_for_out_mute_nid(codec, pin, dac);
3283 vol = alc_look_for_out_vol_nid(codec, pin, dac);
3284 name = alc_get_line_out_pfx(spec, i, true, &index);
3285 if (!name || !strcmp(name, "CLFE")) {
3286 /* Center/LFE */
3287 err = alc_auto_add_vol_ctl(codec, "Center", 0, vol, 1);
3288 if (err < 0)
3289 return err;
3290 err = alc_auto_add_vol_ctl(codec, "LFE", 0, vol, 2);
3291 if (err < 0)
3292 return err;
3293 err = alc_auto_add_sw_ctl(codec, "Center", 0, sw, 1);
3294 if (err < 0)
3295 return err;
3296 err = alc_auto_add_sw_ctl(codec, "LFE", 0, sw, 2);
3297 if (err < 0)
3298 return err;
3299 } else {
3300 err = alc_auto_add_stereo_vol(codec, name, index, vol);
3301 if (err < 0)
3302 return err;
3303 err = alc_auto_add_stereo_sw(codec, name, index, sw);
3304 if (err < 0)
3305 return err;
3306 }
3307 }
3308 return 0;
3309 }
3310
3311 static int alc_auto_create_extra_out(struct hda_codec *codec, hda_nid_t pin,
3312 hda_nid_t dac, const char *pfx,
3313 int cidx)
3314 {
3315 struct alc_spec *spec = codec->spec;
3316 hda_nid_t sw, vol;
3317 int err;
3318
3319 if (!dac) {
3320 unsigned int val;
3321 /* the corresponding DAC is already occupied */
3322 if (!(get_wcaps(codec, pin) & AC_WCAP_OUT_AMP))
3323 return 0; /* no way */
3324 /* create a switch only */
3325 val = HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT);
3326 if (is_ctl_used(spec->sw_ctls, val))
3327 return 0; /* already created */
3328 mark_ctl_usage(spec->sw_ctls, val);
3329 return __add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, pfx, cidx, val);
3330 }
3331
3332 sw = alc_look_for_out_mute_nid(codec, pin, dac);
3333 vol = alc_look_for_out_vol_nid(codec, pin, dac);
3334 err = alc_auto_add_stereo_vol(codec, pfx, cidx, vol);
3335 if (err < 0)
3336 return err;
3337 err = alc_auto_add_stereo_sw(codec, pfx, cidx, sw);
3338 if (err < 0)
3339 return err;
3340 return 0;
3341 }
3342
3343 static struct hda_bind_ctls *new_bind_ctl(struct hda_codec *codec,
3344 unsigned int nums,
3345 struct hda_ctl_ops *ops)
3346 {
3347 struct alc_spec *spec = codec->spec;
3348 struct hda_bind_ctls **ctlp, *ctl;
3349 snd_array_init(&spec->bind_ctls, sizeof(ctl), 8);
3350 ctlp = snd_array_new(&spec->bind_ctls);
3351 if (!ctlp)
3352 return NULL;
3353 ctl = kzalloc(sizeof(*ctl) + sizeof(long) * (nums + 1), GFP_KERNEL);
3354 *ctlp = ctl;
3355 if (ctl)
3356 ctl->ops = ops;
3357 return ctl;
3358 }
3359
3360 /* add playback controls for speaker and HP outputs */
3361 static int alc_auto_create_extra_outs(struct hda_codec *codec, int num_pins,
3362 const hda_nid_t *pins,
3363 const hda_nid_t *dacs,
3364 const char *pfx)
3365 {
3366 struct alc_spec *spec = codec->spec;
3367 struct hda_bind_ctls *ctl;
3368 char name[32];
3369 int i, n, err;
3370
3371 if (!num_pins || !pins[0])
3372 return 0;
3373
3374 if (num_pins == 1) {
3375 hda_nid_t dac = *dacs;
3376 if (!dac)
3377 dac = spec->multiout.dac_nids[0];
3378 return alc_auto_create_extra_out(codec, *pins, dac, pfx, 0);
3379 }
3380
3381 if (dacs[num_pins - 1]) {
3382 /* OK, we have a multi-output system with individual volumes */
3383 for (i = 0; i < num_pins; i++) {
3384 if (num_pins >= 3) {
3385 snprintf(name, sizeof(name), "%s %s",
3386 pfx, channel_name[i]);
3387 err = alc_auto_create_extra_out(codec, pins[i], dacs[i],
3388 name, 0);
3389 } else {
3390 err = alc_auto_create_extra_out(codec, pins[i], dacs[i],
3391 pfx, i);
3392 }
3393 if (err < 0)
3394 return err;
3395 }
3396 return 0;
3397 }
3398
3399 /* Let's create a bind-controls */
3400 ctl = new_bind_ctl(codec, num_pins, &snd_hda_bind_sw);
3401 if (!ctl)
3402 return -ENOMEM;
3403 n = 0;
3404 for (i = 0; i < num_pins; i++) {
3405 if (get_wcaps(codec, pins[i]) & AC_WCAP_OUT_AMP)
3406 ctl->values[n++] =
3407 HDA_COMPOSE_AMP_VAL(pins[i], 3, 0, HDA_OUTPUT);
3408 }
3409 if (n) {
3410 snprintf(name, sizeof(name), "%s Playback Switch", pfx);
3411 err = add_control(spec, ALC_CTL_BIND_SW, name, 0, (long)ctl);
3412 if (err < 0)
3413 return err;
3414 }
3415
3416 ctl = new_bind_ctl(codec, num_pins, &snd_hda_bind_vol);
3417 if (!ctl)
3418 return -ENOMEM;
3419 n = 0;
3420 for (i = 0; i < num_pins; i++) {
3421 hda_nid_t vol;
3422 if (!pins[i] || !dacs[i])
3423 continue;
3424 vol = alc_look_for_out_vol_nid(codec, pins[i], dacs[i]);
3425 if (vol)
3426 ctl->values[n++] =
3427 HDA_COMPOSE_AMP_VAL(vol, 3, 0, HDA_OUTPUT);
3428 }
3429 if (n) {
3430 snprintf(name, sizeof(name), "%s Playback Volume", pfx);
3431 err = add_control(spec, ALC_CTL_BIND_VOL, name, 0, (long)ctl);
3432 if (err < 0)
3433 return err;
3434 }
3435 return 0;
3436 }
3437
3438 static int alc_auto_create_hp_out(struct hda_codec *codec)
3439 {
3440 struct alc_spec *spec = codec->spec;
3441 return alc_auto_create_extra_outs(codec, spec->autocfg.hp_outs,
3442 spec->autocfg.hp_pins,
3443 spec->multiout.hp_out_nid,
3444 "Headphone");
3445 }
3446
3447 static int alc_auto_create_speaker_out(struct hda_codec *codec)
3448 {
3449 struct alc_spec *spec = codec->spec;
3450 return alc_auto_create_extra_outs(codec, spec->autocfg.speaker_outs,
3451 spec->autocfg.speaker_pins,
3452 spec->multiout.extra_out_nid,
3453 "Speaker");
3454 }
3455
3456 static void alc_auto_set_output_and_unmute(struct hda_codec *codec,
3457 hda_nid_t pin, int pin_type,
3458 hda_nid_t dac)
3459 {
3460 int i, num;
3461 hda_nid_t nid, mix = 0;
3462 hda_nid_t srcs[HDA_MAX_CONNECTIONS];
3463
3464 alc_set_pin_output(codec, pin, pin_type);
3465 nid = alc_go_down_to_selector(codec, pin);
3466 num = snd_hda_get_connections(codec, nid, srcs, ARRAY_SIZE(srcs));
3467 for (i = 0; i < num; i++) {
3468 if (alc_auto_mix_to_dac(codec, srcs[i]) != dac)
3469 continue;
3470 mix = srcs[i];
3471 break;
3472 }
3473 if (!mix)
3474 return;
3475
3476 /* need the manual connection? */
3477 if (num > 1)
3478 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CONNECT_SEL, i);
3479 /* unmute mixer widget inputs */
3480 if (nid_has_mute(codec, mix, HDA_INPUT)) {
3481 snd_hda_codec_write(codec, mix, 0, AC_VERB_SET_AMP_GAIN_MUTE,
3482 AMP_IN_UNMUTE(0));
3483 snd_hda_codec_write(codec, mix, 0, AC_VERB_SET_AMP_GAIN_MUTE,
3484 AMP_IN_UNMUTE(1));
3485 }
3486 /* initialize volume */
3487 nid = alc_look_for_out_vol_nid(codec, pin, dac);
3488 if (nid)
3489 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE,
3490 AMP_OUT_ZERO);
3491
3492 /* unmute DAC if it's not assigned to a mixer */
3493 nid = alc_look_for_out_mute_nid(codec, pin, dac);
3494 if (nid == mix && nid_has_mute(codec, dac, HDA_OUTPUT))
3495 snd_hda_codec_write(codec, dac, 0, AC_VERB_SET_AMP_GAIN_MUTE,
3496 AMP_OUT_ZERO);
3497 }
3498
3499 static void alc_auto_init_multi_out(struct hda_codec *codec)
3500 {
3501 struct alc_spec *spec = codec->spec;
3502 int pin_type = get_pin_type(spec->autocfg.line_out_type);
3503 int i;
3504
3505 for (i = 0; i <= HDA_SIDE; i++) {
3506 hda_nid_t nid = spec->autocfg.line_out_pins[i];
3507 if (nid)
3508 alc_auto_set_output_and_unmute(codec, nid, pin_type,
3509 spec->multiout.dac_nids[i]);
3510 }
3511 }
3512
3513 static void alc_auto_init_extra_out(struct hda_codec *codec)
3514 {
3515 struct alc_spec *spec = codec->spec;
3516 int i;
3517 hda_nid_t pin, dac;
3518
3519 for (i = 0; i < spec->autocfg.hp_outs; i++) {
3520 if (spec->autocfg.line_out_type == AUTO_PIN_HP_OUT)
3521 break;
3522 pin = spec->autocfg.hp_pins[i];
3523 if (!pin)
3524 break;
3525 dac = spec->multiout.hp_out_nid[i];
3526 if (!dac) {
3527 if (i > 0 && spec->multiout.hp_out_nid[0])
3528 dac = spec->multiout.hp_out_nid[0];
3529 else
3530 dac = spec->multiout.dac_nids[0];
3531 }
3532 alc_auto_set_output_and_unmute(codec, pin, PIN_HP, dac);
3533 }
3534 for (i = 0; i < spec->autocfg.speaker_outs; i++) {
3535 if (spec->autocfg.line_out_type == AUTO_PIN_SPEAKER_OUT)
3536 break;
3537 pin = spec->autocfg.speaker_pins[i];
3538 if (!pin)
3539 break;
3540 dac = spec->multiout.extra_out_nid[i];
3541 if (!dac) {
3542 if (i > 0 && spec->multiout.extra_out_nid[0])
3543 dac = spec->multiout.extra_out_nid[0];
3544 else
3545 dac = spec->multiout.dac_nids[0];
3546 }
3547 alc_auto_set_output_and_unmute(codec, pin, PIN_OUT, dac);
3548 }
3549 }
3550
3551 /*
3552 * multi-io helper
3553 */
3554 static int alc_auto_fill_multi_ios(struct hda_codec *codec,
3555 unsigned int location,
3556 int offset)
3557 {
3558 struct alc_spec *spec = codec->spec;
3559 struct auto_pin_cfg *cfg = &spec->autocfg;
3560 hda_nid_t prime_dac = spec->private_dac_nids[0];
3561 int type, i, dacs, num_pins = 0;
3562
3563 dacs = spec->multiout.num_dacs;
3564 for (type = AUTO_PIN_LINE_IN; type >= AUTO_PIN_MIC; type--) {
3565 for (i = 0; i < cfg->num_inputs; i++) {
3566 hda_nid_t nid = cfg->inputs[i].pin;
3567 hda_nid_t dac = 0;
3568 unsigned int defcfg, caps;
3569 if (cfg->inputs[i].type != type)
3570 continue;
3571 defcfg = snd_hda_codec_get_pincfg(codec, nid);
3572 if (get_defcfg_connect(defcfg) != AC_JACK_PORT_COMPLEX)
3573 continue;
3574 if (location && get_defcfg_location(defcfg) != location)
3575 continue;
3576 caps = snd_hda_query_pin_caps(codec, nid);
3577 if (!(caps & AC_PINCAP_OUT))
3578 continue;
3579 if (offset && offset + num_pins < dacs) {
3580 dac = spec->private_dac_nids[offset + num_pins];
3581 if (!alc_auto_is_dac_reachable(codec, nid, dac))
3582 dac = 0;
3583 }
3584 if (!dac)
3585 dac = alc_auto_look_for_dac(codec, nid);
3586 if (!dac)
3587 continue;
3588 spec->multi_io[num_pins].pin = nid;
3589 spec->multi_io[num_pins].dac = dac;
3590 num_pins++;
3591 spec->private_dac_nids[spec->multiout.num_dacs++] = dac;
3592 }
3593 }
3594 spec->multiout.num_dacs = dacs;
3595 if (num_pins < 2) {
3596 /* clear up again */
3597 memset(spec->private_dac_nids + dacs, 0,
3598 sizeof(hda_nid_t) * (AUTO_CFG_MAX_OUTS - dacs));
3599 spec->private_dac_nids[0] = prime_dac;
3600 return 0;
3601 }
3602 return num_pins;
3603 }
3604
3605 static int alc_auto_ch_mode_info(struct snd_kcontrol *kcontrol,
3606 struct snd_ctl_elem_info *uinfo)
3607 {
3608 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3609 struct alc_spec *spec = codec->spec;
3610
3611 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
3612 uinfo->count = 1;
3613 uinfo->value.enumerated.items = spec->multi_ios + 1;
3614 if (uinfo->value.enumerated.item > spec->multi_ios)
3615 uinfo->value.enumerated.item = spec->multi_ios;
3616 sprintf(uinfo->value.enumerated.name, "%dch",
3617 (uinfo->value.enumerated.item + 1) * 2);
3618 return 0;
3619 }
3620
3621 static int alc_auto_ch_mode_get(struct snd_kcontrol *kcontrol,
3622 struct snd_ctl_elem_value *ucontrol)
3623 {
3624 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3625 struct alc_spec *spec = codec->spec;
3626 ucontrol->value.enumerated.item[0] = (spec->ext_channel_count - 1) / 2;
3627 return 0;
3628 }
3629
3630 static int alc_set_multi_io(struct hda_codec *codec, int idx, bool output)
3631 {
3632 struct alc_spec *spec = codec->spec;
3633 hda_nid_t nid = spec->multi_io[idx].pin;
3634
3635 if (!spec->multi_io[idx].ctl_in)
3636 spec->multi_io[idx].ctl_in =
3637 snd_hda_codec_read(codec, nid, 0,
3638 AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
3639 if (output) {
3640 snd_hda_codec_update_cache(codec, nid, 0,
3641 AC_VERB_SET_PIN_WIDGET_CONTROL,
3642 PIN_OUT);
3643 if (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP)
3644 snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
3645 HDA_AMP_MUTE, 0);
3646 alc_auto_select_dac(codec, nid, spec->multi_io[idx].dac);
3647 } else {
3648 if (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP)
3649 snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
3650 HDA_AMP_MUTE, HDA_AMP_MUTE);
3651 snd_hda_codec_update_cache(codec, nid, 0,
3652 AC_VERB_SET_PIN_WIDGET_CONTROL,
3653 spec->multi_io[idx].ctl_in);
3654 }
3655 return 0;
3656 }
3657
3658 static int alc_auto_ch_mode_put(struct snd_kcontrol *kcontrol,
3659 struct snd_ctl_elem_value *ucontrol)
3660 {
3661 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3662 struct alc_spec *spec = codec->spec;
3663 int i, ch;
3664
3665 ch = ucontrol->value.enumerated.item[0];
3666 if (ch < 0 || ch > spec->multi_ios)
3667 return -EINVAL;
3668 if (ch == (spec->ext_channel_count - 1) / 2)
3669 return 0;
3670 spec->ext_channel_count = (ch + 1) * 2;
3671 for (i = 0; i < spec->multi_ios; i++)
3672 alc_set_multi_io(codec, i, i < ch);
3673 spec->multiout.max_channels = spec->ext_channel_count;
3674 if (spec->need_dac_fix && !spec->const_channel_count)
3675 spec->multiout.num_dacs = spec->multiout.max_channels / 2;
3676 return 1;
3677 }
3678
3679 static const struct snd_kcontrol_new alc_auto_channel_mode_enum = {
3680 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3681 .name = "Channel Mode",
3682 .info = alc_auto_ch_mode_info,
3683 .get = alc_auto_ch_mode_get,
3684 .put = alc_auto_ch_mode_put,
3685 };
3686
3687 static int alc_auto_add_multi_channel_mode(struct hda_codec *codec)
3688 {
3689 struct alc_spec *spec = codec->spec;
3690
3691 if (spec->multi_ios > 0) {
3692 struct snd_kcontrol_new *knew;
3693
3694 knew = alc_kcontrol_new(spec);
3695 if (!knew)
3696 return -ENOMEM;
3697 *knew = alc_auto_channel_mode_enum;
3698 knew->name = kstrdup("Channel Mode", GFP_KERNEL);
3699 if (!knew->name)
3700 return -ENOMEM;
3701 }
3702 return 0;
3703 }
3704
3705 /* filter out invalid adc_nids (and capsrc_nids) that don't give all
3706 * active input pins
3707 */
3708 static void alc_remove_invalid_adc_nids(struct hda_codec *codec)
3709 {
3710 struct alc_spec *spec = codec->spec;
3711 const struct hda_input_mux *imux;
3712 hda_nid_t adc_nids[ARRAY_SIZE(spec->private_adc_nids)];
3713 hda_nid_t capsrc_nids[ARRAY_SIZE(spec->private_adc_nids)];
3714 int i, n, nums;
3715
3716 imux = spec->input_mux;
3717 if (!imux)
3718 return;
3719 if (spec->dyn_adc_switch)
3720 return;
3721
3722 nums = 0;
3723 for (n = 0; n < spec->num_adc_nids; n++) {
3724 hda_nid_t cap = spec->private_capsrc_nids[n];
3725 int num_conns = snd_hda_get_conn_list(codec, cap, NULL);
3726 for (i = 0; i < imux->num_items; i++) {
3727 hda_nid_t pin = spec->imux_pins[i];
3728 if (pin) {
3729 if (get_connection_index(codec, cap, pin) < 0)
3730 break;
3731 } else if (num_conns <= imux->items[i].index)
3732 break;
3733 }
3734 if (i >= imux->num_items) {
3735 adc_nids[nums] = spec->private_adc_nids[n];
3736 capsrc_nids[nums++] = cap;
3737 }
3738 }
3739 if (!nums) {
3740 /* check whether ADC-switch is possible */
3741 if (!alc_check_dyn_adc_switch(codec)) {
3742 printk(KERN_WARNING "hda_codec: %s: no valid ADC found;"
3743 " using fallback 0x%x\n",
3744 codec->chip_name, spec->private_adc_nids[0]);
3745 spec->num_adc_nids = 1;
3746 spec->auto_mic = 0;
3747 return;
3748 }
3749 } else if (nums != spec->num_adc_nids) {
3750 memcpy(spec->private_adc_nids, adc_nids,
3751 nums * sizeof(hda_nid_t));
3752 memcpy(spec->private_capsrc_nids, capsrc_nids,
3753 nums * sizeof(hda_nid_t));
3754 spec->num_adc_nids = nums;
3755 }
3756
3757 if (spec->auto_mic)
3758 alc_auto_mic_check_imux(codec); /* check auto-mic setups */
3759 else if (spec->input_mux->num_items == 1)
3760 spec->num_adc_nids = 1; /* reduce to a single ADC */
3761 }
3762
3763 /*
3764 * initialize ADC paths
3765 */
3766 static void alc_auto_init_adc(struct hda_codec *codec, int adc_idx)
3767 {
3768 struct alc_spec *spec = codec->spec;
3769 hda_nid_t nid;
3770
3771 nid = spec->adc_nids[adc_idx];
3772 /* mute ADC */
3773 if (nid_has_mute(codec, nid, HDA_INPUT)) {
3774 snd_hda_codec_write(codec, nid, 0,
3775 AC_VERB_SET_AMP_GAIN_MUTE,
3776 AMP_IN_MUTE(0));
3777 return;
3778 }
3779 if (!spec->capsrc_nids)
3780 return;
3781 nid = spec->capsrc_nids[adc_idx];
3782 if (nid_has_mute(codec, nid, HDA_OUTPUT))
3783 snd_hda_codec_write(codec, nid, 0,
3784 AC_VERB_SET_AMP_GAIN_MUTE,
3785 AMP_OUT_MUTE);
3786 }
3787
3788 static void alc_auto_init_input_src(struct hda_codec *codec)
3789 {
3790 struct alc_spec *spec = codec->spec;
3791 int c, nums;
3792
3793 for (c = 0; c < spec->num_adc_nids; c++)
3794 alc_auto_init_adc(codec, c);
3795 if (spec->dyn_adc_switch)
3796 nums = 1;
3797 else
3798 nums = spec->num_adc_nids;
3799 for (c = 0; c < nums; c++)
3800 alc_mux_select(codec, c, spec->cur_mux[c], true);
3801 }
3802
3803 /* add mic boosts if needed */
3804 static int alc_auto_add_mic_boost(struct hda_codec *codec)
3805 {
3806 struct alc_spec *spec = codec->spec;
3807 struct auto_pin_cfg *cfg = &spec->autocfg;
3808 int i, err;
3809 int type_idx = 0;
3810 hda_nid_t nid;
3811 const char *prev_label = NULL;
3812
3813 for (i = 0; i < cfg->num_inputs; i++) {
3814 if (cfg->inputs[i].type > AUTO_PIN_MIC)
3815 break;
3816 nid = cfg->inputs[i].pin;
3817 if (get_wcaps(codec, nid) & AC_WCAP_IN_AMP) {
3818 const char *label;
3819 char boost_label[32];
3820
3821 label = hda_get_autocfg_input_label(codec, cfg, i);
3822 if (spec->shared_mic_hp && !strcmp(label, "Misc"))
3823 label = "Headphone Mic";
3824 if (prev_label && !strcmp(label, prev_label))
3825 type_idx++;
3826 else
3827 type_idx = 0;
3828 prev_label = label;
3829
3830 snprintf(boost_label, sizeof(boost_label),
3831 "%s Boost Volume", label);
3832 err = add_control(spec, ALC_CTL_WIDGET_VOL,
3833 boost_label, type_idx,
3834 HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT));
3835 if (err < 0)
3836 return err;
3837 }
3838 }
3839 return 0;
3840 }
3841
3842 /* select or unmute the given capsrc route */
3843 static void select_or_unmute_capsrc(struct hda_codec *codec, hda_nid_t cap,
3844 int idx)
3845 {
3846 if (get_wcaps_type(get_wcaps(codec, cap)) == AC_WID_AUD_MIX) {
3847 snd_hda_codec_amp_stereo(codec, cap, HDA_INPUT, idx,
3848 HDA_AMP_MUTE, 0);
3849 } else if (snd_hda_get_conn_list(codec, cap, NULL) > 1) {
3850 snd_hda_codec_write_cache(codec, cap, 0,
3851 AC_VERB_SET_CONNECT_SEL, idx);
3852 }
3853 }
3854
3855 /* set the default connection to that pin */
3856 static int init_capsrc_for_pin(struct hda_codec *codec, hda_nid_t pin)
3857 {
3858 struct alc_spec *spec = codec->spec;
3859 int i;
3860
3861 if (!pin)
3862 return 0;
3863 for (i = 0; i < spec->num_adc_nids; i++) {
3864 hda_nid_t cap = get_capsrc(spec, i);
3865 int idx;
3866
3867 idx = get_connection_index(codec, cap, pin);
3868 if (idx < 0)
3869 continue;
3870 select_or_unmute_capsrc(codec, cap, idx);
3871 return i; /* return the found index */
3872 }
3873 return -1; /* not found */
3874 }
3875
3876 /* initialize some special cases for input sources */
3877 static void alc_init_special_input_src(struct hda_codec *codec)
3878 {
3879 struct alc_spec *spec = codec->spec;
3880 int i;
3881
3882 for (i = 0; i < spec->autocfg.num_inputs; i++)
3883 init_capsrc_for_pin(codec, spec->autocfg.inputs[i].pin);
3884 }
3885
3886 /* assign appropriate capture mixers */
3887 static void set_capture_mixer(struct hda_codec *codec)
3888 {
3889 struct alc_spec *spec = codec->spec;
3890 static const struct snd_kcontrol_new *caps[2][3] = {
3891 { alc_capture_mixer_nosrc1,
3892 alc_capture_mixer_nosrc2,
3893 alc_capture_mixer_nosrc3 },
3894 { alc_capture_mixer1,
3895 alc_capture_mixer2,
3896 alc_capture_mixer3 },
3897 };
3898
3899 /* check whether either of ADC or MUX has a volume control */
3900 if (!nid_has_volume(codec, spec->adc_nids[0], HDA_INPUT)) {
3901 if (!spec->capsrc_nids)
3902 return; /* no volume */
3903 if (!nid_has_volume(codec, spec->capsrc_nids[0], HDA_OUTPUT))
3904 return; /* no volume in capsrc, too */
3905 spec->vol_in_capsrc = 1;
3906 }
3907
3908 if (spec->num_adc_nids > 0) {
3909 int mux = 0;
3910 int num_adcs = 0;
3911
3912 if (spec->input_mux && spec->input_mux->num_items > 1)
3913 mux = 1;
3914 if (spec->auto_mic) {
3915 num_adcs = 1;
3916 mux = 0;
3917 } else if (spec->dyn_adc_switch)
3918 num_adcs = 1;
3919 if (!num_adcs) {
3920 if (spec->num_adc_nids > 3)
3921 spec->num_adc_nids = 3;
3922 else if (!spec->num_adc_nids)
3923 return;
3924 num_adcs = spec->num_adc_nids;
3925 }
3926 spec->cap_mixer = caps[mux][num_adcs - 1];
3927 }
3928 }
3929
3930 /*
3931 * standard auto-parser initializations
3932 */
3933 static void alc_auto_init_std(struct hda_codec *codec)
3934 {
3935 struct alc_spec *spec = codec->spec;
3936 alc_auto_init_multi_out(codec);
3937 alc_auto_init_extra_out(codec);
3938 alc_auto_init_analog_input(codec);
3939 alc_auto_init_input_src(codec);
3940 alc_auto_init_digital(codec);
3941 if (spec->unsol_event)
3942 alc_inithook(codec);
3943 }
3944
3945 /*
3946 * Digital-beep handlers
3947 */
3948 #ifdef CONFIG_SND_HDA_INPUT_BEEP
3949 #define set_beep_amp(spec, nid, idx, dir) \
3950 ((spec)->beep_amp = HDA_COMPOSE_AMP_VAL(nid, 3, idx, dir))
3951
3952 static const struct snd_pci_quirk beep_white_list[] = {
3953 SND_PCI_QUIRK(0x1043, 0x829f, "ASUS", 1),
3954 SND_PCI_QUIRK(0x1043, 0x83ce, "EeePC", 1),
3955 SND_PCI_QUIRK(0x1043, 0x831a, "EeePC", 1),
3956 SND_PCI_QUIRK(0x1043, 0x834a, "EeePC", 1),
3957 SND_PCI_QUIRK(0x8086, 0xd613, "Intel", 1),
3958 {}
3959 };
3960
3961 static inline int has_cdefine_beep(struct hda_codec *codec)
3962 {
3963 struct alc_spec *spec = codec->spec;
3964 const struct snd_pci_quirk *q;
3965 q = snd_pci_quirk_lookup(codec->bus->pci, beep_white_list);
3966 if (q)
3967 return q->value;
3968 return spec->cdefine.enable_pcbeep;
3969 }
3970 #else
3971 #define set_beep_amp(spec, nid, idx, dir) /* NOP */
3972 #define has_cdefine_beep(codec) 0
3973 #endif
3974
3975 /* parse the BIOS configuration and set up the alc_spec */
3976 /* return 1 if successful, 0 if the proper config is not found,
3977 * or a negative error code
3978 */
3979 static int alc_parse_auto_config(struct hda_codec *codec,
3980 const hda_nid_t *ignore_nids,
3981 const hda_nid_t *ssid_nids)
3982 {
3983 struct alc_spec *spec = codec->spec;
3984 struct auto_pin_cfg *cfg = &spec->autocfg;
3985 int err;
3986
3987 err = snd_hda_parse_pin_defcfg(codec, cfg, ignore_nids,
3988 spec->parse_flags);
3989 if (err < 0)
3990 return err;
3991 if (!cfg->line_outs) {
3992 if (cfg->dig_outs || cfg->dig_in_pin) {
3993 spec->multiout.max_channels = 2;
3994 spec->no_analog = 1;
3995 goto dig_only;
3996 }
3997 return 0; /* can't find valid BIOS pin config */
3998 }
3999
4000 if (cfg->line_out_type == AUTO_PIN_SPEAKER_OUT &&
4001 cfg->line_outs <= cfg->hp_outs) {
4002 /* use HP as primary out */
4003 cfg->speaker_outs = cfg->line_outs;
4004 memcpy(cfg->speaker_pins, cfg->line_out_pins,
4005 sizeof(cfg->speaker_pins));
4006 cfg->line_outs = cfg->hp_outs;
4007 memcpy(cfg->line_out_pins, cfg->hp_pins, sizeof(cfg->hp_pins));
4008 cfg->hp_outs = 0;
4009 memset(cfg->hp_pins, 0, sizeof(cfg->hp_pins));
4010 cfg->line_out_type = AUTO_PIN_HP_OUT;
4011 }
4012
4013 err = alc_auto_fill_dac_nids(codec);
4014 if (err < 0)
4015 return err;
4016 err = alc_auto_add_multi_channel_mode(codec);
4017 if (err < 0)
4018 return err;
4019 err = alc_auto_create_multi_out_ctls(codec, cfg);
4020 if (err < 0)
4021 return err;
4022 err = alc_auto_create_hp_out(codec);
4023 if (err < 0)
4024 return err;
4025 err = alc_auto_create_speaker_out(codec);
4026 if (err < 0)
4027 return err;
4028 err = alc_auto_create_shared_input(codec);
4029 if (err < 0)
4030 return err;
4031 err = alc_auto_create_input_ctls(codec);
4032 if (err < 0)
4033 return err;
4034
4035 spec->multiout.max_channels = spec->multiout.num_dacs * 2;
4036
4037 dig_only:
4038 alc_auto_parse_digital(codec);
4039
4040 if (!spec->no_analog)
4041 alc_remove_invalid_adc_nids(codec);
4042
4043 if (ssid_nids)
4044 alc_ssid_check(codec, ssid_nids);
4045
4046 if (!spec->no_analog) {
4047 alc_auto_check_switches(codec);
4048 err = alc_auto_add_mic_boost(codec);
4049 if (err < 0)
4050 return err;
4051 }
4052
4053 if (spec->kctls.list)
4054 add_mixer(spec, spec->kctls.list);
4055
4056 return 1;
4057 }
4058
4059 static int alc880_parse_auto_config(struct hda_codec *codec)
4060 {
4061 static const hda_nid_t alc880_ignore[] = { 0x1d, 0 };
4062 static const hda_nid_t alc880_ssids[] = { 0x15, 0x1b, 0x14, 0 };
4063 return alc_parse_auto_config(codec, alc880_ignore, alc880_ssids);
4064 }
4065
4066 #ifdef CONFIG_SND_HDA_POWER_SAVE
4067 static const struct hda_amp_list alc880_loopbacks[] = {
4068 { 0x0b, HDA_INPUT, 0 },
4069 { 0x0b, HDA_INPUT, 1 },
4070 { 0x0b, HDA_INPUT, 2 },
4071 { 0x0b, HDA_INPUT, 3 },
4072 { 0x0b, HDA_INPUT, 4 },
4073 { } /* end */
4074 };
4075 #endif
4076
4077 /*
4078 * ALC880 fix-ups
4079 */
4080 enum {
4081 ALC880_FIXUP_GPIO2,
4082 ALC880_FIXUP_MEDION_RIM,
4083 };
4084
4085 static const struct alc_fixup alc880_fixups[] = {
4086 [ALC880_FIXUP_GPIO2] = {
4087 .type = ALC_FIXUP_VERBS,
4088 .v.verbs = alc_gpio2_init_verbs,
4089 },
4090 [ALC880_FIXUP_MEDION_RIM] = {
4091 .type = ALC_FIXUP_VERBS,
4092 .v.verbs = (const struct hda_verb[]) {
4093 { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
4094 { 0x20, AC_VERB_SET_PROC_COEF, 0x3060 },
4095 { }
4096 },
4097 .chained = true,
4098 .chain_id = ALC880_FIXUP_GPIO2,
4099 },
4100 };
4101
4102 static const struct snd_pci_quirk alc880_fixup_tbl[] = {
4103 SND_PCI_QUIRK(0x161f, 0x205d, "Medion Rim 2150", ALC880_FIXUP_MEDION_RIM),
4104 {}
4105 };
4106
4107
4108 /*
4109 * board setups
4110 */
4111 #ifdef CONFIG_SND_HDA_ENABLE_REALTEK_QUIRKS
4112 #define alc_board_config \
4113 snd_hda_check_board_config
4114 #define alc_board_codec_sid_config \
4115 snd_hda_check_board_codec_sid_config
4116 #include "alc_quirks.c"
4117 #else
4118 #define alc_board_config(codec, nums, models, tbl) -1
4119 #define alc_board_codec_sid_config(codec, nums, models, tbl) -1
4120 #define setup_preset(codec, x) /* NOP */
4121 #endif
4122
4123 /*
4124 * OK, here we have finally the patch for ALC880
4125 */
4126 #ifdef CONFIG_SND_HDA_ENABLE_REALTEK_QUIRKS
4127 #include "alc880_quirks.c"
4128 #endif
4129
4130 static int patch_alc880(struct hda_codec *codec)
4131 {
4132 struct alc_spec *spec;
4133 int board_config;
4134 int err;
4135
4136 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
4137 if (spec == NULL)
4138 return -ENOMEM;
4139
4140 codec->spec = spec;
4141
4142 spec->mixer_nid = 0x0b;
4143 spec->need_dac_fix = 1;
4144
4145 board_config = alc_board_config(codec, ALC880_MODEL_LAST,
4146 alc880_models, alc880_cfg_tbl);
4147 if (board_config < 0) {
4148 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
4149 codec->chip_name);
4150 board_config = ALC_MODEL_AUTO;
4151 }
4152
4153 if (board_config == ALC_MODEL_AUTO) {
4154 alc_pick_fixup(codec, NULL, alc880_fixup_tbl, alc880_fixups);
4155 alc_apply_fixup(codec, ALC_FIXUP_ACT_PRE_PROBE);
4156 }
4157
4158 if (board_config == ALC_MODEL_AUTO) {
4159 /* automatic parse from the BIOS config */
4160 err = alc880_parse_auto_config(codec);
4161 if (err < 0)
4162 goto error;
4163 #ifdef CONFIG_SND_HDA_ENABLE_REALTEK_QUIRKS
4164 else if (!err) {
4165 printk(KERN_INFO
4166 "hda_codec: Cannot set up configuration "
4167 "from BIOS. Using 3-stack mode...\n");
4168 board_config = ALC880_3ST;
4169 }
4170 #endif
4171 }
4172
4173 if (board_config != ALC_MODEL_AUTO) {
4174 spec->vmaster_nid = 0x0c;
4175 setup_preset(codec, &alc880_presets[board_config]);
4176 }
4177
4178 if (!spec->no_analog && !spec->adc_nids) {
4179 alc_auto_fill_adc_caps(codec);
4180 alc_rebuild_imux_for_auto_mic(codec);
4181 alc_remove_invalid_adc_nids(codec);
4182 }
4183
4184 if (!spec->no_analog && !spec->cap_mixer)
4185 set_capture_mixer(codec);
4186
4187 if (!spec->no_analog) {
4188 err = snd_hda_attach_beep_device(codec, 0x1);
4189 if (err < 0)
4190 goto error;
4191 set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
4192 }
4193
4194 alc_apply_fixup(codec, ALC_FIXUP_ACT_PROBE);
4195
4196 codec->patch_ops = alc_patch_ops;
4197 if (board_config == ALC_MODEL_AUTO)
4198 spec->init_hook = alc_auto_init_std;
4199 else
4200 codec->patch_ops.build_controls = __alc_build_controls;
4201 #ifdef CONFIG_SND_HDA_POWER_SAVE
4202 if (!spec->loopback.amplist)
4203 spec->loopback.amplist = alc880_loopbacks;
4204 #endif
4205
4206 return 0;
4207
4208 error:
4209 alc_free(codec);
4210 return err;
4211 }
4212
4213
4214 /*
4215 * ALC260 support
4216 */
4217 static int alc260_parse_auto_config(struct hda_codec *codec)
4218 {
4219 static const hda_nid_t alc260_ignore[] = { 0x17, 0 };
4220 static const hda_nid_t alc260_ssids[] = { 0x10, 0x15, 0x0f, 0 };
4221 return alc_parse_auto_config(codec, alc260_ignore, alc260_ssids);
4222 }
4223
4224 #ifdef CONFIG_SND_HDA_POWER_SAVE
4225 static const struct hda_amp_list alc260_loopbacks[] = {
4226 { 0x07, HDA_INPUT, 0 },
4227 { 0x07, HDA_INPUT, 1 },
4228 { 0x07, HDA_INPUT, 2 },
4229 { 0x07, HDA_INPUT, 3 },
4230 { 0x07, HDA_INPUT, 4 },
4231 { } /* end */
4232 };
4233 #endif
4234
4235 /*
4236 * Pin config fixes
4237 */
4238 enum {
4239 PINFIX_HP_DC5750,
4240 };
4241
4242 static const struct alc_fixup alc260_fixups[] = {
4243 [PINFIX_HP_DC5750] = {
4244 .type = ALC_FIXUP_PINS,
4245 .v.pins = (const struct alc_pincfg[]) {
4246 { 0x11, 0x90130110 }, /* speaker */
4247 { }
4248 }
4249 },
4250 };
4251
4252 static const struct snd_pci_quirk alc260_fixup_tbl[] = {
4253 SND_PCI_QUIRK(0x103c, 0x280a, "HP dc5750", PINFIX_HP_DC5750),
4254 {}
4255 };
4256
4257 /*
4258 */
4259 #ifdef CONFIG_SND_HDA_ENABLE_REALTEK_QUIRKS
4260 #include "alc260_quirks.c"
4261 #endif
4262
4263 static int patch_alc260(struct hda_codec *codec)
4264 {
4265 struct alc_spec *spec;
4266 int err, board_config;
4267
4268 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
4269 if (spec == NULL)
4270 return -ENOMEM;
4271
4272 codec->spec = spec;
4273
4274 spec->mixer_nid = 0x07;
4275
4276 board_config = alc_board_config(codec, ALC260_MODEL_LAST,
4277 alc260_models, alc260_cfg_tbl);
4278 if (board_config < 0) {
4279 snd_printd(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
4280 codec->chip_name);
4281 board_config = ALC_MODEL_AUTO;
4282 }
4283
4284 if (board_config == ALC_MODEL_AUTO) {
4285 alc_pick_fixup(codec, NULL, alc260_fixup_tbl, alc260_fixups);
4286 alc_apply_fixup(codec, ALC_FIXUP_ACT_PRE_PROBE);
4287 }
4288
4289 if (board_config == ALC_MODEL_AUTO) {
4290 /* automatic parse from the BIOS config */
4291 err = alc260_parse_auto_config(codec);
4292 if (err < 0)
4293 goto error;
4294 #ifdef CONFIG_SND_HDA_ENABLE_REALTEK_QUIRKS
4295 else if (!err) {
4296 printk(KERN_INFO
4297 "hda_codec: Cannot set up configuration "
4298 "from BIOS. Using base mode...\n");
4299 board_config = ALC260_BASIC;
4300 }
4301 #endif
4302 }
4303
4304 if (board_config != ALC_MODEL_AUTO) {
4305 setup_preset(codec, &alc260_presets[board_config]);
4306 spec->vmaster_nid = 0x08;
4307 }
4308
4309 if (!spec->no_analog && !spec->adc_nids) {
4310 alc_auto_fill_adc_caps(codec);
4311 alc_rebuild_imux_for_auto_mic(codec);
4312 alc_remove_invalid_adc_nids(codec);
4313 }
4314
4315 if (!spec->no_analog && !spec->cap_mixer)
4316 set_capture_mixer(codec);
4317
4318 if (!spec->no_analog) {
4319 err = snd_hda_attach_beep_device(codec, 0x1);
4320 if (err < 0)
4321 goto error;
4322 set_beep_amp(spec, 0x07, 0x05, HDA_INPUT);
4323 }
4324
4325 alc_apply_fixup(codec, ALC_FIXUP_ACT_PROBE);
4326
4327 codec->patch_ops = alc_patch_ops;
4328 if (board_config == ALC_MODEL_AUTO)
4329 spec->init_hook = alc_auto_init_std;
4330 else
4331 codec->patch_ops.build_controls = __alc_build_controls;
4332 spec->shutup = alc_eapd_shutup;
4333 #ifdef CONFIG_SND_HDA_POWER_SAVE
4334 if (!spec->loopback.amplist)
4335 spec->loopback.amplist = alc260_loopbacks;
4336 #endif
4337
4338 return 0;
4339
4340 error:
4341 alc_free(codec);
4342 return err;
4343 }
4344
4345
4346 /*
4347 * ALC882/883/885/888/889 support
4348 *
4349 * ALC882 is almost identical with ALC880 but has cleaner and more flexible
4350 * configuration. Each pin widget can choose any input DACs and a mixer.
4351 * Each ADC is connected from a mixer of all inputs. This makes possible
4352 * 6-channel independent captures.
4353 *
4354 * In addition, an independent DAC for the multi-playback (not used in this
4355 * driver yet).
4356 */
4357 #ifdef CONFIG_SND_HDA_POWER_SAVE
4358 #define alc882_loopbacks alc880_loopbacks
4359 #endif
4360
4361 /*
4362 * Pin config fixes
4363 */
4364 enum {
4365 ALC882_FIXUP_ABIT_AW9D_MAX,
4366 ALC882_FIXUP_LENOVO_Y530,
4367 ALC882_FIXUP_PB_M5210,
4368 ALC882_FIXUP_ACER_ASPIRE_7736,
4369 ALC882_FIXUP_ASUS_W90V,
4370 ALC889_FIXUP_CD,
4371 ALC889_FIXUP_VAIO_TT,
4372 ALC888_FIXUP_EEE1601,
4373 ALC882_FIXUP_EAPD,
4374 ALC883_FIXUP_EAPD,
4375 ALC883_FIXUP_ACER_EAPD,
4376 ALC882_FIXUP_GPIO3,
4377 ALC889_FIXUP_COEF,
4378 ALC882_FIXUP_ASUS_W2JC,
4379 ALC882_FIXUP_ACER_ASPIRE_4930G,
4380 ALC882_FIXUP_ACER_ASPIRE_8930G,
4381 ALC882_FIXUP_ASPIRE_8930G_VERBS,
4382 ALC885_FIXUP_MACPRO_GPIO,
4383 ALC889_FIXUP_DAC_ROUTE,
4384 };
4385
4386 static void alc889_fixup_coef(struct hda_codec *codec,
4387 const struct alc_fixup *fix, int action)
4388 {
4389 if (action != ALC_FIXUP_ACT_INIT)
4390 return;
4391 alc889_coef_init(codec);
4392 }
4393
4394 /* toggle speaker-output according to the hp-jack state */
4395 static void alc882_gpio_mute(struct hda_codec *codec, int pin, int muted)
4396 {
4397 unsigned int gpiostate, gpiomask, gpiodir;
4398
4399 gpiostate = snd_hda_codec_read(codec, codec->afg, 0,
4400 AC_VERB_GET_GPIO_DATA, 0);
4401
4402 if (!muted)
4403 gpiostate |= (1 << pin);
4404 else
4405 gpiostate &= ~(1 << pin);
4406
4407 gpiomask = snd_hda_codec_read(codec, codec->afg, 0,
4408 AC_VERB_GET_GPIO_MASK, 0);
4409 gpiomask |= (1 << pin);
4410
4411 gpiodir = snd_hda_codec_read(codec, codec->afg, 0,
4412 AC_VERB_GET_GPIO_DIRECTION, 0);
4413 gpiodir |= (1 << pin);
4414
4415
4416 snd_hda_codec_write(codec, codec->afg, 0,
4417 AC_VERB_SET_GPIO_MASK, gpiomask);
4418 snd_hda_codec_write(codec, codec->afg, 0,
4419 AC_VERB_SET_GPIO_DIRECTION, gpiodir);
4420
4421 msleep(1);
4422
4423 snd_hda_codec_write(codec, codec->afg, 0,
4424 AC_VERB_SET_GPIO_DATA, gpiostate);
4425 }
4426
4427 /* set up GPIO at initialization */
4428 static void alc885_fixup_macpro_gpio(struct hda_codec *codec,
4429 const struct alc_fixup *fix, int action)
4430 {
4431 if (action != ALC_FIXUP_ACT_INIT)
4432 return;
4433 alc882_gpio_mute(codec, 0, 0);
4434 alc882_gpio_mute(codec, 1, 0);
4435 }
4436
4437 /* Fix the connection of some pins for ALC889:
4438 * At least, Acer Aspire 5935 shows the connections to DAC3/4 don't
4439 * work correctly (bko#42740)
4440 */
4441 static void alc889_fixup_dac_route(struct hda_codec *codec,
4442 const struct alc_fixup *fix, int action)
4443 {
4444 if (action == ALC_FIXUP_ACT_PRE_PROBE) {
4445 /* fake the connections during parsing the tree */
4446 hda_nid_t conn1[2] = { 0x0c, 0x0d };
4447 hda_nid_t conn2[2] = { 0x0e, 0x0f };
4448 snd_hda_override_conn_list(codec, 0x14, 2, conn1);
4449 snd_hda_override_conn_list(codec, 0x15, 2, conn1);
4450 snd_hda_override_conn_list(codec, 0x18, 2, conn2);
4451 snd_hda_override_conn_list(codec, 0x1a, 2, conn2);
4452 } else if (action == ALC_FIXUP_ACT_PROBE) {
4453 /* restore the connections */
4454 hda_nid_t conn[5] = { 0x0c, 0x0d, 0x0e, 0x0f, 0x26 };
4455 snd_hda_override_conn_list(codec, 0x14, 5, conn);
4456 snd_hda_override_conn_list(codec, 0x15, 5, conn);
4457 snd_hda_override_conn_list(codec, 0x18, 5, conn);
4458 snd_hda_override_conn_list(codec, 0x1a, 5, conn);
4459 }
4460 }
4461
4462 static const struct alc_fixup alc882_fixups[] = {
4463 [ALC882_FIXUP_ABIT_AW9D_MAX] = {
4464 .type = ALC_FIXUP_PINS,
4465 .v.pins = (const struct alc_pincfg[]) {
4466 { 0x15, 0x01080104 }, /* side */
4467 { 0x16, 0x01011012 }, /* rear */
4468 { 0x17, 0x01016011 }, /* clfe */
4469 { }
4470 }
4471 },
4472 [ALC882_FIXUP_LENOVO_Y530] = {
4473 .type = ALC_FIXUP_PINS,
4474 .v.pins = (const struct alc_pincfg[]) {
4475 { 0x15, 0x99130112 }, /* rear int speakers */
4476 { 0x16, 0x99130111 }, /* subwoofer */
4477 { }
4478 }
4479 },
4480 [ALC882_FIXUP_PB_M5210] = {
4481 .type = ALC_FIXUP_VERBS,
4482 .v.verbs = (const struct hda_verb[]) {
4483 { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50 },
4484 {}
4485 }
4486 },
4487 [ALC882_FIXUP_ACER_ASPIRE_7736] = {
4488 .type = ALC_FIXUP_SKU,
4489 .v.sku = ALC_FIXUP_SKU_IGNORE,
4490 },
4491 [ALC882_FIXUP_ASUS_W90V] = {
4492 .type = ALC_FIXUP_PINS,
4493 .v.pins = (const struct alc_pincfg[]) {
4494 { 0x16, 0x99130110 }, /* fix sequence for CLFE */
4495 { }
4496 }
4497 },
4498 [ALC889_FIXUP_CD] = {
4499 .type = ALC_FIXUP_PINS,
4500 .v.pins = (const struct alc_pincfg[]) {
4501 { 0x1c, 0x993301f0 }, /* CD */
4502 { }
4503 }
4504 },
4505 [ALC889_FIXUP_VAIO_TT] = {
4506 .type = ALC_FIXUP_PINS,
4507 .v.pins = (const struct alc_pincfg[]) {
4508 { 0x17, 0x90170111 }, /* hidden surround speaker */
4509 { }
4510 }
4511 },
4512 [ALC888_FIXUP_EEE1601] = {
4513 .type = ALC_FIXUP_VERBS,
4514 .v.verbs = (const struct hda_verb[]) {
4515 { 0x20, AC_VERB_SET_COEF_INDEX, 0x0b },
4516 { 0x20, AC_VERB_SET_PROC_COEF, 0x0838 },
4517 { }
4518 }
4519 },
4520 [ALC882_FIXUP_EAPD] = {
4521 .type = ALC_FIXUP_VERBS,
4522 .v.verbs = (const struct hda_verb[]) {
4523 /* change to EAPD mode */
4524 { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
4525 { 0x20, AC_VERB_SET_PROC_COEF, 0x3060 },
4526 { }
4527 }
4528 },
4529 [ALC883_FIXUP_EAPD] = {
4530 .type = ALC_FIXUP_VERBS,
4531 .v.verbs = (const struct hda_verb[]) {
4532 /* change to EAPD mode */
4533 { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
4534 { 0x20, AC_VERB_SET_PROC_COEF, 0x3070 },
4535 { }
4536 }
4537 },
4538 [ALC883_FIXUP_ACER_EAPD] = {
4539 .type = ALC_FIXUP_VERBS,
4540 .v.verbs = (const struct hda_verb[]) {
4541 /* eanable EAPD on Acer laptops */
4542 { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
4543 { 0x20, AC_VERB_SET_PROC_COEF, 0x3050 },
4544 { }
4545 }
4546 },
4547 [ALC882_FIXUP_GPIO3] = {
4548 .type = ALC_FIXUP_VERBS,
4549 .v.verbs = alc_gpio3_init_verbs,
4550 },
4551 [ALC882_FIXUP_ASUS_W2JC] = {
4552 .type = ALC_FIXUP_VERBS,
4553 .v.verbs = alc_gpio1_init_verbs,
4554 .chained = true,
4555 .chain_id = ALC882_FIXUP_EAPD,
4556 },
4557 [ALC889_FIXUP_COEF] = {
4558 .type = ALC_FIXUP_FUNC,
4559 .v.func = alc889_fixup_coef,
4560 },
4561 [ALC882_FIXUP_ACER_ASPIRE_4930G] = {
4562 .type = ALC_FIXUP_PINS,
4563 .v.pins = (const struct alc_pincfg[]) {
4564 { 0x16, 0x99130111 }, /* CLFE speaker */
4565 { 0x17, 0x99130112 }, /* surround speaker */
4566 { }
4567 }
4568 },
4569 [ALC882_FIXUP_ACER_ASPIRE_8930G] = {
4570 .type = ALC_FIXUP_PINS,
4571 .v.pins = (const struct alc_pincfg[]) {
4572 { 0x16, 0x99130111 }, /* CLFE speaker */
4573 { 0x1b, 0x99130112 }, /* surround speaker */
4574 { }
4575 },
4576 .chained = true,
4577 .chain_id = ALC882_FIXUP_ASPIRE_8930G_VERBS,
4578 },
4579 [ALC882_FIXUP_ASPIRE_8930G_VERBS] = {
4580 /* additional init verbs for Acer Aspire 8930G */
4581 .type = ALC_FIXUP_VERBS,
4582 .v.verbs = (const struct hda_verb[]) {
4583 /* Enable all DACs */
4584 /* DAC DISABLE/MUTE 1? */
4585 /* setting bits 1-5 disables DAC nids 0x02-0x06
4586 * apparently. Init=0x38 */
4587 { 0x20, AC_VERB_SET_COEF_INDEX, 0x03 },
4588 { 0x20, AC_VERB_SET_PROC_COEF, 0x0000 },
4589 /* DAC DISABLE/MUTE 2? */
4590 /* some bit here disables the other DACs.
4591 * Init=0x4900 */
4592 { 0x20, AC_VERB_SET_COEF_INDEX, 0x08 },
4593 { 0x20, AC_VERB_SET_PROC_COEF, 0x0000 },
4594 /* DMIC fix
4595 * This laptop has a stereo digital microphone.
4596 * The mics are only 1cm apart which makes the stereo
4597 * useless. However, either the mic or the ALC889
4598 * makes the signal become a difference/sum signal
4599 * instead of standard stereo, which is annoying.
4600 * So instead we flip this bit which makes the
4601 * codec replicate the sum signal to both channels,
4602 * turning it into a normal mono mic.
4603 */
4604 /* DMIC_CONTROL? Init value = 0x0001 */
4605 { 0x20, AC_VERB_SET_COEF_INDEX, 0x0b },
4606 { 0x20, AC_VERB_SET_PROC_COEF, 0x0003 },
4607 { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
4608 { 0x20, AC_VERB_SET_PROC_COEF, 0x3050 },
4609 { }
4610 }
4611 },
4612 [ALC885_FIXUP_MACPRO_GPIO] = {
4613 .type = ALC_FIXUP_FUNC,
4614 .v.func = alc885_fixup_macpro_gpio,
4615 },
4616 [ALC889_FIXUP_DAC_ROUTE] = {
4617 .type = ALC_FIXUP_FUNC,
4618 .v.func = alc889_fixup_dac_route,
4619 },
4620 };
4621
4622 static const struct snd_pci_quirk alc882_fixup_tbl[] = {
4623 SND_PCI_QUIRK(0x1025, 0x006c, "Acer Aspire 9810", ALC883_FIXUP_ACER_EAPD),
4624 SND_PCI_QUIRK(0x1025, 0x0090, "Acer Aspire", ALC883_FIXUP_ACER_EAPD),
4625 SND_PCI_QUIRK(0x1025, 0x010a, "Acer Ferrari 5000", ALC883_FIXUP_ACER_EAPD),
4626 SND_PCI_QUIRK(0x1025, 0x0110, "Acer Aspire", ALC883_FIXUP_ACER_EAPD),
4627 SND_PCI_QUIRK(0x1025, 0x0112, "Acer Aspire 9303", ALC883_FIXUP_ACER_EAPD),
4628 SND_PCI_QUIRK(0x1025, 0x0121, "Acer Aspire 5920G", ALC883_FIXUP_ACER_EAPD),
4629 SND_PCI_QUIRK(0x1025, 0x013e, "Acer Aspire 4930G",
4630 ALC882_FIXUP_ACER_ASPIRE_4930G),
4631 SND_PCI_QUIRK(0x1025, 0x013f, "Acer Aspire 5930G",
4632 ALC882_FIXUP_ACER_ASPIRE_4930G),
4633 SND_PCI_QUIRK(0x1025, 0x0145, "Acer Aspire 8930G",
4634 ALC882_FIXUP_ACER_ASPIRE_8930G),
4635 SND_PCI_QUIRK(0x1025, 0x0146, "Acer Aspire 6935G",
4636 ALC882_FIXUP_ACER_ASPIRE_8930G),
4637 SND_PCI_QUIRK(0x1025, 0x015e, "Acer Aspire 6930G",
4638 ALC882_FIXUP_ACER_ASPIRE_4930G),
4639 SND_PCI_QUIRK(0x1025, 0x0166, "Acer Aspire 6530G",
4640 ALC882_FIXUP_ACER_ASPIRE_4930G),
4641 SND_PCI_QUIRK(0x1025, 0x0142, "Acer Aspire 7730G",
4642 ALC882_FIXUP_ACER_ASPIRE_4930G),
4643 SND_PCI_QUIRK(0x1025, 0x0155, "Packard-Bell M5120", ALC882_FIXUP_PB_M5210),
4644 SND_PCI_QUIRK(0x1025, 0x0259, "Acer Aspire 5935", ALC889_FIXUP_DAC_ROUTE),
4645 SND_PCI_QUIRK(0x1025, 0x0296, "Acer Aspire 7736z", ALC882_FIXUP_ACER_ASPIRE_7736),
4646 SND_PCI_QUIRK(0x1043, 0x13c2, "Asus A7M", ALC882_FIXUP_EAPD),
4647 SND_PCI_QUIRK(0x1043, 0x1873, "ASUS W90V", ALC882_FIXUP_ASUS_W90V),
4648 SND_PCI_QUIRK(0x1043, 0x1971, "Asus W2JC", ALC882_FIXUP_ASUS_W2JC),
4649 SND_PCI_QUIRK(0x1043, 0x835f, "Asus Eee 1601", ALC888_FIXUP_EEE1601),
4650 SND_PCI_QUIRK(0x104d, 0x9047, "Sony Vaio TT", ALC889_FIXUP_VAIO_TT),
4651
4652 /* All Apple entries are in codec SSIDs */
4653 SND_PCI_QUIRK(0x106b, 0x0c00, "Mac Pro", ALC885_FIXUP_MACPRO_GPIO),
4654 SND_PCI_QUIRK(0x106b, 0x1000, "iMac 24", ALC885_FIXUP_MACPRO_GPIO),
4655 SND_PCI_QUIRK(0x106b, 0x2800, "AppleTV", ALC885_FIXUP_MACPRO_GPIO),
4656 SND_PCI_QUIRK(0x106b, 0x3200, "iMac 7,1 Aluminum", ALC882_FIXUP_EAPD),
4657 SND_PCI_QUIRK(0x106b, 0x3e00, "iMac 24 Aluminum", ALC885_FIXUP_MACPRO_GPIO),
4658
4659 SND_PCI_QUIRK(0x1071, 0x8258, "Evesham Voyaeger", ALC882_FIXUP_EAPD),
4660 SND_PCI_QUIRK_VENDOR(0x1462, "MSI", ALC882_FIXUP_GPIO3),
4661 SND_PCI_QUIRK(0x1458, 0xa002, "Gigabyte EP45-DS3", ALC889_FIXUP_CD),
4662 SND_PCI_QUIRK(0x147b, 0x107a, "Abit AW9D-MAX", ALC882_FIXUP_ABIT_AW9D_MAX),
4663 SND_PCI_QUIRK_VENDOR(0x1558, "Clevo laptop", ALC882_FIXUP_EAPD),
4664 SND_PCI_QUIRK(0x161f, 0x2054, "Medion laptop", ALC883_FIXUP_EAPD),
4665 SND_PCI_QUIRK(0x17aa, 0x3a0d, "Lenovo Y530", ALC882_FIXUP_LENOVO_Y530),
4666 SND_PCI_QUIRK(0x8086, 0x0022, "DX58SO", ALC889_FIXUP_COEF),
4667 {}
4668 };
4669
4670 /*
4671 * BIOS auto configuration
4672 */
4673 /* almost identical with ALC880 parser... */
4674 static int alc882_parse_auto_config(struct hda_codec *codec)
4675 {
4676 static const hda_nid_t alc882_ignore[] = { 0x1d, 0 };
4677 static const hda_nid_t alc882_ssids[] = { 0x15, 0x1b, 0x14, 0 };
4678 return alc_parse_auto_config(codec, alc882_ignore, alc882_ssids);
4679 }
4680
4681 /*
4682 */
4683 #ifdef CONFIG_SND_HDA_ENABLE_REALTEK_QUIRKS
4684 #include "alc882_quirks.c"
4685 #endif
4686
4687 static int patch_alc882(struct hda_codec *codec)
4688 {
4689 struct alc_spec *spec;
4690 int err, board_config;
4691
4692 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
4693 if (spec == NULL)
4694 return -ENOMEM;
4695
4696 codec->spec = spec;
4697
4698 spec->mixer_nid = 0x0b;
4699
4700 switch (codec->vendor_id) {
4701 case 0x10ec0882:
4702 case 0x10ec0885:
4703 break;
4704 default:
4705 /* ALC883 and variants */
4706 alc_fix_pll_init(codec, 0x20, 0x0a, 10);
4707 break;
4708 }
4709
4710 err = alc_codec_rename_from_preset(codec);
4711 if (err < 0)
4712 goto error;
4713
4714 board_config = alc_board_config(codec, ALC882_MODEL_LAST,
4715 alc882_models, NULL);
4716 if (board_config < 0)
4717 board_config = alc_board_codec_sid_config(codec,
4718 ALC882_MODEL_LAST, alc882_models, alc882_ssid_cfg_tbl);
4719
4720 if (board_config < 0) {
4721 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
4722 codec->chip_name);
4723 board_config = ALC_MODEL_AUTO;
4724 }
4725
4726 if (board_config == ALC_MODEL_AUTO) {
4727 alc_pick_fixup(codec, NULL, alc882_fixup_tbl, alc882_fixups);
4728 alc_apply_fixup(codec, ALC_FIXUP_ACT_PRE_PROBE);
4729 }
4730
4731 alc_auto_parse_customize_define(codec);
4732
4733 if (board_config == ALC_MODEL_AUTO) {
4734 /* automatic parse from the BIOS config */
4735 err = alc882_parse_auto_config(codec);
4736 if (err < 0)
4737 goto error;
4738 }
4739
4740 if (board_config != ALC_MODEL_AUTO) {
4741 setup_preset(codec, &alc882_presets[board_config]);
4742 spec->vmaster_nid = 0x0c;
4743 }
4744
4745 if (!spec->no_analog && !spec->adc_nids) {
4746 alc_auto_fill_adc_caps(codec);
4747 alc_rebuild_imux_for_auto_mic(codec);
4748 alc_remove_invalid_adc_nids(codec);
4749 }
4750
4751 if (!spec->no_analog && !spec->cap_mixer)
4752 set_capture_mixer(codec);
4753
4754 if (!spec->no_analog && has_cdefine_beep(codec)) {
4755 err = snd_hda_attach_beep_device(codec, 0x1);
4756 if (err < 0)
4757 goto error;
4758 set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
4759 }
4760
4761 alc_apply_fixup(codec, ALC_FIXUP_ACT_PROBE);
4762
4763 codec->patch_ops = alc_patch_ops;
4764 if (board_config == ALC_MODEL_AUTO)
4765 spec->init_hook = alc_auto_init_std;
4766 else
4767 codec->patch_ops.build_controls = __alc_build_controls;
4768
4769 #ifdef CONFIG_SND_HDA_POWER_SAVE
4770 if (!spec->loopback.amplist)
4771 spec->loopback.amplist = alc882_loopbacks;
4772 #endif
4773
4774 return 0;
4775
4776 error:
4777 alc_free(codec);
4778 return err;
4779 }
4780
4781
4782 /*
4783 * ALC262 support
4784 */
4785 static int alc262_parse_auto_config(struct hda_codec *codec)
4786 {
4787 static const hda_nid_t alc262_ignore[] = { 0x1d, 0 };
4788 static const hda_nid_t alc262_ssids[] = { 0x15, 0x1b, 0x14, 0 };
4789 return alc_parse_auto_config(codec, alc262_ignore, alc262_ssids);
4790 }
4791
4792 /*
4793 * Pin config fixes
4794 */
4795 enum {
4796 ALC262_FIXUP_FSC_H270,
4797 ALC262_FIXUP_HP_Z200,
4798 ALC262_FIXUP_TYAN,
4799 ALC262_FIXUP_LENOVO_3000,
4800 ALC262_FIXUP_BENQ,
4801 ALC262_FIXUP_BENQ_T31,
4802 };
4803
4804 static const struct alc_fixup alc262_fixups[] = {
4805 [ALC262_FIXUP_FSC_H270] = {
4806 .type = ALC_FIXUP_PINS,
4807 .v.pins = (const struct alc_pincfg[]) {
4808 { 0x14, 0x99130110 }, /* speaker */
4809 { 0x15, 0x0221142f }, /* front HP */
4810 { 0x1b, 0x0121141f }, /* rear HP */
4811 { }
4812 }
4813 },
4814 [ALC262_FIXUP_HP_Z200] = {
4815 .type = ALC_FIXUP_PINS,
4816 .v.pins = (const struct alc_pincfg[]) {
4817 { 0x16, 0x99130120 }, /* internal speaker */
4818 { }
4819 }
4820 },
4821 [ALC262_FIXUP_TYAN] = {
4822 .type = ALC_FIXUP_PINS,
4823 .v.pins = (const struct alc_pincfg[]) {
4824 { 0x14, 0x1993e1f0 }, /* int AUX */
4825 { }
4826 }
4827 },
4828 [ALC262_FIXUP_LENOVO_3000] = {
4829 .type = ALC_FIXUP_VERBS,
4830 .v.verbs = (const struct hda_verb[]) {
4831 { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50 },
4832 {}
4833 },
4834 .chained = true,
4835 .chain_id = ALC262_FIXUP_BENQ,
4836 },
4837 [ALC262_FIXUP_BENQ] = {
4838 .type = ALC_FIXUP_VERBS,
4839 .v.verbs = (const struct hda_verb[]) {
4840 { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
4841 { 0x20, AC_VERB_SET_PROC_COEF, 0x3070 },
4842 {}
4843 }
4844 },
4845 [ALC262_FIXUP_BENQ_T31] = {
4846 .type = ALC_FIXUP_VERBS,
4847 .v.verbs = (const struct hda_verb[]) {
4848 { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
4849 { 0x20, AC_VERB_SET_PROC_COEF, 0x3050 },
4850 {}
4851 }
4852 },
4853 };
4854
4855 static const struct snd_pci_quirk alc262_fixup_tbl[] = {
4856 SND_PCI_QUIRK(0x103c, 0x170b, "HP Z200", ALC262_FIXUP_HP_Z200),
4857 SND_PCI_QUIRK(0x10cf, 0x1397, "Fujitsu", ALC262_FIXUP_BENQ),
4858 SND_PCI_QUIRK(0x10cf, 0x142d, "Fujitsu Lifebook E8410", ALC262_FIXUP_BENQ),
4859 SND_PCI_QUIRK(0x10f1, 0x2915, "Tyan Thunder n6650W", ALC262_FIXUP_TYAN),
4860 SND_PCI_QUIRK(0x1734, 0x1147, "FSC Celsius H270", ALC262_FIXUP_FSC_H270),
4861 SND_PCI_QUIRK(0x17aa, 0x384e, "Lenovo 3000", ALC262_FIXUP_LENOVO_3000),
4862 SND_PCI_QUIRK(0x17ff, 0x0560, "Benq ED8", ALC262_FIXUP_BENQ),
4863 SND_PCI_QUIRK(0x17ff, 0x058d, "Benq T31-16", ALC262_FIXUP_BENQ_T31),
4864 {}
4865 };
4866
4867
4868 #ifdef CONFIG_SND_HDA_POWER_SAVE
4869 #define alc262_loopbacks alc880_loopbacks
4870 #endif
4871
4872 /*
4873 */
4874 static int patch_alc262(struct hda_codec *codec)
4875 {
4876 struct alc_spec *spec;
4877 int err;
4878
4879 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
4880 if (spec == NULL)
4881 return -ENOMEM;
4882
4883 codec->spec = spec;
4884
4885 spec->mixer_nid = 0x0b;
4886
4887 #if 0
4888 /* pshou 07/11/05 set a zero PCM sample to DAC when FIFO is
4889 * under-run
4890 */
4891 {
4892 int tmp;
4893 snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_COEF_INDEX, 7);
4894 tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0);
4895 snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_COEF_INDEX, 7);
4896 snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_PROC_COEF, tmp | 0x80);
4897 }
4898 #endif
4899 alc_auto_parse_customize_define(codec);
4900
4901 alc_fix_pll_init(codec, 0x20, 0x0a, 10);
4902
4903 alc_pick_fixup(codec, NULL, alc262_fixup_tbl, alc262_fixups);
4904 alc_apply_fixup(codec, ALC_FIXUP_ACT_PRE_PROBE);
4905
4906 /* automatic parse from the BIOS config */
4907 err = alc262_parse_auto_config(codec);
4908 if (err < 0)
4909 goto error;
4910
4911 if (!spec->no_analog && !spec->adc_nids) {
4912 alc_auto_fill_adc_caps(codec);
4913 alc_rebuild_imux_for_auto_mic(codec);
4914 alc_remove_invalid_adc_nids(codec);
4915 }
4916
4917 if (!spec->no_analog && !spec->cap_mixer)
4918 set_capture_mixer(codec);
4919
4920 if (!spec->no_analog && has_cdefine_beep(codec)) {
4921 err = snd_hda_attach_beep_device(codec, 0x1);
4922 if (err < 0)
4923 goto error;
4924 set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
4925 }
4926
4927 alc_apply_fixup(codec, ALC_FIXUP_ACT_PROBE);
4928
4929 codec->patch_ops = alc_patch_ops;
4930 spec->init_hook = alc_auto_init_std;
4931 spec->shutup = alc_eapd_shutup;
4932
4933 #ifdef CONFIG_SND_HDA_POWER_SAVE
4934 if (!spec->loopback.amplist)
4935 spec->loopback.amplist = alc262_loopbacks;
4936 #endif
4937
4938 return 0;
4939
4940 error:
4941 alc_free(codec);
4942 return err;
4943 }
4944
4945 /*
4946 * ALC268
4947 */
4948 /* bind Beep switches of both NID 0x0f and 0x10 */
4949 static const struct hda_bind_ctls alc268_bind_beep_sw = {
4950 .ops = &snd_hda_bind_sw,
4951 .values = {
4952 HDA_COMPOSE_AMP_VAL(0x0f, 3, 1, HDA_INPUT),
4953 HDA_COMPOSE_AMP_VAL(0x10, 3, 1, HDA_INPUT),
4954 0
4955 },
4956 };
4957
4958 static const struct snd_kcontrol_new alc268_beep_mixer[] = {
4959 HDA_CODEC_VOLUME("Beep Playback Volume", 0x1d, 0x0, HDA_INPUT),
4960 HDA_BIND_SW("Beep Playback Switch", &alc268_bind_beep_sw),
4961 { }
4962 };
4963
4964 /* set PCBEEP vol = 0, mute connections */
4965 static const struct hda_verb alc268_beep_init_verbs[] = {
4966 {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4967 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4968 {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4969 { }
4970 };
4971
4972 /*
4973 * BIOS auto configuration
4974 */
4975 static int alc268_parse_auto_config(struct hda_codec *codec)
4976 {
4977 static const hda_nid_t alc268_ssids[] = { 0x15, 0x1b, 0x14, 0 };
4978 struct alc_spec *spec = codec->spec;
4979 int err = alc_parse_auto_config(codec, NULL, alc268_ssids);
4980 if (err > 0) {
4981 if (!spec->no_analog && spec->autocfg.speaker_pins[0] != 0x1d) {
4982 add_mixer(spec, alc268_beep_mixer);
4983 add_verb(spec, alc268_beep_init_verbs);
4984 }
4985 }
4986 return err;
4987 }
4988
4989 /*
4990 */
4991 static int patch_alc268(struct hda_codec *codec)
4992 {
4993 struct alc_spec *spec;
4994 int i, has_beep, err;
4995
4996 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
4997 if (spec == NULL)
4998 return -ENOMEM;
4999
5000 codec->spec = spec;
5001
5002 /* ALC268 has no aa-loopback mixer */
5003
5004 /* automatic parse from the BIOS config */
5005 err = alc268_parse_auto_config(codec);
5006 if (err < 0)
5007 goto error;
5008
5009 has_beep = 0;
5010 for (i = 0; i < spec->num_mixers; i++) {
5011 if (spec->mixers[i] == alc268_beep_mixer) {
5012 has_beep = 1;
5013 break;
5014 }
5015 }
5016
5017 if (has_beep) {
5018 err = snd_hda_attach_beep_device(codec, 0x1);
5019 if (err < 0)
5020 goto error;
5021 if (!query_amp_caps(codec, 0x1d, HDA_INPUT))
5022 /* override the amp caps for beep generator */
5023 snd_hda_override_amp_caps(codec, 0x1d, HDA_INPUT,
5024 (0x0c << AC_AMPCAP_OFFSET_SHIFT) |
5025 (0x0c << AC_AMPCAP_NUM_STEPS_SHIFT) |
5026 (0x07 << AC_AMPCAP_STEP_SIZE_SHIFT) |
5027 (0 << AC_AMPCAP_MUTE_SHIFT));
5028 }
5029
5030 if (!spec->no_analog && !spec->adc_nids) {
5031 alc_auto_fill_adc_caps(codec);
5032 alc_rebuild_imux_for_auto_mic(codec);
5033 alc_remove_invalid_adc_nids(codec);
5034 }
5035
5036 if (!spec->no_analog && !spec->cap_mixer)
5037 set_capture_mixer(codec);
5038
5039 codec->patch_ops = alc_patch_ops;
5040 spec->init_hook = alc_auto_init_std;
5041 spec->shutup = alc_eapd_shutup;
5042
5043 return 0;
5044
5045 error:
5046 alc_free(codec);
5047 return err;
5048 }
5049
5050 /*
5051 * ALC269
5052 */
5053 #ifdef CONFIG_SND_HDA_POWER_SAVE
5054 #define alc269_loopbacks alc880_loopbacks
5055 #endif
5056
5057 static const struct hda_pcm_stream alc269_44k_pcm_analog_playback = {
5058 .substreams = 1,
5059 .channels_min = 2,
5060 .channels_max = 8,
5061 .rates = SNDRV_PCM_RATE_44100, /* fixed rate */
5062 /* NID is set in alc_build_pcms */
5063 .ops = {
5064 .open = alc_playback_pcm_open,
5065 .prepare = alc_playback_pcm_prepare,
5066 .cleanup = alc_playback_pcm_cleanup
5067 },
5068 };
5069
5070 static const struct hda_pcm_stream alc269_44k_pcm_analog_capture = {
5071 .substreams = 1,
5072 .channels_min = 2,
5073 .channels_max = 2,
5074 .rates = SNDRV_PCM_RATE_44100, /* fixed rate */
5075 /* NID is set in alc_build_pcms */
5076 };
5077
5078 #ifdef CONFIG_SND_HDA_POWER_SAVE
5079 static int alc269_mic2_for_mute_led(struct hda_codec *codec)
5080 {
5081 switch (codec->subsystem_id) {
5082 case 0x103c1586:
5083 return 1;
5084 }
5085 return 0;
5086 }
5087
5088 static int alc269_mic2_mute_check_ps(struct hda_codec *codec, hda_nid_t nid)
5089 {
5090 /* update mute-LED according to the speaker mute state */
5091 if (nid == 0x01 || nid == 0x14) {
5092 int pinval;
5093 if (snd_hda_codec_amp_read(codec, 0x14, 0, HDA_OUTPUT, 0) &
5094 HDA_AMP_MUTE)
5095 pinval = 0x24;
5096 else
5097 pinval = 0x20;
5098 /* mic2 vref pin is used for mute LED control */
5099 snd_hda_codec_update_cache(codec, 0x19, 0,
5100 AC_VERB_SET_PIN_WIDGET_CONTROL,
5101 pinval);
5102 }
5103 return alc_check_power_status(codec, nid);
5104 }
5105 #endif /* CONFIG_SND_HDA_POWER_SAVE */
5106
5107 /* different alc269-variants */
5108 enum {
5109 ALC269_TYPE_ALC269VA,
5110 ALC269_TYPE_ALC269VB,
5111 ALC269_TYPE_ALC269VC,
5112 };
5113
5114 /*
5115 * BIOS auto configuration
5116 */
5117 static int alc269_parse_auto_config(struct hda_codec *codec)
5118 {
5119 static const hda_nid_t alc269_ignore[] = { 0x1d, 0 };
5120 static const hda_nid_t alc269_ssids[] = { 0, 0x1b, 0x14, 0x21 };
5121 static const hda_nid_t alc269va_ssids[] = { 0x15, 0x1b, 0x14, 0 };
5122 struct alc_spec *spec = codec->spec;
5123 const hda_nid_t *ssids = spec->codec_variant == ALC269_TYPE_ALC269VA ?
5124 alc269va_ssids : alc269_ssids;
5125
5126 return alc_parse_auto_config(codec, alc269_ignore, ssids);
5127 }
5128
5129 static void alc269_toggle_power_output(struct hda_codec *codec, int power_up)
5130 {
5131 int val = alc_read_coef_idx(codec, 0x04);
5132 if (power_up)
5133 val |= 1 << 11;
5134 else
5135 val &= ~(1 << 11);
5136 alc_write_coef_idx(codec, 0x04, val);
5137 }
5138
5139 static void alc269_shutup(struct hda_codec *codec)
5140 {
5141 if ((alc_get_coef0(codec) & 0x00ff) == 0x017)
5142 alc269_toggle_power_output(codec, 0);
5143 if ((alc_get_coef0(codec) & 0x00ff) == 0x018) {
5144 alc269_toggle_power_output(codec, 0);
5145 msleep(150);
5146 }
5147 }
5148
5149 #ifdef CONFIG_PM
5150 static int alc269_resume(struct hda_codec *codec)
5151 {
5152 if ((alc_get_coef0(codec) & 0x00ff) == 0x018) {
5153 alc269_toggle_power_output(codec, 0);
5154 msleep(150);
5155 }
5156
5157 codec->patch_ops.init(codec);
5158
5159 if ((alc_get_coef0(codec) & 0x00ff) == 0x017) {
5160 alc269_toggle_power_output(codec, 1);
5161 msleep(200);
5162 }
5163
5164 if ((alc_get_coef0(codec) & 0x00ff) == 0x018)
5165 alc269_toggle_power_output(codec, 1);
5166
5167 snd_hda_codec_resume_amp(codec);
5168 snd_hda_codec_resume_cache(codec);
5169 hda_call_check_power_status(codec, 0x01);
5170 return 0;
5171 }
5172 #endif /* CONFIG_PM */
5173
5174 static void alc269_fixup_hweq(struct hda_codec *codec,
5175 const struct alc_fixup *fix, int action)
5176 {
5177 int coef;
5178
5179 if (action != ALC_FIXUP_ACT_INIT)
5180 return;
5181 coef = alc_read_coef_idx(codec, 0x1e);
5182 alc_write_coef_idx(codec, 0x1e, coef | 0x80);
5183 }
5184
5185 static void alc271_fixup_dmic(struct hda_codec *codec,
5186 const struct alc_fixup *fix, int action)
5187 {
5188 static const struct hda_verb verbs[] = {
5189 {0x20, AC_VERB_SET_COEF_INDEX, 0x0d},
5190 {0x20, AC_VERB_SET_PROC_COEF, 0x4000},
5191 {}
5192 };
5193 unsigned int cfg;
5194
5195 if (strcmp(codec->chip_name, "ALC271X"))
5196 return;
5197 cfg = snd_hda_codec_get_pincfg(codec, 0x12);
5198 if (get_defcfg_connect(cfg) == AC_JACK_PORT_FIXED)
5199 snd_hda_sequence_write(codec, verbs);
5200 }
5201
5202 static void alc269_fixup_pcm_44k(struct hda_codec *codec,
5203 const struct alc_fixup *fix, int action)
5204 {
5205 struct alc_spec *spec = codec->spec;
5206
5207 if (action != ALC_FIXUP_ACT_PROBE)
5208 return;
5209
5210 /* Due to a hardware problem on Lenovo Ideadpad, we need to
5211 * fix the sample rate of analog I/O to 44.1kHz
5212 */
5213 spec->stream_analog_playback = &alc269_44k_pcm_analog_playback;
5214 spec->stream_analog_capture = &alc269_44k_pcm_analog_capture;
5215 }
5216
5217 static void alc269_fixup_stereo_dmic(struct hda_codec *codec,
5218 const struct alc_fixup *fix, int action)
5219 {
5220 int coef;
5221
5222 if (action != ALC_FIXUP_ACT_INIT)
5223 return;
5224 /* The digital-mic unit sends PDM (differential signal) instead of
5225 * the standard PCM, thus you can't record a valid mono stream as is.
5226 * Below is a workaround specific to ALC269 to control the dmic
5227 * signal source as mono.
5228 */
5229 coef = alc_read_coef_idx(codec, 0x07);
5230 alc_write_coef_idx(codec, 0x07, coef | 0x80);
5231 }
5232
5233 static void alc269_quanta_automute(struct hda_codec *codec)
5234 {
5235 update_outputs(codec);
5236
5237 snd_hda_codec_write(codec, 0x20, 0,
5238 AC_VERB_SET_COEF_INDEX, 0x0c);
5239 snd_hda_codec_write(codec, 0x20, 0,
5240 AC_VERB_SET_PROC_COEF, 0x680);
5241
5242 snd_hda_codec_write(codec, 0x20, 0,
5243 AC_VERB_SET_COEF_INDEX, 0x0c);
5244 snd_hda_codec_write(codec, 0x20, 0,
5245 AC_VERB_SET_PROC_COEF, 0x480);
5246 }
5247
5248 static void alc269_fixup_quanta_mute(struct hda_codec *codec,
5249 const struct alc_fixup *fix, int action)
5250 {
5251 struct alc_spec *spec = codec->spec;
5252 if (action != ALC_FIXUP_ACT_PROBE)
5253 return;
5254 spec->automute_hook = alc269_quanta_automute;
5255 }
5256
5257 enum {
5258 ALC269_FIXUP_SONY_VAIO,
5259 ALC275_FIXUP_SONY_VAIO_GPIO2,
5260 ALC269_FIXUP_DELL_M101Z,
5261 ALC269_FIXUP_SKU_IGNORE,
5262 ALC269_FIXUP_ASUS_G73JW,
5263 ALC269_FIXUP_LENOVO_EAPD,
5264 ALC275_FIXUP_SONY_HWEQ,
5265 ALC271_FIXUP_DMIC,
5266 ALC269_FIXUP_PCM_44K,
5267 ALC269_FIXUP_STEREO_DMIC,
5268 ALC269_FIXUP_QUANTA_MUTE,
5269 ALC269_FIXUP_LIFEBOOK,
5270 ALC269_FIXUP_AMIC,
5271 ALC269_FIXUP_DMIC,
5272 ALC269VB_FIXUP_AMIC,
5273 ALC269VB_FIXUP_DMIC,
5274 };
5275
5276 static const struct alc_fixup alc269_fixups[] = {
5277 [ALC269_FIXUP_SONY_VAIO] = {
5278 .type = ALC_FIXUP_VERBS,
5279 .v.verbs = (const struct hda_verb[]) {
5280 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREFGRD},
5281 {}
5282 }
5283 },
5284 [ALC275_FIXUP_SONY_VAIO_GPIO2] = {
5285 .type = ALC_FIXUP_VERBS,
5286 .v.verbs = (const struct hda_verb[]) {
5287 {0x01, AC_VERB_SET_GPIO_MASK, 0x04},
5288 {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x04},
5289 {0x01, AC_VERB_SET_GPIO_DATA, 0x00},
5290 { }
5291 },
5292 .chained = true,
5293 .chain_id = ALC269_FIXUP_SONY_VAIO
5294 },
5295 [ALC269_FIXUP_DELL_M101Z] = {
5296 .type = ALC_FIXUP_VERBS,
5297 .v.verbs = (const struct hda_verb[]) {
5298 /* Enables internal speaker */
5299 {0x20, AC_VERB_SET_COEF_INDEX, 13},
5300 {0x20, AC_VERB_SET_PROC_COEF, 0x4040},
5301 {}
5302 }
5303 },
5304 [ALC269_FIXUP_SKU_IGNORE] = {
5305 .type = ALC_FIXUP_SKU,
5306 .v.sku = ALC_FIXUP_SKU_IGNORE,
5307 },
5308 [ALC269_FIXUP_ASUS_G73JW] = {
5309 .type = ALC_FIXUP_PINS,
5310 .v.pins = (const struct alc_pincfg[]) {
5311 { 0x17, 0x99130111 }, /* subwoofer */
5312 { }
5313 }
5314 },
5315 [ALC269_FIXUP_LENOVO_EAPD] = {
5316 .type = ALC_FIXUP_VERBS,
5317 .v.verbs = (const struct hda_verb[]) {
5318 {0x14, AC_VERB_SET_EAPD_BTLENABLE, 0},
5319 {}
5320 }
5321 },
5322 [ALC275_FIXUP_SONY_HWEQ] = {
5323 .type = ALC_FIXUP_FUNC,
5324 .v.func = alc269_fixup_hweq,
5325 .chained = true,
5326 .chain_id = ALC275_FIXUP_SONY_VAIO_GPIO2
5327 },
5328 [ALC271_FIXUP_DMIC] = {
5329 .type = ALC_FIXUP_FUNC,
5330 .v.func = alc271_fixup_dmic,
5331 },
5332 [ALC269_FIXUP_PCM_44K] = {
5333 .type = ALC_FIXUP_FUNC,
5334 .v.func = alc269_fixup_pcm_44k,
5335 },
5336 [ALC269_FIXUP_STEREO_DMIC] = {
5337 .type = ALC_FIXUP_FUNC,
5338 .v.func = alc269_fixup_stereo_dmic,
5339 },
5340 [ALC269_FIXUP_QUANTA_MUTE] = {
5341 .type = ALC_FIXUP_FUNC,
5342 .v.func = alc269_fixup_quanta_mute,
5343 },
5344 [ALC269_FIXUP_LIFEBOOK] = {
5345 .type = ALC_FIXUP_PINS,
5346 .v.pins = (const struct alc_pincfg[]) {
5347 { 0x1a, 0x2101103f }, /* dock line-out */
5348 { 0x1b, 0x23a11040 }, /* dock mic-in */
5349 { }
5350 },
5351 .chained = true,
5352 .chain_id = ALC269_FIXUP_QUANTA_MUTE
5353 },
5354 [ALC269_FIXUP_AMIC] = {
5355 .type = ALC_FIXUP_PINS,
5356 .v.pins = (const struct alc_pincfg[]) {
5357 { 0x14, 0x99130110 }, /* speaker */
5358 { 0x15, 0x0121401f }, /* HP out */
5359 { 0x18, 0x01a19c20 }, /* mic */
5360 { 0x19, 0x99a3092f }, /* int-mic */
5361 { }
5362 },
5363 },
5364 [ALC269_FIXUP_DMIC] = {
5365 .type = ALC_FIXUP_PINS,
5366 .v.pins = (const struct alc_pincfg[]) {
5367 { 0x12, 0x99a3092f }, /* int-mic */
5368 { 0x14, 0x99130110 }, /* speaker */
5369 { 0x15, 0x0121401f }, /* HP out */
5370 { 0x18, 0x01a19c20 }, /* mic */
5371 { }
5372 },
5373 },
5374 [ALC269VB_FIXUP_AMIC] = {
5375 .type = ALC_FIXUP_PINS,
5376 .v.pins = (const struct alc_pincfg[]) {
5377 { 0x14, 0x99130110 }, /* speaker */
5378 { 0x18, 0x01a19c20 }, /* mic */
5379 { 0x19, 0x99a3092f }, /* int-mic */
5380 { 0x21, 0x0121401f }, /* HP out */
5381 { }
5382 },
5383 },
5384 [ALC269VB_FIXUP_DMIC] = {
5385 .type = ALC_FIXUP_PINS,
5386 .v.pins = (const struct alc_pincfg[]) {
5387 { 0x12, 0x99a3092f }, /* int-mic */
5388 { 0x14, 0x99130110 }, /* speaker */
5389 { 0x18, 0x01a19c20 }, /* mic */
5390 { 0x21, 0x0121401f }, /* HP out */
5391 { }
5392 },
5393 },
5394 };
5395
5396 static const struct snd_pci_quirk alc269_fixup_tbl[] = {
5397 SND_PCI_QUIRK(0x1043, 0x1a13, "Asus G73Jw", ALC269_FIXUP_ASUS_G73JW),
5398 SND_PCI_QUIRK(0x1043, 0x16e3, "ASUS UX50", ALC269_FIXUP_STEREO_DMIC),
5399 SND_PCI_QUIRK(0x1043, 0x831a, "ASUS P901", ALC269_FIXUP_STEREO_DMIC),
5400 SND_PCI_QUIRK(0x1043, 0x834a, "ASUS S101", ALC269_FIXUP_STEREO_DMIC),
5401 SND_PCI_QUIRK(0x1043, 0x8398, "ASUS P1005", ALC269_FIXUP_STEREO_DMIC),
5402 SND_PCI_QUIRK(0x1043, 0x83ce, "ASUS P1005", ALC269_FIXUP_STEREO_DMIC),
5403 SND_PCI_QUIRK(0x104d, 0x9073, "Sony VAIO", ALC275_FIXUP_SONY_VAIO_GPIO2),
5404 SND_PCI_QUIRK(0x104d, 0x907b, "Sony VAIO", ALC275_FIXUP_SONY_HWEQ),
5405 SND_PCI_QUIRK(0x104d, 0x9084, "Sony VAIO", ALC275_FIXUP_SONY_HWEQ),
5406 SND_PCI_QUIRK_VENDOR(0x104d, "Sony VAIO", ALC269_FIXUP_SONY_VAIO),
5407 SND_PCI_QUIRK(0x1028, 0x0470, "Dell M101z", ALC269_FIXUP_DELL_M101Z),
5408 SND_PCI_QUIRK_VENDOR(0x1025, "Acer Aspire", ALC271_FIXUP_DMIC),
5409 SND_PCI_QUIRK(0x10cf, 0x1475, "Lifebook", ALC269_FIXUP_LIFEBOOK),
5410 SND_PCI_QUIRK(0x17aa, 0x20f2, "Thinkpad SL410/510", ALC269_FIXUP_SKU_IGNORE),
5411 SND_PCI_QUIRK(0x17aa, 0x215e, "Thinkpad L512", ALC269_FIXUP_SKU_IGNORE),
5412 SND_PCI_QUIRK(0x17aa, 0x21b8, "Thinkpad Edge 14", ALC269_FIXUP_SKU_IGNORE),
5413 SND_PCI_QUIRK(0x17aa, 0x21ca, "Thinkpad L412", ALC269_FIXUP_SKU_IGNORE),
5414 SND_PCI_QUIRK(0x17aa, 0x21e9, "Thinkpad Edge 15", ALC269_FIXUP_SKU_IGNORE),
5415 SND_PCI_QUIRK(0x17aa, 0x3bf8, "Quanta FL1", ALC269_FIXUP_QUANTA_MUTE),
5416 SND_PCI_QUIRK(0x17aa, 0x3bf8, "Lenovo Ideapd", ALC269_FIXUP_PCM_44K),
5417 SND_PCI_QUIRK(0x17aa, 0x9e54, "LENOVO NB", ALC269_FIXUP_LENOVO_EAPD),
5418
5419 #if 1
5420 /* Below is a quirk table taken from the old code.
5421 * Basically the device should work as is without the fixup table.
5422 * If BIOS doesn't give a proper info, enable the corresponding
5423 * fixup entry.
5424 */
5425 SND_PCI_QUIRK(0x1043, 0x8330, "ASUS Eeepc P703 P900A",
5426 ALC269_FIXUP_AMIC),
5427 SND_PCI_QUIRK(0x1043, 0x1013, "ASUS N61Da", ALC269_FIXUP_AMIC),
5428 SND_PCI_QUIRK(0x1043, 0x1143, "ASUS B53f", ALC269_FIXUP_AMIC),
5429 SND_PCI_QUIRK(0x1043, 0x1133, "ASUS UJ20ft", ALC269_FIXUP_AMIC),
5430 SND_PCI_QUIRK(0x1043, 0x1183, "ASUS K72DR", ALC269_FIXUP_AMIC),
5431 SND_PCI_QUIRK(0x1043, 0x11b3, "ASUS K52DR", ALC269_FIXUP_AMIC),
5432 SND_PCI_QUIRK(0x1043, 0x11e3, "ASUS U33Jc", ALC269_FIXUP_AMIC),
5433 SND_PCI_QUIRK(0x1043, 0x1273, "ASUS UL80Jt", ALC269_FIXUP_AMIC),
5434 SND_PCI_QUIRK(0x1043, 0x1283, "ASUS U53Jc", ALC269_FIXUP_AMIC),
5435 SND_PCI_QUIRK(0x1043, 0x12b3, "ASUS N82JV", ALC269_FIXUP_AMIC),
5436 SND_PCI_QUIRK(0x1043, 0x12d3, "ASUS N61Jv", ALC269_FIXUP_AMIC),
5437 SND_PCI_QUIRK(0x1043, 0x13a3, "ASUS UL30Vt", ALC269_FIXUP_AMIC),
5438 SND_PCI_QUIRK(0x1043, 0x1373, "ASUS G73JX", ALC269_FIXUP_AMIC),
5439 SND_PCI_QUIRK(0x1043, 0x1383, "ASUS UJ30Jc", ALC269_FIXUP_AMIC),
5440 SND_PCI_QUIRK(0x1043, 0x13d3, "ASUS N61JA", ALC269_FIXUP_AMIC),
5441 SND_PCI_QUIRK(0x1043, 0x1413, "ASUS UL50", ALC269_FIXUP_AMIC),
5442 SND_PCI_QUIRK(0x1043, 0x1443, "ASUS UL30", ALC269_FIXUP_AMIC),
5443 SND_PCI_QUIRK(0x1043, 0x1453, "ASUS M60Jv", ALC269_FIXUP_AMIC),
5444 SND_PCI_QUIRK(0x1043, 0x1483, "ASUS UL80", ALC269_FIXUP_AMIC),
5445 SND_PCI_QUIRK(0x1043, 0x14f3, "ASUS F83Vf", ALC269_FIXUP_AMIC),
5446 SND_PCI_QUIRK(0x1043, 0x14e3, "ASUS UL20", ALC269_FIXUP_AMIC),
5447 SND_PCI_QUIRK(0x1043, 0x1513, "ASUS UX30", ALC269_FIXUP_AMIC),
5448 SND_PCI_QUIRK(0x1043, 0x1593, "ASUS N51Vn", ALC269_FIXUP_AMIC),
5449 SND_PCI_QUIRK(0x1043, 0x15a3, "ASUS N60Jv", ALC269_FIXUP_AMIC),
5450 SND_PCI_QUIRK(0x1043, 0x15b3, "ASUS N60Dp", ALC269_FIXUP_AMIC),
5451 SND_PCI_QUIRK(0x1043, 0x15c3, "ASUS N70De", ALC269_FIXUP_AMIC),
5452 SND_PCI_QUIRK(0x1043, 0x15e3, "ASUS F83T", ALC269_FIXUP_AMIC),
5453 SND_PCI_QUIRK(0x1043, 0x1643, "ASUS M60J", ALC269_FIXUP_AMIC),
5454 SND_PCI_QUIRK(0x1043, 0x1653, "ASUS U50", ALC269_FIXUP_AMIC),
5455 SND_PCI_QUIRK(0x1043, 0x1693, "ASUS F50N", ALC269_FIXUP_AMIC),
5456 SND_PCI_QUIRK(0x1043, 0x16a3, "ASUS F5Q", ALC269_FIXUP_AMIC),
5457 SND_PCI_QUIRK(0x1043, 0x1723, "ASUS P80", ALC269_FIXUP_AMIC),
5458 SND_PCI_QUIRK(0x1043, 0x1743, "ASUS U80", ALC269_FIXUP_AMIC),
5459 SND_PCI_QUIRK(0x1043, 0x1773, "ASUS U20A", ALC269_FIXUP_AMIC),
5460 SND_PCI_QUIRK(0x1043, 0x1883, "ASUS F81Se", ALC269_FIXUP_AMIC),
5461 SND_PCI_QUIRK(0x152d, 0x1778, "Quanta ON1", ALC269_FIXUP_DMIC),
5462 SND_PCI_QUIRK(0x17aa, 0x3be9, "Quanta Wistron", ALC269_FIXUP_AMIC),
5463 SND_PCI_QUIRK(0x17aa, 0x3bf8, "Quanta FL1", ALC269_FIXUP_AMIC),
5464 SND_PCI_QUIRK(0x17ff, 0x059a, "Quanta EL3", ALC269_FIXUP_DMIC),
5465 SND_PCI_QUIRK(0x17ff, 0x059b, "Quanta JR1", ALC269_FIXUP_DMIC),
5466 #endif
5467 {}
5468 };
5469
5470 static const struct alc_model_fixup alc269_fixup_models[] = {
5471 {.id = ALC269_FIXUP_AMIC, .name = "laptop-amic"},
5472 {.id = ALC269_FIXUP_DMIC, .name = "laptop-dmic"},
5473 {}
5474 };
5475
5476
5477 static int alc269_fill_coef(struct hda_codec *codec)
5478 {
5479 int val;
5480
5481 if ((alc_get_coef0(codec) & 0x00ff) < 0x015) {
5482 alc_write_coef_idx(codec, 0xf, 0x960b);
5483 alc_write_coef_idx(codec, 0xe, 0x8817);
5484 }
5485
5486 if ((alc_get_coef0(codec) & 0x00ff) == 0x016) {
5487 alc_write_coef_idx(codec, 0xf, 0x960b);
5488 alc_write_coef_idx(codec, 0xe, 0x8814);
5489 }
5490
5491 if ((alc_get_coef0(codec) & 0x00ff) == 0x017) {
5492 val = alc_read_coef_idx(codec, 0x04);
5493 /* Power up output pin */
5494 alc_write_coef_idx(codec, 0x04, val | (1<<11));
5495 }
5496
5497 if ((alc_get_coef0(codec) & 0x00ff) == 0x018) {
5498 val = alc_read_coef_idx(codec, 0xd);
5499 if ((val & 0x0c00) >> 10 != 0x1) {
5500 /* Capless ramp up clock control */
5501 alc_write_coef_idx(codec, 0xd, val | (1<<10));
5502 }
5503 val = alc_read_coef_idx(codec, 0x17);
5504 if ((val & 0x01c0) >> 6 != 0x4) {
5505 /* Class D power on reset */
5506 alc_write_coef_idx(codec, 0x17, val | (1<<7));
5507 }
5508 }
5509
5510 val = alc_read_coef_idx(codec, 0xd); /* Class D */
5511 alc_write_coef_idx(codec, 0xd, val | (1<<14));
5512
5513 val = alc_read_coef_idx(codec, 0x4); /* HP */
5514 alc_write_coef_idx(codec, 0x4, val | (1<<11));
5515
5516 return 0;
5517 }
5518
5519 /*
5520 */
5521 static int patch_alc269(struct hda_codec *codec)
5522 {
5523 struct alc_spec *spec;
5524 int err = 0;
5525
5526 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
5527 if (spec == NULL)
5528 return -ENOMEM;
5529
5530 codec->spec = spec;
5531
5532 spec->mixer_nid = 0x0b;
5533
5534 alc_auto_parse_customize_define(codec);
5535
5536 err = alc_codec_rename_from_preset(codec);
5537 if (err < 0)
5538 goto error;
5539
5540 if (codec->vendor_id == 0x10ec0269) {
5541 spec->codec_variant = ALC269_TYPE_ALC269VA;
5542 switch (alc_get_coef0(codec) & 0x00f0) {
5543 case 0x0010:
5544 if (codec->bus->pci->subsystem_vendor == 0x1025 &&
5545 spec->cdefine.platform_type == 1)
5546 err = alc_codec_rename(codec, "ALC271X");
5547 spec->codec_variant = ALC269_TYPE_ALC269VB;
5548 break;
5549 case 0x0020:
5550 if (codec->bus->pci->subsystem_vendor == 0x17aa &&
5551 codec->bus->pci->subsystem_device == 0x21f3)
5552 err = alc_codec_rename(codec, "ALC3202");
5553 spec->codec_variant = ALC269_TYPE_ALC269VC;
5554 break;
5555 default:
5556 alc_fix_pll_init(codec, 0x20, 0x04, 15);
5557 }
5558 if (err < 0)
5559 goto error;
5560 alc269_fill_coef(codec);
5561 }
5562
5563 alc_pick_fixup(codec, alc269_fixup_models,
5564 alc269_fixup_tbl, alc269_fixups);
5565 alc_apply_fixup(codec, ALC_FIXUP_ACT_PRE_PROBE);
5566
5567 /* automatic parse from the BIOS config */
5568 err = alc269_parse_auto_config(codec);
5569 if (err < 0)
5570 goto error;
5571
5572 if (!spec->no_analog && !spec->adc_nids) {
5573 alc_auto_fill_adc_caps(codec);
5574 alc_rebuild_imux_for_auto_mic(codec);
5575 alc_remove_invalid_adc_nids(codec);
5576 }
5577
5578 if (!spec->no_analog && !spec->cap_mixer)
5579 set_capture_mixer(codec);
5580
5581 if (!spec->no_analog && has_cdefine_beep(codec)) {
5582 err = snd_hda_attach_beep_device(codec, 0x1);
5583 if (err < 0)
5584 goto error;
5585 set_beep_amp(spec, 0x0b, 0x04, HDA_INPUT);
5586 }
5587
5588 alc_apply_fixup(codec, ALC_FIXUP_ACT_PROBE);
5589
5590 codec->patch_ops = alc_patch_ops;
5591 #ifdef CONFIG_PM
5592 codec->patch_ops.resume = alc269_resume;
5593 #endif
5594 spec->init_hook = alc_auto_init_std;
5595 spec->shutup = alc269_shutup;
5596
5597 #ifdef CONFIG_SND_HDA_POWER_SAVE
5598 if (!spec->loopback.amplist)
5599 spec->loopback.amplist = alc269_loopbacks;
5600 if (alc269_mic2_for_mute_led(codec))
5601 codec->patch_ops.check_power_status = alc269_mic2_mute_check_ps;
5602 #endif
5603
5604 return 0;
5605
5606 error:
5607 alc_free(codec);
5608 return err;
5609 }
5610
5611 /*
5612 * ALC861
5613 */
5614
5615 static int alc861_parse_auto_config(struct hda_codec *codec)
5616 {
5617 static const hda_nid_t alc861_ignore[] = { 0x1d, 0 };
5618 static const hda_nid_t alc861_ssids[] = { 0x0e, 0x0f, 0x0b, 0 };
5619 return alc_parse_auto_config(codec, alc861_ignore, alc861_ssids);
5620 }
5621
5622 #ifdef CONFIG_SND_HDA_POWER_SAVE
5623 static const struct hda_amp_list alc861_loopbacks[] = {
5624 { 0x15, HDA_INPUT, 0 },
5625 { 0x15, HDA_INPUT, 1 },
5626 { 0x15, HDA_INPUT, 2 },
5627 { 0x15, HDA_INPUT, 3 },
5628 { } /* end */
5629 };
5630 #endif
5631
5632
5633 /* Pin config fixes */
5634 enum {
5635 PINFIX_FSC_AMILO_PI1505,
5636 PINFIX_ASUS_A6RP,
5637 };
5638
5639 /* On some laptops, VREF of pin 0x0f is abused for controlling the main amp */
5640 static void alc861_fixup_asus_amp_vref_0f(struct hda_codec *codec,
5641 const struct alc_fixup *fix, int action)
5642 {
5643 struct alc_spec *spec = codec->spec;
5644 unsigned int val;
5645
5646 if (action != ALC_FIXUP_ACT_INIT)
5647 return;
5648 val = snd_hda_codec_read(codec, 0x0f, 0,
5649 AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
5650 if (!(val & (AC_PINCTL_IN_EN | AC_PINCTL_OUT_EN)))
5651 val |= AC_PINCTL_IN_EN;
5652 val |= AC_PINCTL_VREF_50;
5653 snd_hda_codec_write(codec, 0x0f, 0,
5654 AC_VERB_SET_PIN_WIDGET_CONTROL, val);
5655 spec->keep_vref_in_automute = 1;
5656 }
5657
5658 static const struct alc_fixup alc861_fixups[] = {
5659 [PINFIX_FSC_AMILO_PI1505] = {
5660 .type = ALC_FIXUP_PINS,
5661 .v.pins = (const struct alc_pincfg[]) {
5662 { 0x0b, 0x0221101f }, /* HP */
5663 { 0x0f, 0x90170310 }, /* speaker */
5664 { }
5665 }
5666 },
5667 [PINFIX_ASUS_A6RP] = {
5668 .type = ALC_FIXUP_FUNC,
5669 .v.func = alc861_fixup_asus_amp_vref_0f,
5670 },
5671 };
5672
5673 static const struct snd_pci_quirk alc861_fixup_tbl[] = {
5674 SND_PCI_QUIRK_VENDOR(0x1043, "ASUS laptop", PINFIX_ASUS_A6RP),
5675 SND_PCI_QUIRK(0x1584, 0x0000, "Uniwill ECS M31EI", PINFIX_ASUS_A6RP),
5676 SND_PCI_QUIRK(0x1584, 0x2b01, "Haier W18", PINFIX_ASUS_A6RP),
5677 SND_PCI_QUIRK(0x1734, 0x10c7, "FSC Amilo Pi1505", PINFIX_FSC_AMILO_PI1505),
5678 {}
5679 };
5680
5681 /*
5682 */
5683 static int patch_alc861(struct hda_codec *codec)
5684 {
5685 struct alc_spec *spec;
5686 int err;
5687
5688 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
5689 if (spec == NULL)
5690 return -ENOMEM;
5691
5692 codec->spec = spec;
5693
5694 spec->mixer_nid = 0x15;
5695
5696 alc_pick_fixup(codec, NULL, alc861_fixup_tbl, alc861_fixups);
5697 alc_apply_fixup(codec, ALC_FIXUP_ACT_PRE_PROBE);
5698
5699 /* automatic parse from the BIOS config */
5700 err = alc861_parse_auto_config(codec);
5701 if (err < 0)
5702 goto error;
5703
5704 if (!spec->no_analog && !spec->adc_nids) {
5705 alc_auto_fill_adc_caps(codec);
5706 alc_rebuild_imux_for_auto_mic(codec);
5707 alc_remove_invalid_adc_nids(codec);
5708 }
5709
5710 if (!spec->no_analog && !spec->cap_mixer)
5711 set_capture_mixer(codec);
5712
5713 if (!spec->no_analog) {
5714 err = snd_hda_attach_beep_device(codec, 0x23);
5715 if (err < 0)
5716 goto error;
5717 set_beep_amp(spec, 0x23, 0, HDA_OUTPUT);
5718 }
5719
5720 alc_apply_fixup(codec, ALC_FIXUP_ACT_PROBE);
5721
5722 codec->patch_ops = alc_patch_ops;
5723 spec->init_hook = alc_auto_init_std;
5724 #ifdef CONFIG_SND_HDA_POWER_SAVE
5725 spec->power_hook = alc_power_eapd;
5726 if (!spec->loopback.amplist)
5727 spec->loopback.amplist = alc861_loopbacks;
5728 #endif
5729
5730 return 0;
5731
5732 error:
5733 alc_free(codec);
5734 return err;
5735 }
5736
5737 /*
5738 * ALC861-VD support
5739 *
5740 * Based on ALC882
5741 *
5742 * In addition, an independent DAC
5743 */
5744 #ifdef CONFIG_SND_HDA_POWER_SAVE
5745 #define alc861vd_loopbacks alc880_loopbacks
5746 #endif
5747
5748 static int alc861vd_parse_auto_config(struct hda_codec *codec)
5749 {
5750 static const hda_nid_t alc861vd_ignore[] = { 0x1d, 0 };
5751 static const hda_nid_t alc861vd_ssids[] = { 0x15, 0x1b, 0x14, 0 };
5752 return alc_parse_auto_config(codec, alc861vd_ignore, alc861vd_ssids);
5753 }
5754
5755 enum {
5756 ALC660VD_FIX_ASUS_GPIO1,
5757 ALC861VD_FIX_DALLAS,
5758 };
5759
5760 /* exclude VREF80 */
5761 static void alc861vd_fixup_dallas(struct hda_codec *codec,
5762 const struct alc_fixup *fix, int action)
5763 {
5764 if (action == ALC_FIXUP_ACT_PRE_PROBE) {
5765 snd_hda_override_pin_caps(codec, 0x18, 0x00001714);
5766 snd_hda_override_pin_caps(codec, 0x19, 0x0000171c);
5767 }
5768 }
5769
5770 static const struct alc_fixup alc861vd_fixups[] = {
5771 [ALC660VD_FIX_ASUS_GPIO1] = {
5772 .type = ALC_FIXUP_VERBS,
5773 .v.verbs = (const struct hda_verb[]) {
5774 /* reset GPIO1 */
5775 {0x01, AC_VERB_SET_GPIO_MASK, 0x03},
5776 {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
5777 {0x01, AC_VERB_SET_GPIO_DATA, 0x01},
5778 { }
5779 }
5780 },
5781 [ALC861VD_FIX_DALLAS] = {
5782 .type = ALC_FIXUP_FUNC,
5783 .v.func = alc861vd_fixup_dallas,
5784 },
5785 };
5786
5787 static const struct snd_pci_quirk alc861vd_fixup_tbl[] = {
5788 SND_PCI_QUIRK(0x103c, 0x30bf, "HP TX1000", ALC861VD_FIX_DALLAS),
5789 SND_PCI_QUIRK(0x1043, 0x1339, "ASUS A7-K", ALC660VD_FIX_ASUS_GPIO1),
5790 SND_PCI_QUIRK(0x1179, 0xff31, "Toshiba L30-149", ALC861VD_FIX_DALLAS),
5791 {}
5792 };
5793
5794 static const struct hda_verb alc660vd_eapd_verbs[] = {
5795 {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
5796 {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
5797 { }
5798 };
5799
5800 /*
5801 */
5802 static int patch_alc861vd(struct hda_codec *codec)
5803 {
5804 struct alc_spec *spec;
5805 int err;
5806
5807 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
5808 if (spec == NULL)
5809 return -ENOMEM;
5810
5811 codec->spec = spec;
5812
5813 spec->mixer_nid = 0x0b;
5814
5815 alc_pick_fixup(codec, NULL, alc861vd_fixup_tbl, alc861vd_fixups);
5816 alc_apply_fixup(codec, ALC_FIXUP_ACT_PRE_PROBE);
5817
5818 /* automatic parse from the BIOS config */
5819 err = alc861vd_parse_auto_config(codec);
5820 if (err < 0)
5821 goto error;
5822
5823 if (codec->vendor_id == 0x10ec0660) {
5824 /* always turn on EAPD */
5825 add_verb(spec, alc660vd_eapd_verbs);
5826 }
5827
5828 if (!spec->no_analog && !spec->adc_nids) {
5829 alc_auto_fill_adc_caps(codec);
5830 alc_rebuild_imux_for_auto_mic(codec);
5831 alc_remove_invalid_adc_nids(codec);
5832 }
5833
5834 if (!spec->no_analog && !spec->cap_mixer)
5835 set_capture_mixer(codec);
5836
5837 if (!spec->no_analog) {
5838 err = snd_hda_attach_beep_device(codec, 0x23);
5839 if (err < 0)
5840 goto error;
5841 set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
5842 }
5843
5844 alc_apply_fixup(codec, ALC_FIXUP_ACT_PROBE);
5845
5846 codec->patch_ops = alc_patch_ops;
5847
5848 spec->init_hook = alc_auto_init_std;
5849 spec->shutup = alc_eapd_shutup;
5850 #ifdef CONFIG_SND_HDA_POWER_SAVE
5851 if (!spec->loopback.amplist)
5852 spec->loopback.amplist = alc861vd_loopbacks;
5853 #endif
5854
5855 return 0;
5856
5857 error:
5858 alc_free(codec);
5859 return err;
5860 }
5861
5862 /*
5863 * ALC662 support
5864 *
5865 * ALC662 is almost identical with ALC880 but has cleaner and more flexible
5866 * configuration. Each pin widget can choose any input DACs and a mixer.
5867 * Each ADC is connected from a mixer of all inputs. This makes possible
5868 * 6-channel independent captures.
5869 *
5870 * In addition, an independent DAC for the multi-playback (not used in this
5871 * driver yet).
5872 */
5873 #ifdef CONFIG_SND_HDA_POWER_SAVE
5874 #define alc662_loopbacks alc880_loopbacks
5875 #endif
5876
5877 /*
5878 * BIOS auto configuration
5879 */
5880
5881 static int alc662_parse_auto_config(struct hda_codec *codec)
5882 {
5883 static const hda_nid_t alc662_ignore[] = { 0x1d, 0 };
5884 static const hda_nid_t alc663_ssids[] = { 0x15, 0x1b, 0x14, 0x21 };
5885 static const hda_nid_t alc662_ssids[] = { 0x15, 0x1b, 0x14, 0 };
5886 const hda_nid_t *ssids;
5887
5888 if (codec->vendor_id == 0x10ec0272 || codec->vendor_id == 0x10ec0663 ||
5889 codec->vendor_id == 0x10ec0665 || codec->vendor_id == 0x10ec0670)
5890 ssids = alc663_ssids;
5891 else
5892 ssids = alc662_ssids;
5893 return alc_parse_auto_config(codec, alc662_ignore, ssids);
5894 }
5895
5896 static void alc272_fixup_mario(struct hda_codec *codec,
5897 const struct alc_fixup *fix, int action)
5898 {
5899 if (action != ALC_FIXUP_ACT_PROBE)
5900 return;
5901 if (snd_hda_override_amp_caps(codec, 0x2, HDA_OUTPUT,
5902 (0x3b << AC_AMPCAP_OFFSET_SHIFT) |
5903 (0x3b << AC_AMPCAP_NUM_STEPS_SHIFT) |
5904 (0x03 << AC_AMPCAP_STEP_SIZE_SHIFT) |
5905 (0 << AC_AMPCAP_MUTE_SHIFT)))
5906 printk(KERN_WARNING
5907 "hda_codec: failed to override amp caps for NID 0x2\n");
5908 }
5909
5910 enum {
5911 ALC662_FIXUP_ASPIRE,
5912 ALC662_FIXUP_IDEAPAD,
5913 ALC272_FIXUP_MARIO,
5914 ALC662_FIXUP_CZC_P10T,
5915 ALC662_FIXUP_SKU_IGNORE,
5916 ALC662_FIXUP_HP_RP5800,
5917 ALC662_FIXUP_ASUS_MODE1,
5918 ALC662_FIXUP_ASUS_MODE2,
5919 ALC662_FIXUP_ASUS_MODE3,
5920 ALC662_FIXUP_ASUS_MODE4,
5921 ALC662_FIXUP_ASUS_MODE5,
5922 ALC662_FIXUP_ASUS_MODE6,
5923 ALC662_FIXUP_ASUS_MODE7,
5924 ALC662_FIXUP_ASUS_MODE8,
5925 };
5926
5927 static const struct alc_fixup alc662_fixups[] = {
5928 [ALC662_FIXUP_ASPIRE] = {
5929 .type = ALC_FIXUP_PINS,
5930 .v.pins = (const struct alc_pincfg[]) {
5931 { 0x15, 0x99130112 }, /* subwoofer */
5932 { }
5933 }
5934 },
5935 [ALC662_FIXUP_IDEAPAD] = {
5936 .type = ALC_FIXUP_PINS,
5937 .v.pins = (const struct alc_pincfg[]) {
5938 { 0x17, 0x99130112 }, /* subwoofer */
5939 { }
5940 }
5941 },
5942 [ALC272_FIXUP_MARIO] = {
5943 .type = ALC_FIXUP_FUNC,
5944 .v.func = alc272_fixup_mario,
5945 },
5946 [ALC662_FIXUP_CZC_P10T] = {
5947 .type = ALC_FIXUP_VERBS,
5948 .v.verbs = (const struct hda_verb[]) {
5949 {0x14, AC_VERB_SET_EAPD_BTLENABLE, 0},
5950 {}
5951 }
5952 },
5953 [ALC662_FIXUP_SKU_IGNORE] = {
5954 .type = ALC_FIXUP_SKU,
5955 .v.sku = ALC_FIXUP_SKU_IGNORE,
5956 },
5957 [ALC662_FIXUP_HP_RP5800] = {
5958 .type = ALC_FIXUP_PINS,
5959 .v.pins = (const struct alc_pincfg[]) {
5960 { 0x14, 0x0221201f }, /* HP out */
5961 { }
5962 },
5963 .chained = true,
5964 .chain_id = ALC662_FIXUP_SKU_IGNORE
5965 },
5966 [ALC662_FIXUP_ASUS_MODE1] = {
5967 .type = ALC_FIXUP_PINS,
5968 .v.pins = (const struct alc_pincfg[]) {
5969 { 0x14, 0x99130110 }, /* speaker */
5970 { 0x18, 0x01a19c20 }, /* mic */
5971 { 0x19, 0x99a3092f }, /* int-mic */
5972 { 0x21, 0x0121401f }, /* HP out */
5973 { }
5974 },
5975 .chained = true,
5976 .chain_id = ALC662_FIXUP_SKU_IGNORE
5977 },
5978 [ALC662_FIXUP_ASUS_MODE2] = {
5979 .type = ALC_FIXUP_PINS,
5980 .v.pins = (const struct alc_pincfg[]) {
5981 { 0x14, 0x99130110 }, /* speaker */
5982 { 0x18, 0x01a19820 }, /* mic */
5983 { 0x19, 0x99a3092f }, /* int-mic */
5984 { 0x1b, 0x0121401f }, /* HP out */
5985 { }
5986 },
5987 .chained = true,
5988 .chain_id = ALC662_FIXUP_SKU_IGNORE
5989 },
5990 [ALC662_FIXUP_ASUS_MODE3] = {
5991 .type = ALC_FIXUP_PINS,
5992 .v.pins = (const struct alc_pincfg[]) {
5993 { 0x14, 0x99130110 }, /* speaker */
5994 { 0x15, 0x0121441f }, /* HP */
5995 { 0x18, 0x01a19840 }, /* mic */
5996 { 0x19, 0x99a3094f }, /* int-mic */
5997 { 0x21, 0x01211420 }, /* HP2 */
5998 { }
5999 },
6000 .chained = true,
6001 .chain_id = ALC662_FIXUP_SKU_IGNORE
6002 },
6003 [ALC662_FIXUP_ASUS_MODE4] = {
6004 .type = ALC_FIXUP_PINS,
6005 .v.pins = (const struct alc_pincfg[]) {
6006 { 0x14, 0x99130110 }, /* speaker */
6007 { 0x16, 0x99130111 }, /* speaker */
6008 { 0x18, 0x01a19840 }, /* mic */
6009 { 0x19, 0x99a3094f }, /* int-mic */
6010 { 0x21, 0x0121441f }, /* HP */
6011 { }
6012 },
6013 .chained = true,
6014 .chain_id = ALC662_FIXUP_SKU_IGNORE
6015 },
6016 [ALC662_FIXUP_ASUS_MODE5] = {
6017 .type = ALC_FIXUP_PINS,
6018 .v.pins = (const struct alc_pincfg[]) {
6019 { 0x14, 0x99130110 }, /* speaker */
6020 { 0x15, 0x0121441f }, /* HP */
6021 { 0x16, 0x99130111 }, /* speaker */
6022 { 0x18, 0x01a19840 }, /* mic */
6023 { 0x19, 0x99a3094f }, /* int-mic */
6024 { }
6025 },
6026 .chained = true,
6027 .chain_id = ALC662_FIXUP_SKU_IGNORE
6028 },
6029 [ALC662_FIXUP_ASUS_MODE6] = {
6030 .type = ALC_FIXUP_PINS,
6031 .v.pins = (const struct alc_pincfg[]) {
6032 { 0x14, 0x99130110 }, /* speaker */
6033 { 0x15, 0x01211420 }, /* HP2 */
6034 { 0x18, 0x01a19840 }, /* mic */
6035 { 0x19, 0x99a3094f }, /* int-mic */
6036 { 0x1b, 0x0121441f }, /* HP */
6037 { }
6038 },
6039 .chained = true,
6040 .chain_id = ALC662_FIXUP_SKU_IGNORE
6041 },
6042 [ALC662_FIXUP_ASUS_MODE7] = {
6043 .type = ALC_FIXUP_PINS,
6044 .v.pins = (const struct alc_pincfg[]) {
6045 { 0x14, 0x99130110 }, /* speaker */
6046 { 0x17, 0x99130111 }, /* speaker */
6047 { 0x18, 0x01a19840 }, /* mic */
6048 { 0x19, 0x99a3094f }, /* int-mic */
6049 { 0x1b, 0x01214020 }, /* HP */
6050 { 0x21, 0x0121401f }, /* HP */
6051 { }
6052 },
6053 .chained = true,
6054 .chain_id = ALC662_FIXUP_SKU_IGNORE
6055 },
6056 [ALC662_FIXUP_ASUS_MODE8] = {
6057 .type = ALC_FIXUP_PINS,
6058 .v.pins = (const struct alc_pincfg[]) {
6059 { 0x14, 0x99130110 }, /* speaker */
6060 { 0x12, 0x99a30970 }, /* int-mic */
6061 { 0x15, 0x01214020 }, /* HP */
6062 { 0x17, 0x99130111 }, /* speaker */
6063 { 0x18, 0x01a19840 }, /* mic */
6064 { 0x21, 0x0121401f }, /* HP */
6065 { }
6066 },
6067 .chained = true,
6068 .chain_id = ALC662_FIXUP_SKU_IGNORE
6069 },
6070 };
6071
6072 static const struct snd_pci_quirk alc662_fixup_tbl[] = {
6073 SND_PCI_QUIRK(0x1019, 0x9087, "ECS", ALC662_FIXUP_ASUS_MODE2),
6074 SND_PCI_QUIRK(0x1025, 0x0308, "Acer Aspire 8942G", ALC662_FIXUP_ASPIRE),
6075 SND_PCI_QUIRK(0x1025, 0x031c, "Gateway NV79", ALC662_FIXUP_SKU_IGNORE),
6076 SND_PCI_QUIRK(0x1025, 0x038b, "Acer Aspire 8943G", ALC662_FIXUP_ASPIRE),
6077 SND_PCI_QUIRK(0x103c, 0x1632, "HP RP5800", ALC662_FIXUP_HP_RP5800),
6078 SND_PCI_QUIRK(0x105b, 0x0cd6, "Foxconn", ALC662_FIXUP_ASUS_MODE2),
6079 SND_PCI_QUIRK(0x144d, 0xc051, "Samsung R720", ALC662_FIXUP_IDEAPAD),
6080 SND_PCI_QUIRK(0x17aa, 0x38af, "Lenovo Ideapad Y550P", ALC662_FIXUP_IDEAPAD),
6081 SND_PCI_QUIRK(0x17aa, 0x3a0d, "Lenovo Ideapad Y550", ALC662_FIXUP_IDEAPAD),
6082 SND_PCI_QUIRK(0x1b35, 0x2206, "CZC P10T", ALC662_FIXUP_CZC_P10T),
6083
6084 #if 0
6085 /* Below is a quirk table taken from the old code.
6086 * Basically the device should work as is without the fixup table.
6087 * If BIOS doesn't give a proper info, enable the corresponding
6088 * fixup entry.
6089 */
6090 SND_PCI_QUIRK(0x1043, 0x1000, "ASUS N50Vm", ALC662_FIXUP_ASUS_MODE1),
6091 SND_PCI_QUIRK(0x1043, 0x1092, "ASUS NB", ALC662_FIXUP_ASUS_MODE3),
6092 SND_PCI_QUIRK(0x1043, 0x1173, "ASUS K73Jn", ALC662_FIXUP_ASUS_MODE1),
6093 SND_PCI_QUIRK(0x1043, 0x11c3, "ASUS M70V", ALC662_FIXUP_ASUS_MODE3),
6094 SND_PCI_QUIRK(0x1043, 0x11d3, "ASUS NB", ALC662_FIXUP_ASUS_MODE1),
6095 SND_PCI_QUIRK(0x1043, 0x11f3, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
6096 SND_PCI_QUIRK(0x1043, 0x1203, "ASUS NB", ALC662_FIXUP_ASUS_MODE1),
6097 SND_PCI_QUIRK(0x1043, 0x1303, "ASUS G60J", ALC662_FIXUP_ASUS_MODE1),
6098 SND_PCI_QUIRK(0x1043, 0x1333, "ASUS G60Jx", ALC662_FIXUP_ASUS_MODE1),
6099 SND_PCI_QUIRK(0x1043, 0x1339, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
6100 SND_PCI_QUIRK(0x1043, 0x13e3, "ASUS N71JA", ALC662_FIXUP_ASUS_MODE7),
6101 SND_PCI_QUIRK(0x1043, 0x1463, "ASUS N71", ALC662_FIXUP_ASUS_MODE7),
6102 SND_PCI_QUIRK(0x1043, 0x14d3, "ASUS G72", ALC662_FIXUP_ASUS_MODE8),
6103 SND_PCI_QUIRK(0x1043, 0x1563, "ASUS N90", ALC662_FIXUP_ASUS_MODE3),
6104 SND_PCI_QUIRK(0x1043, 0x15d3, "ASUS N50SF F50SF", ALC662_FIXUP_ASUS_MODE1),
6105 SND_PCI_QUIRK(0x1043, 0x16c3, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
6106 SND_PCI_QUIRK(0x1043, 0x16f3, "ASUS K40C K50C", ALC662_FIXUP_ASUS_MODE2),
6107 SND_PCI_QUIRK(0x1043, 0x1733, "ASUS N81De", ALC662_FIXUP_ASUS_MODE1),
6108 SND_PCI_QUIRK(0x1043, 0x1753, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
6109 SND_PCI_QUIRK(0x1043, 0x1763, "ASUS NB", ALC662_FIXUP_ASUS_MODE6),
6110 SND_PCI_QUIRK(0x1043, 0x1765, "ASUS NB", ALC662_FIXUP_ASUS_MODE6),
6111 SND_PCI_QUIRK(0x1043, 0x1783, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
6112 SND_PCI_QUIRK(0x1043, 0x1793, "ASUS F50GX", ALC662_FIXUP_ASUS_MODE1),
6113 SND_PCI_QUIRK(0x1043, 0x17b3, "ASUS F70SL", ALC662_FIXUP_ASUS_MODE3),
6114 SND_PCI_QUIRK(0x1043, 0x17f3, "ASUS X58LE", ALC662_FIXUP_ASUS_MODE2),
6115 SND_PCI_QUIRK(0x1043, 0x1813, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
6116 SND_PCI_QUIRK(0x1043, 0x1823, "ASUS NB", ALC662_FIXUP_ASUS_MODE5),
6117 SND_PCI_QUIRK(0x1043, 0x1833, "ASUS NB", ALC662_FIXUP_ASUS_MODE6),
6118 SND_PCI_QUIRK(0x1043, 0x1843, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
6119 SND_PCI_QUIRK(0x1043, 0x1853, "ASUS F50Z", ALC662_FIXUP_ASUS_MODE1),
6120 SND_PCI_QUIRK(0x1043, 0x1864, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
6121 SND_PCI_QUIRK(0x1043, 0x1876, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
6122 SND_PCI_QUIRK(0x1043, 0x1893, "ASUS M50Vm", ALC662_FIXUP_ASUS_MODE3),
6123 SND_PCI_QUIRK(0x1043, 0x1894, "ASUS X55", ALC662_FIXUP_ASUS_MODE3),
6124 SND_PCI_QUIRK(0x1043, 0x18b3, "ASUS N80Vc", ALC662_FIXUP_ASUS_MODE1),
6125 SND_PCI_QUIRK(0x1043, 0x18c3, "ASUS VX5", ALC662_FIXUP_ASUS_MODE1),
6126 SND_PCI_QUIRK(0x1043, 0x18d3, "ASUS N81Te", ALC662_FIXUP_ASUS_MODE1),
6127 SND_PCI_QUIRK(0x1043, 0x18f3, "ASUS N505Tp", ALC662_FIXUP_ASUS_MODE1),
6128 SND_PCI_QUIRK(0x1043, 0x1903, "ASUS F5GL", ALC662_FIXUP_ASUS_MODE1),
6129 SND_PCI_QUIRK(0x1043, 0x1913, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
6130 SND_PCI_QUIRK(0x1043, 0x1933, "ASUS F80Q", ALC662_FIXUP_ASUS_MODE2),
6131 SND_PCI_QUIRK(0x1043, 0x1943, "ASUS Vx3V", ALC662_FIXUP_ASUS_MODE1),
6132 SND_PCI_QUIRK(0x1043, 0x1953, "ASUS NB", ALC662_FIXUP_ASUS_MODE1),
6133 SND_PCI_QUIRK(0x1043, 0x1963, "ASUS X71C", ALC662_FIXUP_ASUS_MODE3),
6134 SND_PCI_QUIRK(0x1043, 0x1983, "ASUS N5051A", ALC662_FIXUP_ASUS_MODE1),
6135 SND_PCI_QUIRK(0x1043, 0x1993, "ASUS N20", ALC662_FIXUP_ASUS_MODE1),
6136 SND_PCI_QUIRK(0x1043, 0x19b3, "ASUS F7Z", ALC662_FIXUP_ASUS_MODE1),
6137 SND_PCI_QUIRK(0x1043, 0x19c3, "ASUS F5Z/F6x", ALC662_FIXUP_ASUS_MODE2),
6138 SND_PCI_QUIRK(0x1043, 0x19e3, "ASUS NB", ALC662_FIXUP_ASUS_MODE1),
6139 SND_PCI_QUIRK(0x1043, 0x19f3, "ASUS NB", ALC662_FIXUP_ASUS_MODE4),
6140 #endif
6141 {}
6142 };
6143
6144 static const struct alc_model_fixup alc662_fixup_models[] = {
6145 {.id = ALC272_FIXUP_MARIO, .name = "mario"},
6146 {.id = ALC662_FIXUP_ASUS_MODE1, .name = "asus-mode1"},
6147 {.id = ALC662_FIXUP_ASUS_MODE2, .name = "asus-mode2"},
6148 {.id = ALC662_FIXUP_ASUS_MODE3, .name = "asus-mode3"},
6149 {.id = ALC662_FIXUP_ASUS_MODE4, .name = "asus-mode4"},
6150 {.id = ALC662_FIXUP_ASUS_MODE5, .name = "asus-mode5"},
6151 {.id = ALC662_FIXUP_ASUS_MODE6, .name = "asus-mode6"},
6152 {.id = ALC662_FIXUP_ASUS_MODE7, .name = "asus-mode7"},
6153 {.id = ALC662_FIXUP_ASUS_MODE8, .name = "asus-mode8"},
6154 {}
6155 };
6156
6157
6158 /*
6159 */
6160 static int patch_alc662(struct hda_codec *codec)
6161 {
6162 struct alc_spec *spec;
6163 int err = 0;
6164
6165 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
6166 if (!spec)
6167 return -ENOMEM;
6168
6169 codec->spec = spec;
6170
6171 spec->mixer_nid = 0x0b;
6172
6173 /* handle multiple HPs as is */
6174 spec->parse_flags = HDA_PINCFG_NO_HP_FIXUP;
6175
6176 alc_auto_parse_customize_define(codec);
6177
6178 alc_fix_pll_init(codec, 0x20, 0x04, 15);
6179
6180 err = alc_codec_rename_from_preset(codec);
6181 if (err < 0)
6182 goto error;
6183
6184 if ((alc_get_coef0(codec) & (1 << 14)) &&
6185 codec->bus->pci->subsystem_vendor == 0x1025 &&
6186 spec->cdefine.platform_type == 1) {
6187 if (alc_codec_rename(codec, "ALC272X") < 0)
6188 goto error;
6189 }
6190
6191 alc_pick_fixup(codec, alc662_fixup_models,
6192 alc662_fixup_tbl, alc662_fixups);
6193 alc_apply_fixup(codec, ALC_FIXUP_ACT_PRE_PROBE);
6194 /* automatic parse from the BIOS config */
6195 err = alc662_parse_auto_config(codec);
6196 if (err < 0)
6197 goto error;
6198
6199 if (!spec->no_analog && !spec->adc_nids) {
6200 alc_auto_fill_adc_caps(codec);
6201 alc_rebuild_imux_for_auto_mic(codec);
6202 alc_remove_invalid_adc_nids(codec);
6203 }
6204
6205 if (!spec->no_analog && !spec->cap_mixer)
6206 set_capture_mixer(codec);
6207
6208 if (!spec->no_analog && has_cdefine_beep(codec)) {
6209 err = snd_hda_attach_beep_device(codec, 0x1);
6210 if (err < 0)
6211 goto error;
6212 switch (codec->vendor_id) {
6213 case 0x10ec0662:
6214 set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
6215 break;
6216 case 0x10ec0272:
6217 case 0x10ec0663:
6218 case 0x10ec0665:
6219 set_beep_amp(spec, 0x0b, 0x04, HDA_INPUT);
6220 break;
6221 case 0x10ec0273:
6222 set_beep_amp(spec, 0x0b, 0x03, HDA_INPUT);
6223 break;
6224 }
6225 }
6226
6227 alc_apply_fixup(codec, ALC_FIXUP_ACT_PROBE);
6228
6229 codec->patch_ops = alc_patch_ops;
6230 spec->init_hook = alc_auto_init_std;
6231 spec->shutup = alc_eapd_shutup;
6232
6233 #ifdef CONFIG_SND_HDA_POWER_SAVE
6234 if (!spec->loopback.amplist)
6235 spec->loopback.amplist = alc662_loopbacks;
6236 #endif
6237
6238 return 0;
6239
6240 error:
6241 alc_free(codec);
6242 return err;
6243 }
6244
6245 /*
6246 * ALC680 support
6247 */
6248
6249 static int alc680_parse_auto_config(struct hda_codec *codec)
6250 {
6251 return alc_parse_auto_config(codec, NULL, NULL);
6252 }
6253
6254 /*
6255 */
6256 static int patch_alc680(struct hda_codec *codec)
6257 {
6258 struct alc_spec *spec;
6259 int err;
6260
6261 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
6262 if (spec == NULL)
6263 return -ENOMEM;
6264
6265 codec->spec = spec;
6266
6267 /* ALC680 has no aa-loopback mixer */
6268
6269 /* automatic parse from the BIOS config */
6270 err = alc680_parse_auto_config(codec);
6271 if (err < 0) {
6272 alc_free(codec);
6273 return err;
6274 }
6275
6276 if (!spec->no_analog && !spec->cap_mixer)
6277 set_capture_mixer(codec);
6278
6279 codec->patch_ops = alc_patch_ops;
6280 spec->init_hook = alc_auto_init_std;
6281
6282 return 0;
6283 }
6284
6285 /*
6286 * patch entries
6287 */
6288 static const struct hda_codec_preset snd_hda_preset_realtek[] = {
6289 { .id = 0x10ec0221, .name = "ALC221", .patch = patch_alc269 },
6290 { .id = 0x10ec0260, .name = "ALC260", .patch = patch_alc260 },
6291 { .id = 0x10ec0262, .name = "ALC262", .patch = patch_alc262 },
6292 { .id = 0x10ec0267, .name = "ALC267", .patch = patch_alc268 },
6293 { .id = 0x10ec0268, .name = "ALC268", .patch = patch_alc268 },
6294 { .id = 0x10ec0269, .name = "ALC269", .patch = patch_alc269 },
6295 { .id = 0x10ec0270, .name = "ALC270", .patch = patch_alc269 },
6296 { .id = 0x10ec0272, .name = "ALC272", .patch = patch_alc662 },
6297 { .id = 0x10ec0275, .name = "ALC275", .patch = patch_alc269 },
6298 { .id = 0x10ec0276, .name = "ALC276", .patch = patch_alc269 },
6299 { .id = 0x10ec0861, .rev = 0x100340, .name = "ALC660",
6300 .patch = patch_alc861 },
6301 { .id = 0x10ec0660, .name = "ALC660-VD", .patch = patch_alc861vd },
6302 { .id = 0x10ec0861, .name = "ALC861", .patch = patch_alc861 },
6303 { .id = 0x10ec0862, .name = "ALC861-VD", .patch = patch_alc861vd },
6304 { .id = 0x10ec0662, .rev = 0x100002, .name = "ALC662 rev2",
6305 .patch = patch_alc882 },
6306 { .id = 0x10ec0662, .rev = 0x100101, .name = "ALC662 rev1",
6307 .patch = patch_alc662 },
6308 { .id = 0x10ec0662, .rev = 0x100300, .name = "ALC662 rev3",
6309 .patch = patch_alc662 },
6310 { .id = 0x10ec0663, .name = "ALC663", .patch = patch_alc662 },
6311 { .id = 0x10ec0665, .name = "ALC665", .patch = patch_alc662 },
6312 { .id = 0x10ec0670, .name = "ALC670", .patch = patch_alc662 },
6313 { .id = 0x10ec0680, .name = "ALC680", .patch = patch_alc680 },
6314 { .id = 0x10ec0880, .name = "ALC880", .patch = patch_alc880 },
6315 { .id = 0x10ec0882, .name = "ALC882", .patch = patch_alc882 },
6316 { .id = 0x10ec0883, .name = "ALC883", .patch = patch_alc882 },
6317 { .id = 0x10ec0885, .rev = 0x100101, .name = "ALC889A",
6318 .patch = patch_alc882 },
6319 { .id = 0x10ec0885, .rev = 0x100103, .name = "ALC889A",
6320 .patch = patch_alc882 },
6321 { .id = 0x10ec0885, .name = "ALC885", .patch = patch_alc882 },
6322 { .id = 0x10ec0887, .name = "ALC887", .patch = patch_alc882 },
6323 { .id = 0x10ec0888, .rev = 0x100101, .name = "ALC1200",
6324 .patch = patch_alc882 },
6325 { .id = 0x10ec0888, .name = "ALC888", .patch = patch_alc882 },
6326 { .id = 0x10ec0889, .name = "ALC889", .patch = patch_alc882 },
6327 { .id = 0x10ec0892, .name = "ALC892", .patch = patch_alc662 },
6328 { .id = 0x10ec0899, .name = "ALC898", .patch = patch_alc882 },
6329 {} /* terminator */
6330 };
6331
6332 MODULE_ALIAS("snd-hda-codec-id:10ec*");
6333
6334 MODULE_LICENSE("GPL");
6335 MODULE_DESCRIPTION("Realtek HD-audio codec");
6336
6337 static struct hda_codec_preset_list realtek_list = {
6338 .preset = snd_hda_preset_realtek,
6339 .owner = THIS_MODULE,
6340 };
6341
6342 static int __init patch_realtek_init(void)
6343 {
6344 return snd_hda_add_codec_preset(&realtek_list);
6345 }
6346
6347 static void __exit patch_realtek_exit(void)
6348 {
6349 snd_hda_delete_codec_preset(&realtek_list);
6350 }
6351
6352 module_init(patch_realtek_init)
6353 module_exit(patch_realtek_exit)
ubuntu-bionic-kernel mirror