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