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