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