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