diff options
Diffstat (limited to 'sound/pci')
-rw-r--r-- | sound/pci/hda/patch_via.c | 5756 |
1 files changed, 1510 insertions, 4246 deletions
diff --git a/sound/pci/hda/patch_via.c b/sound/pci/hda/patch_via.c index de004ed2ef8..fb5468b4c55 100644 --- a/sound/pci/hda/patch_via.c +++ b/sound/pci/hda/patch_via.c | |||
@@ -54,36 +54,10 @@ | |||
54 | #include "hda_codec.h" | 54 | #include "hda_codec.h" |
55 | #include "hda_local.h" | 55 | #include "hda_local.h" |
56 | 56 | ||
57 | #define NID_MAPPING (-1) | ||
58 | |||
59 | /* amp values */ | ||
60 | #define AMP_VAL_IDX_SHIFT 19 | ||
61 | #define AMP_VAL_IDX_MASK (0x0f<<19) | ||
62 | |||
63 | /* Pin Widget NID */ | 57 | /* Pin Widget NID */ |
64 | #define VT1708_HP_NID 0x13 | ||
65 | #define VT1708_DIGOUT_NID 0x14 | ||
66 | #define VT1708_DIGIN_NID 0x16 | ||
67 | #define VT1708_DIGIN_PIN 0x26 | ||
68 | #define VT1708_HP_PIN_NID 0x20 | 58 | #define VT1708_HP_PIN_NID 0x20 |
69 | #define VT1708_CD_PIN_NID 0x24 | 59 | #define VT1708_CD_PIN_NID 0x24 |
70 | 60 | ||
71 | #define VT1709_HP_DAC_NID 0x28 | ||
72 | #define VT1709_DIGOUT_NID 0x13 | ||
73 | #define VT1709_DIGIN_NID 0x17 | ||
74 | #define VT1709_DIGIN_PIN 0x25 | ||
75 | |||
76 | #define VT1708B_HP_NID 0x25 | ||
77 | #define VT1708B_DIGOUT_NID 0x12 | ||
78 | #define VT1708B_DIGIN_NID 0x15 | ||
79 | #define VT1708B_DIGIN_PIN 0x21 | ||
80 | |||
81 | #define VT1708S_HP_NID 0x25 | ||
82 | #define VT1708S_DIGOUT_NID 0x12 | ||
83 | |||
84 | #define VT1702_HP_NID 0x17 | ||
85 | #define VT1702_DIGOUT_NID 0x11 | ||
86 | |||
87 | enum VIA_HDA_CODEC { | 61 | enum VIA_HDA_CODEC { |
88 | UNKNOWN = -1, | 62 | UNKNOWN = -1, |
89 | VT1708, | 63 | VT1708, |
@@ -107,6 +81,32 @@ enum VIA_HDA_CODEC { | |||
107 | (spec)->codec_type == VT1812 ||\ | 81 | (spec)->codec_type == VT1812 ||\ |
108 | (spec)->codec_type == VT1802) | 82 | (spec)->codec_type == VT1802) |
109 | 83 | ||
84 | #define MAX_NID_PATH_DEPTH 5 | ||
85 | |||
86 | /* output-path: DAC -> ... -> pin | ||
87 | * idx[] contains the source index number of the next widget; | ||
88 | * e.g. idx[0] is the index of the DAC selected by path[1] widget | ||
89 | * multi[] indicates whether it's a selector widget with multi-connectors | ||
90 | * (i.e. the connection selection is mandatory) | ||
91 | * vol_ctl and mute_ctl contains the NIDs for the assigned mixers | ||
92 | */ | ||
93 | struct nid_path { | ||
94 | int depth; | ||
95 | hda_nid_t path[MAX_NID_PATH_DEPTH]; | ||
96 | unsigned char idx[MAX_NID_PATH_DEPTH]; | ||
97 | unsigned char multi[MAX_NID_PATH_DEPTH]; | ||
98 | unsigned int vol_ctl; | ||
99 | unsigned int mute_ctl; | ||
100 | }; | ||
101 | |||
102 | /* input-path */ | ||
103 | struct via_input { | ||
104 | hda_nid_t pin; /* input-pin or aa-mix */ | ||
105 | int adc_idx; /* ADC index to be used */ | ||
106 | int mux_idx; /* MUX index (if any) */ | ||
107 | const char *label; /* input-source label */ | ||
108 | }; | ||
109 | |||
110 | struct via_spec { | 110 | struct via_spec { |
111 | /* codec parameterization */ | 111 | /* codec parameterization */ |
112 | const struct snd_kcontrol_new *mixers[6]; | 112 | const struct snd_kcontrol_new *mixers[6]; |
@@ -115,57 +115,80 @@ struct via_spec { | |||
115 | const struct hda_verb *init_verbs[5]; | 115 | const struct hda_verb *init_verbs[5]; |
116 | unsigned int num_iverbs; | 116 | unsigned int num_iverbs; |
117 | 117 | ||
118 | char *stream_name_analog; | 118 | char stream_name_analog[32]; |
119 | char stream_name_hp[32]; | ||
119 | const struct hda_pcm_stream *stream_analog_playback; | 120 | const struct hda_pcm_stream *stream_analog_playback; |
120 | const struct hda_pcm_stream *stream_analog_capture; | 121 | const struct hda_pcm_stream *stream_analog_capture; |
121 | 122 | ||
122 | char *stream_name_digital; | 123 | char stream_name_digital[32]; |
123 | const struct hda_pcm_stream *stream_digital_playback; | 124 | const struct hda_pcm_stream *stream_digital_playback; |
124 | const struct hda_pcm_stream *stream_digital_capture; | 125 | const struct hda_pcm_stream *stream_digital_capture; |
125 | 126 | ||
126 | /* playback */ | 127 | /* playback */ |
127 | struct hda_multi_out multiout; | 128 | struct hda_multi_out multiout; |
128 | hda_nid_t slave_dig_outs[2]; | 129 | hda_nid_t slave_dig_outs[2]; |
130 | hda_nid_t hp_dac_nid; | ||
131 | int num_active_streams; | ||
132 | |||
133 | struct nid_path out_path[4]; | ||
134 | struct nid_path hp_path; | ||
135 | struct nid_path hp_dep_path; | ||
136 | struct nid_path speaker_path; | ||
129 | 137 | ||
130 | /* capture */ | 138 | /* capture */ |
131 | unsigned int num_adc_nids; | 139 | unsigned int num_adc_nids; |
132 | const hda_nid_t *adc_nids; | 140 | hda_nid_t adc_nids[3]; |
133 | hda_nid_t mux_nids[3]; | 141 | hda_nid_t mux_nids[3]; |
142 | hda_nid_t aa_mix_nid; | ||
134 | hda_nid_t dig_in_nid; | 143 | hda_nid_t dig_in_nid; |
135 | hda_nid_t dig_in_pin; | ||
136 | 144 | ||
137 | /* capture source */ | 145 | /* capture source */ |
138 | const struct hda_input_mux *input_mux; | 146 | bool dyn_adc_switch; |
147 | int num_inputs; | ||
148 | struct via_input inputs[AUTO_CFG_MAX_INS + 1]; | ||
139 | unsigned int cur_mux[3]; | 149 | unsigned int cur_mux[3]; |
140 | 150 | ||
151 | /* dynamic ADC switching */ | ||
152 | hda_nid_t cur_adc; | ||
153 | unsigned int cur_adc_stream_tag; | ||
154 | unsigned int cur_adc_format; | ||
155 | |||
141 | /* PCM information */ | 156 | /* PCM information */ |
142 | struct hda_pcm pcm_rec[3]; | 157 | struct hda_pcm pcm_rec[3]; |
143 | 158 | ||
144 | /* dynamic controls, init_verbs and input_mux */ | 159 | /* dynamic controls, init_verbs and input_mux */ |
145 | struct auto_pin_cfg autocfg; | 160 | struct auto_pin_cfg autocfg; |
146 | struct snd_array kctls; | 161 | struct snd_array kctls; |
147 | struct hda_input_mux private_imux[2]; | ||
148 | hda_nid_t private_dac_nids[AUTO_CFG_MAX_OUTS]; | 162 | hda_nid_t private_dac_nids[AUTO_CFG_MAX_OUTS]; |
149 | 163 | ||
150 | /* HP mode source */ | 164 | /* HP mode source */ |
151 | const struct hda_input_mux *hp_mux; | ||
152 | unsigned int hp_independent_mode; | 165 | unsigned int hp_independent_mode; |
153 | unsigned int hp_independent_mode_index; | ||
154 | unsigned int smart51_enabled; | ||
155 | unsigned int dmic_enabled; | 166 | unsigned int dmic_enabled; |
167 | unsigned int no_pin_power_ctl; | ||
156 | enum VIA_HDA_CODEC codec_type; | 168 | enum VIA_HDA_CODEC codec_type; |
157 | 169 | ||
170 | /* smart51 setup */ | ||
171 | unsigned int smart51_nums; | ||
172 | hda_nid_t smart51_pins[2]; | ||
173 | int smart51_idxs[2]; | ||
174 | const char *smart51_labels[2]; | ||
175 | unsigned int smart51_enabled; | ||
176 | |||
158 | /* work to check hp jack state */ | 177 | /* work to check hp jack state */ |
159 | struct hda_codec *codec; | 178 | struct hda_codec *codec; |
160 | struct delayed_work vt1708_hp_work; | 179 | struct delayed_work vt1708_hp_work; |
161 | int vt1708_jack_detectect; | 180 | int vt1708_jack_detect; |
162 | int vt1708_hp_present; | 181 | int vt1708_hp_present; |
163 | 182 | ||
164 | void (*set_widgets_power_state)(struct hda_codec *codec); | 183 | void (*set_widgets_power_state)(struct hda_codec *codec); |
165 | 184 | ||
166 | #ifdef CONFIG_SND_HDA_POWER_SAVE | ||
167 | struct hda_loopback_check loopback; | 185 | struct hda_loopback_check loopback; |
168 | #endif | 186 | int num_loopbacks; |
187 | struct hda_amp_list loopback_list[8]; | ||
188 | |||
189 | /* bind capture-volume */ | ||
190 | struct hda_bind_ctls *bind_cap_vol; | ||
191 | struct hda_bind_ctls *bind_cap_sw; | ||
169 | }; | 192 | }; |
170 | 193 | ||
171 | static enum VIA_HDA_CODEC get_codec_type(struct hda_codec *codec); | 194 | static enum VIA_HDA_CODEC get_codec_type(struct hda_codec *codec); |
@@ -237,33 +260,23 @@ static enum VIA_HDA_CODEC get_codec_type(struct hda_codec *codec) | |||
237 | #define VIA_JACK_EVENT 0x20 | 260 | #define VIA_JACK_EVENT 0x20 |
238 | #define VIA_HP_EVENT 0x01 | 261 | #define VIA_HP_EVENT 0x01 |
239 | #define VIA_GPIO_EVENT 0x02 | 262 | #define VIA_GPIO_EVENT 0x02 |
240 | #define VIA_MONO_EVENT 0x03 | 263 | #define VIA_LINE_EVENT 0x03 |
241 | #define VIA_SPEAKER_EVENT 0x04 | ||
242 | #define VIA_BIND_HP_EVENT 0x05 | ||
243 | 264 | ||
244 | enum { | 265 | enum { |
245 | VIA_CTL_WIDGET_VOL, | 266 | VIA_CTL_WIDGET_VOL, |
246 | VIA_CTL_WIDGET_MUTE, | 267 | VIA_CTL_WIDGET_MUTE, |
247 | VIA_CTL_WIDGET_ANALOG_MUTE, | 268 | VIA_CTL_WIDGET_ANALOG_MUTE, |
248 | VIA_CTL_WIDGET_BIND_PIN_MUTE, | ||
249 | }; | ||
250 | |||
251 | enum { | ||
252 | AUTO_SEQ_FRONT = 0, | ||
253 | AUTO_SEQ_SURROUND, | ||
254 | AUTO_SEQ_CENLFE, | ||
255 | AUTO_SEQ_SIDE | ||
256 | }; | 269 | }; |
257 | 270 | ||
258 | static void analog_low_current_mode(struct hda_codec *codec, int stream_idle); | 271 | static void analog_low_current_mode(struct hda_codec *codec); |
259 | static int is_aa_path_mute(struct hda_codec *codec); | 272 | static bool is_aa_path_mute(struct hda_codec *codec); |
260 | 273 | ||
261 | static void vt1708_start_hp_work(struct via_spec *spec) | 274 | static void vt1708_start_hp_work(struct via_spec *spec) |
262 | { | 275 | { |
263 | if (spec->codec_type != VT1708 || spec->autocfg.hp_pins[0] == 0) | 276 | if (spec->codec_type != VT1708 || spec->autocfg.hp_pins[0] == 0) |
264 | return; | 277 | return; |
265 | snd_hda_codec_write(spec->codec, 0x1, 0, 0xf81, | 278 | snd_hda_codec_write(spec->codec, 0x1, 0, 0xf81, |
266 | !spec->vt1708_jack_detectect); | 279 | !spec->vt1708_jack_detect); |
267 | if (!delayed_work_pending(&spec->vt1708_hp_work)) | 280 | if (!delayed_work_pending(&spec->vt1708_hp_work)) |
268 | schedule_delayed_work(&spec->vt1708_hp_work, | 281 | schedule_delayed_work(&spec->vt1708_hp_work, |
269 | msecs_to_jiffies(100)); | 282 | msecs_to_jiffies(100)); |
@@ -277,7 +290,7 @@ static void vt1708_stop_hp_work(struct via_spec *spec) | |||
277 | && !is_aa_path_mute(spec->codec)) | 290 | && !is_aa_path_mute(spec->codec)) |
278 | return; | 291 | return; |
279 | snd_hda_codec_write(spec->codec, 0x1, 0, 0xf81, | 292 | snd_hda_codec_write(spec->codec, 0x1, 0, 0xf81, |
280 | !spec->vt1708_jack_detectect); | 293 | !spec->vt1708_jack_detect); |
281 | cancel_delayed_work_sync(&spec->vt1708_hp_work); | 294 | cancel_delayed_work_sync(&spec->vt1708_hp_work); |
282 | } | 295 | } |
283 | 296 | ||
@@ -295,7 +308,7 @@ static int analog_input_switch_put(struct snd_kcontrol *kcontrol, | |||
295 | struct hda_codec *codec = snd_kcontrol_chip(kcontrol); | 308 | struct hda_codec *codec = snd_kcontrol_chip(kcontrol); |
296 | 309 | ||
297 | set_widgets_power_state(codec); | 310 | set_widgets_power_state(codec); |
298 | analog_low_current_mode(snd_kcontrol_chip(kcontrol), -1); | 311 | analog_low_current_mode(snd_kcontrol_chip(kcontrol)); |
299 | if (snd_hda_get_bool_hint(codec, "analog_loopback_hp_detect") == 1) { | 312 | if (snd_hda_get_bool_hint(codec, "analog_loopback_hp_detect") == 1) { |
300 | if (is_aa_path_mute(codec)) | 313 | if (is_aa_path_mute(codec)) |
301 | vt1708_start_hp_work(codec->spec); | 314 | vt1708_start_hp_work(codec->spec); |
@@ -315,168 +328,44 @@ static int analog_input_switch_put(struct snd_kcontrol *kcontrol, | |||
315 | .put = analog_input_switch_put, \ | 328 | .put = analog_input_switch_put, \ |
316 | .private_value = HDA_COMPOSE_AMP_VAL(0, 3, 0, 0) } | 329 | .private_value = HDA_COMPOSE_AMP_VAL(0, 3, 0, 0) } |
317 | 330 | ||
318 | static void via_hp_bind_automute(struct hda_codec *codec); | ||
319 | |||
320 | static int bind_pin_switch_put(struct snd_kcontrol *kcontrol, | ||
321 | struct snd_ctl_elem_value *ucontrol) | ||
322 | { | ||
323 | struct hda_codec *codec = snd_kcontrol_chip(kcontrol); | ||
324 | struct via_spec *spec = codec->spec; | ||
325 | int i; | ||
326 | int change = 0; | ||
327 | |||
328 | long *valp = ucontrol->value.integer.value; | ||
329 | int lmute, rmute; | ||
330 | if (strstr(kcontrol->id.name, "Switch") == NULL) { | ||
331 | snd_printd("Invalid control!\n"); | ||
332 | return change; | ||
333 | } | ||
334 | change = snd_hda_mixer_amp_switch_put(kcontrol, | ||
335 | ucontrol); | ||
336 | /* Get mute value */ | ||
337 | lmute = *valp ? 0 : HDA_AMP_MUTE; | ||
338 | valp++; | ||
339 | rmute = *valp ? 0 : HDA_AMP_MUTE; | ||
340 | |||
341 | /* Set hp pins */ | ||
342 | if (!spec->hp_independent_mode) { | ||
343 | for (i = 0; i < spec->autocfg.hp_outs; i++) { | ||
344 | snd_hda_codec_amp_update( | ||
345 | codec, spec->autocfg.hp_pins[i], | ||
346 | 0, HDA_OUTPUT, 0, HDA_AMP_MUTE, | ||
347 | lmute); | ||
348 | snd_hda_codec_amp_update( | ||
349 | codec, spec->autocfg.hp_pins[i], | ||
350 | 1, HDA_OUTPUT, 0, HDA_AMP_MUTE, | ||
351 | rmute); | ||
352 | } | ||
353 | } | ||
354 | |||
355 | if (!lmute && !rmute) { | ||
356 | /* Line Outs */ | ||
357 | for (i = 0; i < spec->autocfg.line_outs; i++) | ||
358 | snd_hda_codec_amp_stereo( | ||
359 | codec, spec->autocfg.line_out_pins[i], | ||
360 | HDA_OUTPUT, 0, HDA_AMP_MUTE, 0); | ||
361 | /* Speakers */ | ||
362 | for (i = 0; i < spec->autocfg.speaker_outs; i++) | ||
363 | snd_hda_codec_amp_stereo( | ||
364 | codec, spec->autocfg.speaker_pins[i], | ||
365 | HDA_OUTPUT, 0, HDA_AMP_MUTE, 0); | ||
366 | /* unmute */ | ||
367 | via_hp_bind_automute(codec); | ||
368 | |||
369 | } else { | ||
370 | if (lmute) { | ||
371 | /* Mute all left channels */ | ||
372 | for (i = 1; i < spec->autocfg.line_outs; i++) | ||
373 | snd_hda_codec_amp_update( | ||
374 | codec, | ||
375 | spec->autocfg.line_out_pins[i], | ||
376 | 0, HDA_OUTPUT, 0, HDA_AMP_MUTE, | ||
377 | lmute); | ||
378 | for (i = 0; i < spec->autocfg.speaker_outs; i++) | ||
379 | snd_hda_codec_amp_update( | ||
380 | codec, | ||
381 | spec->autocfg.speaker_pins[i], | ||
382 | 0, HDA_OUTPUT, 0, HDA_AMP_MUTE, | ||
383 | lmute); | ||
384 | } | ||
385 | if (rmute) { | ||
386 | /* mute all right channels */ | ||
387 | for (i = 1; i < spec->autocfg.line_outs; i++) | ||
388 | snd_hda_codec_amp_update( | ||
389 | codec, | ||
390 | spec->autocfg.line_out_pins[i], | ||
391 | 1, HDA_OUTPUT, 0, HDA_AMP_MUTE, | ||
392 | rmute); | ||
393 | for (i = 0; i < spec->autocfg.speaker_outs; i++) | ||
394 | snd_hda_codec_amp_update( | ||
395 | codec, | ||
396 | spec->autocfg.speaker_pins[i], | ||
397 | 1, HDA_OUTPUT, 0, HDA_AMP_MUTE, | ||
398 | rmute); | ||
399 | } | ||
400 | } | ||
401 | return change; | ||
402 | } | ||
403 | |||
404 | #define BIND_PIN_MUTE \ | ||
405 | { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \ | ||
406 | .name = NULL, \ | ||
407 | .index = 0, \ | ||
408 | .info = snd_hda_mixer_amp_switch_info, \ | ||
409 | .get = snd_hda_mixer_amp_switch_get, \ | ||
410 | .put = bind_pin_switch_put, \ | ||
411 | .private_value = HDA_COMPOSE_AMP_VAL(0, 3, 0, 0) } | ||
412 | |||
413 | static const struct snd_kcontrol_new via_control_templates[] = { | 331 | static const struct snd_kcontrol_new via_control_templates[] = { |
414 | HDA_CODEC_VOLUME(NULL, 0, 0, 0), | 332 | HDA_CODEC_VOLUME(NULL, 0, 0, 0), |
415 | HDA_CODEC_MUTE(NULL, 0, 0, 0), | 333 | HDA_CODEC_MUTE(NULL, 0, 0, 0), |
416 | ANALOG_INPUT_MUTE, | 334 | ANALOG_INPUT_MUTE, |
417 | BIND_PIN_MUTE, | ||
418 | }; | ||
419 | |||
420 | static const hda_nid_t vt1708_adc_nids[2] = { | ||
421 | /* ADC1-2 */ | ||
422 | 0x15, 0x27 | ||
423 | }; | ||
424 | |||
425 | static const hda_nid_t vt1709_adc_nids[3] = { | ||
426 | /* ADC1-2 */ | ||
427 | 0x14, 0x15, 0x16 | ||
428 | }; | ||
429 | |||
430 | static const hda_nid_t vt1708B_adc_nids[2] = { | ||
431 | /* ADC1-2 */ | ||
432 | 0x13, 0x14 | ||
433 | }; | 335 | }; |
434 | 336 | ||
435 | static const hda_nid_t vt1708S_adc_nids[2] = { | ||
436 | /* ADC1-2 */ | ||
437 | 0x13, 0x14 | ||
438 | }; | ||
439 | |||
440 | static const hda_nid_t vt1702_adc_nids[3] = { | ||
441 | /* ADC1-2 */ | ||
442 | 0x12, 0x20, 0x1F | ||
443 | }; | ||
444 | |||
445 | static const hda_nid_t vt1718S_adc_nids[2] = { | ||
446 | /* ADC1-2 */ | ||
447 | 0x10, 0x11 | ||
448 | }; | ||
449 | |||
450 | static const hda_nid_t vt1716S_adc_nids[2] = { | ||
451 | /* ADC1-2 */ | ||
452 | 0x13, 0x14 | ||
453 | }; | ||
454 | |||
455 | static const hda_nid_t vt2002P_adc_nids[2] = { | ||
456 | /* ADC1-2 */ | ||
457 | 0x10, 0x11 | ||
458 | }; | ||
459 | 337 | ||
460 | static const hda_nid_t vt1812_adc_nids[2] = { | 338 | /* add dynamic controls */ |
461 | /* ADC1-2 */ | 339 | static struct snd_kcontrol_new *__via_clone_ctl(struct via_spec *spec, |
462 | 0x10, 0x11 | 340 | const struct snd_kcontrol_new *tmpl, |
463 | }; | 341 | const char *name) |
342 | { | ||
343 | struct snd_kcontrol_new *knew; | ||
464 | 344 | ||
345 | snd_array_init(&spec->kctls, sizeof(*knew), 32); | ||
346 | knew = snd_array_new(&spec->kctls); | ||
347 | if (!knew) | ||
348 | return NULL; | ||
349 | *knew = *tmpl; | ||
350 | if (!name) | ||
351 | name = tmpl->name; | ||
352 | if (name) { | ||
353 | knew->name = kstrdup(name, GFP_KERNEL); | ||
354 | if (!knew->name) | ||
355 | return NULL; | ||
356 | } | ||
357 | return knew; | ||
358 | } | ||
465 | 359 | ||
466 | /* add dynamic controls */ | ||
467 | static int __via_add_control(struct via_spec *spec, int type, const char *name, | 360 | static int __via_add_control(struct via_spec *spec, int type, const char *name, |
468 | int idx, unsigned long val) | 361 | int idx, unsigned long val) |
469 | { | 362 | { |
470 | struct snd_kcontrol_new *knew; | 363 | struct snd_kcontrol_new *knew; |
471 | 364 | ||
472 | snd_array_init(&spec->kctls, sizeof(*knew), 32); | 365 | knew = __via_clone_ctl(spec, &via_control_templates[type], name); |
473 | knew = snd_array_new(&spec->kctls); | ||
474 | if (!knew) | 366 | if (!knew) |
475 | return -ENOMEM; | 367 | return -ENOMEM; |
476 | *knew = via_control_templates[type]; | 368 | knew->index = idx; |
477 | knew->name = kstrdup(name, GFP_KERNEL); | ||
478 | if (!knew->name) | ||
479 | return -ENOMEM; | ||
480 | if (get_amp_nid_(val)) | 369 | if (get_amp_nid_(val)) |
481 | knew->subdevice = HDA_SUBDEV_AMP_FLAG; | 370 | knew->subdevice = HDA_SUBDEV_AMP_FLAG; |
482 | knew->private_value = val; | 371 | knew->private_value = val; |
@@ -486,21 +375,7 @@ static int __via_add_control(struct via_spec *spec, int type, const char *name, | |||
486 | #define via_add_control(spec, type, name, val) \ | 375 | #define via_add_control(spec, type, name, val) \ |
487 | __via_add_control(spec, type, name, 0, val) | 376 | __via_add_control(spec, type, name, 0, val) |
488 | 377 | ||
489 | static struct snd_kcontrol_new *via_clone_control(struct via_spec *spec, | 378 | #define via_clone_control(spec, tmpl) __via_clone_ctl(spec, tmpl, NULL) |
490 | const struct snd_kcontrol_new *tmpl) | ||
491 | { | ||
492 | struct snd_kcontrol_new *knew; | ||
493 | |||
494 | snd_array_init(&spec->kctls, sizeof(*knew), 32); | ||
495 | knew = snd_array_new(&spec->kctls); | ||
496 | if (!knew) | ||
497 | return NULL; | ||
498 | *knew = *tmpl; | ||
499 | knew->name = kstrdup(tmpl->name, GFP_KERNEL); | ||
500 | if (!knew->name) | ||
501 | return NULL; | ||
502 | return knew; | ||
503 | } | ||
504 | 379 | ||
505 | static void via_free_kctls(struct hda_codec *codec) | 380 | static void via_free_kctls(struct hda_codec *codec) |
506 | { | 381 | { |
@@ -535,58 +410,189 @@ static int via_new_analog_input(struct via_spec *spec, const char *ctlname, | |||
535 | return 0; | 410 | return 0; |
536 | } | 411 | } |
537 | 412 | ||
538 | static void via_auto_set_output_and_unmute(struct hda_codec *codec, | 413 | /* return the index of the given widget nid as the source of mux; |
539 | hda_nid_t nid, int pin_type, | 414 | * return -1 if not found; |
540 | int dac_idx) | 415 | * if num_conns is non-NULL, set the total number of connections |
416 | */ | ||
417 | static int __get_connection_index(struct hda_codec *codec, hda_nid_t mux, | ||
418 | hda_nid_t nid, int *num_conns) | ||
419 | { | ||
420 | hda_nid_t conn[HDA_MAX_NUM_INPUTS]; | ||
421 | int i, nums; | ||
422 | |||
423 | nums = snd_hda_get_connections(codec, mux, conn, ARRAY_SIZE(conn)); | ||
424 | if (num_conns) | ||
425 | *num_conns = nums; | ||
426 | for (i = 0; i < nums; i++) | ||
427 | if (conn[i] == nid) | ||
428 | return i; | ||
429 | return -1; | ||
430 | } | ||
431 | |||
432 | #define get_connection_index(codec, mux, nid) \ | ||
433 | __get_connection_index(codec, mux, nid, NULL) | ||
434 | |||
435 | static bool check_amp_caps(struct hda_codec *codec, hda_nid_t nid, int dir, | ||
436 | unsigned int mask) | ||
437 | { | ||
438 | unsigned int caps; | ||
439 | if (!nid) | ||
440 | return false; | ||
441 | caps = get_wcaps(codec, nid); | ||
442 | if (dir == HDA_INPUT) | ||
443 | caps &= AC_WCAP_IN_AMP; | ||
444 | else | ||
445 | caps &= AC_WCAP_OUT_AMP; | ||
446 | if (!caps) | ||
447 | return false; | ||
448 | if (query_amp_caps(codec, nid, dir) & mask) | ||
449 | return true; | ||
450 | return false; | ||
451 | } | ||
452 | |||
453 | #define have_mute(codec, nid, dir) \ | ||
454 | check_amp_caps(codec, nid, dir, AC_AMPCAP_MUTE) | ||
455 | |||
456 | /* enable/disable the output-route */ | ||
457 | static void activate_output_path(struct hda_codec *codec, struct nid_path *path, | ||
458 | bool enable, bool force) | ||
541 | { | 459 | { |
542 | /* set as output */ | 460 | int i; |
543 | snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, | 461 | for (i = 0; i < path->depth; i++) { |
462 | hda_nid_t src, dst; | ||
463 | int idx = path->idx[i]; | ||
464 | src = path->path[i]; | ||
465 | if (i < path->depth - 1) | ||
466 | dst = path->path[i + 1]; | ||
467 | else | ||
468 | dst = 0; | ||
469 | if (enable && path->multi[i]) | ||
470 | snd_hda_codec_write(codec, dst, 0, | ||
471 | AC_VERB_SET_CONNECT_SEL, idx); | ||
472 | if (have_mute(codec, dst, HDA_INPUT)) { | ||
473 | int val = enable ? AMP_IN_UNMUTE(idx) : | ||
474 | AMP_IN_MUTE(idx); | ||
475 | snd_hda_codec_write(codec, dst, 0, | ||
476 | AC_VERB_SET_AMP_GAIN_MUTE, val); | ||
477 | } | ||
478 | if (!force && (src == path->vol_ctl || src == path->mute_ctl)) | ||
479 | continue; | ||
480 | if (have_mute(codec, src, HDA_OUTPUT)) { | ||
481 | int val = enable ? AMP_OUT_UNMUTE : AMP_OUT_MUTE; | ||
482 | snd_hda_codec_write(codec, src, 0, | ||
483 | AC_VERB_SET_AMP_GAIN_MUTE, val); | ||
484 | } | ||
485 | } | ||
486 | } | ||
487 | |||
488 | /* set the given pin as output */ | ||
489 | static void init_output_pin(struct hda_codec *codec, hda_nid_t pin, | ||
490 | int pin_type) | ||
491 | { | ||
492 | if (!pin) | ||
493 | return; | ||
494 | snd_hda_codec_write(codec, pin, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, | ||
544 | pin_type); | 495 | pin_type); |
545 | snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE, | 496 | if (snd_hda_query_pin_caps(codec, pin) & AC_PINCAP_EAPD) |
546 | AMP_OUT_UNMUTE); | 497 | snd_hda_codec_write(codec, pin, 0, |
547 | if (snd_hda_query_pin_caps(codec, nid) & AC_PINCAP_EAPD) | ||
548 | snd_hda_codec_write(codec, nid, 0, | ||
549 | AC_VERB_SET_EAPD_BTLENABLE, 0x02); | 498 | AC_VERB_SET_EAPD_BTLENABLE, 0x02); |
550 | } | 499 | } |
551 | 500 | ||
501 | static void via_auto_init_output(struct hda_codec *codec, | ||
502 | struct nid_path *path, int pin_type, | ||
503 | bool force) | ||
504 | { | ||
505 | struct via_spec *spec = codec->spec; | ||
506 | unsigned int caps; | ||
507 | hda_nid_t pin, nid; | ||
508 | int i, idx; | ||
509 | |||
510 | if (!path->depth) | ||
511 | return; | ||
512 | pin = path->path[path->depth - 1]; | ||
513 | |||
514 | init_output_pin(codec, pin, pin_type); | ||
515 | caps = query_amp_caps(codec, pin, HDA_OUTPUT); | ||
516 | if (caps & AC_AMPCAP_MUTE) { | ||
517 | unsigned int val; | ||
518 | val = (caps & AC_AMPCAP_OFFSET) >> AC_AMPCAP_OFFSET_SHIFT; | ||
519 | snd_hda_codec_write(codec, pin, 0, AC_VERB_SET_AMP_GAIN_MUTE, | ||
520 | AMP_OUT_MUTE | val); | ||
521 | } | ||
522 | |||
523 | activate_output_path(codec, path, true, force); | ||
524 | |||
525 | /* initialize the AA-path */ | ||
526 | if (!spec->aa_mix_nid) | ||
527 | return; | ||
528 | for (i = path->depth - 1; i > 0; i--) { | ||
529 | nid = path->path[i]; | ||
530 | idx = get_connection_index(codec, nid, spec->aa_mix_nid); | ||
531 | if (idx >= 0) { | ||
532 | if (have_mute(codec, nid, HDA_INPUT)) | ||
533 | snd_hda_codec_write(codec, nid, 0, | ||
534 | AC_VERB_SET_AMP_GAIN_MUTE, | ||
535 | AMP_IN_UNMUTE(idx)); | ||
536 | break; | ||
537 | } | ||
538 | } | ||
539 | } | ||
552 | 540 | ||
553 | static void via_auto_init_multi_out(struct hda_codec *codec) | 541 | static void via_auto_init_multi_out(struct hda_codec *codec) |
554 | { | 542 | { |
555 | struct via_spec *spec = codec->spec; | 543 | struct via_spec *spec = codec->spec; |
556 | int i; | 544 | int i; |
557 | 545 | ||
558 | for (i = 0; i <= AUTO_SEQ_SIDE; i++) { | 546 | for (i = 0; i < spec->autocfg.line_outs + spec->smart51_nums; i++) |
559 | hda_nid_t nid = spec->autocfg.line_out_pins[i]; | 547 | via_auto_init_output(codec, &spec->out_path[i], PIN_OUT, true); |
560 | if (nid) | ||
561 | via_auto_set_output_and_unmute(codec, nid, PIN_OUT, i); | ||
562 | } | ||
563 | } | 548 | } |
564 | 549 | ||
565 | static void via_auto_init_hp_out(struct hda_codec *codec) | 550 | static void via_auto_init_hp_out(struct hda_codec *codec) |
566 | { | 551 | { |
567 | struct via_spec *spec = codec->spec; | 552 | struct via_spec *spec = codec->spec; |
568 | hda_nid_t pin; | ||
569 | int i; | ||
570 | 553 | ||
571 | for (i = 0; i < spec->autocfg.hp_outs; i++) { | 554 | if (!spec->hp_dac_nid) { |
572 | pin = spec->autocfg.hp_pins[i]; | 555 | via_auto_init_output(codec, &spec->hp_dep_path, PIN_HP, true); |
573 | if (pin) /* connect to front */ | 556 | return; |
574 | via_auto_set_output_and_unmute(codec, pin, PIN_HP, 0); | 557 | } |
558 | if (spec->hp_independent_mode) { | ||
559 | activate_output_path(codec, &spec->hp_dep_path, false, false); | ||
560 | via_auto_init_output(codec, &spec->hp_path, PIN_HP, true); | ||
561 | } else { | ||
562 | activate_output_path(codec, &spec->hp_path, false, false); | ||
563 | via_auto_init_output(codec, &spec->hp_dep_path, PIN_HP, true); | ||
575 | } | 564 | } |
576 | } | 565 | } |
577 | 566 | ||
578 | static int is_smart51_pins(struct via_spec *spec, hda_nid_t pin); | 567 | static void via_auto_init_speaker_out(struct hda_codec *codec) |
568 | { | ||
569 | struct via_spec *spec = codec->spec; | ||
570 | |||
571 | if (spec->autocfg.speaker_outs) | ||
572 | via_auto_init_output(codec, &spec->speaker_path, PIN_OUT, true); | ||
573 | } | ||
574 | |||
575 | static bool is_smart51_pins(struct hda_codec *codec, hda_nid_t pin); | ||
579 | 576 | ||
580 | static void via_auto_init_analog_input(struct hda_codec *codec) | 577 | static void via_auto_init_analog_input(struct hda_codec *codec) |
581 | { | 578 | { |
582 | struct via_spec *spec = codec->spec; | 579 | struct via_spec *spec = codec->spec; |
583 | const struct auto_pin_cfg *cfg = &spec->autocfg; | 580 | const struct auto_pin_cfg *cfg = &spec->autocfg; |
581 | hda_nid_t conn[HDA_MAX_CONNECTIONS]; | ||
584 | unsigned int ctl; | 582 | unsigned int ctl; |
585 | int i; | 583 | int i, num_conns; |
586 | 584 | ||
585 | /* init ADCs */ | ||
586 | for (i = 0; i < spec->num_adc_nids; i++) { | ||
587 | snd_hda_codec_write(codec, spec->adc_nids[i], 0, | ||
588 | AC_VERB_SET_AMP_GAIN_MUTE, | ||
589 | AMP_IN_UNMUTE(0)); | ||
590 | } | ||
591 | |||
592 | /* init pins */ | ||
587 | for (i = 0; i < cfg->num_inputs; i++) { | 593 | for (i = 0; i < cfg->num_inputs; i++) { |
588 | hda_nid_t nid = cfg->inputs[i].pin; | 594 | hda_nid_t nid = cfg->inputs[i].pin; |
589 | if (spec->smart51_enabled && is_smart51_pins(spec, nid)) | 595 | if (spec->smart51_enabled && is_smart51_pins(codec, nid)) |
590 | ctl = PIN_OUT; | 596 | ctl = PIN_OUT; |
591 | else if (cfg->inputs[i].type == AUTO_PIN_MIC) | 597 | else if (cfg->inputs[i].type == AUTO_PIN_MIC) |
592 | ctl = PIN_VREF50; | 598 | ctl = PIN_VREF50; |
@@ -595,6 +601,32 @@ static void via_auto_init_analog_input(struct hda_codec *codec) | |||
595 | snd_hda_codec_write(codec, nid, 0, | 601 | snd_hda_codec_write(codec, nid, 0, |
596 | AC_VERB_SET_PIN_WIDGET_CONTROL, ctl); | 602 | AC_VERB_SET_PIN_WIDGET_CONTROL, ctl); |
597 | } | 603 | } |
604 | |||
605 | /* init input-src */ | ||
606 | for (i = 0; i < spec->num_adc_nids; i++) { | ||
607 | int adc_idx = spec->inputs[spec->cur_mux[i]].adc_idx; | ||
608 | if (spec->mux_nids[adc_idx]) { | ||
609 | int mux_idx = spec->inputs[spec->cur_mux[i]].mux_idx; | ||
610 | snd_hda_codec_write(codec, spec->mux_nids[adc_idx], 0, | ||
611 | AC_VERB_SET_CONNECT_SEL, | ||
612 | mux_idx); | ||
613 | } | ||
614 | if (spec->dyn_adc_switch) | ||
615 | break; /* only one input-src */ | ||
616 | } | ||
617 | |||
618 | /* init aa-mixer */ | ||
619 | if (!spec->aa_mix_nid) | ||
620 | return; | ||
621 | num_conns = snd_hda_get_connections(codec, spec->aa_mix_nid, conn, | ||
622 | ARRAY_SIZE(conn)); | ||
623 | for (i = 0; i < num_conns; i++) { | ||
624 | unsigned int caps = get_wcaps(codec, conn[i]); | ||
625 | if (get_wcaps_type(caps) == AC_WID_PIN) | ||
626 | snd_hda_codec_write(codec, spec->aa_mix_nid, 0, | ||
627 | AC_VERB_SET_AMP_GAIN_MUTE, | ||
628 | AMP_IN_MUTE(i)); | ||
629 | } | ||
598 | } | 630 | } |
599 | 631 | ||
600 | static void set_pin_power_state(struct hda_codec *codec, hda_nid_t nid, | 632 | static void set_pin_power_state(struct hda_codec *codec, hda_nid_t nid, |
@@ -605,9 +637,13 @@ static void set_pin_power_state(struct hda_codec *codec, hda_nid_t nid, | |||
605 | unsigned no_presence = (def_conf & AC_DEFCFG_MISC) | 637 | unsigned no_presence = (def_conf & AC_DEFCFG_MISC) |
606 | >> AC_DEFCFG_MISC_SHIFT | 638 | >> AC_DEFCFG_MISC_SHIFT |
607 | & AC_DEFCFG_MISC_NO_PRESENCE; /* do not support pin sense */ | 639 | & AC_DEFCFG_MISC_NO_PRESENCE; /* do not support pin sense */ |
608 | unsigned present = snd_hda_jack_detect(codec, nid); | ||
609 | struct via_spec *spec = codec->spec; | 640 | struct via_spec *spec = codec->spec; |
610 | if ((spec->smart51_enabled && is_smart51_pins(spec, nid)) | 641 | unsigned present = 0; |
642 | |||
643 | no_presence |= spec->no_pin_power_ctl; | ||
644 | if (!no_presence) | ||
645 | present = snd_hda_jack_detect(codec, nid); | ||
646 | if ((spec->smart51_enabled && is_smart51_pins(codec, nid)) | ||
611 | || ((no_presence || present) | 647 | || ((no_presence || present) |
612 | && get_defcfg_connect(def_conf) != AC_JACK_PORT_NONE)) { | 648 | && get_defcfg_connect(def_conf) != AC_JACK_PORT_NONE)) { |
613 | *affected_parm = AC_PWRST_D0; /* if it's connected */ | 649 | *affected_parm = AC_PWRST_D0; /* if it's connected */ |
@@ -618,123 +654,77 @@ static void set_pin_power_state(struct hda_codec *codec, hda_nid_t nid, | |||
618 | snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_POWER_STATE, parm); | 654 | snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_POWER_STATE, parm); |
619 | } | 655 | } |
620 | 656 | ||
621 | /* | 657 | static int via_pin_power_ctl_info(struct snd_kcontrol *kcontrol, |
622 | * input MUX handling | 658 | struct snd_ctl_elem_info *uinfo) |
623 | */ | ||
624 | static int via_mux_enum_info(struct snd_kcontrol *kcontrol, | ||
625 | struct snd_ctl_elem_info *uinfo) | ||
626 | { | 659 | { |
627 | struct hda_codec *codec = snd_kcontrol_chip(kcontrol); | 660 | static const char * const texts[] = { |
628 | struct via_spec *spec = codec->spec; | 661 | "Disabled", "Enabled" |
629 | return snd_hda_input_mux_info(spec->input_mux, uinfo); | 662 | }; |
663 | |||
664 | uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED; | ||
665 | uinfo->count = 1; | ||
666 | uinfo->value.enumerated.items = 2; | ||
667 | if (uinfo->value.enumerated.item >= uinfo->value.enumerated.items) | ||
668 | uinfo->value.enumerated.item = uinfo->value.enumerated.items - 1; | ||
669 | strcpy(uinfo->value.enumerated.name, | ||
670 | texts[uinfo->value.enumerated.item]); | ||
671 | return 0; | ||
630 | } | 672 | } |
631 | 673 | ||
632 | static int via_mux_enum_get(struct snd_kcontrol *kcontrol, | 674 | static int via_pin_power_ctl_get(struct snd_kcontrol *kcontrol, |
633 | struct snd_ctl_elem_value *ucontrol) | 675 | struct snd_ctl_elem_value *ucontrol) |
634 | { | 676 | { |
635 | struct hda_codec *codec = snd_kcontrol_chip(kcontrol); | 677 | struct hda_codec *codec = snd_kcontrol_chip(kcontrol); |
636 | struct via_spec *spec = codec->spec; | 678 | struct via_spec *spec = codec->spec; |
637 | unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id); | 679 | ucontrol->value.enumerated.item[0] = !spec->no_pin_power_ctl; |
638 | |||
639 | ucontrol->value.enumerated.item[0] = spec->cur_mux[adc_idx]; | ||
640 | return 0; | 680 | return 0; |
641 | } | 681 | } |
642 | 682 | ||
643 | static int via_mux_enum_put(struct snd_kcontrol *kcontrol, | 683 | static int via_pin_power_ctl_put(struct snd_kcontrol *kcontrol, |
644 | struct snd_ctl_elem_value *ucontrol) | 684 | struct snd_ctl_elem_value *ucontrol) |
645 | { | 685 | { |
646 | struct hda_codec *codec = snd_kcontrol_chip(kcontrol); | 686 | struct hda_codec *codec = snd_kcontrol_chip(kcontrol); |
647 | struct via_spec *spec = codec->spec; | 687 | struct via_spec *spec = codec->spec; |
648 | unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id); | 688 | unsigned int val = !ucontrol->value.enumerated.item[0]; |
649 | int ret; | ||
650 | 689 | ||
651 | if (!spec->mux_nids[adc_idx]) | 690 | if (val == spec->no_pin_power_ctl) |
652 | return -EINVAL; | 691 | return 0; |
653 | /* switch to D0 beofre change index */ | 692 | spec->no_pin_power_ctl = val; |
654 | if (snd_hda_codec_read(codec, spec->mux_nids[adc_idx], 0, | ||
655 | AC_VERB_GET_POWER_STATE, 0x00) != AC_PWRST_D0) | ||
656 | snd_hda_codec_write(codec, spec->mux_nids[adc_idx], 0, | ||
657 | AC_VERB_SET_POWER_STATE, AC_PWRST_D0); | ||
658 | |||
659 | ret = snd_hda_input_mux_put(codec, spec->input_mux, ucontrol, | ||
660 | spec->mux_nids[adc_idx], | ||
661 | &spec->cur_mux[adc_idx]); | ||
662 | /* update jack power state */ | ||
663 | set_widgets_power_state(codec); | 693 | set_widgets_power_state(codec); |
664 | 694 | return 1; | |
665 | return ret; | ||
666 | } | 695 | } |
667 | 696 | ||
697 | static const struct snd_kcontrol_new via_pin_power_ctl_enum = { | ||
698 | .iface = SNDRV_CTL_ELEM_IFACE_MIXER, | ||
699 | .name = "Dynamic Power-Control", | ||
700 | .info = via_pin_power_ctl_info, | ||
701 | .get = via_pin_power_ctl_get, | ||
702 | .put = via_pin_power_ctl_put, | ||
703 | }; | ||
704 | |||
705 | |||
668 | static int via_independent_hp_info(struct snd_kcontrol *kcontrol, | 706 | static int via_independent_hp_info(struct snd_kcontrol *kcontrol, |
669 | struct snd_ctl_elem_info *uinfo) | 707 | struct snd_ctl_elem_info *uinfo) |
670 | { | 708 | { |
671 | struct hda_codec *codec = snd_kcontrol_chip(kcontrol); | 709 | static const char * const texts[] = { "OFF", "ON" }; |
672 | struct via_spec *spec = codec->spec; | 710 | |
673 | return snd_hda_input_mux_info(spec->hp_mux, uinfo); | 711 | uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED; |
712 | uinfo->count = 1; | ||
713 | uinfo->value.enumerated.items = 2; | ||
714 | if (uinfo->value.enumerated.item >= 2) | ||
715 | uinfo->value.enumerated.item = 1; | ||
716 | strcpy(uinfo->value.enumerated.name, | ||
717 | texts[uinfo->value.enumerated.item]); | ||
718 | return 0; | ||
674 | } | 719 | } |
675 | 720 | ||
676 | static int via_independent_hp_get(struct snd_kcontrol *kcontrol, | 721 | static int via_independent_hp_get(struct snd_kcontrol *kcontrol, |
677 | struct snd_ctl_elem_value *ucontrol) | 722 | struct snd_ctl_elem_value *ucontrol) |
678 | { | 723 | { |
679 | struct hda_codec *codec = snd_kcontrol_chip(kcontrol); | 724 | struct hda_codec *codec = snd_kcontrol_chip(kcontrol); |
680 | hda_nid_t nid = kcontrol->private_value; | ||
681 | unsigned int pinsel; | ||
682 | |||
683 | /* use !! to translate conn sel 2 for VT1718S */ | ||
684 | pinsel = !!snd_hda_codec_read(codec, nid, 0, | ||
685 | AC_VERB_GET_CONNECT_SEL, | ||
686 | 0x00); | ||
687 | ucontrol->value.enumerated.item[0] = pinsel; | ||
688 | |||
689 | return 0; | ||
690 | } | ||
691 | |||
692 | static void activate_ctl(struct hda_codec *codec, const char *name, int active) | ||
693 | { | ||
694 | struct snd_kcontrol *ctl = snd_hda_find_mixer_ctl(codec, name); | ||
695 | if (ctl) { | ||
696 | ctl->vd[0].access &= ~SNDRV_CTL_ELEM_ACCESS_INACTIVE; | ||
697 | ctl->vd[0].access |= active | ||
698 | ? 0 : SNDRV_CTL_ELEM_ACCESS_INACTIVE; | ||
699 | snd_ctl_notify(codec->bus->card, | ||
700 | SNDRV_CTL_EVENT_MASK_VALUE, &ctl->id); | ||
701 | } | ||
702 | } | ||
703 | |||
704 | static hda_nid_t side_mute_channel(struct via_spec *spec) | ||
705 | { | ||
706 | switch (spec->codec_type) { | ||
707 | case VT1708: return 0x1b; | ||
708 | case VT1709_10CH: return 0x29; | ||
709 | case VT1708B_8CH: /* fall thru */ | ||
710 | case VT1708S: return 0x27; | ||
711 | case VT2002P: return 0x19; | ||
712 | case VT1802: return 0x15; | ||
713 | case VT1812: return 0x15; | ||
714 | default: return 0; | ||
715 | } | ||
716 | } | ||
717 | |||
718 | static int update_side_mute_status(struct hda_codec *codec) | ||
719 | { | ||
720 | /* mute side channel */ | ||
721 | struct via_spec *spec = codec->spec; | 725 | struct via_spec *spec = codec->spec; |
722 | unsigned int parm; | ||
723 | hda_nid_t sw3 = side_mute_channel(spec); | ||
724 | 726 | ||
725 | if (sw3) { | 727 | ucontrol->value.enumerated.item[0] = spec->hp_independent_mode; |
726 | if (VT2002P_COMPATIBLE(spec)) | ||
727 | parm = spec->hp_independent_mode ? | ||
728 | AMP_IN_MUTE(1) : AMP_IN_UNMUTE(1); | ||
729 | else | ||
730 | parm = spec->hp_independent_mode ? | ||
731 | AMP_OUT_MUTE : AMP_OUT_UNMUTE; | ||
732 | snd_hda_codec_write(codec, sw3, 0, | ||
733 | AC_VERB_SET_AMP_GAIN_MUTE, parm); | ||
734 | if (spec->codec_type == VT1812) | ||
735 | snd_hda_codec_write(codec, 0x1d, 0, | ||
736 | AC_VERB_SET_AMP_GAIN_MUTE, parm); | ||
737 | } | ||
738 | return 0; | 728 | return 0; |
739 | } | 729 | } |
740 | 730 | ||
@@ -743,66 +733,27 @@ static int via_independent_hp_put(struct snd_kcontrol *kcontrol, | |||
743 | { | 733 | { |
744 | struct hda_codec *codec = snd_kcontrol_chip(kcontrol); | 734 | struct hda_codec *codec = snd_kcontrol_chip(kcontrol); |
745 | struct via_spec *spec = codec->spec; | 735 | struct via_spec *spec = codec->spec; |
746 | hda_nid_t nid = kcontrol->private_value; | ||
747 | unsigned int pinsel = ucontrol->value.enumerated.item[0]; | ||
748 | unsigned int parm0, parm1; | ||
749 | /* Get Independent Mode index of headphone pin widget */ | ||
750 | spec->hp_independent_mode = spec->hp_independent_mode_index == pinsel | ||
751 | ? 1 : 0; | ||
752 | if (spec->codec_type == VT1718S) { | ||
753 | snd_hda_codec_write(codec, nid, 0, | ||
754 | AC_VERB_SET_CONNECT_SEL, pinsel ? 2 : 0); | ||
755 | /* Set correct mute switch for MW3 */ | ||
756 | parm0 = spec->hp_independent_mode ? | ||
757 | AMP_IN_UNMUTE(0) : AMP_IN_MUTE(0); | ||
758 | parm1 = spec->hp_independent_mode ? | ||
759 | AMP_IN_MUTE(1) : AMP_IN_UNMUTE(1); | ||
760 | snd_hda_codec_write(codec, 0x1b, 0, | ||
761 | AC_VERB_SET_AMP_GAIN_MUTE, parm0); | ||
762 | snd_hda_codec_write(codec, 0x1b, 0, | ||
763 | AC_VERB_SET_AMP_GAIN_MUTE, parm1); | ||
764 | } | ||
765 | else | ||
766 | snd_hda_codec_write(codec, nid, 0, | ||
767 | AC_VERB_SET_CONNECT_SEL, pinsel); | ||
768 | 736 | ||
769 | if (spec->codec_type == VT1812) | 737 | spec->hp_independent_mode = !!ucontrol->value.enumerated.item[0]; |
770 | snd_hda_codec_write(codec, 0x35, 0, | 738 | if (spec->hp_independent_mode) { |
771 | AC_VERB_SET_CONNECT_SEL, pinsel); | 739 | activate_output_path(codec, &spec->hp_dep_path, false, false); |
772 | if (spec->multiout.hp_nid && spec->multiout.hp_nid | 740 | activate_output_path(codec, &spec->hp_path, true, false); |
773 | != spec->multiout.dac_nids[HDA_FRONT]) | 741 | } else { |
774 | snd_hda_codec_setup_stream(codec, spec->multiout.hp_nid, | 742 | activate_output_path(codec, &spec->hp_path, false, false); |
775 | 0, 0, 0); | 743 | activate_output_path(codec, &spec->hp_dep_path, true, false); |
776 | |||
777 | update_side_mute_status(codec); | ||
778 | /* update HP volume/swtich active state */ | ||
779 | if (spec->codec_type == VT1708S | ||
780 | || spec->codec_type == VT1702 | ||
781 | || spec->codec_type == VT1718S | ||
782 | || spec->codec_type == VT1716S | ||
783 | || VT2002P_COMPATIBLE(spec)) { | ||
784 | activate_ctl(codec, "Headphone Playback Volume", | ||
785 | spec->hp_independent_mode); | ||
786 | activate_ctl(codec, "Headphone Playback Switch", | ||
787 | spec->hp_independent_mode); | ||
788 | } | 744 | } |
745 | |||
789 | /* update jack power state */ | 746 | /* update jack power state */ |
790 | set_widgets_power_state(codec); | 747 | set_widgets_power_state(codec); |
791 | return 0; | 748 | return 0; |
792 | } | 749 | } |
793 | 750 | ||
794 | static const struct snd_kcontrol_new via_hp_mixer[2] = { | 751 | static const struct snd_kcontrol_new via_hp_mixer = { |
795 | { | 752 | .iface = SNDRV_CTL_ELEM_IFACE_MIXER, |
796 | .iface = SNDRV_CTL_ELEM_IFACE_MIXER, | 753 | .name = "Independent HP", |
797 | .name = "Independent HP", | 754 | .info = via_independent_hp_info, |
798 | .info = via_independent_hp_info, | 755 | .get = via_independent_hp_get, |
799 | .get = via_independent_hp_get, | 756 | .put = via_independent_hp_put, |
800 | .put = via_independent_hp_put, | ||
801 | }, | ||
802 | { | ||
803 | .iface = NID_MAPPING, | ||
804 | .name = "Independent HP", | ||
805 | }, | ||
806 | }; | 757 | }; |
807 | 758 | ||
808 | static int via_hp_build(struct hda_codec *codec) | 759 | static int via_hp_build(struct hda_codec *codec) |
@@ -810,61 +761,28 @@ static int via_hp_build(struct hda_codec *codec) | |||
810 | struct via_spec *spec = codec->spec; | 761 | struct via_spec *spec = codec->spec; |
811 | struct snd_kcontrol_new *knew; | 762 | struct snd_kcontrol_new *knew; |
812 | hda_nid_t nid; | 763 | hda_nid_t nid; |
813 | int nums; | ||
814 | hda_nid_t conn[HDA_MAX_CONNECTIONS]; | ||
815 | |||
816 | switch (spec->codec_type) { | ||
817 | case VT1718S: | ||
818 | nid = 0x34; | ||
819 | break; | ||
820 | case VT2002P: | ||
821 | case VT1802: | ||
822 | nid = 0x35; | ||
823 | break; | ||
824 | case VT1812: | ||
825 | nid = 0x3d; | ||
826 | break; | ||
827 | default: | ||
828 | nid = spec->autocfg.hp_pins[0]; | ||
829 | break; | ||
830 | } | ||
831 | 764 | ||
832 | if (spec->codec_type != VT1708) { | 765 | nid = spec->autocfg.hp_pins[0]; |
833 | nums = snd_hda_get_connections(codec, nid, | 766 | knew = via_clone_control(spec, &via_hp_mixer); |
834 | conn, HDA_MAX_CONNECTIONS); | ||
835 | if (nums <= 1) | ||
836 | return 0; | ||
837 | } | ||
838 | |||
839 | knew = via_clone_control(spec, &via_hp_mixer[0]); | ||
840 | if (knew == NULL) | 767 | if (knew == NULL) |
841 | return -ENOMEM; | 768 | return -ENOMEM; |
842 | 769 | ||
843 | knew->subdevice = HDA_SUBDEV_NID_FLAG | nid; | 770 | knew->subdevice = HDA_SUBDEV_NID_FLAG | nid; |
844 | knew->private_value = nid; | ||
845 | |||
846 | nid = side_mute_channel(spec); | ||
847 | if (nid) { | ||
848 | knew = via_clone_control(spec, &via_hp_mixer[1]); | ||
849 | if (knew == NULL) | ||
850 | return -ENOMEM; | ||
851 | knew->subdevice = nid; | ||
852 | } | ||
853 | 771 | ||
854 | return 0; | 772 | return 0; |
855 | } | 773 | } |
856 | 774 | ||
857 | static void notify_aa_path_ctls(struct hda_codec *codec) | 775 | static void notify_aa_path_ctls(struct hda_codec *codec) |
858 | { | 776 | { |
777 | struct via_spec *spec = codec->spec; | ||
859 | int i; | 778 | int i; |
860 | struct snd_ctl_elem_id id; | 779 | |
861 | const char *labels[] = {"Mic", "Front Mic", "Line", "Rear Mic"}; | 780 | for (i = 0; i < spec->smart51_nums; i++) { |
862 | struct snd_kcontrol *ctl; | 781 | struct snd_kcontrol *ctl; |
863 | 782 | struct snd_ctl_elem_id id; | |
864 | memset(&id, 0, sizeof(id)); | 783 | memset(&id, 0, sizeof(id)); |
865 | id.iface = SNDRV_CTL_ELEM_IFACE_MIXER; | 784 | id.iface = SNDRV_CTL_ELEM_IFACE_MIXER; |
866 | for (i = 0; i < ARRAY_SIZE(labels); i++) { | 785 | sprintf(id.name, "%s Playback Volume", spec->smart51_labels[i]); |
867 | sprintf(id.name, "%s Playback Volume", labels[i]); | ||
868 | ctl = snd_hda_find_mixer_ctl(codec, id.name); | 786 | ctl = snd_hda_find_mixer_ctl(codec, id.name); |
869 | if (ctl) | 787 | if (ctl) |
870 | snd_ctl_notify(codec->bus->card, | 788 | snd_ctl_notify(codec->bus->card, |
@@ -876,66 +794,28 @@ static void notify_aa_path_ctls(struct hda_codec *codec) | |||
876 | static void mute_aa_path(struct hda_codec *codec, int mute) | 794 | static void mute_aa_path(struct hda_codec *codec, int mute) |
877 | { | 795 | { |
878 | struct via_spec *spec = codec->spec; | 796 | struct via_spec *spec = codec->spec; |
879 | hda_nid_t nid_mixer; | 797 | int val = mute ? HDA_AMP_MUTE : HDA_AMP_UNMUTE; |
880 | int start_idx; | ||
881 | int end_idx; | ||
882 | int i; | 798 | int i; |
883 | /* get nid of MW0 and start & end index */ | 799 | |
884 | switch (spec->codec_type) { | ||
885 | case VT1708: | ||
886 | nid_mixer = 0x17; | ||
887 | start_idx = 2; | ||
888 | end_idx = 4; | ||
889 | break; | ||
890 | case VT1709_10CH: | ||
891 | case VT1709_6CH: | ||
892 | nid_mixer = 0x18; | ||
893 | start_idx = 2; | ||
894 | end_idx = 4; | ||
895 | break; | ||
896 | case VT1708B_8CH: | ||
897 | case VT1708B_4CH: | ||
898 | case VT1708S: | ||
899 | case VT1716S: | ||
900 | nid_mixer = 0x16; | ||
901 | start_idx = 2; | ||
902 | end_idx = 4; | ||
903 | break; | ||
904 | case VT1718S: | ||
905 | nid_mixer = 0x21; | ||
906 | start_idx = 1; | ||
907 | end_idx = 3; | ||
908 | break; | ||
909 | default: | ||
910 | return; | ||
911 | } | ||
912 | /* check AA path's mute status */ | 800 | /* check AA path's mute status */ |
913 | for (i = start_idx; i <= end_idx; i++) { | 801 | for (i = 0; i < spec->smart51_nums; i++) { |
914 | int val = mute ? HDA_AMP_MUTE : HDA_AMP_UNMUTE; | 802 | if (spec->smart51_idxs[i] < 0) |
915 | snd_hda_codec_amp_stereo(codec, nid_mixer, HDA_INPUT, i, | 803 | continue; |
804 | snd_hda_codec_amp_stereo(codec, spec->aa_mix_nid, | ||
805 | HDA_INPUT, spec->smart51_idxs[i], | ||
916 | HDA_AMP_MUTE, val); | 806 | HDA_AMP_MUTE, val); |
917 | } | 807 | } |
918 | } | 808 | } |
919 | static int is_smart51_pins(struct via_spec *spec, hda_nid_t pin) | 809 | |
810 | static bool is_smart51_pins(struct hda_codec *codec, hda_nid_t pin) | ||
920 | { | 811 | { |
921 | const struct auto_pin_cfg *cfg = &spec->autocfg; | 812 | struct via_spec *spec = codec->spec; |
922 | int i; | 813 | int i; |
923 | 814 | ||
924 | for (i = 0; i < cfg->num_inputs; i++) { | 815 | for (i = 0; i < spec->smart51_nums; i++) |
925 | if (pin == cfg->inputs[i].pin) | 816 | if (spec->smart51_pins[i] == pin) |
926 | return cfg->inputs[i].type <= AUTO_PIN_LINE_IN; | 817 | return true; |
927 | } | 818 | return false; |
928 | return 0; | ||
929 | } | ||
930 | |||
931 | static int via_smart51_info(struct snd_kcontrol *kcontrol, | ||
932 | struct snd_ctl_elem_info *uinfo) | ||
933 | { | ||
934 | uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN; | ||
935 | uinfo->count = 1; | ||
936 | uinfo->value.integer.min = 0; | ||
937 | uinfo->value.integer.max = 1; | ||
938 | return 0; | ||
939 | } | 819 | } |
940 | 820 | ||
941 | static int via_smart51_get(struct snd_kcontrol *kcontrol, | 821 | static int via_smart51_get(struct snd_kcontrol *kcontrol, |
@@ -943,23 +823,8 @@ static int via_smart51_get(struct snd_kcontrol *kcontrol, | |||
943 | { | 823 | { |
944 | struct hda_codec *codec = snd_kcontrol_chip(kcontrol); | 824 | struct hda_codec *codec = snd_kcontrol_chip(kcontrol); |
945 | struct via_spec *spec = codec->spec; | 825 | struct via_spec *spec = codec->spec; |
946 | const struct auto_pin_cfg *cfg = &spec->autocfg; | ||
947 | int on = 1; | ||
948 | int i; | ||
949 | 826 | ||
950 | for (i = 0; i < cfg->num_inputs; i++) { | 827 | *ucontrol->value.integer.value = spec->smart51_enabled; |
951 | hda_nid_t nid = cfg->inputs[i].pin; | ||
952 | int ctl = snd_hda_codec_read(codec, nid, 0, | ||
953 | AC_VERB_GET_PIN_WIDGET_CONTROL, 0); | ||
954 | if (cfg->inputs[i].type > AUTO_PIN_LINE_IN) | ||
955 | continue; | ||
956 | if (cfg->inputs[i].type == AUTO_PIN_MIC && | ||
957 | spec->hp_independent_mode && spec->codec_type != VT1718S) | ||
958 | continue; /* ignore FMic for independent HP */ | ||
959 | if ((ctl & AC_PINCTL_IN_EN) && !(ctl & AC_PINCTL_OUT_EN)) | ||
960 | on = 0; | ||
961 | } | ||
962 | *ucontrol->value.integer.value = on; | ||
963 | return 0; | 828 | return 0; |
964 | } | 829 | } |
965 | 830 | ||
@@ -968,21 +833,14 @@ static int via_smart51_put(struct snd_kcontrol *kcontrol, | |||
968 | { | 833 | { |
969 | struct hda_codec *codec = snd_kcontrol_chip(kcontrol); | 834 | struct hda_codec *codec = snd_kcontrol_chip(kcontrol); |
970 | struct via_spec *spec = codec->spec; | 835 | struct via_spec *spec = codec->spec; |
971 | const struct auto_pin_cfg *cfg = &spec->autocfg; | ||
972 | int out_in = *ucontrol->value.integer.value | 836 | int out_in = *ucontrol->value.integer.value |
973 | ? AC_PINCTL_OUT_EN : AC_PINCTL_IN_EN; | 837 | ? AC_PINCTL_OUT_EN : AC_PINCTL_IN_EN; |
974 | int i; | 838 | int i; |
975 | 839 | ||
976 | for (i = 0; i < cfg->num_inputs; i++) { | 840 | for (i = 0; i < spec->smart51_nums; i++) { |
977 | hda_nid_t nid = cfg->inputs[i].pin; | 841 | hda_nid_t nid = spec->smart51_pins[i]; |
978 | unsigned int parm; | 842 | unsigned int parm; |
979 | 843 | ||
980 | if (cfg->inputs[i].type > AUTO_PIN_LINE_IN) | ||
981 | continue; | ||
982 | if (cfg->inputs[i].type == AUTO_PIN_MIC && | ||
983 | spec->hp_independent_mode && spec->codec_type != VT1718S) | ||
984 | continue; /* don't retask FMic for independent HP */ | ||
985 | |||
986 | parm = snd_hda_codec_read(codec, nid, 0, | 844 | parm = snd_hda_codec_read(codec, nid, 0, |
987 | AC_VERB_GET_PIN_WIDGET_CONTROL, 0); | 845 | AC_VERB_GET_PIN_WIDGET_CONTROL, 0); |
988 | parm &= ~(AC_PINCTL_IN_EN | AC_PINCTL_OUT_EN); | 846 | parm &= ~(AC_PINCTL_IN_EN | AC_PINCTL_OUT_EN); |
@@ -994,23 +852,6 @@ static int via_smart51_put(struct snd_kcontrol *kcontrol, | |||
994 | mute_aa_path(codec, 1); | 852 | mute_aa_path(codec, 1); |
995 | notify_aa_path_ctls(codec); | 853 | notify_aa_path_ctls(codec); |
996 | } | 854 | } |
997 | if (spec->codec_type == VT1718S) { | ||
998 | snd_hda_codec_amp_stereo( | ||
999 | codec, nid, HDA_OUTPUT, 0, HDA_AMP_MUTE, | ||
1000 | HDA_AMP_UNMUTE); | ||
1001 | } | ||
1002 | if (cfg->inputs[i].type == AUTO_PIN_MIC) { | ||
1003 | if (spec->codec_type == VT1708S | ||
1004 | || spec->codec_type == VT1716S) { | ||
1005 | /* input = index 1 (AOW3) */ | ||
1006 | snd_hda_codec_write( | ||
1007 | codec, nid, 0, | ||
1008 | AC_VERB_SET_CONNECT_SEL, 1); | ||
1009 | snd_hda_codec_amp_stereo( | ||
1010 | codec, nid, HDA_OUTPUT, | ||
1011 | 0, HDA_AMP_MUTE, HDA_AMP_UNMUTE); | ||
1012 | } | ||
1013 | } | ||
1014 | } | 855 | } |
1015 | spec->smart51_enabled = *ucontrol->value.integer.value; | 856 | spec->smart51_enabled = *ucontrol->value.integer.value; |
1016 | set_widgets_power_state(codec); | 857 | set_widgets_power_state(codec); |
@@ -1021,135 +862,49 @@ static const struct snd_kcontrol_new via_smart51_mixer = { | |||
1021 | .iface = SNDRV_CTL_ELEM_IFACE_MIXER, | 862 | .iface = SNDRV_CTL_ELEM_IFACE_MIXER, |
1022 | .name = "Smart 5.1", | 863 | .name = "Smart 5.1", |
1023 | .count = 1, | 864 | .count = 1, |
1024 | .info = via_smart51_info, | 865 | .info = snd_ctl_boolean_mono_info, |
1025 | .get = via_smart51_get, | 866 | .get = via_smart51_get, |
1026 | .put = via_smart51_put, | 867 | .put = via_smart51_put, |
1027 | }; | 868 | }; |
1028 | 869 | ||
1029 | static int via_smart51_build(struct via_spec *spec) | 870 | static int via_smart51_build(struct hda_codec *codec) |
1030 | { | 871 | { |
1031 | struct snd_kcontrol_new *knew; | 872 | struct via_spec *spec = codec->spec; |
1032 | const struct auto_pin_cfg *cfg = &spec->autocfg; | ||
1033 | hda_nid_t nid; | ||
1034 | int i; | ||
1035 | 873 | ||
1036 | if (!cfg) | 874 | if (!spec->smart51_nums) |
1037 | return 0; | ||
1038 | if (cfg->line_outs > 2) | ||
1039 | return 0; | 875 | return 0; |
1040 | 876 | if (!via_clone_control(spec, &via_smart51_mixer)) | |
1041 | knew = via_clone_control(spec, &via_smart51_mixer); | ||
1042 | if (knew == NULL) | ||
1043 | return -ENOMEM; | 877 | return -ENOMEM; |
1044 | |||
1045 | for (i = 0; i < cfg->num_inputs; i++) { | ||
1046 | nid = cfg->inputs[i].pin; | ||
1047 | if (cfg->inputs[i].type <= AUTO_PIN_LINE_IN) { | ||
1048 | knew->subdevice = HDA_SUBDEV_NID_FLAG | nid; | ||
1049 | break; | ||
1050 | } | ||
1051 | } | ||
1052 | |||
1053 | return 0; | 878 | return 0; |
1054 | } | 879 | } |
1055 | 880 | ||
1056 | /* capture mixer elements */ | 881 | /* check AA path's mute status */ |
1057 | static const struct snd_kcontrol_new vt1708_capture_mixer[] = { | 882 | static bool is_aa_path_mute(struct hda_codec *codec) |
1058 | HDA_CODEC_VOLUME("Capture Volume", 0x15, 0x0, HDA_INPUT), | ||
1059 | HDA_CODEC_MUTE("Capture Switch", 0x15, 0x0, HDA_INPUT), | ||
1060 | HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x27, 0x0, HDA_INPUT), | ||
1061 | HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x27, 0x0, HDA_INPUT), | ||
1062 | { | ||
1063 | .iface = SNDRV_CTL_ELEM_IFACE_MIXER, | ||
1064 | /* The multiple "Capture Source" controls confuse alsamixer | ||
1065 | * So call somewhat different.. | ||
1066 | */ | ||
1067 | /* .name = "Capture Source", */ | ||
1068 | .name = "Input Source", | ||
1069 | .count = 1, | ||
1070 | .info = via_mux_enum_info, | ||
1071 | .get = via_mux_enum_get, | ||
1072 | .put = via_mux_enum_put, | ||
1073 | }, | ||
1074 | { } /* end */ | ||
1075 | }; | ||
1076 | |||
1077 | /* check AA path's mute statue */ | ||
1078 | static int is_aa_path_mute(struct hda_codec *codec) | ||
1079 | { | 883 | { |
1080 | int mute = 1; | ||
1081 | hda_nid_t nid_mixer; | ||
1082 | int start_idx; | ||
1083 | int end_idx; | ||
1084 | int i; | ||
1085 | struct via_spec *spec = codec->spec; | 884 | struct via_spec *spec = codec->spec; |
1086 | /* get nid of MW0 and start & end index */ | 885 | const struct hda_amp_list *p; |
1087 | switch (spec->codec_type) { | 886 | int i, ch, v; |
1088 | case VT1708B_8CH: | 887 | |
1089 | case VT1708B_4CH: | 888 | for (i = 0; i < spec->num_loopbacks; i++) { |
1090 | case VT1708S: | 889 | p = &spec->loopback_list[i]; |
1091 | case VT1716S: | 890 | for (ch = 0; ch < 2; ch++) { |
1092 | nid_mixer = 0x16; | 891 | v = snd_hda_codec_amp_read(codec, p->nid, ch, p->dir, |
1093 | start_idx = 2; | 892 | p->idx); |
1094 | end_idx = 4; | 893 | if (!(v & HDA_AMP_MUTE) && v > 0) |
1095 | break; | 894 | return false; |
1096 | case VT1702: | ||
1097 | nid_mixer = 0x1a; | ||
1098 | start_idx = 1; | ||
1099 | end_idx = 3; | ||
1100 | break; | ||
1101 | case VT1718S: | ||
1102 | nid_mixer = 0x21; | ||
1103 | start_idx = 1; | ||
1104 | end_idx = 3; | ||
1105 | break; | ||
1106 | case VT2002P: | ||
1107 | case VT1812: | ||
1108 | case VT1802: | ||
1109 | nid_mixer = 0x21; | ||
1110 | start_idx = 0; | ||
1111 | end_idx = 2; | ||
1112 | break; | ||
1113 | default: | ||
1114 | return 0; | ||
1115 | } | ||
1116 | /* check AA path's mute status */ | ||
1117 | for (i = start_idx; i <= end_idx; i++) { | ||
1118 | unsigned int con_list = snd_hda_codec_read( | ||
1119 | codec, nid_mixer, 0, AC_VERB_GET_CONNECT_LIST, i/4*4); | ||
1120 | int shift = 8 * (i % 4); | ||
1121 | hda_nid_t nid_pin = (con_list & (0xff << shift)) >> shift; | ||
1122 | unsigned int defconf = snd_hda_codec_get_pincfg(codec, nid_pin); | ||
1123 | if (get_defcfg_connect(defconf) == AC_JACK_PORT_COMPLEX) { | ||
1124 | /* check mute status while the pin is connected */ | ||
1125 | int mute_l = snd_hda_codec_amp_read(codec, nid_mixer, 0, | ||
1126 | HDA_INPUT, i) >> 7; | ||
1127 | int mute_r = snd_hda_codec_amp_read(codec, nid_mixer, 1, | ||
1128 | HDA_INPUT, i) >> 7; | ||
1129 | if (!mute_l || !mute_r) { | ||
1130 | mute = 0; | ||
1131 | break; | ||
1132 | } | ||
1133 | } | 895 | } |
1134 | } | 896 | } |
1135 | return mute; | 897 | return true; |
1136 | } | 898 | } |
1137 | 899 | ||
1138 | /* enter/exit analog low-current mode */ | 900 | /* enter/exit analog low-current mode */ |
1139 | static void analog_low_current_mode(struct hda_codec *codec, int stream_idle) | 901 | static void analog_low_current_mode(struct hda_codec *codec) |
1140 | { | 902 | { |
1141 | struct via_spec *spec = codec->spec; | 903 | struct via_spec *spec = codec->spec; |
1142 | static int saved_stream_idle = 1; /* saved stream idle status */ | 904 | bool enable; |
1143 | int enable = is_aa_path_mute(codec); | 905 | unsigned int verb, parm; |
1144 | unsigned int verb = 0; | ||
1145 | unsigned int parm = 0; | ||
1146 | 906 | ||
1147 | if (stream_idle == -1) /* stream status did not change */ | 907 | enable = is_aa_path_mute(codec) && (spec->num_active_streams > 0); |
1148 | enable = enable && saved_stream_idle; | ||
1149 | else { | ||
1150 | enable = enable && stream_idle; | ||
1151 | saved_stream_idle = stream_idle; | ||
1152 | } | ||
1153 | 908 | ||
1154 | /* decide low current mode's verb & parameter */ | 909 | /* decide low current mode's verb & parameter */ |
1155 | switch (spec->codec_type) { | 910 | switch (spec->codec_type) { |
@@ -1184,121 +939,74 @@ static void analog_low_current_mode(struct hda_codec *codec, int stream_idle) | |||
1184 | /* | 939 | /* |
1185 | * generic initialization of ADC, input mixers and output mixers | 940 | * generic initialization of ADC, input mixers and output mixers |
1186 | */ | 941 | */ |
1187 | static const struct hda_verb vt1708_volume_init_verbs[] = { | 942 | static const struct hda_verb vt1708_init_verbs[] = { |
1188 | /* | ||
1189 | * Unmute ADC0-1 and set the default input to mic-in | ||
1190 | */ | ||
1191 | {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, | ||
1192 | {0x27, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, | ||
1193 | |||
1194 | |||
1195 | /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback | ||
1196 | * mixer widget | ||
1197 | */ | ||
1198 | /* Amp Indices: CD = 1, Mic1 = 2, Line = 3, Mic2 = 4 */ | ||
1199 | {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, | ||
1200 | {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, | ||
1201 | {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)}, | ||
1202 | {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)}, | ||
1203 | {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)}, | ||
1204 | |||
1205 | /* | ||
1206 | * Set up output mixers (0x19 - 0x1b) | ||
1207 | */ | ||
1208 | /* set vol=0 to output mixers */ | ||
1209 | {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, | ||
1210 | {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, | ||
1211 | {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, | ||
1212 | |||
1213 | /* Setup default input MW0 to PW4 */ | ||
1214 | {0x20, AC_VERB_SET_CONNECT_SEL, 0}, | ||
1215 | /* PW9 Output enable */ | ||
1216 | {0x25, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40}, | ||
1217 | /* power down jack detect function */ | 943 | /* power down jack detect function */ |
1218 | {0x1, 0xf81, 0x1}, | 944 | {0x1, 0xf81, 0x1}, |
1219 | { } | 945 | { } |
1220 | }; | 946 | }; |
1221 | 947 | ||
1222 | static int via_playback_pcm_open(struct hda_pcm_stream *hinfo, | 948 | static void set_stream_active(struct hda_codec *codec, bool active) |
949 | { | ||
950 | struct via_spec *spec = codec->spec; | ||
951 | |||
952 | if (active) | ||
953 | spec->num_active_streams++; | ||
954 | else | ||
955 | spec->num_active_streams--; | ||
956 | analog_low_current_mode(codec); | ||
957 | } | ||
958 | |||
959 | static int via_playback_multi_pcm_open(struct hda_pcm_stream *hinfo, | ||
1223 | struct hda_codec *codec, | 960 | struct hda_codec *codec, |
1224 | struct snd_pcm_substream *substream) | 961 | struct snd_pcm_substream *substream) |
1225 | { | 962 | { |
1226 | struct via_spec *spec = codec->spec; | 963 | struct via_spec *spec = codec->spec; |
1227 | int idle = substream->pstr->substream_opened == 1 | 964 | int err; |
1228 | && substream->ref_count == 0; | 965 | |
1229 | analog_low_current_mode(codec, idle); | 966 | if (!spec->hp_independent_mode) |
1230 | return snd_hda_multi_out_analog_open(codec, &spec->multiout, substream, | 967 | spec->multiout.hp_nid = spec->hp_dac_nid; |
1231 | hinfo); | 968 | set_stream_active(codec, true); |
969 | err = snd_hda_multi_out_analog_open(codec, &spec->multiout, substream, | ||
970 | hinfo); | ||
971 | if (err < 0) { | ||
972 | spec->multiout.hp_nid = 0; | ||
973 | set_stream_active(codec, false); | ||
974 | return err; | ||
975 | } | ||
976 | return 0; | ||
1232 | } | 977 | } |
1233 | 978 | ||
1234 | static void playback_multi_pcm_prep_0(struct hda_codec *codec, | 979 | static int via_playback_multi_pcm_close(struct hda_pcm_stream *hinfo, |
1235 | unsigned int stream_tag, | 980 | struct hda_codec *codec, |
1236 | unsigned int format, | 981 | struct snd_pcm_substream *substream) |
1237 | struct snd_pcm_substream *substream) | ||
1238 | { | 982 | { |
1239 | struct via_spec *spec = codec->spec; | 983 | struct via_spec *spec = codec->spec; |
1240 | struct hda_multi_out *mout = &spec->multiout; | 984 | |
1241 | const hda_nid_t *nids = mout->dac_nids; | 985 | spec->multiout.hp_nid = 0; |
1242 | int chs = substream->runtime->channels; | 986 | set_stream_active(codec, false); |
1243 | int i; | 987 | return 0; |
1244 | struct hda_spdif_out *spdif = | 988 | } |
1245 | snd_hda_spdif_out_of_nid(codec, spec->multiout.dig_out_nid); | 989 | |
1246 | 990 | static int via_playback_hp_pcm_open(struct hda_pcm_stream *hinfo, | |
1247 | mutex_lock(&codec->spdif_mutex); | 991 | struct hda_codec *codec, |
1248 | if (mout->dig_out_nid && mout->dig_out_used != HDA_DIG_EXCLUSIVE) { | 992 | struct snd_pcm_substream *substream) |
1249 | if (chs == 2 && | 993 | { |
1250 | snd_hda_is_supported_format(codec, mout->dig_out_nid, | 994 | struct via_spec *spec = codec->spec; |
1251 | format) && | 995 | |
1252 | !(spdif->status & IEC958_AES0_NONAUDIO)) { | 996 | if (snd_BUG_ON(!spec->hp_dac_nid)) |
1253 | mout->dig_out_used = HDA_DIG_ANALOG_DUP; | 997 | return -EINVAL; |
1254 | /* turn off SPDIF once; otherwise the IEC958 bits won't | 998 | if (!spec->hp_independent_mode || spec->multiout.hp_nid) |
1255 | * be updated */ | 999 | return -EBUSY; |
1256 | if (spdif->ctls & AC_DIG1_ENABLE) | 1000 | set_stream_active(codec, true); |
1257 | snd_hda_codec_write(codec, mout->dig_out_nid, 0, | 1001 | return 0; |
1258 | AC_VERB_SET_DIGI_CONVERT_1, | 1002 | } |
1259 | spdif->ctls & | 1003 | |
1260 | ~AC_DIG1_ENABLE & 0xff); | 1004 | static int via_playback_hp_pcm_close(struct hda_pcm_stream *hinfo, |
1261 | snd_hda_codec_setup_stream(codec, mout->dig_out_nid, | 1005 | struct hda_codec *codec, |
1262 | stream_tag, 0, format); | 1006 | struct snd_pcm_substream *substream) |
1263 | /* turn on again (if needed) */ | 1007 | { |
1264 | if (spdif->ctls & AC_DIG1_ENABLE) | 1008 | set_stream_active(codec, false); |
1265 | snd_hda_codec_write(codec, mout->dig_out_nid, 0, | 1009 | return 0; |
1266 | AC_VERB_SET_DIGI_CONVERT_1, | ||
1267 | spdif->ctls & 0xff); | ||
1268 | } else { | ||
1269 | mout->dig_out_used = 0; | ||
1270 | snd_hda_codec_setup_stream(codec, mout->dig_out_nid, | ||
1271 | 0, 0, 0); | ||
1272 | } | ||
1273 | } | ||
1274 | mutex_unlock(&codec->spdif_mutex); | ||
1275 | |||
1276 | /* front */ | ||
1277 | snd_hda_codec_setup_stream(codec, nids[HDA_FRONT], stream_tag, | ||
1278 | 0, format); | ||
1279 | |||
1280 | if (mout->hp_nid && mout->hp_nid != nids[HDA_FRONT] | ||
1281 | && !spec->hp_independent_mode) | ||
1282 | /* headphone out will just decode front left/right (stereo) */ | ||
1283 | snd_hda_codec_setup_stream(codec, mout->hp_nid, stream_tag, | ||
1284 | 0, format); | ||
1285 | |||
1286 | /* extra outputs copied from front */ | ||
1287 | for (i = 0; i < ARRAY_SIZE(mout->extra_out_nid); i++) | ||
1288 | if (mout->extra_out_nid[i]) | ||
1289 | snd_hda_codec_setup_stream(codec, | ||
1290 | mout->extra_out_nid[i], | ||
1291 | stream_tag, 0, format); | ||
1292 | |||
1293 | /* surrounds */ | ||
1294 | for (i = 1; i < mout->num_dacs; i++) { | ||
1295 | if (chs >= (i + 1) * 2) /* independent out */ | ||
1296 | snd_hda_codec_setup_stream(codec, nids[i], stream_tag, | ||
1297 | i * 2, format); | ||
1298 | else /* copy front */ | ||
1299 | snd_hda_codec_setup_stream(codec, nids[i], stream_tag, | ||
1300 | 0, format); | ||
1301 | } | ||
1302 | } | 1010 | } |
1303 | 1011 | ||
1304 | static int via_playback_multi_pcm_prepare(struct hda_pcm_stream *hinfo, | 1012 | static int via_playback_multi_pcm_prepare(struct hda_pcm_stream *hinfo, |
@@ -1308,18 +1016,23 @@ static int via_playback_multi_pcm_prepare(struct hda_pcm_stream *hinfo, | |||
1308 | struct snd_pcm_substream *substream) | 1016 | struct snd_pcm_substream *substream) |
1309 | { | 1017 | { |
1310 | struct via_spec *spec = codec->spec; | 1018 | struct via_spec *spec = codec->spec; |
1311 | struct hda_multi_out *mout = &spec->multiout; | ||
1312 | const hda_nid_t *nids = mout->dac_nids; | ||
1313 | 1019 | ||
1314 | if (substream->number == 0) | 1020 | snd_hda_multi_out_analog_prepare(codec, &spec->multiout, stream_tag, |
1315 | playback_multi_pcm_prep_0(codec, stream_tag, format, | 1021 | format, substream); |
1316 | substream); | 1022 | vt1708_start_hp_work(spec); |
1317 | else { | 1023 | return 0; |
1318 | if (mout->hp_nid && mout->hp_nid != nids[HDA_FRONT] && | 1024 | } |
1319 | spec->hp_independent_mode) | 1025 | |
1320 | snd_hda_codec_setup_stream(codec, mout->hp_nid, | 1026 | static int via_playback_hp_pcm_prepare(struct hda_pcm_stream *hinfo, |
1321 | stream_tag, 0, format); | 1027 | struct hda_codec *codec, |
1322 | } | 1028 | unsigned int stream_tag, |
1029 | unsigned int format, | ||
1030 | struct snd_pcm_substream *substream) | ||
1031 | { | ||
1032 | struct via_spec *spec = codec->spec; | ||
1033 | |||
1034 | snd_hda_codec_setup_stream(codec, spec->hp_dac_nid, | ||
1035 | stream_tag, 0, format); | ||
1323 | vt1708_start_hp_work(spec); | 1036 | vt1708_start_hp_work(spec); |
1324 | return 0; | 1037 | return 0; |
1325 | } | 1038 | } |
@@ -1329,37 +1042,19 @@ static int via_playback_multi_pcm_cleanup(struct hda_pcm_stream *hinfo, | |||
1329 | struct snd_pcm_substream *substream) | 1042 | struct snd_pcm_substream *substream) |
1330 | { | 1043 | { |
1331 | struct via_spec *spec = codec->spec; | 1044 | struct via_spec *spec = codec->spec; |
1332 | struct hda_multi_out *mout = &spec->multiout; | ||
1333 | const hda_nid_t *nids = mout->dac_nids; | ||
1334 | int i; | ||
1335 | 1045 | ||
1336 | if (substream->number == 0) { | 1046 | snd_hda_multi_out_analog_cleanup(codec, &spec->multiout); |
1337 | for (i = 0; i < mout->num_dacs; i++) | 1047 | vt1708_stop_hp_work(spec); |
1338 | snd_hda_codec_setup_stream(codec, nids[i], 0, 0, 0); | 1048 | return 0; |
1339 | 1049 | } | |
1340 | if (mout->hp_nid && !spec->hp_independent_mode) | 1050 | |
1341 | snd_hda_codec_setup_stream(codec, mout->hp_nid, | 1051 | static int via_playback_hp_pcm_cleanup(struct hda_pcm_stream *hinfo, |
1342 | 0, 0, 0); | 1052 | struct hda_codec *codec, |
1343 | 1053 | struct snd_pcm_substream *substream) | |
1344 | for (i = 0; i < ARRAY_SIZE(mout->extra_out_nid); i++) | 1054 | { |
1345 | if (mout->extra_out_nid[i]) | 1055 | struct via_spec *spec = codec->spec; |
1346 | snd_hda_codec_setup_stream(codec, | 1056 | |
1347 | mout->extra_out_nid[i], | 1057 | snd_hda_codec_setup_stream(codec, spec->hp_dac_nid, 0, 0, 0); |
1348 | 0, 0, 0); | ||
1349 | mutex_lock(&codec->spdif_mutex); | ||
1350 | if (mout->dig_out_nid && | ||
1351 | mout->dig_out_used == HDA_DIG_ANALOG_DUP) { | ||
1352 | snd_hda_codec_setup_stream(codec, mout->dig_out_nid, | ||
1353 | 0, 0, 0); | ||
1354 | mout->dig_out_used = 0; | ||
1355 | } | ||
1356 | mutex_unlock(&codec->spdif_mutex); | ||
1357 | } else { | ||
1358 | if (mout->hp_nid && mout->hp_nid != nids[HDA_FRONT] && | ||
1359 | spec->hp_independent_mode) | ||
1360 | snd_hda_codec_setup_stream(codec, mout->hp_nid, | ||
1361 | 0, 0, 0); | ||
1362 | } | ||
1363 | vt1708_stop_hp_work(spec); | 1058 | vt1708_stop_hp_work(spec); |
1364 | return 0; | 1059 | return 0; |
1365 | } | 1060 | } |
@@ -1428,47 +1123,120 @@ static int via_capture_pcm_cleanup(struct hda_pcm_stream *hinfo, | |||
1428 | return 0; | 1123 | return 0; |
1429 | } | 1124 | } |
1430 | 1125 | ||
1431 | static const struct hda_pcm_stream vt1708_pcm_analog_playback = { | 1126 | /* analog capture with dynamic ADC switching */ |
1432 | .substreams = 2, | 1127 | static int via_dyn_adc_capture_pcm_prepare(struct hda_pcm_stream *hinfo, |
1128 | struct hda_codec *codec, | ||
1129 | unsigned int stream_tag, | ||
1130 | unsigned int format, | ||
1131 | struct snd_pcm_substream *substream) | ||
1132 | { | ||
1133 | struct via_spec *spec = codec->spec; | ||
1134 | int adc_idx = spec->inputs[spec->cur_mux[0]].adc_idx; | ||
1135 | |||
1136 | spec->cur_adc = spec->adc_nids[adc_idx]; | ||
1137 | spec->cur_adc_stream_tag = stream_tag; | ||
1138 | spec->cur_adc_format = format; | ||
1139 | snd_hda_codec_setup_stream(codec, spec->cur_adc, stream_tag, 0, format); | ||
1140 | return 0; | ||
1141 | } | ||
1142 | |||
1143 | static int via_dyn_adc_capture_pcm_cleanup(struct hda_pcm_stream *hinfo, | ||
1144 | struct hda_codec *codec, | ||
1145 | struct snd_pcm_substream *substream) | ||
1146 | { | ||
1147 | struct via_spec *spec = codec->spec; | ||
1148 | |||
1149 | snd_hda_codec_cleanup_stream(codec, spec->cur_adc); | ||
1150 | spec->cur_adc = 0; | ||
1151 | return 0; | ||
1152 | } | ||
1153 | |||
1154 | /* re-setup the stream if running; called from input-src put */ | ||
1155 | static bool via_dyn_adc_pcm_resetup(struct hda_codec *codec, int cur) | ||
1156 | { | ||
1157 | struct via_spec *spec = codec->spec; | ||
1158 | int adc_idx = spec->inputs[cur].adc_idx; | ||
1159 | hda_nid_t adc = spec->adc_nids[adc_idx]; | ||
1160 | |||
1161 | if (spec->cur_adc && spec->cur_adc != adc) { | ||
1162 | /* stream is running, let's swap the current ADC */ | ||
1163 | __snd_hda_codec_cleanup_stream(codec, spec->cur_adc, 1); | ||
1164 | spec->cur_adc = adc; | ||
1165 | snd_hda_codec_setup_stream(codec, adc, | ||
1166 | spec->cur_adc_stream_tag, 0, | ||
1167 | spec->cur_adc_format); | ||
1168 | return true; | ||
1169 | } | ||
1170 | return false; | ||
1171 | } | ||
1172 | |||
1173 | static const struct hda_pcm_stream via_pcm_analog_playback = { | ||
1174 | .substreams = 1, | ||
1433 | .channels_min = 2, | 1175 | .channels_min = 2, |
1434 | .channels_max = 8, | 1176 | .channels_max = 8, |
1435 | .nid = 0x10, /* NID to query formats and rates */ | 1177 | /* NID is set in via_build_pcms */ |
1436 | .ops = { | 1178 | .ops = { |
1437 | .open = via_playback_pcm_open, | 1179 | .open = via_playback_multi_pcm_open, |
1180 | .close = via_playback_multi_pcm_close, | ||
1438 | .prepare = via_playback_multi_pcm_prepare, | 1181 | .prepare = via_playback_multi_pcm_prepare, |
1439 | .cleanup = via_playback_multi_pcm_cleanup | 1182 | .cleanup = via_playback_multi_pcm_cleanup |
1440 | }, | 1183 | }, |
1441 | }; | 1184 | }; |
1442 | 1185 | ||
1186 | static const struct hda_pcm_stream via_pcm_hp_playback = { | ||
1187 | .substreams = 1, | ||
1188 | .channels_min = 2, | ||
1189 | .channels_max = 2, | ||
1190 | /* NID is set in via_build_pcms */ | ||
1191 | .ops = { | ||
1192 | .open = via_playback_hp_pcm_open, | ||
1193 | .close = via_playback_hp_pcm_close, | ||
1194 | .prepare = via_playback_hp_pcm_prepare, | ||
1195 | .cleanup = via_playback_hp_pcm_cleanup | ||
1196 | }, | ||
1197 | }; | ||
1198 | |||
1443 | static const struct hda_pcm_stream vt1708_pcm_analog_s16_playback = { | 1199 | static const struct hda_pcm_stream vt1708_pcm_analog_s16_playback = { |
1444 | .substreams = 2, | 1200 | .substreams = 1, |
1445 | .channels_min = 2, | 1201 | .channels_min = 2, |
1446 | .channels_max = 8, | 1202 | .channels_max = 8, |
1447 | .nid = 0x10, /* NID to query formats and rates */ | 1203 | /* NID is set in via_build_pcms */ |
1448 | /* We got noisy outputs on the right channel on VT1708 when | 1204 | /* We got noisy outputs on the right channel on VT1708 when |
1449 | * 24bit samples are used. Until any workaround is found, | 1205 | * 24bit samples are used. Until any workaround is found, |
1450 | * disable the 24bit format, so far. | 1206 | * disable the 24bit format, so far. |
1451 | */ | 1207 | */ |
1452 | .formats = SNDRV_PCM_FMTBIT_S16_LE, | 1208 | .formats = SNDRV_PCM_FMTBIT_S16_LE, |
1453 | .ops = { | 1209 | .ops = { |
1454 | .open = via_playback_pcm_open, | 1210 | .open = via_playback_multi_pcm_open, |
1211 | .close = via_playback_multi_pcm_close, | ||
1455 | .prepare = via_playback_multi_pcm_prepare, | 1212 | .prepare = via_playback_multi_pcm_prepare, |
1456 | .cleanup = via_playback_multi_pcm_cleanup | 1213 | .cleanup = via_playback_multi_pcm_cleanup |
1457 | }, | 1214 | }, |
1458 | }; | 1215 | }; |
1459 | 1216 | ||
1460 | static const struct hda_pcm_stream vt1708_pcm_analog_capture = { | 1217 | static const struct hda_pcm_stream via_pcm_analog_capture = { |
1461 | .substreams = 2, | 1218 | .substreams = 1, /* will be changed in via_build_pcms() */ |
1462 | .channels_min = 2, | 1219 | .channels_min = 2, |
1463 | .channels_max = 2, | 1220 | .channels_max = 2, |
1464 | .nid = 0x15, /* NID to query formats and rates */ | 1221 | /* NID is set in via_build_pcms */ |
1465 | .ops = { | 1222 | .ops = { |
1466 | .prepare = via_capture_pcm_prepare, | 1223 | .prepare = via_capture_pcm_prepare, |
1467 | .cleanup = via_capture_pcm_cleanup | 1224 | .cleanup = via_capture_pcm_cleanup |
1468 | }, | 1225 | }, |
1469 | }; | 1226 | }; |
1470 | 1227 | ||
1471 | static const struct hda_pcm_stream vt1708_pcm_digital_playback = { | 1228 | static const struct hda_pcm_stream via_pcm_dyn_adc_analog_capture = { |
1229 | .substreams = 1, | ||
1230 | .channels_min = 2, | ||
1231 | .channels_max = 2, | ||
1232 | /* NID is set in via_build_pcms */ | ||
1233 | .ops = { | ||
1234 | .prepare = via_dyn_adc_capture_pcm_prepare, | ||
1235 | .cleanup = via_dyn_adc_capture_pcm_cleanup, | ||
1236 | }, | ||
1237 | }; | ||
1238 | |||
1239 | static const struct hda_pcm_stream via_pcm_digital_playback = { | ||
1472 | .substreams = 1, | 1240 | .substreams = 1, |
1473 | .channels_min = 2, | 1241 | .channels_min = 2, |
1474 | .channels_max = 2, | 1242 | .channels_max = 2, |
@@ -1481,19 +1249,47 @@ static const struct hda_pcm_stream vt1708_pcm_digital_playback = { | |||
1481 | }, | 1249 | }, |
1482 | }; | 1250 | }; |
1483 | 1251 | ||
1484 | static const struct hda_pcm_stream vt1708_pcm_digital_capture = { | 1252 | static const struct hda_pcm_stream via_pcm_digital_capture = { |
1485 | .substreams = 1, | 1253 | .substreams = 1, |
1486 | .channels_min = 2, | 1254 | .channels_min = 2, |
1487 | .channels_max = 2, | 1255 | .channels_max = 2, |
1488 | }; | 1256 | }; |
1489 | 1257 | ||
1258 | /* | ||
1259 | * slave controls for virtual master | ||
1260 | */ | ||
1261 | static const char * const via_slave_vols[] = { | ||
1262 | "Front Playback Volume", | ||
1263 | "Surround Playback Volume", | ||
1264 | "Center Playback Volume", | ||
1265 | "LFE Playback Volume", | ||
1266 | "Side Playback Volume", | ||
1267 | "Headphone Playback Volume", | ||
1268 | "Speaker Playback Volume", | ||
1269 | NULL, | ||
1270 | }; | ||
1271 | |||
1272 | static const char * const via_slave_sws[] = { | ||
1273 | "Front Playback Switch", | ||
1274 | "Surround Playback Switch", | ||
1275 | "Center Playback Switch", | ||
1276 | "LFE Playback Switch", | ||
1277 | "Side Playback Switch", | ||
1278 | "Headphone Playback Switch", | ||
1279 | "Speaker Playback Switch", | ||
1280 | NULL, | ||
1281 | }; | ||
1282 | |||
1490 | static int via_build_controls(struct hda_codec *codec) | 1283 | static int via_build_controls(struct hda_codec *codec) |
1491 | { | 1284 | { |
1492 | struct via_spec *spec = codec->spec; | 1285 | struct via_spec *spec = codec->spec; |
1493 | struct snd_kcontrol *kctl; | 1286 | struct snd_kcontrol *kctl; |
1494 | const struct snd_kcontrol_new *knew; | ||
1495 | int err, i; | 1287 | int err, i; |
1496 | 1288 | ||
1289 | if (spec->set_widgets_power_state) | ||
1290 | if (!via_clone_control(spec, &via_pin_power_ctl_enum)) | ||
1291 | return -ENOMEM; | ||
1292 | |||
1497 | for (i = 0; i < spec->num_mixers; i++) { | 1293 | for (i = 0; i < spec->num_mixers; i++) { |
1498 | err = snd_hda_add_new_ctls(codec, spec->mixers[i]); | 1294 | err = snd_hda_add_new_ctls(codec, spec->mixers[i]); |
1499 | if (err < 0) | 1295 | if (err < 0) |
@@ -1518,6 +1314,23 @@ static int via_build_controls(struct hda_codec *codec) | |||
1518 | return err; | 1314 | return err; |
1519 | } | 1315 | } |
1520 | 1316 | ||
1317 | /* if we have no master control, let's create it */ | ||
1318 | if (!snd_hda_find_mixer_ctl(codec, "Master Playback Volume")) { | ||
1319 | unsigned int vmaster_tlv[4]; | ||
1320 | snd_hda_set_vmaster_tlv(codec, spec->multiout.dac_nids[0], | ||
1321 | HDA_OUTPUT, vmaster_tlv); | ||
1322 | err = snd_hda_add_vmaster(codec, "Master Playback Volume", | ||
1323 | vmaster_tlv, via_slave_vols); | ||
1324 | if (err < 0) | ||
1325 | return err; | ||
1326 | } | ||
1327 | if (!snd_hda_find_mixer_ctl(codec, "Master Playback Switch")) { | ||
1328 | err = snd_hda_add_vmaster(codec, "Master Playback Switch", | ||
1329 | NULL, via_slave_sws); | ||
1330 | if (err < 0) | ||
1331 | return err; | ||
1332 | } | ||
1333 | |||
1521 | /* assign Capture Source enums to NID */ | 1334 | /* assign Capture Source enums to NID */ |
1522 | kctl = snd_hda_find_mixer_ctl(codec, "Input Source"); | 1335 | kctl = snd_hda_find_mixer_ctl(codec, "Input Source"); |
1523 | for (i = 0; kctl && i < kctl->count; i++) { | 1336 | for (i = 0; kctl && i < kctl->count; i++) { |
@@ -1526,22 +1339,9 @@ static int via_build_controls(struct hda_codec *codec) | |||
1526 | return err; | 1339 | return err; |
1527 | } | 1340 | } |
1528 | 1341 | ||
1529 | /* other nid->control mapping */ | ||
1530 | for (i = 0; i < spec->num_mixers; i++) { | ||
1531 | for (knew = spec->mixers[i]; knew->name; knew++) { | ||
1532 | if (knew->iface != NID_MAPPING) | ||
1533 | continue; | ||
1534 | kctl = snd_hda_find_mixer_ctl(codec, knew->name); | ||
1535 | if (kctl == NULL) | ||
1536 | continue; | ||
1537 | err = snd_hda_add_nid(codec, kctl, 0, | ||
1538 | knew->subdevice); | ||
1539 | } | ||
1540 | } | ||
1541 | |||
1542 | /* init power states */ | 1342 | /* init power states */ |
1543 | set_widgets_power_state(codec); | 1343 | set_widgets_power_state(codec); |
1544 | analog_low_current_mode(codec, 1); | 1344 | analog_low_current_mode(codec); |
1545 | 1345 | ||
1546 | via_free_kctls(codec); /* no longer needed */ | 1346 | via_free_kctls(codec); /* no longer needed */ |
1547 | return 0; | 1347 | return 0; |
@@ -1555,36 +1355,71 @@ static int via_build_pcms(struct hda_codec *codec) | |||
1555 | codec->num_pcms = 1; | 1355 | codec->num_pcms = 1; |
1556 | codec->pcm_info = info; | 1356 | codec->pcm_info = info; |
1557 | 1357 | ||
1358 | snprintf(spec->stream_name_analog, sizeof(spec->stream_name_analog), | ||
1359 | "%s Analog", codec->chip_name); | ||
1558 | info->name = spec->stream_name_analog; | 1360 | info->name = spec->stream_name_analog; |
1361 | |||
1362 | if (!spec->stream_analog_playback) | ||
1363 | spec->stream_analog_playback = &via_pcm_analog_playback; | ||
1559 | info->stream[SNDRV_PCM_STREAM_PLAYBACK] = | 1364 | info->stream[SNDRV_PCM_STREAM_PLAYBACK] = |
1560 | *(spec->stream_analog_playback); | 1365 | *spec->stream_analog_playback; |
1561 | info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = | 1366 | info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = |
1562 | spec->multiout.dac_nids[0]; | 1367 | spec->multiout.dac_nids[0]; |
1563 | info->stream[SNDRV_PCM_STREAM_CAPTURE] = *(spec->stream_analog_capture); | ||
1564 | info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adc_nids[0]; | ||
1565 | |||
1566 | info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max = | 1368 | info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max = |
1567 | spec->multiout.max_channels; | 1369 | spec->multiout.max_channels; |
1568 | 1370 | ||
1371 | if (!spec->stream_analog_capture) { | ||
1372 | if (spec->dyn_adc_switch) | ||
1373 | spec->stream_analog_capture = | ||
1374 | &via_pcm_dyn_adc_analog_capture; | ||
1375 | else | ||
1376 | spec->stream_analog_capture = &via_pcm_analog_capture; | ||
1377 | } | ||
1378 | info->stream[SNDRV_PCM_STREAM_CAPTURE] = | ||
1379 | *spec->stream_analog_capture; | ||
1380 | info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adc_nids[0]; | ||
1381 | if (!spec->dyn_adc_switch) | ||
1382 | info->stream[SNDRV_PCM_STREAM_CAPTURE].substreams = | ||
1383 | spec->num_adc_nids; | ||
1384 | |||
1569 | if (spec->multiout.dig_out_nid || spec->dig_in_nid) { | 1385 | if (spec->multiout.dig_out_nid || spec->dig_in_nid) { |
1570 | codec->num_pcms++; | 1386 | codec->num_pcms++; |
1571 | info++; | 1387 | info++; |
1388 | snprintf(spec->stream_name_digital, | ||
1389 | sizeof(spec->stream_name_digital), | ||
1390 | "%s Digital", codec->chip_name); | ||
1572 | info->name = spec->stream_name_digital; | 1391 | info->name = spec->stream_name_digital; |
1573 | info->pcm_type = HDA_PCM_TYPE_SPDIF; | 1392 | info->pcm_type = HDA_PCM_TYPE_SPDIF; |
1574 | if (spec->multiout.dig_out_nid) { | 1393 | if (spec->multiout.dig_out_nid) { |
1394 | if (!spec->stream_digital_playback) | ||
1395 | spec->stream_digital_playback = | ||
1396 | &via_pcm_digital_playback; | ||
1575 | info->stream[SNDRV_PCM_STREAM_PLAYBACK] = | 1397 | info->stream[SNDRV_PCM_STREAM_PLAYBACK] = |
1576 | *(spec->stream_digital_playback); | 1398 | *spec->stream_digital_playback; |
1577 | info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = | 1399 | info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = |
1578 | spec->multiout.dig_out_nid; | 1400 | spec->multiout.dig_out_nid; |
1579 | } | 1401 | } |
1580 | if (spec->dig_in_nid) { | 1402 | if (spec->dig_in_nid) { |
1403 | if (!spec->stream_digital_capture) | ||
1404 | spec->stream_digital_capture = | ||
1405 | &via_pcm_digital_capture; | ||
1581 | info->stream[SNDRV_PCM_STREAM_CAPTURE] = | 1406 | info->stream[SNDRV_PCM_STREAM_CAPTURE] = |
1582 | *(spec->stream_digital_capture); | 1407 | *spec->stream_digital_capture; |
1583 | info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = | 1408 | info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = |
1584 | spec->dig_in_nid; | 1409 | spec->dig_in_nid; |
1585 | } | 1410 | } |
1586 | } | 1411 | } |
1587 | 1412 | ||
1413 | if (spec->hp_dac_nid) { | ||
1414 | codec->num_pcms++; | ||
1415 | info++; | ||
1416 | snprintf(spec->stream_name_hp, sizeof(spec->stream_name_hp), | ||
1417 | "%s HP", codec->chip_name); | ||
1418 | info->name = spec->stream_name_hp; | ||
1419 | info->stream[SNDRV_PCM_STREAM_PLAYBACK] = via_pcm_hp_playback; | ||
1420 | info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = | ||
1421 | spec->hp_dac_nid; | ||
1422 | } | ||
1588 | return 0; | 1423 | return 0; |
1589 | } | 1424 | } |
1590 | 1425 | ||
@@ -1597,57 +1432,55 @@ static void via_free(struct hda_codec *codec) | |||
1597 | 1432 | ||
1598 | via_free_kctls(codec); | 1433 | via_free_kctls(codec); |
1599 | vt1708_stop_hp_work(spec); | 1434 | vt1708_stop_hp_work(spec); |
1600 | kfree(codec->spec); | 1435 | kfree(spec->bind_cap_vol); |
1436 | kfree(spec->bind_cap_sw); | ||
1437 | kfree(spec); | ||
1601 | } | 1438 | } |
1602 | 1439 | ||
1603 | /* mute internal speaker if HP is plugged */ | 1440 | /* mute/unmute outputs */ |
1604 | static void via_hp_automute(struct hda_codec *codec) | 1441 | static void toggle_output_mutes(struct hda_codec *codec, int num_pins, |
1442 | hda_nid_t *pins, bool mute) | ||
1605 | { | 1443 | { |
1606 | unsigned int present = 0; | 1444 | int i; |
1607 | struct via_spec *spec = codec->spec; | 1445 | for (i = 0; i < num_pins; i++) |
1608 | 1446 | snd_hda_codec_write(codec, pins[i], 0, | |
1609 | present = snd_hda_jack_detect(codec, spec->autocfg.hp_pins[0]); | 1447 | AC_VERB_SET_PIN_WIDGET_CONTROL, |
1610 | 1448 | mute ? 0 : PIN_OUT); | |
1611 | if (!spec->hp_independent_mode) { | ||
1612 | struct snd_ctl_elem_id id; | ||
1613 | /* auto mute */ | ||
1614 | snd_hda_codec_amp_stereo( | ||
1615 | codec, spec->autocfg.line_out_pins[0], HDA_OUTPUT, 0, | ||
1616 | HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0); | ||
1617 | /* notify change */ | ||
1618 | memset(&id, 0, sizeof(id)); | ||
1619 | id.iface = SNDRV_CTL_ELEM_IFACE_MIXER; | ||
1620 | strcpy(id.name, "Front Playback Switch"); | ||
1621 | snd_ctl_notify(codec->bus->card, SNDRV_CTL_EVENT_MASK_VALUE, | ||
1622 | &id); | ||
1623 | } | ||
1624 | } | 1449 | } |
1625 | 1450 | ||
1626 | /* mute mono out if HP or Line out is plugged */ | 1451 | /* mute internal speaker if line-out is plugged */ |
1627 | static void via_mono_automute(struct hda_codec *codec) | 1452 | static void via_line_automute(struct hda_codec *codec, int present) |
1628 | { | 1453 | { |
1629 | unsigned int hp_present, lineout_present; | ||
1630 | struct via_spec *spec = codec->spec; | 1454 | struct via_spec *spec = codec->spec; |
1631 | 1455 | ||
1632 | if (spec->codec_type != VT1716S) | 1456 | if (!spec->autocfg.speaker_outs) |
1633 | return; | 1457 | return; |
1634 | 1458 | if (!present) | |
1635 | lineout_present = snd_hda_jack_detect(codec, | 1459 | present = snd_hda_jack_detect(codec, |
1636 | spec->autocfg.line_out_pins[0]); | 1460 | spec->autocfg.line_out_pins[0]); |
1461 | toggle_output_mutes(codec, spec->autocfg.speaker_outs, | ||
1462 | spec->autocfg.speaker_pins, | ||
1463 | present); | ||
1464 | } | ||
1637 | 1465 | ||
1638 | /* Mute Mono Out if Line Out is plugged */ | 1466 | /* mute internal speaker if HP is plugged */ |
1639 | if (lineout_present) { | 1467 | static void via_hp_automute(struct hda_codec *codec) |
1640 | snd_hda_codec_amp_stereo( | 1468 | { |
1641 | codec, 0x2A, HDA_OUTPUT, 0, HDA_AMP_MUTE, HDA_AMP_MUTE); | 1469 | int present = 0; |
1642 | return; | 1470 | struct via_spec *spec = codec->spec; |
1643 | } | ||
1644 | |||
1645 | hp_present = snd_hda_jack_detect(codec, spec->autocfg.hp_pins[0]); | ||
1646 | 1471 | ||
1647 | if (!spec->hp_independent_mode) | 1472 | if (!spec->hp_independent_mode && spec->autocfg.hp_pins[0]) { |
1648 | snd_hda_codec_amp_stereo( | 1473 | int nums; |
1649 | codec, 0x2A, HDA_OUTPUT, 0, HDA_AMP_MUTE, | 1474 | present = snd_hda_jack_detect(codec, spec->autocfg.hp_pins[0]); |
1650 | hp_present ? HDA_AMP_MUTE : 0); | 1475 | if (spec->smart51_enabled) |
1476 | nums = spec->autocfg.line_outs + spec->smart51_nums; | ||
1477 | else | ||
1478 | nums = spec->autocfg.line_outs; | ||
1479 | toggle_output_mutes(codec, nums, | ||
1480 | spec->autocfg.line_out_pins, | ||
1481 | present); | ||
1482 | } | ||
1483 | via_line_automute(codec, present); | ||
1651 | } | 1484 | } |
1652 | 1485 | ||
1653 | static void via_gpio_control(struct hda_codec *codec) | 1486 | static void via_gpio_control(struct hda_codec *codec) |
@@ -1672,9 +1505,9 @@ static void via_gpio_control(struct hda_codec *codec) | |||
1672 | 1505 | ||
1673 | if (gpio_data == 0x02) { | 1506 | if (gpio_data == 0x02) { |
1674 | /* unmute line out */ | 1507 | /* unmute line out */ |
1675 | snd_hda_codec_amp_stereo(codec, spec->autocfg.line_out_pins[0], | 1508 | snd_hda_codec_write(codec, spec->autocfg.line_out_pins[0], 0, |
1676 | HDA_OUTPUT, 0, HDA_AMP_MUTE, 0); | 1509 | AC_VERB_SET_PIN_WIDGET_CONTROL, |
1677 | 1510 | PIN_OUT); | |
1678 | if (vol_counter & 0x20) { | 1511 | if (vol_counter & 0x20) { |
1679 | /* decrease volume */ | 1512 | /* decrease volume */ |
1680 | if (vol > master_vol) | 1513 | if (vol > master_vol) |
@@ -1691,73 +1524,12 @@ static void via_gpio_control(struct hda_codec *codec) | |||
1691 | } | 1524 | } |
1692 | } else if (!(gpio_data & 0x02)) { | 1525 | } else if (!(gpio_data & 0x02)) { |
1693 | /* mute line out */ | 1526 | /* mute line out */ |
1694 | snd_hda_codec_amp_stereo(codec, | 1527 | snd_hda_codec_write(codec, spec->autocfg.line_out_pins[0], 0, |
1695 | spec->autocfg.line_out_pins[0], | 1528 | AC_VERB_SET_PIN_WIDGET_CONTROL, |
1696 | HDA_OUTPUT, 0, HDA_AMP_MUTE, | 1529 | 0); |
1697 | HDA_AMP_MUTE); | ||
1698 | } | ||
1699 | } | ||
1700 | |||
1701 | /* mute Internal-Speaker if HP is plugged */ | ||
1702 | static void via_speaker_automute(struct hda_codec *codec) | ||
1703 | { | ||
1704 | unsigned int hp_present; | ||
1705 | struct via_spec *spec = codec->spec; | ||
1706 | |||
1707 | if (!VT2002P_COMPATIBLE(spec)) | ||
1708 | return; | ||
1709 | |||
1710 | hp_present = snd_hda_jack_detect(codec, spec->autocfg.hp_pins[0]); | ||
1711 | |||
1712 | if (!spec->hp_independent_mode) { | ||
1713 | struct snd_ctl_elem_id id; | ||
1714 | snd_hda_codec_amp_stereo( | ||
1715 | codec, spec->autocfg.speaker_pins[0], HDA_OUTPUT, 0, | ||
1716 | HDA_AMP_MUTE, hp_present ? HDA_AMP_MUTE : 0); | ||
1717 | /* notify change */ | ||
1718 | memset(&id, 0, sizeof(id)); | ||
1719 | id.iface = SNDRV_CTL_ELEM_IFACE_MIXER; | ||
1720 | strcpy(id.name, "Speaker Playback Switch"); | ||
1721 | snd_ctl_notify(codec->bus->card, SNDRV_CTL_EVENT_MASK_VALUE, | ||
1722 | &id); | ||
1723 | } | ||
1724 | } | ||
1725 | |||
1726 | /* mute line-out and internal speaker if HP is plugged */ | ||
1727 | static void via_hp_bind_automute(struct hda_codec *codec) | ||
1728 | { | ||
1729 | /* use long instead of int below just to avoid an internal compiler | ||
1730 | * error with gcc 4.0.x | ||
1731 | */ | ||
1732 | unsigned long hp_present, present = 0; | ||
1733 | struct via_spec *spec = codec->spec; | ||
1734 | int i; | ||
1735 | |||
1736 | if (!spec->autocfg.hp_pins[0] || !spec->autocfg.line_out_pins[0]) | ||
1737 | return; | ||
1738 | |||
1739 | hp_present = snd_hda_jack_detect(codec, spec->autocfg.hp_pins[0]); | ||
1740 | |||
1741 | present = snd_hda_jack_detect(codec, spec->autocfg.line_out_pins[0]); | ||
1742 | |||
1743 | if (!spec->hp_independent_mode) { | ||
1744 | /* Mute Line-Outs */ | ||
1745 | for (i = 0; i < spec->autocfg.line_outs; i++) | ||
1746 | snd_hda_codec_amp_stereo( | ||
1747 | codec, spec->autocfg.line_out_pins[i], | ||
1748 | HDA_OUTPUT, 0, | ||
1749 | HDA_AMP_MUTE, hp_present ? HDA_AMP_MUTE : 0); | ||
1750 | if (hp_present) | ||
1751 | present = hp_present; | ||
1752 | } | 1530 | } |
1753 | /* Speakers */ | ||
1754 | for (i = 0; i < spec->autocfg.speaker_outs; i++) | ||
1755 | snd_hda_codec_amp_stereo( | ||
1756 | codec, spec->autocfg.speaker_pins[i], HDA_OUTPUT, 0, | ||
1757 | HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0); | ||
1758 | } | 1531 | } |
1759 | 1532 | ||
1760 | |||
1761 | /* unsolicited event for jack sensing */ | 1533 | /* unsolicited event for jack sensing */ |
1762 | static void via_unsol_event(struct hda_codec *codec, | 1534 | static void via_unsol_event(struct hda_codec *codec, |
1763 | unsigned int res) | 1535 | unsigned int res) |
@@ -1773,39 +1545,8 @@ static void via_unsol_event(struct hda_codec *codec, | |||
1773 | via_hp_automute(codec); | 1545 | via_hp_automute(codec); |
1774 | else if (res == VIA_GPIO_EVENT) | 1546 | else if (res == VIA_GPIO_EVENT) |
1775 | via_gpio_control(codec); | 1547 | via_gpio_control(codec); |
1776 | else if (res == VIA_MONO_EVENT) | 1548 | else if (res == VIA_LINE_EVENT) |
1777 | via_mono_automute(codec); | 1549 | via_line_automute(codec, false); |
1778 | else if (res == VIA_SPEAKER_EVENT) | ||
1779 | via_speaker_automute(codec); | ||
1780 | else if (res == VIA_BIND_HP_EVENT) | ||
1781 | via_hp_bind_automute(codec); | ||
1782 | } | ||
1783 | |||
1784 | static int via_init(struct hda_codec *codec) | ||
1785 | { | ||
1786 | struct via_spec *spec = codec->spec; | ||
1787 | int i; | ||
1788 | for (i = 0; i < spec->num_iverbs; i++) | ||
1789 | snd_hda_sequence_write(codec, spec->init_verbs[i]); | ||
1790 | |||
1791 | /* Lydia Add for EAPD enable */ | ||
1792 | if (!spec->dig_in_nid) { /* No Digital In connection */ | ||
1793 | if (spec->dig_in_pin) { | ||
1794 | snd_hda_codec_write(codec, spec->dig_in_pin, 0, | ||
1795 | AC_VERB_SET_PIN_WIDGET_CONTROL, | ||
1796 | PIN_OUT); | ||
1797 | snd_hda_codec_write(codec, spec->dig_in_pin, 0, | ||
1798 | AC_VERB_SET_EAPD_BTLENABLE, 0x02); | ||
1799 | } | ||
1800 | } else /* enable SPDIF-input pin */ | ||
1801 | snd_hda_codec_write(codec, spec->autocfg.dig_in_pin, 0, | ||
1802 | AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN); | ||
1803 | |||
1804 | /* assign slave outs */ | ||
1805 | if (spec->slave_dig_outs[0]) | ||
1806 | codec->slave_dig_outs = spec->slave_dig_outs; | ||
1807 | |||
1808 | return 0; | ||
1809 | } | 1550 | } |
1810 | 1551 | ||
1811 | #ifdef SND_HDA_NEEDS_RESUME | 1552 | #ifdef SND_HDA_NEEDS_RESUME |
@@ -1827,11 +1568,15 @@ static int via_check_power_status(struct hda_codec *codec, hda_nid_t nid) | |||
1827 | 1568 | ||
1828 | /* | 1569 | /* |
1829 | */ | 1570 | */ |
1571 | |||
1572 | static int via_init(struct hda_codec *codec); | ||
1573 | |||
1830 | static const struct hda_codec_ops via_patch_ops = { | 1574 | static const struct hda_codec_ops via_patch_ops = { |
1831 | .build_controls = via_build_controls, | 1575 | .build_controls = via_build_controls, |
1832 | .build_pcms = via_build_pcms, | 1576 | .build_pcms = via_build_pcms, |
1833 | .init = via_init, | 1577 | .init = via_init, |
1834 | .free = via_free, | 1578 | .free = via_free, |
1579 | .unsol_event = via_unsol_event, | ||
1835 | #ifdef SND_HDA_NEEDS_RESUME | 1580 | #ifdef SND_HDA_NEEDS_RESUME |
1836 | .suspend = via_suspend, | 1581 | .suspend = via_suspend, |
1837 | #endif | 1582 | #endif |
@@ -1840,237 +1585,696 @@ static const struct hda_codec_ops via_patch_ops = { | |||
1840 | #endif | 1585 | #endif |
1841 | }; | 1586 | }; |
1842 | 1587 | ||
1843 | /* fill in the dac_nids table from the parsed pin configuration */ | 1588 | static bool is_empty_dac(struct hda_codec *codec, hda_nid_t dac) |
1844 | static int vt1708_auto_fill_dac_nids(struct via_spec *spec, | ||
1845 | const struct auto_pin_cfg *cfg) | ||
1846 | { | 1589 | { |
1590 | struct via_spec *spec = codec->spec; | ||
1591 | int i; | ||
1592 | |||
1593 | for (i = 0; i < spec->multiout.num_dacs; i++) { | ||
1594 | if (spec->multiout.dac_nids[i] == dac) | ||
1595 | return false; | ||
1596 | } | ||
1597 | if (spec->hp_dac_nid == dac) | ||
1598 | return false; | ||
1599 | return true; | ||
1600 | } | ||
1601 | |||
1602 | static bool __parse_output_path(struct hda_codec *codec, hda_nid_t nid, | ||
1603 | hda_nid_t target_dac, struct nid_path *path, | ||
1604 | int depth, int wid_type) | ||
1605 | { | ||
1606 | hda_nid_t conn[8]; | ||
1607 | int i, nums; | ||
1608 | |||
1609 | nums = snd_hda_get_connections(codec, nid, conn, ARRAY_SIZE(conn)); | ||
1610 | for (i = 0; i < nums; i++) { | ||
1611 | if (get_wcaps_type(get_wcaps(codec, conn[i])) != AC_WID_AUD_OUT) | ||
1612 | continue; | ||
1613 | if (conn[i] == target_dac || is_empty_dac(codec, conn[i])) | ||
1614 | goto found; | ||
1615 | } | ||
1616 | if (depth >= MAX_NID_PATH_DEPTH) | ||
1617 | return false; | ||
1618 | for (i = 0; i < nums; i++) { | ||
1619 | unsigned int type; | ||
1620 | type = get_wcaps_type(get_wcaps(codec, conn[i])); | ||
1621 | if (type == AC_WID_AUD_OUT || | ||
1622 | (wid_type != -1 && type != wid_type)) | ||
1623 | continue; | ||
1624 | if (__parse_output_path(codec, conn[i], target_dac, | ||
1625 | path, depth + 1, AC_WID_AUD_SEL)) | ||
1626 | goto found; | ||
1627 | } | ||
1628 | return false; | ||
1629 | |||
1630 | found: | ||
1631 | path->path[path->depth] = conn[i]; | ||
1632 | path->idx[path->depth] = i; | ||
1633 | if (nums > 1 && get_wcaps_type(get_wcaps(codec, nid)) != AC_WID_AUD_MIX) | ||
1634 | path->multi[path->depth] = 1; | ||
1635 | path->depth++; | ||
1636 | return true; | ||
1637 | } | ||
1638 | |||
1639 | static bool parse_output_path(struct hda_codec *codec, hda_nid_t nid, | ||
1640 | hda_nid_t target_dac, struct nid_path *path) | ||
1641 | { | ||
1642 | if (__parse_output_path(codec, nid, target_dac, path, 1, -1)) { | ||
1643 | path->path[path->depth] = nid; | ||
1644 | path->depth++; | ||
1645 | return true; | ||
1646 | } | ||
1647 | return false; | ||
1648 | } | ||
1649 | |||
1650 | static int via_auto_fill_dac_nids(struct hda_codec *codec) | ||
1651 | { | ||
1652 | struct via_spec *spec = codec->spec; | ||
1653 | const struct auto_pin_cfg *cfg = &spec->autocfg; | ||
1847 | int i; | 1654 | int i; |
1848 | hda_nid_t nid; | 1655 | hda_nid_t nid; |
1849 | 1656 | ||
1657 | spec->multiout.dac_nids = spec->private_dac_nids; | ||
1850 | spec->multiout.num_dacs = cfg->line_outs; | 1658 | spec->multiout.num_dacs = cfg->line_outs; |
1659 | for (i = 0; i < cfg->line_outs; i++) { | ||
1660 | nid = cfg->line_out_pins[i]; | ||
1661 | if (!nid) | ||
1662 | continue; | ||
1663 | if (parse_output_path(codec, nid, 0, &spec->out_path[i])) | ||
1664 | spec->private_dac_nids[i] = spec->out_path[i].path[0]; | ||
1665 | } | ||
1666 | return 0; | ||
1667 | } | ||
1851 | 1668 | ||
1852 | spec->multiout.dac_nids = spec->private_dac_nids; | 1669 | static int create_ch_ctls(struct hda_codec *codec, const char *pfx, |
1670 | int chs, bool check_dac, struct nid_path *path) | ||
1671 | { | ||
1672 | struct via_spec *spec = codec->spec; | ||
1673 | char name[32]; | ||
1674 | hda_nid_t dac, pin, sel, nid; | ||
1675 | int err; | ||
1853 | 1676 | ||
1854 | for (i = 0; i < 4; i++) { | 1677 | dac = check_dac ? path->path[0] : 0; |
1855 | nid = cfg->line_out_pins[i]; | 1678 | pin = path->path[path->depth - 1]; |
1856 | if (nid) { | 1679 | sel = path->depth > 1 ? path->path[1] : 0; |
1857 | /* config dac list */ | 1680 | |
1858 | switch (i) { | 1681 | if (dac && check_amp_caps(codec, dac, HDA_OUTPUT, AC_AMPCAP_NUM_STEPS)) |
1859 | case AUTO_SEQ_FRONT: | 1682 | nid = dac; |
1860 | spec->private_dac_nids[i] = 0x10; | 1683 | else if (check_amp_caps(codec, pin, HDA_OUTPUT, AC_AMPCAP_NUM_STEPS)) |
1861 | break; | 1684 | nid = pin; |
1862 | case AUTO_SEQ_CENLFE: | 1685 | else if (check_amp_caps(codec, sel, HDA_OUTPUT, AC_AMPCAP_NUM_STEPS)) |
1863 | spec->private_dac_nids[i] = 0x12; | 1686 | nid = sel; |
1864 | break; | 1687 | else |
1865 | case AUTO_SEQ_SURROUND: | 1688 | nid = 0; |
1866 | spec->private_dac_nids[i] = 0x11; | 1689 | if (nid) { |
1867 | break; | 1690 | sprintf(name, "%s Playback Volume", pfx); |
1868 | case AUTO_SEQ_SIDE: | 1691 | err = via_add_control(spec, VIA_CTL_WIDGET_VOL, name, |
1869 | spec->private_dac_nids[i] = 0x13; | 1692 | HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_OUTPUT)); |
1870 | break; | 1693 | if (err < 0) |
1871 | } | 1694 | return err; |
1872 | } | 1695 | path->vol_ctl = nid; |
1873 | } | 1696 | } |
1874 | 1697 | ||
1698 | if (dac && check_amp_caps(codec, dac, HDA_OUTPUT, AC_AMPCAP_MUTE)) | ||
1699 | nid = dac; | ||
1700 | else if (check_amp_caps(codec, pin, HDA_OUTPUT, AC_AMPCAP_MUTE)) | ||
1701 | nid = pin; | ||
1702 | else if (check_amp_caps(codec, sel, HDA_OUTPUT, AC_AMPCAP_MUTE)) | ||
1703 | nid = sel; | ||
1704 | else | ||
1705 | nid = 0; | ||
1706 | if (nid) { | ||
1707 | sprintf(name, "%s Playback Switch", pfx); | ||
1708 | err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, name, | ||
1709 | HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_OUTPUT)); | ||
1710 | if (err < 0) | ||
1711 | return err; | ||
1712 | path->mute_ctl = nid; | ||
1713 | } | ||
1875 | return 0; | 1714 | return 0; |
1876 | } | 1715 | } |
1877 | 1716 | ||
1717 | static void mangle_smart51(struct hda_codec *codec) | ||
1718 | { | ||
1719 | struct via_spec *spec = codec->spec; | ||
1720 | struct auto_pin_cfg *cfg = &spec->autocfg; | ||
1721 | struct auto_pin_cfg_item *ins = cfg->inputs; | ||
1722 | int i, j, nums, attr; | ||
1723 | int pins[AUTO_CFG_MAX_INS]; | ||
1724 | |||
1725 | for (attr = INPUT_PIN_ATTR_REAR; attr >= INPUT_PIN_ATTR_NORMAL; attr--) { | ||
1726 | nums = 0; | ||
1727 | for (i = 0; i < cfg->num_inputs; i++) { | ||
1728 | unsigned int def; | ||
1729 | if (ins[i].type > AUTO_PIN_LINE_IN) | ||
1730 | continue; | ||
1731 | def = snd_hda_codec_get_pincfg(codec, ins[i].pin); | ||
1732 | if (snd_hda_get_input_pin_attr(def) != attr) | ||
1733 | continue; | ||
1734 | for (j = 0; j < nums; j++) | ||
1735 | if (ins[pins[j]].type < ins[i].type) { | ||
1736 | memmove(pins + j + 1, pins + j, | ||
1737 | (nums - j - 1) * sizeof(int)); | ||
1738 | break; | ||
1739 | } | ||
1740 | pins[j] = i; | ||
1741 | nums++; | ||
1742 | } | ||
1743 | if (cfg->line_outs + nums < 3) | ||
1744 | continue; | ||
1745 | for (i = 0; i < nums; i++) { | ||
1746 | hda_nid_t pin = ins[pins[i]].pin; | ||
1747 | spec->smart51_pins[spec->smart51_nums++] = pin; | ||
1748 | cfg->line_out_pins[cfg->line_outs++] = pin; | ||
1749 | if (cfg->line_outs == 3) | ||
1750 | break; | ||
1751 | } | ||
1752 | return; | ||
1753 | } | ||
1754 | } | ||
1755 | |||
1878 | /* add playback controls from the parsed DAC table */ | 1756 | /* add playback controls from the parsed DAC table */ |
1879 | static int vt1708_auto_create_multi_out_ctls(struct via_spec *spec, | 1757 | static int via_auto_create_multi_out_ctls(struct hda_codec *codec) |
1880 | const struct auto_pin_cfg *cfg) | ||
1881 | { | 1758 | { |
1882 | char name[32]; | 1759 | struct via_spec *spec = codec->spec; |
1760 | struct auto_pin_cfg *cfg = &spec->autocfg; | ||
1883 | static const char * const chname[4] = { | 1761 | static const char * const chname[4] = { |
1884 | "Front", "Surround", "C/LFE", "Side" | 1762 | "Front", "Surround", "C/LFE", "Side" |
1885 | }; | 1763 | }; |
1886 | hda_nid_t nid, nid_vol, nid_vols[] = {0x17, 0x19, 0x1a, 0x1b}; | 1764 | int i, idx, err; |
1887 | int i, err; | 1765 | int old_line_outs; |
1888 | |||
1889 | for (i = 0; i <= AUTO_SEQ_SIDE; i++) { | ||
1890 | nid = cfg->line_out_pins[i]; | ||
1891 | 1766 | ||
1892 | if (!nid) | 1767 | /* check smart51 */ |
1893 | continue; | 1768 | old_line_outs = cfg->line_outs; |
1894 | 1769 | if (cfg->line_outs == 1) | |
1895 | nid_vol = nid_vols[i]; | 1770 | mangle_smart51(codec); |
1896 | 1771 | ||
1897 | if (i == AUTO_SEQ_CENLFE) { | 1772 | err = via_auto_fill_dac_nids(codec); |
1898 | /* Center/LFE */ | 1773 | if (err < 0) |
1899 | err = via_add_control(spec, VIA_CTL_WIDGET_VOL, | 1774 | return err; |
1900 | "Center Playback Volume", | ||
1901 | HDA_COMPOSE_AMP_VAL(nid_vol, 1, 0, | ||
1902 | HDA_OUTPUT)); | ||
1903 | if (err < 0) | ||
1904 | return err; | ||
1905 | err = via_add_control(spec, VIA_CTL_WIDGET_VOL, | ||
1906 | "LFE Playback Volume", | ||
1907 | HDA_COMPOSE_AMP_VAL(nid_vol, 2, 0, | ||
1908 | HDA_OUTPUT)); | ||
1909 | if (err < 0) | ||
1910 | return err; | ||
1911 | err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, | ||
1912 | "Center Playback Switch", | ||
1913 | HDA_COMPOSE_AMP_VAL(nid_vol, 1, 0, | ||
1914 | HDA_OUTPUT)); | ||
1915 | if (err < 0) | ||
1916 | return err; | ||
1917 | err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, | ||
1918 | "LFE Playback Switch", | ||
1919 | HDA_COMPOSE_AMP_VAL(nid_vol, 2, 0, | ||
1920 | HDA_OUTPUT)); | ||
1921 | if (err < 0) | ||
1922 | return err; | ||
1923 | } else if (i == AUTO_SEQ_FRONT) { | ||
1924 | /* add control to mixer index 0 */ | ||
1925 | err = via_add_control(spec, VIA_CTL_WIDGET_VOL, | ||
1926 | "Master Front Playback Volume", | ||
1927 | HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, | ||
1928 | HDA_INPUT)); | ||
1929 | if (err < 0) | ||
1930 | return err; | ||
1931 | err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, | ||
1932 | "Master Front Playback Switch", | ||
1933 | HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, | ||
1934 | HDA_INPUT)); | ||
1935 | if (err < 0) | ||
1936 | return err; | ||
1937 | 1775 | ||
1938 | /* add control to PW3 */ | 1776 | for (i = 0; i < cfg->line_outs; i++) { |
1939 | sprintf(name, "%s Playback Volume", chname[i]); | 1777 | hda_nid_t pin, dac; |
1940 | err = via_add_control(spec, VIA_CTL_WIDGET_VOL, name, | 1778 | pin = cfg->line_out_pins[i]; |
1941 | HDA_COMPOSE_AMP_VAL(nid, 3, 0, | 1779 | dac = spec->multiout.dac_nids[i]; |
1942 | HDA_OUTPUT)); | 1780 | if (!pin || !dac) |
1781 | continue; | ||
1782 | if (i == HDA_CLFE) { | ||
1783 | err = create_ch_ctls(codec, "Center", 1, true, | ||
1784 | &spec->out_path[i]); | ||
1943 | if (err < 0) | 1785 | if (err < 0) |
1944 | return err; | 1786 | return err; |
1945 | sprintf(name, "%s Playback Switch", chname[i]); | 1787 | err = create_ch_ctls(codec, "LFE", 2, true, |
1946 | err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, name, | 1788 | &spec->out_path[i]); |
1947 | HDA_COMPOSE_AMP_VAL(nid, 3, 0, | ||
1948 | HDA_OUTPUT)); | ||
1949 | if (err < 0) | 1789 | if (err < 0) |
1950 | return err; | 1790 | return err; |
1951 | } else { | 1791 | } else { |
1952 | sprintf(name, "%s Playback Volume", chname[i]); | 1792 | const char *pfx = chname[i]; |
1953 | err = via_add_control(spec, VIA_CTL_WIDGET_VOL, name, | 1793 | if (cfg->line_out_type == AUTO_PIN_SPEAKER_OUT && |
1954 | HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, | 1794 | cfg->line_outs == 1) |
1955 | HDA_OUTPUT)); | 1795 | pfx = "Speaker"; |
1956 | if (err < 0) | 1796 | err = create_ch_ctls(codec, pfx, 3, true, |
1957 | return err; | 1797 | &spec->out_path[i]); |
1958 | sprintf(name, "%s Playback Switch", chname[i]); | ||
1959 | err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, name, | ||
1960 | HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, | ||
1961 | HDA_OUTPUT)); | ||
1962 | if (err < 0) | 1798 | if (err < 0) |
1963 | return err; | 1799 | return err; |
1964 | } | 1800 | } |
1965 | } | 1801 | } |
1966 | 1802 | ||
1803 | idx = get_connection_index(codec, spec->aa_mix_nid, | ||
1804 | spec->multiout.dac_nids[0]); | ||
1805 | if (idx >= 0) { | ||
1806 | /* add control to mixer */ | ||
1807 | err = via_add_control(spec, VIA_CTL_WIDGET_VOL, | ||
1808 | "PCM Playback Volume", | ||
1809 | HDA_COMPOSE_AMP_VAL(spec->aa_mix_nid, 3, | ||
1810 | idx, HDA_INPUT)); | ||
1811 | if (err < 0) | ||
1812 | return err; | ||
1813 | err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, | ||
1814 | "PCM Playback Switch", | ||
1815 | HDA_COMPOSE_AMP_VAL(spec->aa_mix_nid, 3, | ||
1816 | idx, HDA_INPUT)); | ||
1817 | if (err < 0) | ||
1818 | return err; | ||
1819 | } | ||
1820 | |||
1821 | cfg->line_outs = old_line_outs; | ||
1822 | |||
1823 | return 0; | ||
1824 | } | ||
1825 | |||
1826 | static int via_auto_create_hp_ctls(struct hda_codec *codec, hda_nid_t pin) | ||
1827 | { | ||
1828 | struct via_spec *spec = codec->spec; | ||
1829 | struct nid_path *path; | ||
1830 | int err; | ||
1831 | |||
1832 | if (!pin) | ||
1833 | return 0; | ||
1834 | |||
1835 | if (parse_output_path(codec, pin, 0, &spec->hp_path)) | ||
1836 | spec->hp_dac_nid = spec->hp_path.path[0]; | ||
1837 | |||
1838 | if (!parse_output_path(codec, pin, spec->multiout.dac_nids[HDA_FRONT], | ||
1839 | &spec->hp_dep_path) && | ||
1840 | !spec->hp_dac_nid) | ||
1841 | return 0; | ||
1842 | |||
1843 | if (spec->hp_dac_nid) | ||
1844 | path = &spec->hp_path; | ||
1845 | else | ||
1846 | path = &spec->hp_dep_path; | ||
1847 | err = create_ch_ctls(codec, "Headphone", 3, false, path); | ||
1848 | if (err < 0) | ||
1849 | return err; | ||
1850 | if (spec->hp_dac_nid) { | ||
1851 | spec->hp_dep_path.vol_ctl = spec->hp_path.vol_ctl; | ||
1852 | spec->hp_dep_path.mute_ctl = spec->hp_path.mute_ctl; | ||
1853 | } | ||
1854 | |||
1967 | return 0; | 1855 | return 0; |
1968 | } | 1856 | } |
1969 | 1857 | ||
1970 | static void create_hp_imux(struct via_spec *spec) | 1858 | static int via_auto_create_speaker_ctls(struct hda_codec *codec) |
1971 | { | 1859 | { |
1860 | struct via_spec *spec = codec->spec; | ||
1861 | hda_nid_t pin, dac; | ||
1862 | |||
1863 | pin = spec->autocfg.speaker_pins[0]; | ||
1864 | if (!spec->autocfg.speaker_outs || !pin) | ||
1865 | return 0; | ||
1866 | |||
1867 | if (parse_output_path(codec, pin, 0, &spec->speaker_path)) { | ||
1868 | dac = spec->speaker_path.path[0]; | ||
1869 | spec->multiout.extra_out_nid[0] = dac; | ||
1870 | return create_ch_ctls(codec, "Speaker", 3, true, | ||
1871 | &spec->speaker_path); | ||
1872 | } | ||
1873 | if (parse_output_path(codec, pin, spec->multiout.dac_nids[HDA_FRONT], | ||
1874 | &spec->speaker_path)) | ||
1875 | return create_ch_ctls(codec, "Speaker", 3, false, | ||
1876 | &spec->speaker_path); | ||
1877 | |||
1878 | return 0; | ||
1879 | } | ||
1880 | |||
1881 | /* look for ADCs */ | ||
1882 | static int via_fill_adcs(struct hda_codec *codec) | ||
1883 | { | ||
1884 | struct via_spec *spec = codec->spec; | ||
1885 | hda_nid_t nid = codec->start_nid; | ||
1972 | int i; | 1886 | int i; |
1973 | struct hda_input_mux *imux = &spec->private_imux[1]; | ||
1974 | static const char * const texts[] = { "OFF", "ON", NULL}; | ||
1975 | 1887 | ||
1976 | /* for hp mode select */ | 1888 | for (i = 0; i < codec->num_nodes; i++, nid++) { |
1977 | for (i = 0; texts[i]; i++) | 1889 | unsigned int wcaps = get_wcaps(codec, nid); |
1978 | snd_hda_add_imux_item(imux, texts[i], i, NULL); | 1890 | if (get_wcaps_type(wcaps) != AC_WID_AUD_IN) |
1891 | continue; | ||
1892 | if (wcaps & AC_WCAP_DIGITAL) | ||
1893 | continue; | ||
1894 | if (!(wcaps & AC_WCAP_CONN_LIST)) | ||
1895 | continue; | ||
1896 | if (spec->num_adc_nids >= ARRAY_SIZE(spec->adc_nids)) | ||
1897 | return -ENOMEM; | ||
1898 | spec->adc_nids[spec->num_adc_nids++] = nid; | ||
1899 | } | ||
1900 | return 0; | ||
1901 | } | ||
1902 | |||
1903 | /* input-src control */ | ||
1904 | static int via_mux_enum_info(struct snd_kcontrol *kcontrol, | ||
1905 | struct snd_ctl_elem_info *uinfo) | ||
1906 | { | ||
1907 | struct hda_codec *codec = snd_kcontrol_chip(kcontrol); | ||
1908 | struct via_spec *spec = codec->spec; | ||
1979 | 1909 | ||
1980 | spec->hp_mux = &spec->private_imux[1]; | 1910 | uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED; |
1911 | uinfo->count = 1; | ||
1912 | uinfo->value.enumerated.items = spec->num_inputs; | ||
1913 | if (uinfo->value.enumerated.item >= spec->num_inputs) | ||
1914 | uinfo->value.enumerated.item = spec->num_inputs - 1; | ||
1915 | strcpy(uinfo->value.enumerated.name, | ||
1916 | spec->inputs[uinfo->value.enumerated.item].label); | ||
1917 | return 0; | ||
1981 | } | 1918 | } |
1982 | 1919 | ||
1983 | static int vt1708_auto_create_hp_ctls(struct via_spec *spec, hda_nid_t pin) | 1920 | static int via_mux_enum_get(struct snd_kcontrol *kcontrol, |
1921 | struct snd_ctl_elem_value *ucontrol) | ||
1984 | { | 1922 | { |
1985 | int err; | 1923 | struct hda_codec *codec = snd_kcontrol_chip(kcontrol); |
1924 | struct via_spec *spec = codec->spec; | ||
1925 | unsigned int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id); | ||
1986 | 1926 | ||
1987 | if (!pin) | 1927 | ucontrol->value.enumerated.item[0] = spec->cur_mux[idx]; |
1928 | return 0; | ||
1929 | } | ||
1930 | |||
1931 | static int via_mux_enum_put(struct snd_kcontrol *kcontrol, | ||
1932 | struct snd_ctl_elem_value *ucontrol) | ||
1933 | { | ||
1934 | struct hda_codec *codec = snd_kcontrol_chip(kcontrol); | ||
1935 | struct via_spec *spec = codec->spec; | ||
1936 | unsigned int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id); | ||
1937 | hda_nid_t mux; | ||
1938 | int cur; | ||
1939 | |||
1940 | cur = ucontrol->value.enumerated.item[0]; | ||
1941 | if (cur < 0 || cur >= spec->num_inputs) | ||
1942 | return -EINVAL; | ||
1943 | if (spec->cur_mux[idx] == cur) | ||
1988 | return 0; | 1944 | return 0; |
1945 | spec->cur_mux[idx] = cur; | ||
1946 | if (spec->dyn_adc_switch) { | ||
1947 | int adc_idx = spec->inputs[cur].adc_idx; | ||
1948 | mux = spec->mux_nids[adc_idx]; | ||
1949 | via_dyn_adc_pcm_resetup(codec, cur); | ||
1950 | } else { | ||
1951 | mux = spec->mux_nids[idx]; | ||
1952 | if (snd_BUG_ON(!mux)) | ||
1953 | return -EINVAL; | ||
1954 | } | ||
1955 | |||
1956 | if (mux) { | ||
1957 | /* switch to D0 beofre change index */ | ||
1958 | if (snd_hda_codec_read(codec, mux, 0, | ||
1959 | AC_VERB_GET_POWER_STATE, 0x00) != AC_PWRST_D0) | ||
1960 | snd_hda_codec_write(codec, mux, 0, | ||
1961 | AC_VERB_SET_POWER_STATE, AC_PWRST_D0); | ||
1962 | snd_hda_codec_write(codec, mux, 0, | ||
1963 | AC_VERB_SET_CONNECT_SEL, | ||
1964 | spec->inputs[cur].mux_idx); | ||
1965 | } | ||
1989 | 1966 | ||
1990 | spec->multiout.hp_nid = VT1708_HP_NID; /* AOW3 */ | 1967 | /* update jack power state */ |
1991 | spec->hp_independent_mode_index = 1; | 1968 | set_widgets_power_state(codec); |
1969 | return 0; | ||
1970 | } | ||
1992 | 1971 | ||
1993 | err = via_add_control(spec, VIA_CTL_WIDGET_VOL, | 1972 | static const struct snd_kcontrol_new via_input_src_ctl = { |
1994 | "Headphone Playback Volume", | 1973 | .iface = SNDRV_CTL_ELEM_IFACE_MIXER, |
1995 | HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT)); | 1974 | /* The multiple "Capture Source" controls confuse alsamixer |
1975 | * So call somewhat different.. | ||
1976 | */ | ||
1977 | /* .name = "Capture Source", */ | ||
1978 | .name = "Input Source", | ||
1979 | .info = via_mux_enum_info, | ||
1980 | .get = via_mux_enum_get, | ||
1981 | .put = via_mux_enum_put, | ||
1982 | }; | ||
1983 | |||
1984 | static int create_input_src_ctls(struct hda_codec *codec, int count) | ||
1985 | { | ||
1986 | struct via_spec *spec = codec->spec; | ||
1987 | struct snd_kcontrol_new *knew; | ||
1988 | |||
1989 | if (spec->num_inputs <= 1 || !count) | ||
1990 | return 0; /* no need for single src */ | ||
1991 | |||
1992 | knew = via_clone_control(spec, &via_input_src_ctl); | ||
1993 | if (!knew) | ||
1994 | return -ENOMEM; | ||
1995 | knew->count = count; | ||
1996 | return 0; | ||
1997 | } | ||
1998 | |||
1999 | /* add the powersave loopback-list entry */ | ||
2000 | static void add_loopback_list(struct via_spec *spec, hda_nid_t mix, int idx) | ||
2001 | { | ||
2002 | struct hda_amp_list *list; | ||
2003 | |||
2004 | if (spec->num_loopbacks >= ARRAY_SIZE(spec->loopback_list) - 1) | ||
2005 | return; | ||
2006 | list = spec->loopback_list + spec->num_loopbacks; | ||
2007 | list->nid = mix; | ||
2008 | list->dir = HDA_INPUT; | ||
2009 | list->idx = idx; | ||
2010 | spec->num_loopbacks++; | ||
2011 | spec->loopback.amplist = spec->loopback_list; | ||
2012 | } | ||
2013 | |||
2014 | /* check whether the path from src to dst is reachable */ | ||
2015 | static bool is_reachable_nid(struct hda_codec *codec, hda_nid_t src, | ||
2016 | hda_nid_t dst, int depth) | ||
2017 | { | ||
2018 | hda_nid_t conn[8]; | ||
2019 | int i, nums; | ||
2020 | |||
2021 | nums = snd_hda_get_connections(codec, src, conn, ARRAY_SIZE(conn)); | ||
2022 | for (i = 0; i < nums; i++) | ||
2023 | if (conn[i] == dst) | ||
2024 | return true; | ||
2025 | if (++depth > MAX_NID_PATH_DEPTH) | ||
2026 | return false; | ||
2027 | for (i = 0; i < nums; i++) | ||
2028 | if (is_reachable_nid(codec, conn[i], dst, depth)) | ||
2029 | return true; | ||
2030 | return false; | ||
2031 | } | ||
2032 | |||
2033 | /* add the input-route to the given pin */ | ||
2034 | static bool add_input_route(struct hda_codec *codec, hda_nid_t pin) | ||
2035 | { | ||
2036 | struct via_spec *spec = codec->spec; | ||
2037 | int c, idx; | ||
2038 | |||
2039 | spec->inputs[spec->num_inputs].adc_idx = -1; | ||
2040 | spec->inputs[spec->num_inputs].pin = pin; | ||
2041 | for (c = 0; c < spec->num_adc_nids; c++) { | ||
2042 | if (spec->mux_nids[c]) { | ||
2043 | idx = get_connection_index(codec, spec->mux_nids[c], | ||
2044 | pin); | ||
2045 | if (idx < 0) | ||
2046 | continue; | ||
2047 | spec->inputs[spec->num_inputs].mux_idx = idx; | ||
2048 | } else { | ||
2049 | if (!is_reachable_nid(codec, spec->adc_nids[c], pin, 0)) | ||
2050 | continue; | ||
2051 | } | ||
2052 | spec->inputs[spec->num_inputs].adc_idx = c; | ||
2053 | /* Can primary ADC satisfy all inputs? */ | ||
2054 | if (!spec->dyn_adc_switch && | ||
2055 | spec->num_inputs > 0 && spec->inputs[0].adc_idx != c) { | ||
2056 | snd_printd(KERN_INFO | ||
2057 | "via: dynamic ADC switching enabled\n"); | ||
2058 | spec->dyn_adc_switch = 1; | ||
2059 | } | ||
2060 | return true; | ||
2061 | } | ||
2062 | return false; | ||
2063 | } | ||
2064 | |||
2065 | static int get_mux_nids(struct hda_codec *codec); | ||
2066 | |||
2067 | /* parse input-routes; fill ADCs, MUXs and input-src entries */ | ||
2068 | static int parse_analog_inputs(struct hda_codec *codec) | ||
2069 | { | ||
2070 | struct via_spec *spec = codec->spec; | ||
2071 | const struct auto_pin_cfg *cfg = &spec->autocfg; | ||
2072 | int i, err; | ||
2073 | |||
2074 | err = via_fill_adcs(codec); | ||
1996 | if (err < 0) | 2075 | if (err < 0) |
1997 | return err; | 2076 | return err; |
1998 | err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, | 2077 | err = get_mux_nids(codec); |
1999 | "Headphone Playback Switch", | ||
2000 | HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT)); | ||
2001 | if (err < 0) | 2078 | if (err < 0) |
2002 | return err; | 2079 | return err; |
2003 | 2080 | ||
2004 | create_hp_imux(spec); | 2081 | /* fill all input-routes */ |
2082 | for (i = 0; i < cfg->num_inputs; i++) { | ||
2083 | if (add_input_route(codec, cfg->inputs[i].pin)) | ||
2084 | spec->inputs[spec->num_inputs++].label = | ||
2085 | hda_get_autocfg_input_label(codec, cfg, i); | ||
2086 | } | ||
2087 | |||
2088 | /* check for internal loopback recording */ | ||
2089 | if (spec->aa_mix_nid && | ||
2090 | add_input_route(codec, spec->aa_mix_nid)) | ||
2091 | spec->inputs[spec->num_inputs++].label = "Stereo Mixer"; | ||
2005 | 2092 | ||
2006 | return 0; | 2093 | return 0; |
2007 | } | 2094 | } |
2008 | 2095 | ||
2009 | /* create playback/capture controls for input pins */ | 2096 | /* create analog-loopback volume/switch controls */ |
2010 | static int vt_auto_create_analog_input_ctls(struct hda_codec *codec, | 2097 | static int create_loopback_ctls(struct hda_codec *codec) |
2011 | const struct auto_pin_cfg *cfg, | ||
2012 | hda_nid_t cap_nid, | ||
2013 | const hda_nid_t pin_idxs[], | ||
2014 | int num_idxs) | ||
2015 | { | 2098 | { |
2016 | struct via_spec *spec = codec->spec; | 2099 | struct via_spec *spec = codec->spec; |
2017 | struct hda_input_mux *imux = &spec->private_imux[0]; | 2100 | const struct auto_pin_cfg *cfg = &spec->autocfg; |
2018 | int i, err, idx, type, type_idx = 0; | 2101 | const char *prev_label = NULL; |
2102 | int type_idx = 0; | ||
2103 | int i, j, err, idx; | ||
2019 | 2104 | ||
2020 | /* for internal loopback recording select */ | 2105 | if (!spec->aa_mix_nid) |
2021 | for (idx = 0; idx < num_idxs; idx++) { | 2106 | return 0; |
2022 | if (pin_idxs[idx] == 0xff) { | 2107 | |
2023 | snd_hda_add_imux_item(imux, "Stereo Mixer", idx, NULL); | 2108 | for (i = 0; i < cfg->num_inputs; i++) { |
2024 | break; | 2109 | hda_nid_t pin = cfg->inputs[i].pin; |
2110 | const char *label = hda_get_autocfg_input_label(codec, cfg, i); | ||
2111 | |||
2112 | if (prev_label && !strcmp(label, prev_label)) | ||
2113 | type_idx++; | ||
2114 | else | ||
2115 | type_idx = 0; | ||
2116 | prev_label = label; | ||
2117 | idx = get_connection_index(codec, spec->aa_mix_nid, pin); | ||
2118 | if (idx >= 0) { | ||
2119 | err = via_new_analog_input(spec, label, type_idx, | ||
2120 | idx, spec->aa_mix_nid); | ||
2121 | if (err < 0) | ||
2122 | return err; | ||
2123 | add_loopback_list(spec, spec->aa_mix_nid, idx); | ||
2124 | } | ||
2125 | |||
2126 | /* remember the label for smart51 control */ | ||
2127 | for (j = 0; j < spec->smart51_nums; j++) { | ||
2128 | if (spec->smart51_pins[j] == pin) { | ||
2129 | spec->smart51_idxs[j] = idx; | ||
2130 | spec->smart51_labels[j] = label; | ||
2131 | break; | ||
2132 | } | ||
2025 | } | 2133 | } |
2026 | } | 2134 | } |
2135 | return 0; | ||
2136 | } | ||
2137 | |||
2138 | /* create mic-boost controls (if present) */ | ||
2139 | static int create_mic_boost_ctls(struct hda_codec *codec) | ||
2140 | { | ||
2141 | struct via_spec *spec = codec->spec; | ||
2142 | const struct auto_pin_cfg *cfg = &spec->autocfg; | ||
2143 | int i, err; | ||
2027 | 2144 | ||
2028 | for (i = 0; i < cfg->num_inputs; i++) { | 2145 | for (i = 0; i < cfg->num_inputs; i++) { |
2146 | hda_nid_t pin = cfg->inputs[i].pin; | ||
2147 | unsigned int caps; | ||
2029 | const char *label; | 2148 | const char *label; |
2030 | type = cfg->inputs[i].type; | 2149 | char name[32]; |
2031 | for (idx = 0; idx < num_idxs; idx++) | 2150 | |
2032 | if (pin_idxs[idx] == cfg->inputs[i].pin) | 2151 | if (cfg->inputs[i].type != AUTO_PIN_MIC) |
2033 | break; | 2152 | continue; |
2034 | if (idx >= num_idxs) | 2153 | caps = query_amp_caps(codec, pin, HDA_INPUT); |
2154 | if (caps == -1 || !(caps & AC_AMPCAP_NUM_STEPS)) | ||
2035 | continue; | 2155 | continue; |
2036 | if (i > 0 && type == cfg->inputs[i - 1].type) | ||
2037 | type_idx++; | ||
2038 | else | ||
2039 | type_idx = 0; | ||
2040 | label = hda_get_autocfg_input_label(codec, cfg, i); | 2156 | label = hda_get_autocfg_input_label(codec, cfg, i); |
2041 | if (spec->codec_type == VT1708S || | 2157 | snprintf(name, sizeof(name), "%s Boost Volume", label); |
2042 | spec->codec_type == VT1702 || | 2158 | err = via_add_control(spec, VIA_CTL_WIDGET_VOL, name, |
2043 | spec->codec_type == VT1716S) | 2159 | HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_INPUT)); |
2044 | err = via_new_analog_input(spec, label, type_idx, | ||
2045 | idx+1, cap_nid); | ||
2046 | else | ||
2047 | err = via_new_analog_input(spec, label, type_idx, | ||
2048 | idx, cap_nid); | ||
2049 | if (err < 0) | 2160 | if (err < 0) |
2050 | return err; | 2161 | return err; |
2051 | snd_hda_add_imux_item(imux, label, idx, NULL); | ||
2052 | } | 2162 | } |
2053 | return 0; | 2163 | return 0; |
2054 | } | 2164 | } |
2055 | 2165 | ||
2056 | /* create playback/capture controls for input pins */ | 2166 | /* create capture and input-src controls for multiple streams */ |
2057 | static int vt1708_auto_create_analog_input_ctls(struct hda_codec *codec, | 2167 | static int create_multi_adc_ctls(struct hda_codec *codec) |
2058 | const struct auto_pin_cfg *cfg) | ||
2059 | { | 2168 | { |
2060 | static const hda_nid_t pin_idxs[] = { 0xff, 0x24, 0x1d, 0x1e, 0x21 }; | 2169 | struct via_spec *spec = codec->spec; |
2061 | return vt_auto_create_analog_input_ctls(codec, cfg, 0x17, pin_idxs, | 2170 | int i, err; |
2062 | ARRAY_SIZE(pin_idxs)); | 2171 | |
2172 | /* create capture mixer elements */ | ||
2173 | for (i = 0; i < spec->num_adc_nids; i++) { | ||
2174 | hda_nid_t adc = spec->adc_nids[i]; | ||
2175 | err = __via_add_control(spec, VIA_CTL_WIDGET_VOL, | ||
2176 | "Capture Volume", i, | ||
2177 | HDA_COMPOSE_AMP_VAL(adc, 3, 0, | ||
2178 | HDA_INPUT)); | ||
2179 | if (err < 0) | ||
2180 | return err; | ||
2181 | err = __via_add_control(spec, VIA_CTL_WIDGET_MUTE, | ||
2182 | "Capture Switch", i, | ||
2183 | HDA_COMPOSE_AMP_VAL(adc, 3, 0, | ||
2184 | HDA_INPUT)); | ||
2185 | if (err < 0) | ||
2186 | return err; | ||
2187 | } | ||
2188 | |||
2189 | /* input-source control */ | ||
2190 | for (i = 0; i < spec->num_adc_nids; i++) | ||
2191 | if (!spec->mux_nids[i]) | ||
2192 | break; | ||
2193 | err = create_input_src_ctls(codec, i); | ||
2194 | if (err < 0) | ||
2195 | return err; | ||
2196 | return 0; | ||
2063 | } | 2197 | } |
2064 | 2198 | ||
2065 | #ifdef CONFIG_SND_HDA_POWER_SAVE | 2199 | /* bind capture volume/switch */ |
2066 | static const struct hda_amp_list vt1708_loopbacks[] = { | 2200 | static struct snd_kcontrol_new via_bind_cap_vol_ctl = |
2067 | { 0x17, HDA_INPUT, 1 }, | 2201 | HDA_BIND_VOL("Capture Volume", 0); |
2068 | { 0x17, HDA_INPUT, 2 }, | 2202 | static struct snd_kcontrol_new via_bind_cap_sw_ctl = |
2069 | { 0x17, HDA_INPUT, 3 }, | 2203 | HDA_BIND_SW("Capture Switch", 0); |
2070 | { 0x17, HDA_INPUT, 4 }, | 2204 | |
2071 | { } /* end */ | 2205 | static int init_bind_ctl(struct via_spec *spec, struct hda_bind_ctls **ctl_ret, |
2072 | }; | 2206 | struct hda_ctl_ops *ops) |
2073 | #endif | 2207 | { |
2208 | struct hda_bind_ctls *ctl; | ||
2209 | int i; | ||
2210 | |||
2211 | ctl = kzalloc(sizeof(*ctl) + sizeof(long) * 4, GFP_KERNEL); | ||
2212 | if (!ctl) | ||
2213 | return -ENOMEM; | ||
2214 | ctl->ops = ops; | ||
2215 | for (i = 0; i < spec->num_adc_nids; i++) | ||
2216 | ctl->values[i] = | ||
2217 | HDA_COMPOSE_AMP_VAL(spec->adc_nids[i], 3, 0, HDA_INPUT); | ||
2218 | *ctl_ret = ctl; | ||
2219 | return 0; | ||
2220 | } | ||
2221 | |||
2222 | /* create capture and input-src controls for dynamic ADC-switch case */ | ||
2223 | static int create_dyn_adc_ctls(struct hda_codec *codec) | ||
2224 | { | ||
2225 | struct via_spec *spec = codec->spec; | ||
2226 | struct snd_kcontrol_new *knew; | ||
2227 | int err; | ||
2228 | |||
2229 | /* set up the bind capture ctls */ | ||
2230 | err = init_bind_ctl(spec, &spec->bind_cap_vol, &snd_hda_bind_vol); | ||
2231 | if (err < 0) | ||
2232 | return err; | ||
2233 | err = init_bind_ctl(spec, &spec->bind_cap_sw, &snd_hda_bind_sw); | ||
2234 | if (err < 0) | ||
2235 | return err; | ||
2236 | |||
2237 | /* create capture mixer elements */ | ||
2238 | knew = via_clone_control(spec, &via_bind_cap_vol_ctl); | ||
2239 | if (!knew) | ||
2240 | return -ENOMEM; | ||
2241 | knew->private_value = (long)spec->bind_cap_vol; | ||
2242 | |||
2243 | knew = via_clone_control(spec, &via_bind_cap_sw_ctl); | ||
2244 | if (!knew) | ||
2245 | return -ENOMEM; | ||
2246 | knew->private_value = (long)spec->bind_cap_sw; | ||
2247 | |||
2248 | /* input-source control */ | ||
2249 | err = create_input_src_ctls(codec, 1); | ||
2250 | if (err < 0) | ||
2251 | return err; | ||
2252 | return 0; | ||
2253 | } | ||
2254 | |||
2255 | /* parse and create capture-related stuff */ | ||
2256 | static int via_auto_create_analog_input_ctls(struct hda_codec *codec) | ||
2257 | { | ||
2258 | struct via_spec *spec = codec->spec; | ||
2259 | int err; | ||
2260 | |||
2261 | err = parse_analog_inputs(codec); | ||
2262 | if (err < 0) | ||
2263 | return err; | ||
2264 | if (spec->dyn_adc_switch) | ||
2265 | err = create_dyn_adc_ctls(codec); | ||
2266 | else | ||
2267 | err = create_multi_adc_ctls(codec); | ||
2268 | if (err < 0) | ||
2269 | return err; | ||
2270 | err = create_loopback_ctls(codec); | ||
2271 | if (err < 0) | ||
2272 | return err; | ||
2273 | err = create_mic_boost_ctls(codec); | ||
2274 | if (err < 0) | ||
2275 | return err; | ||
2276 | return 0; | ||
2277 | } | ||
2074 | 2278 | ||
2075 | static void vt1708_set_pinconfig_connect(struct hda_codec *codec, hda_nid_t nid) | 2279 | static void vt1708_set_pinconfig_connect(struct hda_codec *codec, hda_nid_t nid) |
2076 | { | 2280 | { |
@@ -2089,7 +2293,7 @@ static void vt1708_set_pinconfig_connect(struct hda_codec *codec, hda_nid_t nid) | |||
2089 | return; | 2293 | return; |
2090 | } | 2294 | } |
2091 | 2295 | ||
2092 | static int vt1708_jack_detectect_get(struct snd_kcontrol *kcontrol, | 2296 | static int vt1708_jack_detect_get(struct snd_kcontrol *kcontrol, |
2093 | struct snd_ctl_elem_value *ucontrol) | 2297 | struct snd_ctl_elem_value *ucontrol) |
2094 | { | 2298 | { |
2095 | struct hda_codec *codec = snd_kcontrol_chip(kcontrol); | 2299 | struct hda_codec *codec = snd_kcontrol_chip(kcontrol); |
@@ -2097,13 +2301,13 @@ static int vt1708_jack_detectect_get(struct snd_kcontrol *kcontrol, | |||
2097 | 2301 | ||
2098 | if (spec->codec_type != VT1708) | 2302 | if (spec->codec_type != VT1708) |
2099 | return 0; | 2303 | return 0; |
2100 | spec->vt1708_jack_detectect = | 2304 | spec->vt1708_jack_detect = |
2101 | !((snd_hda_codec_read(codec, 0x1, 0, 0xf84, 0) >> 8) & 0x1); | 2305 | !((snd_hda_codec_read(codec, 0x1, 0, 0xf84, 0) >> 8) & 0x1); |
2102 | ucontrol->value.integer.value[0] = spec->vt1708_jack_detectect; | 2306 | ucontrol->value.integer.value[0] = spec->vt1708_jack_detect; |
2103 | return 0; | 2307 | return 0; |
2104 | } | 2308 | } |
2105 | 2309 | ||
2106 | static int vt1708_jack_detectect_put(struct snd_kcontrol *kcontrol, | 2310 | static int vt1708_jack_detect_put(struct snd_kcontrol *kcontrol, |
2107 | struct snd_ctl_elem_value *ucontrol) | 2311 | struct snd_ctl_elem_value *ucontrol) |
2108 | { | 2312 | { |
2109 | struct hda_codec *codec = snd_kcontrol_chip(kcontrol); | 2313 | struct hda_codec *codec = snd_kcontrol_chip(kcontrol); |
@@ -2112,98 +2316,149 @@ static int vt1708_jack_detectect_put(struct snd_kcontrol *kcontrol, | |||
2112 | 2316 | ||
2113 | if (spec->codec_type != VT1708) | 2317 | if (spec->codec_type != VT1708) |
2114 | return 0; | 2318 | return 0; |
2115 | spec->vt1708_jack_detectect = ucontrol->value.integer.value[0]; | 2319 | spec->vt1708_jack_detect = ucontrol->value.integer.value[0]; |
2116 | change = (0x1 & (snd_hda_codec_read(codec, 0x1, 0, 0xf84, 0) >> 8)) | 2320 | change = (0x1 & (snd_hda_codec_read(codec, 0x1, 0, 0xf84, 0) >> 8)) |
2117 | == !spec->vt1708_jack_detectect; | 2321 | == !spec->vt1708_jack_detect; |
2118 | if (spec->vt1708_jack_detectect) { | 2322 | if (spec->vt1708_jack_detect) { |
2119 | mute_aa_path(codec, 1); | 2323 | mute_aa_path(codec, 1); |
2120 | notify_aa_path_ctls(codec); | 2324 | notify_aa_path_ctls(codec); |
2121 | } | 2325 | } |
2122 | return change; | 2326 | return change; |
2123 | } | 2327 | } |
2124 | 2328 | ||
2125 | static const struct snd_kcontrol_new vt1708_jack_detectect[] = { | 2329 | static const struct snd_kcontrol_new vt1708_jack_detect_ctl = { |
2126 | { | 2330 | .iface = SNDRV_CTL_ELEM_IFACE_MIXER, |
2127 | .iface = SNDRV_CTL_ELEM_IFACE_MIXER, | 2331 | .name = "Jack Detect", |
2128 | .name = "Jack Detect", | 2332 | .count = 1, |
2129 | .count = 1, | 2333 | .info = snd_ctl_boolean_mono_info, |
2130 | .info = snd_ctl_boolean_mono_info, | 2334 | .get = vt1708_jack_detect_get, |
2131 | .get = vt1708_jack_detectect_get, | 2335 | .put = vt1708_jack_detect_put, |
2132 | .put = vt1708_jack_detectect_put, | ||
2133 | }, | ||
2134 | {} /* end */ | ||
2135 | }; | 2336 | }; |
2136 | 2337 | ||
2137 | static int vt1708_parse_auto_config(struct hda_codec *codec) | 2338 | static void fill_dig_outs(struct hda_codec *codec); |
2339 | static void fill_dig_in(struct hda_codec *codec); | ||
2340 | |||
2341 | static int via_parse_auto_config(struct hda_codec *codec) | ||
2138 | { | 2342 | { |
2139 | struct via_spec *spec = codec->spec; | 2343 | struct via_spec *spec = codec->spec; |
2140 | int err; | 2344 | int err; |
2141 | 2345 | ||
2142 | /* Add HP and CD pin config connect bit re-config action */ | ||
2143 | vt1708_set_pinconfig_connect(codec, VT1708_HP_PIN_NID); | ||
2144 | vt1708_set_pinconfig_connect(codec, VT1708_CD_PIN_NID); | ||
2145 | |||
2146 | err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, NULL); | 2346 | err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, NULL); |
2147 | if (err < 0) | 2347 | if (err < 0) |
2148 | return err; | 2348 | return err; |
2149 | err = vt1708_auto_fill_dac_nids(spec, &spec->autocfg); | ||
2150 | if (err < 0) | ||
2151 | return err; | ||
2152 | if (!spec->autocfg.line_outs && !spec->autocfg.hp_pins[0]) | 2349 | if (!spec->autocfg.line_outs && !spec->autocfg.hp_pins[0]) |
2153 | return 0; /* can't find valid BIOS pin config */ | 2350 | return -EINVAL; |
2154 | 2351 | ||
2155 | err = vt1708_auto_create_multi_out_ctls(spec, &spec->autocfg); | 2352 | err = via_auto_create_multi_out_ctls(codec); |
2156 | if (err < 0) | 2353 | if (err < 0) |
2157 | return err; | 2354 | return err; |
2158 | err = vt1708_auto_create_hp_ctls(spec, spec->autocfg.hp_pins[0]); | 2355 | err = via_auto_create_hp_ctls(codec, spec->autocfg.hp_pins[0]); |
2159 | if (err < 0) | 2356 | if (err < 0) |
2160 | return err; | 2357 | return err; |
2161 | err = vt1708_auto_create_analog_input_ctls(codec, &spec->autocfg); | 2358 | err = via_auto_create_speaker_ctls(codec); |
2162 | if (err < 0) | 2359 | if (err < 0) |
2163 | return err; | 2360 | return err; |
2164 | /* add jack detect on/off control */ | 2361 | err = via_auto_create_analog_input_ctls(codec); |
2165 | err = snd_hda_add_new_ctls(codec, vt1708_jack_detectect); | ||
2166 | if (err < 0) | 2362 | if (err < 0) |
2167 | return err; | 2363 | return err; |
2168 | 2364 | ||
2169 | spec->multiout.max_channels = spec->multiout.num_dacs * 2; | 2365 | spec->multiout.max_channels = spec->multiout.num_dacs * 2; |
2170 | 2366 | ||
2171 | if (spec->autocfg.dig_outs) | 2367 | fill_dig_outs(codec); |
2172 | spec->multiout.dig_out_nid = VT1708_DIGOUT_NID; | 2368 | fill_dig_in(codec); |
2173 | spec->dig_in_pin = VT1708_DIGIN_PIN; | ||
2174 | if (spec->autocfg.dig_in_pin) | ||
2175 | spec->dig_in_nid = VT1708_DIGIN_NID; | ||
2176 | 2369 | ||
2177 | if (spec->kctls.list) | 2370 | if (spec->kctls.list) |
2178 | spec->mixers[spec->num_mixers++] = spec->kctls.list; | 2371 | spec->mixers[spec->num_mixers++] = spec->kctls.list; |
2179 | 2372 | ||
2180 | spec->init_verbs[spec->num_iverbs++] = vt1708_volume_init_verbs; | 2373 | spec->init_verbs[spec->num_iverbs++] = vt1708_init_verbs; |
2181 | 2374 | ||
2182 | spec->input_mux = &spec->private_imux[0]; | 2375 | if (spec->hp_dac_nid && spec->hp_dep_path.depth) { |
2376 | err = via_hp_build(codec); | ||
2377 | if (err < 0) | ||
2378 | return err; | ||
2379 | } | ||
2183 | 2380 | ||
2184 | if (spec->hp_mux) | 2381 | err = via_smart51_build(codec); |
2185 | via_hp_build(codec); | 2382 | if (err < 0) |
2383 | return err; | ||
2384 | |||
2385 | /* assign slave outs */ | ||
2386 | if (spec->slave_dig_outs[0]) | ||
2387 | codec->slave_dig_outs = spec->slave_dig_outs; | ||
2186 | 2388 | ||
2187 | via_smart51_build(spec); | ||
2188 | return 1; | 2389 | return 1; |
2189 | } | 2390 | } |
2190 | 2391 | ||
2191 | /* init callback for auto-configuration model -- overriding the default init */ | 2392 | static void via_auto_init_dig_outs(struct hda_codec *codec) |
2192 | static int via_auto_init(struct hda_codec *codec) | 2393 | { |
2394 | struct via_spec *spec = codec->spec; | ||
2395 | if (spec->multiout.dig_out_nid) | ||
2396 | init_output_pin(codec, spec->autocfg.dig_out_pins[0], PIN_OUT); | ||
2397 | if (spec->slave_dig_outs[0]) | ||
2398 | init_output_pin(codec, spec->autocfg.dig_out_pins[1], PIN_OUT); | ||
2399 | } | ||
2400 | |||
2401 | static void via_auto_init_dig_in(struct hda_codec *codec) | ||
2402 | { | ||
2403 | struct via_spec *spec = codec->spec; | ||
2404 | if (!spec->dig_in_nid) | ||
2405 | return; | ||
2406 | snd_hda_codec_write(codec, spec->autocfg.dig_in_pin, 0, | ||
2407 | AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN); | ||
2408 | } | ||
2409 | |||
2410 | /* initialize the unsolicited events */ | ||
2411 | static void via_auto_init_unsol_event(struct hda_codec *codec) | ||
2193 | { | 2412 | { |
2194 | struct via_spec *spec = codec->spec; | 2413 | struct via_spec *spec = codec->spec; |
2414 | struct auto_pin_cfg *cfg = &spec->autocfg; | ||
2415 | unsigned int ev; | ||
2416 | int i; | ||
2417 | |||
2418 | if (cfg->hp_pins[0] && is_jack_detectable(codec, cfg->hp_pins[0])) | ||
2419 | snd_hda_codec_write(codec, cfg->hp_pins[0], 0, | ||
2420 | AC_VERB_SET_UNSOLICITED_ENABLE, | ||
2421 | AC_USRSP_EN | VIA_HP_EVENT | VIA_JACK_EVENT); | ||
2422 | |||
2423 | if (cfg->speaker_pins[0]) | ||
2424 | ev = VIA_LINE_EVENT; | ||
2425 | else | ||
2426 | ev = 0; | ||
2427 | for (i = 0; i < cfg->line_outs; i++) { | ||
2428 | if (cfg->line_out_pins[i] && | ||
2429 | is_jack_detectable(codec, cfg->line_out_pins[i])) | ||
2430 | snd_hda_codec_write(codec, cfg->line_out_pins[0], 0, | ||
2431 | AC_VERB_SET_UNSOLICITED_ENABLE, | ||
2432 | AC_USRSP_EN | ev | VIA_JACK_EVENT); | ||
2433 | } | ||
2434 | |||
2435 | for (i = 0; i < cfg->num_inputs; i++) { | ||
2436 | if (is_jack_detectable(codec, cfg->inputs[i].pin)) | ||
2437 | snd_hda_codec_write(codec, cfg->inputs[i].pin, 0, | ||
2438 | AC_VERB_SET_UNSOLICITED_ENABLE, | ||
2439 | AC_USRSP_EN | VIA_JACK_EVENT); | ||
2440 | } | ||
2441 | } | ||
2442 | |||
2443 | static int via_init(struct hda_codec *codec) | ||
2444 | { | ||
2445 | struct via_spec *spec = codec->spec; | ||
2446 | int i; | ||
2447 | |||
2448 | for (i = 0; i < spec->num_iverbs; i++) | ||
2449 | snd_hda_sequence_write(codec, spec->init_verbs[i]); | ||
2195 | 2450 | ||
2196 | via_init(codec); | ||
2197 | via_auto_init_multi_out(codec); | 2451 | via_auto_init_multi_out(codec); |
2198 | via_auto_init_hp_out(codec); | 2452 | via_auto_init_hp_out(codec); |
2453 | via_auto_init_speaker_out(codec); | ||
2199 | via_auto_init_analog_input(codec); | 2454 | via_auto_init_analog_input(codec); |
2455 | via_auto_init_dig_outs(codec); | ||
2456 | via_auto_init_dig_in(codec); | ||
2200 | 2457 | ||
2201 | if (VT2002P_COMPATIBLE(spec)) { | 2458 | via_auto_init_unsol_event(codec); |
2202 | via_hp_bind_automute(codec); | 2459 | |
2203 | } else { | 2460 | via_hp_automute(codec); |
2204 | via_hp_automute(codec); | 2461 | via_line_automute(codec, false); |
2205 | via_speaker_automute(codec); | ||
2206 | } | ||
2207 | 2462 | ||
2208 | return 0; | 2463 | return 0; |
2209 | } | 2464 | } |
@@ -2260,437 +2515,34 @@ static int patch_vt1708(struct hda_codec *codec) | |||
2260 | if (spec == NULL) | 2515 | if (spec == NULL) |
2261 | return -ENOMEM; | 2516 | return -ENOMEM; |
2262 | 2517 | ||
2518 | spec->aa_mix_nid = 0x17; | ||
2519 | |||
2520 | /* Add HP and CD pin config connect bit re-config action */ | ||
2521 | vt1708_set_pinconfig_connect(codec, VT1708_HP_PIN_NID); | ||
2522 | vt1708_set_pinconfig_connect(codec, VT1708_CD_PIN_NID); | ||
2523 | |||
2263 | /* automatic parse from the BIOS config */ | 2524 | /* automatic parse from the BIOS config */ |
2264 | err = vt1708_parse_auto_config(codec); | 2525 | err = via_parse_auto_config(codec); |
2265 | if (err < 0) { | 2526 | if (err < 0) { |
2266 | via_free(codec); | 2527 | via_free(codec); |
2267 | return err; | 2528 | return err; |
2268 | } else if (!err) { | ||
2269 | printk(KERN_INFO "hda_codec: Cannot set up configuration " | ||
2270 | "from BIOS. Using genenic mode...\n"); | ||
2271 | } | 2529 | } |
2272 | 2530 | ||
2531 | /* add jack detect on/off control */ | ||
2532 | if (!via_clone_control(spec, &vt1708_jack_detect_ctl)) | ||
2533 | return -ENOMEM; | ||
2273 | 2534 | ||
2274 | spec->stream_name_analog = "VT1708 Analog"; | ||
2275 | spec->stream_analog_playback = &vt1708_pcm_analog_playback; | ||
2276 | /* disable 32bit format on VT1708 */ | 2535 | /* disable 32bit format on VT1708 */ |
2277 | if (codec->vendor_id == 0x11061708) | 2536 | if (codec->vendor_id == 0x11061708) |
2278 | spec->stream_analog_playback = &vt1708_pcm_analog_s16_playback; | 2537 | spec->stream_analog_playback = &vt1708_pcm_analog_s16_playback; |
2279 | spec->stream_analog_capture = &vt1708_pcm_analog_capture; | ||
2280 | |||
2281 | spec->stream_name_digital = "VT1708 Digital"; | ||
2282 | spec->stream_digital_playback = &vt1708_pcm_digital_playback; | ||
2283 | spec->stream_digital_capture = &vt1708_pcm_digital_capture; | ||
2284 | |||
2285 | |||
2286 | if (!spec->adc_nids && spec->input_mux) { | ||
2287 | spec->adc_nids = vt1708_adc_nids; | ||
2288 | spec->num_adc_nids = ARRAY_SIZE(vt1708_adc_nids); | ||
2289 | get_mux_nids(codec); | ||
2290 | spec->mixers[spec->num_mixers] = vt1708_capture_mixer; | ||
2291 | spec->num_mixers++; | ||
2292 | } | ||
2293 | 2538 | ||
2294 | codec->patch_ops = via_patch_ops; | 2539 | codec->patch_ops = via_patch_ops; |
2295 | 2540 | ||
2296 | codec->patch_ops.init = via_auto_init; | ||
2297 | #ifdef CONFIG_SND_HDA_POWER_SAVE | ||
2298 | spec->loopback.amplist = vt1708_loopbacks; | ||
2299 | #endif | ||
2300 | INIT_DELAYED_WORK(&spec->vt1708_hp_work, vt1708_update_hp_jack_state); | 2541 | INIT_DELAYED_WORK(&spec->vt1708_hp_work, vt1708_update_hp_jack_state); |
2301 | return 0; | 2542 | return 0; |
2302 | } | 2543 | } |
2303 | 2544 | ||
2304 | /* capture mixer elements */ | 2545 | static int patch_vt1709(struct hda_codec *codec) |
2305 | static const struct snd_kcontrol_new vt1709_capture_mixer[] = { | ||
2306 | HDA_CODEC_VOLUME("Capture Volume", 0x14, 0x0, HDA_INPUT), | ||
2307 | HDA_CODEC_MUTE("Capture Switch", 0x14, 0x0, HDA_INPUT), | ||
2308 | HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x15, 0x0, HDA_INPUT), | ||
2309 | HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x15, 0x0, HDA_INPUT), | ||
2310 | HDA_CODEC_VOLUME_IDX("Capture Volume", 2, 0x16, 0x0, HDA_INPUT), | ||
2311 | HDA_CODEC_MUTE_IDX("Capture Switch", 2, 0x16, 0x0, HDA_INPUT), | ||
2312 | { | ||
2313 | .iface = SNDRV_CTL_ELEM_IFACE_MIXER, | ||
2314 | /* The multiple "Capture Source" controls confuse alsamixer | ||
2315 | * So call somewhat different.. | ||
2316 | */ | ||
2317 | /* .name = "Capture Source", */ | ||
2318 | .name = "Input Source", | ||
2319 | .count = 1, | ||
2320 | .info = via_mux_enum_info, | ||
2321 | .get = via_mux_enum_get, | ||
2322 | .put = via_mux_enum_put, | ||
2323 | }, | ||
2324 | { } /* end */ | ||
2325 | }; | ||
2326 | |||
2327 | static const struct hda_verb vt1709_uniwill_init_verbs[] = { | ||
2328 | {0x20, AC_VERB_SET_UNSOLICITED_ENABLE, | ||
2329 | AC_USRSP_EN | VIA_HP_EVENT | VIA_JACK_EVENT}, | ||
2330 | { } | ||
2331 | }; | ||
2332 | |||
2333 | /* | ||
2334 | * generic initialization of ADC, input mixers and output mixers | ||
2335 | */ | ||
2336 | static const struct hda_verb vt1709_10ch_volume_init_verbs[] = { | ||
2337 | /* | ||
2338 | * Unmute ADC0-2 and set the default input to mic-in | ||
2339 | */ | ||
2340 | {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, | ||
2341 | {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, | ||
2342 | {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, | ||
2343 | |||
2344 | |||
2345 | /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback | ||
2346 | * mixer widget | ||
2347 | */ | ||
2348 | /* Amp Indices: AOW0=0, CD = 1, Mic1 = 2, Line = 3, Mic2 = 4 */ | ||
2349 | {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, | ||
2350 | {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, | ||
2351 | {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)}, | ||
2352 | {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)}, | ||
2353 | {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)}, | ||
2354 | |||
2355 | /* | ||
2356 | * Set up output selector (0x1a, 0x1b, 0x29) | ||
2357 | */ | ||
2358 | /* set vol=0 to output mixers */ | ||
2359 | {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, | ||
2360 | {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, | ||
2361 | {0x29, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, | ||
2362 | |||
2363 | /* | ||
2364 | * Unmute PW3 and PW4 | ||
2365 | */ | ||
2366 | {0x1f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, | ||
2367 | {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, | ||
2368 | |||
2369 | /* Set input of PW4 as MW0 */ | ||
2370 | {0x20, AC_VERB_SET_CONNECT_SEL, 0}, | ||
2371 | /* PW9 Output enable */ | ||
2372 | {0x24, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40}, | ||
2373 | { } | ||
2374 | }; | ||
2375 | |||
2376 | static const struct hda_pcm_stream vt1709_10ch_pcm_analog_playback = { | ||
2377 | .substreams = 1, | ||
2378 | .channels_min = 2, | ||
2379 | .channels_max = 10, | ||
2380 | .nid = 0x10, /* NID to query formats and rates */ | ||
2381 | .ops = { | ||
2382 | .open = via_playback_pcm_open, | ||
2383 | .prepare = via_playback_multi_pcm_prepare, | ||
2384 | .cleanup = via_playback_multi_pcm_cleanup, | ||
2385 | }, | ||
2386 | }; | ||
2387 | |||
2388 | static const struct hda_pcm_stream vt1709_6ch_pcm_analog_playback = { | ||
2389 | .substreams = 1, | ||
2390 | .channels_min = 2, | ||
2391 | .channels_max = 6, | ||
2392 | .nid = 0x10, /* NID to query formats and rates */ | ||
2393 | .ops = { | ||
2394 | .open = via_playback_pcm_open, | ||
2395 | .prepare = via_playback_multi_pcm_prepare, | ||
2396 | .cleanup = via_playback_multi_pcm_cleanup, | ||
2397 | }, | ||
2398 | }; | ||
2399 | |||
2400 | static const struct hda_pcm_stream vt1709_pcm_analog_capture = { | ||
2401 | .substreams = 2, | ||
2402 | .channels_min = 2, | ||
2403 | .channels_max = 2, | ||
2404 | .nid = 0x14, /* NID to query formats and rates */ | ||
2405 | .ops = { | ||
2406 | .prepare = via_capture_pcm_prepare, | ||
2407 | .cleanup = via_capture_pcm_cleanup | ||
2408 | }, | ||
2409 | }; | ||
2410 | |||
2411 | static const struct hda_pcm_stream vt1709_pcm_digital_playback = { | ||
2412 | .substreams = 1, | ||
2413 | .channels_min = 2, | ||
2414 | .channels_max = 2, | ||
2415 | /* NID is set in via_build_pcms */ | ||
2416 | .ops = { | ||
2417 | .open = via_dig_playback_pcm_open, | ||
2418 | .close = via_dig_playback_pcm_close | ||
2419 | }, | ||
2420 | }; | ||
2421 | |||
2422 | static const struct hda_pcm_stream vt1709_pcm_digital_capture = { | ||
2423 | .substreams = 1, | ||
2424 | .channels_min = 2, | ||
2425 | .channels_max = 2, | ||
2426 | }; | ||
2427 | |||
2428 | static int vt1709_auto_fill_dac_nids(struct via_spec *spec, | ||
2429 | const struct auto_pin_cfg *cfg) | ||
2430 | { | ||
2431 | int i; | ||
2432 | hda_nid_t nid; | ||
2433 | |||
2434 | if (cfg->line_outs == 4) /* 10 channels */ | ||
2435 | spec->multiout.num_dacs = cfg->line_outs+1; /* AOW0~AOW4 */ | ||
2436 | else if (cfg->line_outs == 3) /* 6 channels */ | ||
2437 | spec->multiout.num_dacs = cfg->line_outs; /* AOW0~AOW2 */ | ||
2438 | |||
2439 | spec->multiout.dac_nids = spec->private_dac_nids; | ||
2440 | |||
2441 | if (cfg->line_outs == 4) { /* 10 channels */ | ||
2442 | for (i = 0; i < cfg->line_outs; i++) { | ||
2443 | nid = cfg->line_out_pins[i]; | ||
2444 | if (nid) { | ||
2445 | /* config dac list */ | ||
2446 | switch (i) { | ||
2447 | case AUTO_SEQ_FRONT: | ||
2448 | /* AOW0 */ | ||
2449 | spec->private_dac_nids[i] = 0x10; | ||
2450 | break; | ||
2451 | case AUTO_SEQ_CENLFE: | ||
2452 | /* AOW2 */ | ||
2453 | spec->private_dac_nids[i] = 0x12; | ||
2454 | break; | ||
2455 | case AUTO_SEQ_SURROUND: | ||
2456 | /* AOW3 */ | ||
2457 | spec->private_dac_nids[i] = 0x11; | ||
2458 | break; | ||
2459 | case AUTO_SEQ_SIDE: | ||
2460 | /* AOW1 */ | ||
2461 | spec->private_dac_nids[i] = 0x27; | ||
2462 | break; | ||
2463 | default: | ||
2464 | break; | ||
2465 | } | ||
2466 | } | ||
2467 | } | ||
2468 | spec->private_dac_nids[cfg->line_outs] = 0x28; /* AOW4 */ | ||
2469 | |||
2470 | } else if (cfg->line_outs == 3) { /* 6 channels */ | ||
2471 | for (i = 0; i < cfg->line_outs; i++) { | ||
2472 | nid = cfg->line_out_pins[i]; | ||
2473 | if (nid) { | ||
2474 | /* config dac list */ | ||
2475 | switch (i) { | ||
2476 | case AUTO_SEQ_FRONT: | ||
2477 | /* AOW0 */ | ||
2478 | spec->private_dac_nids[i] = 0x10; | ||
2479 | break; | ||
2480 | case AUTO_SEQ_CENLFE: | ||
2481 | /* AOW2 */ | ||
2482 | spec->private_dac_nids[i] = 0x12; | ||
2483 | break; | ||
2484 | case AUTO_SEQ_SURROUND: | ||
2485 | /* AOW1 */ | ||
2486 | spec->private_dac_nids[i] = 0x11; | ||
2487 | break; | ||
2488 | default: | ||
2489 | break; | ||
2490 | } | ||
2491 | } | ||
2492 | } | ||
2493 | } | ||
2494 | |||
2495 | return 0; | ||
2496 | } | ||
2497 | |||
2498 | /* add playback controls from the parsed DAC table */ | ||
2499 | static int vt1709_auto_create_multi_out_ctls(struct via_spec *spec, | ||
2500 | const struct auto_pin_cfg *cfg) | ||
2501 | { | ||
2502 | char name[32]; | ||
2503 | static const char * const chname[4] = { | ||
2504 | "Front", "Surround", "C/LFE", "Side" | ||
2505 | }; | ||
2506 | hda_nid_t nid, nid_vol, nid_vols[] = {0x18, 0x1a, 0x1b, 0x29}; | ||
2507 | int i, err; | ||
2508 | |||
2509 | for (i = 0; i <= AUTO_SEQ_SIDE; i++) { | ||
2510 | nid = cfg->line_out_pins[i]; | ||
2511 | |||
2512 | if (!nid) | ||
2513 | continue; | ||
2514 | |||
2515 | nid_vol = nid_vols[i]; | ||
2516 | |||
2517 | if (i == AUTO_SEQ_CENLFE) { | ||
2518 | /* Center/LFE */ | ||
2519 | err = via_add_control(spec, VIA_CTL_WIDGET_VOL, | ||
2520 | "Center Playback Volume", | ||
2521 | HDA_COMPOSE_AMP_VAL(nid_vol, 1, 0, | ||
2522 | HDA_OUTPUT)); | ||
2523 | if (err < 0) | ||
2524 | return err; | ||
2525 | err = via_add_control(spec, VIA_CTL_WIDGET_VOL, | ||
2526 | "LFE Playback Volume", | ||
2527 | HDA_COMPOSE_AMP_VAL(nid_vol, 2, 0, | ||
2528 | HDA_OUTPUT)); | ||
2529 | if (err < 0) | ||
2530 | return err; | ||
2531 | err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, | ||
2532 | "Center Playback Switch", | ||
2533 | HDA_COMPOSE_AMP_VAL(nid_vol, 1, 0, | ||
2534 | HDA_OUTPUT)); | ||
2535 | if (err < 0) | ||
2536 | return err; | ||
2537 | err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, | ||
2538 | "LFE Playback Switch", | ||
2539 | HDA_COMPOSE_AMP_VAL(nid_vol, 2, 0, | ||
2540 | HDA_OUTPUT)); | ||
2541 | if (err < 0) | ||
2542 | return err; | ||
2543 | } else if (i == AUTO_SEQ_FRONT) { | ||
2544 | /* ADD control to mixer index 0 */ | ||
2545 | err = via_add_control(spec, VIA_CTL_WIDGET_VOL, | ||
2546 | "Master Front Playback Volume", | ||
2547 | HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, | ||
2548 | HDA_INPUT)); | ||
2549 | if (err < 0) | ||
2550 | return err; | ||
2551 | err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, | ||
2552 | "Master Front Playback Switch", | ||
2553 | HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, | ||
2554 | HDA_INPUT)); | ||
2555 | if (err < 0) | ||
2556 | return err; | ||
2557 | |||
2558 | /* add control to PW3 */ | ||
2559 | sprintf(name, "%s Playback Volume", chname[i]); | ||
2560 | err = via_add_control(spec, VIA_CTL_WIDGET_VOL, name, | ||
2561 | HDA_COMPOSE_AMP_VAL(nid, 3, 0, | ||
2562 | HDA_OUTPUT)); | ||
2563 | if (err < 0) | ||
2564 | return err; | ||
2565 | sprintf(name, "%s Playback Switch", chname[i]); | ||
2566 | err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, name, | ||
2567 | HDA_COMPOSE_AMP_VAL(nid, 3, 0, | ||
2568 | HDA_OUTPUT)); | ||
2569 | if (err < 0) | ||
2570 | return err; | ||
2571 | } else if (i == AUTO_SEQ_SURROUND) { | ||
2572 | sprintf(name, "%s Playback Volume", chname[i]); | ||
2573 | err = via_add_control(spec, VIA_CTL_WIDGET_VOL, name, | ||
2574 | HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, | ||
2575 | HDA_OUTPUT)); | ||
2576 | if (err < 0) | ||
2577 | return err; | ||
2578 | sprintf(name, "%s Playback Switch", chname[i]); | ||
2579 | err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, name, | ||
2580 | HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, | ||
2581 | HDA_OUTPUT)); | ||
2582 | if (err < 0) | ||
2583 | return err; | ||
2584 | } else if (i == AUTO_SEQ_SIDE) { | ||
2585 | sprintf(name, "%s Playback Volume", chname[i]); | ||
2586 | err = via_add_control(spec, VIA_CTL_WIDGET_VOL, name, | ||
2587 | HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, | ||
2588 | HDA_OUTPUT)); | ||
2589 | if (err < 0) | ||
2590 | return err; | ||
2591 | sprintf(name, "%s Playback Switch", chname[i]); | ||
2592 | err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, name, | ||
2593 | HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, | ||
2594 | HDA_OUTPUT)); | ||
2595 | if (err < 0) | ||
2596 | return err; | ||
2597 | } | ||
2598 | } | ||
2599 | |||
2600 | return 0; | ||
2601 | } | ||
2602 | |||
2603 | static int vt1709_auto_create_hp_ctls(struct via_spec *spec, hda_nid_t pin) | ||
2604 | { | ||
2605 | int err; | ||
2606 | |||
2607 | if (!pin) | ||
2608 | return 0; | ||
2609 | |||
2610 | if (spec->multiout.num_dacs == 5) /* 10 channels */ | ||
2611 | spec->multiout.hp_nid = VT1709_HP_DAC_NID; | ||
2612 | else if (spec->multiout.num_dacs == 3) /* 6 channels */ | ||
2613 | spec->multiout.hp_nid = 0; | ||
2614 | spec->hp_independent_mode_index = 1; | ||
2615 | |||
2616 | err = via_add_control(spec, VIA_CTL_WIDGET_VOL, | ||
2617 | "Headphone Playback Volume", | ||
2618 | HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT)); | ||
2619 | if (err < 0) | ||
2620 | return err; | ||
2621 | err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, | ||
2622 | "Headphone Playback Switch", | ||
2623 | HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT)); | ||
2624 | if (err < 0) | ||
2625 | return err; | ||
2626 | |||
2627 | return 0; | ||
2628 | } | ||
2629 | |||
2630 | /* create playback/capture controls for input pins */ | ||
2631 | static int vt1709_auto_create_analog_input_ctls(struct hda_codec *codec, | ||
2632 | const struct auto_pin_cfg *cfg) | ||
2633 | { | ||
2634 | static const hda_nid_t pin_idxs[] = { 0xff, 0x23, 0x1d, 0x1e, 0x21 }; | ||
2635 | return vt_auto_create_analog_input_ctls(codec, cfg, 0x18, pin_idxs, | ||
2636 | ARRAY_SIZE(pin_idxs)); | ||
2637 | } | ||
2638 | |||
2639 | static int vt1709_parse_auto_config(struct hda_codec *codec) | ||
2640 | { | ||
2641 | struct via_spec *spec = codec->spec; | ||
2642 | int err; | ||
2643 | |||
2644 | err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, NULL); | ||
2645 | if (err < 0) | ||
2646 | return err; | ||
2647 | err = vt1709_auto_fill_dac_nids(spec, &spec->autocfg); | ||
2648 | if (err < 0) | ||
2649 | return err; | ||
2650 | if (!spec->autocfg.line_outs && !spec->autocfg.hp_pins[0]) | ||
2651 | return 0; /* can't find valid BIOS pin config */ | ||
2652 | |||
2653 | err = vt1709_auto_create_multi_out_ctls(spec, &spec->autocfg); | ||
2654 | if (err < 0) | ||
2655 | return err; | ||
2656 | err = vt1709_auto_create_hp_ctls(spec, spec->autocfg.hp_pins[0]); | ||
2657 | if (err < 0) | ||
2658 | return err; | ||
2659 | err = vt1709_auto_create_analog_input_ctls(codec, &spec->autocfg); | ||
2660 | if (err < 0) | ||
2661 | return err; | ||
2662 | |||
2663 | spec->multiout.max_channels = spec->multiout.num_dacs * 2; | ||
2664 | |||
2665 | if (spec->autocfg.dig_outs) | ||
2666 | spec->multiout.dig_out_nid = VT1709_DIGOUT_NID; | ||
2667 | spec->dig_in_pin = VT1709_DIGIN_PIN; | ||
2668 | if (spec->autocfg.dig_in_pin) | ||
2669 | spec->dig_in_nid = VT1709_DIGIN_NID; | ||
2670 | |||
2671 | if (spec->kctls.list) | ||
2672 | spec->mixers[spec->num_mixers++] = spec->kctls.list; | ||
2673 | |||
2674 | spec->input_mux = &spec->private_imux[0]; | ||
2675 | |||
2676 | if (spec->hp_mux) | ||
2677 | via_hp_build(codec); | ||
2678 | |||
2679 | via_smart51_build(spec); | ||
2680 | return 1; | ||
2681 | } | ||
2682 | |||
2683 | #ifdef CONFIG_SND_HDA_POWER_SAVE | ||
2684 | static const struct hda_amp_list vt1709_loopbacks[] = { | ||
2685 | { 0x18, HDA_INPUT, 1 }, | ||
2686 | { 0x18, HDA_INPUT, 2 }, | ||
2687 | { 0x18, HDA_INPUT, 3 }, | ||
2688 | { 0x18, HDA_INPUT, 4 }, | ||
2689 | { } /* end */ | ||
2690 | }; | ||
2691 | #endif | ||
2692 | |||
2693 | static int patch_vt1709_10ch(struct hda_codec *codec) | ||
2694 | { | 2546 | { |
2695 | struct via_spec *spec; | 2547 | struct via_spec *spec; |
2696 | int err; | 2548 | int err; |
@@ -2700,528 +2552,19 @@ static int patch_vt1709_10ch(struct hda_codec *codec) | |||
2700 | if (spec == NULL) | 2552 | if (spec == NULL) |
2701 | return -ENOMEM; | 2553 | return -ENOMEM; |
2702 | 2554 | ||
2703 | err = vt1709_parse_auto_config(codec); | 2555 | spec->aa_mix_nid = 0x18; |
2704 | if (err < 0) { | ||
2705 | via_free(codec); | ||
2706 | return err; | ||
2707 | } else if (!err) { | ||
2708 | printk(KERN_INFO "hda_codec: Cannot set up configuration. " | ||
2709 | "Using genenic mode...\n"); | ||
2710 | } | ||
2711 | |||
2712 | spec->init_verbs[spec->num_iverbs++] = vt1709_10ch_volume_init_verbs; | ||
2713 | spec->init_verbs[spec->num_iverbs++] = vt1709_uniwill_init_verbs; | ||
2714 | |||
2715 | spec->stream_name_analog = "VT1709 Analog"; | ||
2716 | spec->stream_analog_playback = &vt1709_10ch_pcm_analog_playback; | ||
2717 | spec->stream_analog_capture = &vt1709_pcm_analog_capture; | ||
2718 | |||
2719 | spec->stream_name_digital = "VT1709 Digital"; | ||
2720 | spec->stream_digital_playback = &vt1709_pcm_digital_playback; | ||
2721 | spec->stream_digital_capture = &vt1709_pcm_digital_capture; | ||
2722 | |||
2723 | |||
2724 | if (!spec->adc_nids && spec->input_mux) { | ||
2725 | spec->adc_nids = vt1709_adc_nids; | ||
2726 | spec->num_adc_nids = ARRAY_SIZE(vt1709_adc_nids); | ||
2727 | get_mux_nids(codec); | ||
2728 | spec->mixers[spec->num_mixers] = vt1709_capture_mixer; | ||
2729 | spec->num_mixers++; | ||
2730 | } | ||
2731 | |||
2732 | codec->patch_ops = via_patch_ops; | ||
2733 | |||
2734 | codec->patch_ops.init = via_auto_init; | ||
2735 | codec->patch_ops.unsol_event = via_unsol_event; | ||
2736 | #ifdef CONFIG_SND_HDA_POWER_SAVE | ||
2737 | spec->loopback.amplist = vt1709_loopbacks; | ||
2738 | #endif | ||
2739 | |||
2740 | return 0; | ||
2741 | } | ||
2742 | /* | ||
2743 | * generic initialization of ADC, input mixers and output mixers | ||
2744 | */ | ||
2745 | static const struct hda_verb vt1709_6ch_volume_init_verbs[] = { | ||
2746 | /* | ||
2747 | * Unmute ADC0-2 and set the default input to mic-in | ||
2748 | */ | ||
2749 | {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, | ||
2750 | {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, | ||
2751 | {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, | ||
2752 | |||
2753 | |||
2754 | /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback | ||
2755 | * mixer widget | ||
2756 | */ | ||
2757 | /* Amp Indices: AOW0=0, CD = 1, Mic1 = 2, Line = 3, Mic2 = 4 */ | ||
2758 | {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, | ||
2759 | {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, | ||
2760 | {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)}, | ||
2761 | {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)}, | ||
2762 | {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)}, | ||
2763 | |||
2764 | /* | ||
2765 | * Set up output selector (0x1a, 0x1b, 0x29) | ||
2766 | */ | ||
2767 | /* set vol=0 to output mixers */ | ||
2768 | {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, | ||
2769 | {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, | ||
2770 | {0x29, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, | ||
2771 | 2556 | ||
2772 | /* | 2557 | err = via_parse_auto_config(codec); |
2773 | * Unmute PW3 and PW4 | ||
2774 | */ | ||
2775 | {0x1f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, | ||
2776 | {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, | ||
2777 | |||
2778 | /* Set input of PW4 as MW0 */ | ||
2779 | {0x20, AC_VERB_SET_CONNECT_SEL, 0}, | ||
2780 | /* PW9 Output enable */ | ||
2781 | {0x24, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40}, | ||
2782 | { } | ||
2783 | }; | ||
2784 | |||
2785 | static int patch_vt1709_6ch(struct hda_codec *codec) | ||
2786 | { | ||
2787 | struct via_spec *spec; | ||
2788 | int err; | ||
2789 | |||
2790 | /* create a codec specific record */ | ||
2791 | spec = via_new_spec(codec); | ||
2792 | if (spec == NULL) | ||
2793 | return -ENOMEM; | ||
2794 | |||
2795 | err = vt1709_parse_auto_config(codec); | ||
2796 | if (err < 0) { | 2558 | if (err < 0) { |
2797 | via_free(codec); | 2559 | via_free(codec); |
2798 | return err; | 2560 | return err; |
2799 | } else if (!err) { | ||
2800 | printk(KERN_INFO "hda_codec: Cannot set up configuration. " | ||
2801 | "Using genenic mode...\n"); | ||
2802 | } | ||
2803 | |||
2804 | spec->init_verbs[spec->num_iverbs++] = vt1709_6ch_volume_init_verbs; | ||
2805 | spec->init_verbs[spec->num_iverbs++] = vt1709_uniwill_init_verbs; | ||
2806 | |||
2807 | spec->stream_name_analog = "VT1709 Analog"; | ||
2808 | spec->stream_analog_playback = &vt1709_6ch_pcm_analog_playback; | ||
2809 | spec->stream_analog_capture = &vt1709_pcm_analog_capture; | ||
2810 | |||
2811 | spec->stream_name_digital = "VT1709 Digital"; | ||
2812 | spec->stream_digital_playback = &vt1709_pcm_digital_playback; | ||
2813 | spec->stream_digital_capture = &vt1709_pcm_digital_capture; | ||
2814 | |||
2815 | |||
2816 | if (!spec->adc_nids && spec->input_mux) { | ||
2817 | spec->adc_nids = vt1709_adc_nids; | ||
2818 | spec->num_adc_nids = ARRAY_SIZE(vt1709_adc_nids); | ||
2819 | get_mux_nids(codec); | ||
2820 | spec->mixers[spec->num_mixers] = vt1709_capture_mixer; | ||
2821 | spec->num_mixers++; | ||
2822 | } | 2561 | } |
2823 | 2562 | ||
2824 | codec->patch_ops = via_patch_ops; | 2563 | codec->patch_ops = via_patch_ops; |
2825 | 2564 | ||
2826 | codec->patch_ops.init = via_auto_init; | ||
2827 | codec->patch_ops.unsol_event = via_unsol_event; | ||
2828 | #ifdef CONFIG_SND_HDA_POWER_SAVE | ||
2829 | spec->loopback.amplist = vt1709_loopbacks; | ||
2830 | #endif | ||
2831 | return 0; | ||
2832 | } | ||
2833 | |||
2834 | /* capture mixer elements */ | ||
2835 | static const struct snd_kcontrol_new vt1708B_capture_mixer[] = { | ||
2836 | HDA_CODEC_VOLUME("Capture Volume", 0x13, 0x0, HDA_INPUT), | ||
2837 | HDA_CODEC_MUTE("Capture Switch", 0x13, 0x0, HDA_INPUT), | ||
2838 | HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x14, 0x0, HDA_INPUT), | ||
2839 | HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x14, 0x0, HDA_INPUT), | ||
2840 | { | ||
2841 | .iface = SNDRV_CTL_ELEM_IFACE_MIXER, | ||
2842 | /* The multiple "Capture Source" controls confuse alsamixer | ||
2843 | * So call somewhat different.. | ||
2844 | */ | ||
2845 | /* .name = "Capture Source", */ | ||
2846 | .name = "Input Source", | ||
2847 | .count = 1, | ||
2848 | .info = via_mux_enum_info, | ||
2849 | .get = via_mux_enum_get, | ||
2850 | .put = via_mux_enum_put, | ||
2851 | }, | ||
2852 | { } /* end */ | ||
2853 | }; | ||
2854 | /* | ||
2855 | * generic initialization of ADC, input mixers and output mixers | ||
2856 | */ | ||
2857 | static const struct hda_verb vt1708B_8ch_volume_init_verbs[] = { | ||
2858 | /* | ||
2859 | * Unmute ADC0-1 and set the default input to mic-in | ||
2860 | */ | ||
2861 | {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, | ||
2862 | {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, | ||
2863 | |||
2864 | |||
2865 | /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback | ||
2866 | * mixer widget | ||
2867 | */ | ||
2868 | /* Amp Indices: CD = 1, Mic1 = 2, Line = 3, Mic2 = 4 */ | ||
2869 | {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, | ||
2870 | {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, | ||
2871 | {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)}, | ||
2872 | {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)}, | ||
2873 | {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)}, | ||
2874 | |||
2875 | /* | ||
2876 | * Set up output mixers | ||
2877 | */ | ||
2878 | /* set vol=0 to output mixers */ | ||
2879 | {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, | ||
2880 | {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, | ||
2881 | {0x27, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, | ||
2882 | |||
2883 | /* Setup default input to PW4 */ | ||
2884 | {0x1d, AC_VERB_SET_CONNECT_SEL, 0}, | ||
2885 | /* PW9 Output enable */ | ||
2886 | {0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40}, | ||
2887 | /* PW10 Input enable */ | ||
2888 | {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20}, | ||
2889 | { } | ||
2890 | }; | ||
2891 | |||
2892 | static const struct hda_verb vt1708B_4ch_volume_init_verbs[] = { | ||
2893 | /* | ||
2894 | * Unmute ADC0-1 and set the default input to mic-in | ||
2895 | */ | ||
2896 | {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, | ||
2897 | {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, | ||
2898 | |||
2899 | |||
2900 | /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback | ||
2901 | * mixer widget | ||
2902 | */ | ||
2903 | /* Amp Indices: CD = 1, Mic1 = 2, Line = 3, Mic2 = 4 */ | ||
2904 | {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, | ||
2905 | {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, | ||
2906 | {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)}, | ||
2907 | {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)}, | ||
2908 | {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)}, | ||
2909 | |||
2910 | /* | ||
2911 | * Set up output mixers | ||
2912 | */ | ||
2913 | /* set vol=0 to output mixers */ | ||
2914 | {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, | ||
2915 | {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, | ||
2916 | {0x27, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, | ||
2917 | |||
2918 | /* Setup default input of PW4 to MW0 */ | ||
2919 | {0x1d, AC_VERB_SET_CONNECT_SEL, 0x0}, | ||
2920 | /* PW9 Output enable */ | ||
2921 | {0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40}, | ||
2922 | /* PW10 Input enable */ | ||
2923 | {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20}, | ||
2924 | { } | ||
2925 | }; | ||
2926 | |||
2927 | static const struct hda_verb vt1708B_uniwill_init_verbs[] = { | ||
2928 | {0x1d, AC_VERB_SET_UNSOLICITED_ENABLE, | ||
2929 | AC_USRSP_EN | VIA_HP_EVENT | VIA_JACK_EVENT}, | ||
2930 | {0x19, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT}, | ||
2931 | {0x1a, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT}, | ||
2932 | {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT}, | ||
2933 | {0x1c, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT}, | ||
2934 | {0x1e, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT}, | ||
2935 | {0x22, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT}, | ||
2936 | {0x23, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT}, | ||
2937 | { } | ||
2938 | }; | ||
2939 | |||
2940 | static int via_pcm_open_close(struct hda_pcm_stream *hinfo, | ||
2941 | struct hda_codec *codec, | ||
2942 | struct snd_pcm_substream *substream) | ||
2943 | { | ||
2944 | int idle = substream->pstr->substream_opened == 1 | ||
2945 | && substream->ref_count == 0; | ||
2946 | |||
2947 | analog_low_current_mode(codec, idle); | ||
2948 | return 0; | ||
2949 | } | ||
2950 | |||
2951 | static const struct hda_pcm_stream vt1708B_8ch_pcm_analog_playback = { | ||
2952 | .substreams = 2, | ||
2953 | .channels_min = 2, | ||
2954 | .channels_max = 8, | ||
2955 | .nid = 0x10, /* NID to query formats and rates */ | ||
2956 | .ops = { | ||
2957 | .open = via_playback_pcm_open, | ||
2958 | .prepare = via_playback_multi_pcm_prepare, | ||
2959 | .cleanup = via_playback_multi_pcm_cleanup, | ||
2960 | .close = via_pcm_open_close | ||
2961 | }, | ||
2962 | }; | ||
2963 | |||
2964 | static const struct hda_pcm_stream vt1708B_4ch_pcm_analog_playback = { | ||
2965 | .substreams = 2, | ||
2966 | .channels_min = 2, | ||
2967 | .channels_max = 4, | ||
2968 | .nid = 0x10, /* NID to query formats and rates */ | ||
2969 | .ops = { | ||
2970 | .open = via_playback_pcm_open, | ||
2971 | .prepare = via_playback_multi_pcm_prepare, | ||
2972 | .cleanup = via_playback_multi_pcm_cleanup | ||
2973 | }, | ||
2974 | }; | ||
2975 | |||
2976 | static const struct hda_pcm_stream vt1708B_pcm_analog_capture = { | ||
2977 | .substreams = 2, | ||
2978 | .channels_min = 2, | ||
2979 | .channels_max = 2, | ||
2980 | .nid = 0x13, /* NID to query formats and rates */ | ||
2981 | .ops = { | ||
2982 | .open = via_pcm_open_close, | ||
2983 | .prepare = via_capture_pcm_prepare, | ||
2984 | .cleanup = via_capture_pcm_cleanup, | ||
2985 | .close = via_pcm_open_close | ||
2986 | }, | ||
2987 | }; | ||
2988 | |||
2989 | static const struct hda_pcm_stream vt1708B_pcm_digital_playback = { | ||
2990 | .substreams = 1, | ||
2991 | .channels_min = 2, | ||
2992 | .channels_max = 2, | ||
2993 | /* NID is set in via_build_pcms */ | ||
2994 | .ops = { | ||
2995 | .open = via_dig_playback_pcm_open, | ||
2996 | .close = via_dig_playback_pcm_close, | ||
2997 | .prepare = via_dig_playback_pcm_prepare, | ||
2998 | .cleanup = via_dig_playback_pcm_cleanup | ||
2999 | }, | ||
3000 | }; | ||
3001 | |||
3002 | static const struct hda_pcm_stream vt1708B_pcm_digital_capture = { | ||
3003 | .substreams = 1, | ||
3004 | .channels_min = 2, | ||
3005 | .channels_max = 2, | ||
3006 | }; | ||
3007 | |||
3008 | /* fill in the dac_nids table from the parsed pin configuration */ | ||
3009 | static int vt1708B_auto_fill_dac_nids(struct via_spec *spec, | ||
3010 | const struct auto_pin_cfg *cfg) | ||
3011 | { | ||
3012 | int i; | ||
3013 | hda_nid_t nid; | ||
3014 | |||
3015 | spec->multiout.num_dacs = cfg->line_outs; | ||
3016 | |||
3017 | spec->multiout.dac_nids = spec->private_dac_nids; | ||
3018 | |||
3019 | for (i = 0; i < 4; i++) { | ||
3020 | nid = cfg->line_out_pins[i]; | ||
3021 | if (nid) { | ||
3022 | /* config dac list */ | ||
3023 | switch (i) { | ||
3024 | case AUTO_SEQ_FRONT: | ||
3025 | spec->private_dac_nids[i] = 0x10; | ||
3026 | break; | ||
3027 | case AUTO_SEQ_CENLFE: | ||
3028 | spec->private_dac_nids[i] = 0x24; | ||
3029 | break; | ||
3030 | case AUTO_SEQ_SURROUND: | ||
3031 | spec->private_dac_nids[i] = 0x11; | ||
3032 | break; | ||
3033 | case AUTO_SEQ_SIDE: | ||
3034 | spec->private_dac_nids[i] = 0x25; | ||
3035 | break; | ||
3036 | } | ||
3037 | } | ||
3038 | } | ||
3039 | |||
3040 | return 0; | 2565 | return 0; |
3041 | } | 2566 | } |
3042 | 2567 | ||
3043 | /* add playback controls from the parsed DAC table */ | ||
3044 | static int vt1708B_auto_create_multi_out_ctls(struct via_spec *spec, | ||
3045 | const struct auto_pin_cfg *cfg) | ||
3046 | { | ||
3047 | char name[32]; | ||
3048 | static const char * const chname[4] = { | ||
3049 | "Front", "Surround", "C/LFE", "Side" | ||
3050 | }; | ||
3051 | hda_nid_t nid_vols[] = {0x16, 0x18, 0x26, 0x27}; | ||
3052 | hda_nid_t nid, nid_vol = 0; | ||
3053 | int i, err; | ||
3054 | |||
3055 | for (i = 0; i <= AUTO_SEQ_SIDE; i++) { | ||
3056 | nid = cfg->line_out_pins[i]; | ||
3057 | |||
3058 | if (!nid) | ||
3059 | continue; | ||
3060 | |||
3061 | nid_vol = nid_vols[i]; | ||
3062 | |||
3063 | if (i == AUTO_SEQ_CENLFE) { | ||
3064 | /* Center/LFE */ | ||
3065 | err = via_add_control(spec, VIA_CTL_WIDGET_VOL, | ||
3066 | "Center Playback Volume", | ||
3067 | HDA_COMPOSE_AMP_VAL(nid_vol, 1, 0, | ||
3068 | HDA_OUTPUT)); | ||
3069 | if (err < 0) | ||
3070 | return err; | ||
3071 | err = via_add_control(spec, VIA_CTL_WIDGET_VOL, | ||
3072 | "LFE Playback Volume", | ||
3073 | HDA_COMPOSE_AMP_VAL(nid_vol, 2, 0, | ||
3074 | HDA_OUTPUT)); | ||
3075 | if (err < 0) | ||
3076 | return err; | ||
3077 | err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, | ||
3078 | "Center Playback Switch", | ||
3079 | HDA_COMPOSE_AMP_VAL(nid_vol, 1, 0, | ||
3080 | HDA_OUTPUT)); | ||
3081 | if (err < 0) | ||
3082 | return err; | ||
3083 | err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, | ||
3084 | "LFE Playback Switch", | ||
3085 | HDA_COMPOSE_AMP_VAL(nid_vol, 2, 0, | ||
3086 | HDA_OUTPUT)); | ||
3087 | if (err < 0) | ||
3088 | return err; | ||
3089 | } else if (i == AUTO_SEQ_FRONT) { | ||
3090 | /* add control to mixer index 0 */ | ||
3091 | err = via_add_control(spec, VIA_CTL_WIDGET_VOL, | ||
3092 | "Master Front Playback Volume", | ||
3093 | HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, | ||
3094 | HDA_INPUT)); | ||
3095 | if (err < 0) | ||
3096 | return err; | ||
3097 | err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, | ||
3098 | "Master Front Playback Switch", | ||
3099 | HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, | ||
3100 | HDA_INPUT)); | ||
3101 | if (err < 0) | ||
3102 | return err; | ||
3103 | |||
3104 | /* add control to PW3 */ | ||
3105 | sprintf(name, "%s Playback Volume", chname[i]); | ||
3106 | err = via_add_control(spec, VIA_CTL_WIDGET_VOL, name, | ||
3107 | HDA_COMPOSE_AMP_VAL(nid, 3, 0, | ||
3108 | HDA_OUTPUT)); | ||
3109 | if (err < 0) | ||
3110 | return err; | ||
3111 | sprintf(name, "%s Playback Switch", chname[i]); | ||
3112 | err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, name, | ||
3113 | HDA_COMPOSE_AMP_VAL(nid, 3, 0, | ||
3114 | HDA_OUTPUT)); | ||
3115 | if (err < 0) | ||
3116 | return err; | ||
3117 | } else { | ||
3118 | sprintf(name, "%s Playback Volume", chname[i]); | ||
3119 | err = via_add_control(spec, VIA_CTL_WIDGET_VOL, name, | ||
3120 | HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, | ||
3121 | HDA_OUTPUT)); | ||
3122 | if (err < 0) | ||
3123 | return err; | ||
3124 | sprintf(name, "%s Playback Switch", chname[i]); | ||
3125 | err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, name, | ||
3126 | HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, | ||
3127 | HDA_OUTPUT)); | ||
3128 | if (err < 0) | ||
3129 | return err; | ||
3130 | } | ||
3131 | } | ||
3132 | |||
3133 | return 0; | ||
3134 | } | ||
3135 | |||
3136 | static int vt1708B_auto_create_hp_ctls(struct via_spec *spec, hda_nid_t pin) | ||
3137 | { | ||
3138 | int err; | ||
3139 | |||
3140 | if (!pin) | ||
3141 | return 0; | ||
3142 | |||
3143 | spec->multiout.hp_nid = VT1708B_HP_NID; /* AOW3 */ | ||
3144 | spec->hp_independent_mode_index = 1; | ||
3145 | |||
3146 | err = via_add_control(spec, VIA_CTL_WIDGET_VOL, | ||
3147 | "Headphone Playback Volume", | ||
3148 | HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT)); | ||
3149 | if (err < 0) | ||
3150 | return err; | ||
3151 | err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, | ||
3152 | "Headphone Playback Switch", | ||
3153 | HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT)); | ||
3154 | if (err < 0) | ||
3155 | return err; | ||
3156 | |||
3157 | create_hp_imux(spec); | ||
3158 | |||
3159 | return 0; | ||
3160 | } | ||
3161 | |||
3162 | /* create playback/capture controls for input pins */ | ||
3163 | static int vt1708B_auto_create_analog_input_ctls(struct hda_codec *codec, | ||
3164 | const struct auto_pin_cfg *cfg) | ||
3165 | { | ||
3166 | static const hda_nid_t pin_idxs[] = { 0xff, 0x1f, 0x1a, 0x1b, 0x1e }; | ||
3167 | return vt_auto_create_analog_input_ctls(codec, cfg, 0x16, pin_idxs, | ||
3168 | ARRAY_SIZE(pin_idxs)); | ||
3169 | } | ||
3170 | |||
3171 | static int vt1708B_parse_auto_config(struct hda_codec *codec) | ||
3172 | { | ||
3173 | struct via_spec *spec = codec->spec; | ||
3174 | int err; | ||
3175 | |||
3176 | err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, NULL); | ||
3177 | if (err < 0) | ||
3178 | return err; | ||
3179 | err = vt1708B_auto_fill_dac_nids(spec, &spec->autocfg); | ||
3180 | if (err < 0) | ||
3181 | return err; | ||
3182 | if (!spec->autocfg.line_outs && !spec->autocfg.hp_pins[0]) | ||
3183 | return 0; /* can't find valid BIOS pin config */ | ||
3184 | |||
3185 | err = vt1708B_auto_create_multi_out_ctls(spec, &spec->autocfg); | ||
3186 | if (err < 0) | ||
3187 | return err; | ||
3188 | err = vt1708B_auto_create_hp_ctls(spec, spec->autocfg.hp_pins[0]); | ||
3189 | if (err < 0) | ||
3190 | return err; | ||
3191 | err = vt1708B_auto_create_analog_input_ctls(codec, &spec->autocfg); | ||
3192 | if (err < 0) | ||
3193 | return err; | ||
3194 | |||
3195 | spec->multiout.max_channels = spec->multiout.num_dacs * 2; | ||
3196 | |||
3197 | if (spec->autocfg.dig_outs) | ||
3198 | spec->multiout.dig_out_nid = VT1708B_DIGOUT_NID; | ||
3199 | spec->dig_in_pin = VT1708B_DIGIN_PIN; | ||
3200 | if (spec->autocfg.dig_in_pin) | ||
3201 | spec->dig_in_nid = VT1708B_DIGIN_NID; | ||
3202 | |||
3203 | if (spec->kctls.list) | ||
3204 | spec->mixers[spec->num_mixers++] = spec->kctls.list; | ||
3205 | |||
3206 | spec->input_mux = &spec->private_imux[0]; | ||
3207 | |||
3208 | if (spec->hp_mux) | ||
3209 | via_hp_build(codec); | ||
3210 | |||
3211 | via_smart51_build(spec); | ||
3212 | return 1; | ||
3213 | } | ||
3214 | |||
3215 | #ifdef CONFIG_SND_HDA_POWER_SAVE | ||
3216 | static const struct hda_amp_list vt1708B_loopbacks[] = { | ||
3217 | { 0x16, HDA_INPUT, 1 }, | ||
3218 | { 0x16, HDA_INPUT, 2 }, | ||
3219 | { 0x16, HDA_INPUT, 3 }, | ||
3220 | { 0x16, HDA_INPUT, 4 }, | ||
3221 | { } /* end */ | ||
3222 | }; | ||
3223 | #endif | ||
3224 | |||
3225 | static void set_widgets_power_state_vt1708B(struct hda_codec *codec) | 2568 | static void set_widgets_power_state_vt1708B(struct hda_codec *codec) |
3226 | { | 2569 | { |
3227 | struct via_spec *spec = codec->spec; | 2570 | struct via_spec *spec = codec->spec; |
@@ -3303,157 +2646,37 @@ static void set_widgets_power_state_vt1708B(struct hda_codec *codec) | |||
3303 | } | 2646 | } |
3304 | 2647 | ||
3305 | static int patch_vt1708S(struct hda_codec *codec); | 2648 | static int patch_vt1708S(struct hda_codec *codec); |
3306 | static int patch_vt1708B_8ch(struct hda_codec *codec) | 2649 | static int patch_vt1708B(struct hda_codec *codec) |
3307 | { | 2650 | { |
3308 | struct via_spec *spec; | 2651 | struct via_spec *spec; |
3309 | int err; | 2652 | int err; |
3310 | 2653 | ||
3311 | if (get_codec_type(codec) == VT1708BCE) | 2654 | if (get_codec_type(codec) == VT1708BCE) |
3312 | return patch_vt1708S(codec); | 2655 | return patch_vt1708S(codec); |
3313 | /* create a codec specific record */ | ||
3314 | spec = via_new_spec(codec); | ||
3315 | if (spec == NULL) | ||
3316 | return -ENOMEM; | ||
3317 | |||
3318 | /* automatic parse from the BIOS config */ | ||
3319 | err = vt1708B_parse_auto_config(codec); | ||
3320 | if (err < 0) { | ||
3321 | via_free(codec); | ||
3322 | return err; | ||
3323 | } else if (!err) { | ||
3324 | printk(KERN_INFO "hda_codec: Cannot set up configuration " | ||
3325 | "from BIOS. Using genenic mode...\n"); | ||
3326 | } | ||
3327 | |||
3328 | spec->init_verbs[spec->num_iverbs++] = vt1708B_8ch_volume_init_verbs; | ||
3329 | spec->init_verbs[spec->num_iverbs++] = vt1708B_uniwill_init_verbs; | ||
3330 | |||
3331 | spec->stream_name_analog = "VT1708B Analog"; | ||
3332 | spec->stream_analog_playback = &vt1708B_8ch_pcm_analog_playback; | ||
3333 | spec->stream_analog_capture = &vt1708B_pcm_analog_capture; | ||
3334 | |||
3335 | spec->stream_name_digital = "VT1708B Digital"; | ||
3336 | spec->stream_digital_playback = &vt1708B_pcm_digital_playback; | ||
3337 | spec->stream_digital_capture = &vt1708B_pcm_digital_capture; | ||
3338 | |||
3339 | if (!spec->adc_nids && spec->input_mux) { | ||
3340 | spec->adc_nids = vt1708B_adc_nids; | ||
3341 | spec->num_adc_nids = ARRAY_SIZE(vt1708B_adc_nids); | ||
3342 | get_mux_nids(codec); | ||
3343 | spec->mixers[spec->num_mixers] = vt1708B_capture_mixer; | ||
3344 | spec->num_mixers++; | ||
3345 | } | ||
3346 | |||
3347 | codec->patch_ops = via_patch_ops; | ||
3348 | |||
3349 | codec->patch_ops.init = via_auto_init; | ||
3350 | codec->patch_ops.unsol_event = via_unsol_event; | ||
3351 | #ifdef CONFIG_SND_HDA_POWER_SAVE | ||
3352 | spec->loopback.amplist = vt1708B_loopbacks; | ||
3353 | #endif | ||
3354 | |||
3355 | spec->set_widgets_power_state = set_widgets_power_state_vt1708B; | ||
3356 | |||
3357 | return 0; | ||
3358 | } | ||
3359 | |||
3360 | static int patch_vt1708B_4ch(struct hda_codec *codec) | ||
3361 | { | ||
3362 | struct via_spec *spec; | ||
3363 | int err; | ||
3364 | 2656 | ||
3365 | /* create a codec specific record */ | 2657 | /* create a codec specific record */ |
3366 | spec = via_new_spec(codec); | 2658 | spec = via_new_spec(codec); |
3367 | if (spec == NULL) | 2659 | if (spec == NULL) |
3368 | return -ENOMEM; | 2660 | return -ENOMEM; |
3369 | 2661 | ||
2662 | spec->aa_mix_nid = 0x16; | ||
2663 | |||
3370 | /* automatic parse from the BIOS config */ | 2664 | /* automatic parse from the BIOS config */ |
3371 | err = vt1708B_parse_auto_config(codec); | 2665 | err = via_parse_auto_config(codec); |
3372 | if (err < 0) { | 2666 | if (err < 0) { |
3373 | via_free(codec); | 2667 | via_free(codec); |
3374 | return err; | 2668 | return err; |
3375 | } else if (!err) { | ||
3376 | printk(KERN_INFO "hda_codec: Cannot set up configuration " | ||
3377 | "from BIOS. Using genenic mode...\n"); | ||
3378 | } | ||
3379 | |||
3380 | spec->init_verbs[spec->num_iverbs++] = vt1708B_4ch_volume_init_verbs; | ||
3381 | spec->init_verbs[spec->num_iverbs++] = vt1708B_uniwill_init_verbs; | ||
3382 | |||
3383 | spec->stream_name_analog = "VT1708B Analog"; | ||
3384 | spec->stream_analog_playback = &vt1708B_4ch_pcm_analog_playback; | ||
3385 | spec->stream_analog_capture = &vt1708B_pcm_analog_capture; | ||
3386 | |||
3387 | spec->stream_name_digital = "VT1708B Digital"; | ||
3388 | spec->stream_digital_playback = &vt1708B_pcm_digital_playback; | ||
3389 | spec->stream_digital_capture = &vt1708B_pcm_digital_capture; | ||
3390 | |||
3391 | if (!spec->adc_nids && spec->input_mux) { | ||
3392 | spec->adc_nids = vt1708B_adc_nids; | ||
3393 | spec->num_adc_nids = ARRAY_SIZE(vt1708B_adc_nids); | ||
3394 | get_mux_nids(codec); | ||
3395 | spec->mixers[spec->num_mixers] = vt1708B_capture_mixer; | ||
3396 | spec->num_mixers++; | ||
3397 | } | 2669 | } |
3398 | 2670 | ||
3399 | codec->patch_ops = via_patch_ops; | 2671 | codec->patch_ops = via_patch_ops; |
3400 | 2672 | ||
3401 | codec->patch_ops.init = via_auto_init; | ||
3402 | codec->patch_ops.unsol_event = via_unsol_event; | ||
3403 | #ifdef CONFIG_SND_HDA_POWER_SAVE | ||
3404 | spec->loopback.amplist = vt1708B_loopbacks; | ||
3405 | #endif | ||
3406 | |||
3407 | spec->set_widgets_power_state = set_widgets_power_state_vt1708B; | 2673 | spec->set_widgets_power_state = set_widgets_power_state_vt1708B; |
3408 | 2674 | ||
3409 | return 0; | 2675 | return 0; |
3410 | } | 2676 | } |
3411 | 2677 | ||
3412 | /* Patch for VT1708S */ | 2678 | /* Patch for VT1708S */ |
3413 | 2679 | static const struct hda_verb vt1708S_init_verbs[] = { | |
3414 | /* capture mixer elements */ | ||
3415 | static const struct snd_kcontrol_new vt1708S_capture_mixer[] = { | ||
3416 | HDA_CODEC_VOLUME("Capture Volume", 0x13, 0x0, HDA_INPUT), | ||
3417 | HDA_CODEC_MUTE("Capture Switch", 0x13, 0x0, HDA_INPUT), | ||
3418 | HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x14, 0x0, HDA_INPUT), | ||
3419 | HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x14, 0x0, HDA_INPUT), | ||
3420 | HDA_CODEC_VOLUME("Mic Boost Capture Volume", 0x1A, 0x0, HDA_INPUT), | ||
3421 | HDA_CODEC_VOLUME("Front Mic Boost Capture Volume", 0x1E, 0x0, | ||
3422 | HDA_INPUT), | ||
3423 | { | ||
3424 | .iface = SNDRV_CTL_ELEM_IFACE_MIXER, | ||
3425 | /* The multiple "Capture Source" controls confuse alsamixer | ||
3426 | * So call somewhat different.. | ||
3427 | */ | ||
3428 | /* .name = "Capture Source", */ | ||
3429 | .name = "Input Source", | ||
3430 | .count = 1, | ||
3431 | .info = via_mux_enum_info, | ||
3432 | .get = via_mux_enum_get, | ||
3433 | .put = via_mux_enum_put, | ||
3434 | }, | ||
3435 | { } /* end */ | ||
3436 | }; | ||
3437 | |||
3438 | static const struct hda_verb vt1708S_volume_init_verbs[] = { | ||
3439 | /* Unmute ADC0-1 and set the default input to mic-in */ | ||
3440 | {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, | ||
3441 | {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, | ||
3442 | |||
3443 | /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the | ||
3444 | * analog-loopback mixer widget */ | ||
3445 | /* Amp Indices: CD = 1, Mic1 = 2, Line = 3, Mic2 = 4 */ | ||
3446 | {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, | ||
3447 | {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, | ||
3448 | {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)}, | ||
3449 | {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)}, | ||
3450 | {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)}, | ||
3451 | |||
3452 | /* Setup default input of PW4 to MW0 */ | ||
3453 | {0x1d, AC_VERB_SET_CONNECT_SEL, 0x0}, | ||
3454 | /* PW9, PW10 Output enable */ | ||
3455 | {0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40}, | ||
3456 | {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40}, | ||
3457 | /* Enable Mic Boost Volume backdoor */ | 2680 | /* Enable Mic Boost Volume backdoor */ |
3458 | {0x1, 0xf98, 0x1}, | 2681 | {0x1, 0xf98, 0x1}, |
3459 | /* don't bybass mixer */ | 2682 | /* don't bybass mixer */ |
@@ -3461,277 +2684,6 @@ static const struct hda_verb vt1708S_volume_init_verbs[] = { | |||
3461 | { } | 2684 | { } |
3462 | }; | 2685 | }; |
3463 | 2686 | ||
3464 | static const struct hda_verb vt1708S_uniwill_init_verbs[] = { | ||
3465 | {0x1d, AC_VERB_SET_UNSOLICITED_ENABLE, | ||
3466 | AC_USRSP_EN | VIA_HP_EVENT | VIA_JACK_EVENT}, | ||
3467 | {0x19, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT}, | ||
3468 | {0x1a, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT}, | ||
3469 | {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT}, | ||
3470 | {0x1c, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT}, | ||
3471 | {0x1e, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT}, | ||
3472 | {0x22, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT}, | ||
3473 | {0x23, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT}, | ||
3474 | { } | ||
3475 | }; | ||
3476 | |||
3477 | static const struct hda_verb vt1705_uniwill_init_verbs[] = { | ||
3478 | {0x1d, AC_VERB_SET_UNSOLICITED_ENABLE, | ||
3479 | AC_USRSP_EN | VIA_HP_EVENT | VIA_JACK_EVENT}, | ||
3480 | {0x19, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT}, | ||
3481 | {0x1a, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT}, | ||
3482 | {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT}, | ||
3483 | {0x1c, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT}, | ||
3484 | {0x1e, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT}, | ||
3485 | {0x23, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT}, | ||
3486 | { } | ||
3487 | }; | ||
3488 | |||
3489 | static const struct hda_pcm_stream vt1708S_pcm_analog_playback = { | ||
3490 | .substreams = 2, | ||
3491 | .channels_min = 2, | ||
3492 | .channels_max = 8, | ||
3493 | .nid = 0x10, /* NID to query formats and rates */ | ||
3494 | .ops = { | ||
3495 | .open = via_playback_pcm_open, | ||
3496 | .prepare = via_playback_multi_pcm_prepare, | ||
3497 | .cleanup = via_playback_multi_pcm_cleanup, | ||
3498 | .close = via_pcm_open_close | ||
3499 | }, | ||
3500 | }; | ||
3501 | |||
3502 | static const struct hda_pcm_stream vt1705_pcm_analog_playback = { | ||
3503 | .substreams = 2, | ||
3504 | .channels_min = 2, | ||
3505 | .channels_max = 6, | ||
3506 | .nid = 0x10, /* NID to query formats and rates */ | ||
3507 | .ops = { | ||
3508 | .open = via_playback_pcm_open, | ||
3509 | .prepare = via_playback_multi_pcm_prepare, | ||
3510 | .cleanup = via_playback_multi_pcm_cleanup, | ||
3511 | .close = via_pcm_open_close | ||
3512 | }, | ||
3513 | }; | ||
3514 | |||
3515 | static const struct hda_pcm_stream vt1708S_pcm_analog_capture = { | ||
3516 | .substreams = 2, | ||
3517 | .channels_min = 2, | ||
3518 | .channels_max = 2, | ||
3519 | .nid = 0x13, /* NID to query formats and rates */ | ||
3520 | .ops = { | ||
3521 | .open = via_pcm_open_close, | ||
3522 | .prepare = via_capture_pcm_prepare, | ||
3523 | .cleanup = via_capture_pcm_cleanup, | ||
3524 | .close = via_pcm_open_close | ||
3525 | }, | ||
3526 | }; | ||
3527 | |||
3528 | static const struct hda_pcm_stream vt1708S_pcm_digital_playback = { | ||
3529 | .substreams = 1, | ||
3530 | .channels_min = 2, | ||
3531 | .channels_max = 2, | ||
3532 | /* NID is set in via_build_pcms */ | ||
3533 | .ops = { | ||
3534 | .open = via_dig_playback_pcm_open, | ||
3535 | .close = via_dig_playback_pcm_close, | ||
3536 | .prepare = via_dig_playback_pcm_prepare, | ||
3537 | .cleanup = via_dig_playback_pcm_cleanup | ||
3538 | }, | ||
3539 | }; | ||
3540 | |||
3541 | /* fill in the dac_nids table from the parsed pin configuration */ | ||
3542 | static int vt1708S_auto_fill_dac_nids(struct via_spec *spec, | ||
3543 | const struct auto_pin_cfg *cfg) | ||
3544 | { | ||
3545 | int i; | ||
3546 | hda_nid_t nid; | ||
3547 | |||
3548 | spec->multiout.num_dacs = cfg->line_outs; | ||
3549 | |||
3550 | spec->multiout.dac_nids = spec->private_dac_nids; | ||
3551 | |||
3552 | for (i = 0; i < 4; i++) { | ||
3553 | nid = cfg->line_out_pins[i]; | ||
3554 | if (nid) { | ||
3555 | /* config dac list */ | ||
3556 | switch (i) { | ||
3557 | case AUTO_SEQ_FRONT: | ||
3558 | spec->private_dac_nids[i] = 0x10; | ||
3559 | break; | ||
3560 | case AUTO_SEQ_CENLFE: | ||
3561 | if (spec->codec->vendor_id == 0x11064397) | ||
3562 | spec->private_dac_nids[i] = 0x25; | ||
3563 | else | ||
3564 | spec->private_dac_nids[i] = 0x24; | ||
3565 | break; | ||
3566 | case AUTO_SEQ_SURROUND: | ||
3567 | spec->private_dac_nids[i] = 0x11; | ||
3568 | break; | ||
3569 | case AUTO_SEQ_SIDE: | ||
3570 | spec->private_dac_nids[i] = 0x25; | ||
3571 | break; | ||
3572 | } | ||
3573 | } | ||
3574 | } | ||
3575 | |||
3576 | /* for Smart 5.1, line/mic inputs double as output pins */ | ||
3577 | if (cfg->line_outs == 1) { | ||
3578 | spec->multiout.num_dacs = 3; | ||
3579 | spec->private_dac_nids[AUTO_SEQ_SURROUND] = 0x11; | ||
3580 | if (spec->codec->vendor_id == 0x11064397) | ||
3581 | spec->private_dac_nids[AUTO_SEQ_CENLFE] = 0x25; | ||
3582 | else | ||
3583 | spec->private_dac_nids[AUTO_SEQ_CENLFE] = 0x24; | ||
3584 | } | ||
3585 | |||
3586 | return 0; | ||
3587 | } | ||
3588 | |||
3589 | /* add playback controls from the parsed DAC table */ | ||
3590 | static int vt1708S_auto_create_multi_out_ctls(struct hda_codec *codec, | ||
3591 | const struct auto_pin_cfg *cfg) | ||
3592 | { | ||
3593 | struct via_spec *spec = codec->spec; | ||
3594 | char name[32]; | ||
3595 | static const char * const chname[4] = { | ||
3596 | "Front", "Surround", "C/LFE", "Side" | ||
3597 | }; | ||
3598 | hda_nid_t nid_vols[2][4] = { {0x10, 0x11, 0x24, 0x25}, | ||
3599 | {0x10, 0x11, 0x25, 0} }; | ||
3600 | hda_nid_t nid_mutes[2][4] = { {0x1C, 0x18, 0x26, 0x27}, | ||
3601 | {0x1C, 0x18, 0x27, 0} }; | ||
3602 | hda_nid_t nid, nid_vol, nid_mute; | ||
3603 | int i, err; | ||
3604 | |||
3605 | for (i = 0; i <= AUTO_SEQ_SIDE; i++) { | ||
3606 | nid = cfg->line_out_pins[i]; | ||
3607 | |||
3608 | /* for Smart 5.1, there are always at least six channels */ | ||
3609 | if (!nid && i > AUTO_SEQ_CENLFE) | ||
3610 | continue; | ||
3611 | |||
3612 | if (codec->vendor_id == 0x11064397) { | ||
3613 | nid_vol = nid_vols[1][i]; | ||
3614 | nid_mute = nid_mutes[1][i]; | ||
3615 | } else { | ||
3616 | nid_vol = nid_vols[0][i]; | ||
3617 | nid_mute = nid_mutes[0][i]; | ||
3618 | } | ||
3619 | if (!nid_vol && !nid_mute) | ||
3620 | continue; | ||
3621 | |||
3622 | if (i == AUTO_SEQ_CENLFE) { | ||
3623 | /* Center/LFE */ | ||
3624 | err = via_add_control(spec, VIA_CTL_WIDGET_VOL, | ||
3625 | "Center Playback Volume", | ||
3626 | HDA_COMPOSE_AMP_VAL(nid_vol, 1, 0, | ||
3627 | HDA_OUTPUT)); | ||
3628 | if (err < 0) | ||
3629 | return err; | ||
3630 | err = via_add_control(spec, VIA_CTL_WIDGET_VOL, | ||
3631 | "LFE Playback Volume", | ||
3632 | HDA_COMPOSE_AMP_VAL(nid_vol, 2, 0, | ||
3633 | HDA_OUTPUT)); | ||
3634 | if (err < 0) | ||
3635 | return err; | ||
3636 | err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, | ||
3637 | "Center Playback Switch", | ||
3638 | HDA_COMPOSE_AMP_VAL(nid_mute, | ||
3639 | 1, 0, | ||
3640 | HDA_OUTPUT)); | ||
3641 | if (err < 0) | ||
3642 | return err; | ||
3643 | err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, | ||
3644 | "LFE Playback Switch", | ||
3645 | HDA_COMPOSE_AMP_VAL(nid_mute, | ||
3646 | 2, 0, | ||
3647 | HDA_OUTPUT)); | ||
3648 | if (err < 0) | ||
3649 | return err; | ||
3650 | } else if (i == AUTO_SEQ_FRONT) { | ||
3651 | /* add control to mixer index 0 */ | ||
3652 | err = via_add_control(spec, VIA_CTL_WIDGET_VOL, | ||
3653 | "Master Front Playback Volume", | ||
3654 | HDA_COMPOSE_AMP_VAL(0x16, 3, 0, | ||
3655 | HDA_INPUT)); | ||
3656 | if (err < 0) | ||
3657 | return err; | ||
3658 | err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, | ||
3659 | "Master Front Playback Switch", | ||
3660 | HDA_COMPOSE_AMP_VAL(0x16, 3, 0, | ||
3661 | HDA_INPUT)); | ||
3662 | if (err < 0) | ||
3663 | return err; | ||
3664 | |||
3665 | /* Front */ | ||
3666 | sprintf(name, "%s Playback Volume", chname[i]); | ||
3667 | err = via_add_control(spec, VIA_CTL_WIDGET_VOL, name, | ||
3668 | HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, | ||
3669 | HDA_OUTPUT)); | ||
3670 | if (err < 0) | ||
3671 | return err; | ||
3672 | sprintf(name, "%s Playback Switch", chname[i]); | ||
3673 | err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, name, | ||
3674 | HDA_COMPOSE_AMP_VAL(nid_mute, | ||
3675 | 3, 0, | ||
3676 | HDA_OUTPUT)); | ||
3677 | if (err < 0) | ||
3678 | return err; | ||
3679 | } else { | ||
3680 | sprintf(name, "%s Playback Volume", chname[i]); | ||
3681 | err = via_add_control(spec, VIA_CTL_WIDGET_VOL, name, | ||
3682 | HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, | ||
3683 | HDA_OUTPUT)); | ||
3684 | if (err < 0) | ||
3685 | return err; | ||
3686 | sprintf(name, "%s Playback Switch", chname[i]); | ||
3687 | err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, name, | ||
3688 | HDA_COMPOSE_AMP_VAL(nid_mute, | ||
3689 | 3, 0, | ||
3690 | HDA_OUTPUT)); | ||
3691 | if (err < 0) | ||
3692 | return err; | ||
3693 | } | ||
3694 | } | ||
3695 | |||
3696 | return 0; | ||
3697 | } | ||
3698 | |||
3699 | static int vt1708S_auto_create_hp_ctls(struct via_spec *spec, hda_nid_t pin) | ||
3700 | { | ||
3701 | int err; | ||
3702 | |||
3703 | if (!pin) | ||
3704 | return 0; | ||
3705 | |||
3706 | spec->multiout.hp_nid = VT1708S_HP_NID; /* AOW3 */ | ||
3707 | spec->hp_independent_mode_index = 1; | ||
3708 | |||
3709 | err = via_add_control(spec, VIA_CTL_WIDGET_VOL, | ||
3710 | "Headphone Playback Volume", | ||
3711 | HDA_COMPOSE_AMP_VAL(0x25, 3, 0, HDA_OUTPUT)); | ||
3712 | if (err < 0) | ||
3713 | return err; | ||
3714 | |||
3715 | err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, | ||
3716 | "Headphone Playback Switch", | ||
3717 | HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT)); | ||
3718 | if (err < 0) | ||
3719 | return err; | ||
3720 | |||
3721 | create_hp_imux(spec); | ||
3722 | |||
3723 | return 0; | ||
3724 | } | ||
3725 | |||
3726 | /* create playback/capture controls for input pins */ | ||
3727 | static int vt1708S_auto_create_analog_input_ctls(struct hda_codec *codec, | ||
3728 | const struct auto_pin_cfg *cfg) | ||
3729 | { | ||
3730 | static const hda_nid_t pin_idxs[] = { 0x1f, 0x1a, 0x1b, 0x1e, 0, 0xff }; | ||
3731 | return vt_auto_create_analog_input_ctls(codec, cfg, 0x16, pin_idxs, | ||
3732 | ARRAY_SIZE(pin_idxs)); | ||
3733 | } | ||
3734 | |||
3735 | /* fill out digital output widgets; one for master and one for slave outputs */ | 2687 | /* fill out digital output widgets; one for master and one for slave outputs */ |
3736 | static void fill_dig_outs(struct hda_codec *codec) | 2688 | static void fill_dig_outs(struct hda_codec *codec) |
3737 | { | 2689 | { |
@@ -3757,56 +2709,33 @@ static void fill_dig_outs(struct hda_codec *codec) | |||
3757 | } | 2709 | } |
3758 | } | 2710 | } |
3759 | 2711 | ||
3760 | static int vt1708S_parse_auto_config(struct hda_codec *codec) | 2712 | static void fill_dig_in(struct hda_codec *codec) |
3761 | { | 2713 | { |
3762 | struct via_spec *spec = codec->spec; | 2714 | struct via_spec *spec = codec->spec; |
3763 | int err; | 2715 | hda_nid_t dig_nid; |
3764 | 2716 | int i, err; | |
3765 | err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, NULL); | ||
3766 | if (err < 0) | ||
3767 | return err; | ||
3768 | err = vt1708S_auto_fill_dac_nids(spec, &spec->autocfg); | ||
3769 | if (err < 0) | ||
3770 | return err; | ||
3771 | if (!spec->autocfg.line_outs && !spec->autocfg.hp_pins[0]) | ||
3772 | return 0; /* can't find valid BIOS pin config */ | ||
3773 | |||
3774 | err = vt1708S_auto_create_multi_out_ctls(codec, &spec->autocfg); | ||
3775 | if (err < 0) | ||
3776 | return err; | ||
3777 | err = vt1708S_auto_create_hp_ctls(spec, spec->autocfg.hp_pins[0]); | ||
3778 | if (err < 0) | ||
3779 | return err; | ||
3780 | err = vt1708S_auto_create_analog_input_ctls(codec, &spec->autocfg); | ||
3781 | if (err < 0) | ||
3782 | return err; | ||
3783 | |||
3784 | spec->multiout.max_channels = spec->multiout.num_dacs * 2; | ||
3785 | |||
3786 | fill_dig_outs(codec); | ||
3787 | |||
3788 | if (spec->kctls.list) | ||
3789 | spec->mixers[spec->num_mixers++] = spec->kctls.list; | ||
3790 | |||
3791 | spec->input_mux = &spec->private_imux[0]; | ||
3792 | 2717 | ||
3793 | if (spec->hp_mux) | 2718 | if (!spec->autocfg.dig_in_pin) |
3794 | via_hp_build(codec); | 2719 | return; |
3795 | 2720 | ||
3796 | via_smart51_build(spec); | 2721 | dig_nid = codec->start_nid; |
3797 | return 1; | 2722 | for (i = 0; i < codec->num_nodes; i++, dig_nid++) { |
2723 | unsigned int wcaps = get_wcaps(codec, dig_nid); | ||
2724 | if (get_wcaps_type(wcaps) != AC_WID_AUD_IN) | ||
2725 | continue; | ||
2726 | if (!(wcaps & AC_WCAP_DIGITAL)) | ||
2727 | continue; | ||
2728 | if (!(wcaps & AC_WCAP_CONN_LIST)) | ||
2729 | continue; | ||
2730 | err = get_connection_index(codec, dig_nid, | ||
2731 | spec->autocfg.dig_in_pin); | ||
2732 | if (err >= 0) { | ||
2733 | spec->dig_in_nid = dig_nid; | ||
2734 | break; | ||
2735 | } | ||
2736 | } | ||
3798 | } | 2737 | } |
3799 | 2738 | ||
3800 | #ifdef CONFIG_SND_HDA_POWER_SAVE | ||
3801 | static const struct hda_amp_list vt1708S_loopbacks[] = { | ||
3802 | { 0x16, HDA_INPUT, 1 }, | ||
3803 | { 0x16, HDA_INPUT, 2 }, | ||
3804 | { 0x16, HDA_INPUT, 3 }, | ||
3805 | { 0x16, HDA_INPUT, 4 }, | ||
3806 | { } /* end */ | ||
3807 | }; | ||
3808 | #endif | ||
3809 | |||
3810 | static void override_mic_boost(struct hda_codec *codec, hda_nid_t pin, | 2739 | static void override_mic_boost(struct hda_codec *codec, hda_nid_t pin, |
3811 | int offset, int num_steps, int step_size) | 2740 | int offset, int num_steps, int step_size) |
3812 | { | 2741 | { |
@@ -3827,62 +2756,21 @@ static int patch_vt1708S(struct hda_codec *codec) | |||
3827 | if (spec == NULL) | 2756 | if (spec == NULL) |
3828 | return -ENOMEM; | 2757 | return -ENOMEM; |
3829 | 2758 | ||
2759 | spec->aa_mix_nid = 0x16; | ||
2760 | override_mic_boost(codec, 0x1a, 0, 3, 40); | ||
2761 | override_mic_boost(codec, 0x1e, 0, 3, 40); | ||
2762 | |||
3830 | /* automatic parse from the BIOS config */ | 2763 | /* automatic parse from the BIOS config */ |
3831 | err = vt1708S_parse_auto_config(codec); | 2764 | err = via_parse_auto_config(codec); |
3832 | if (err < 0) { | 2765 | if (err < 0) { |
3833 | via_free(codec); | 2766 | via_free(codec); |
3834 | return err; | 2767 | return err; |
3835 | } else if (!err) { | ||
3836 | printk(KERN_INFO "hda_codec: Cannot set up configuration " | ||
3837 | "from BIOS. Using genenic mode...\n"); | ||
3838 | } | 2768 | } |
3839 | 2769 | ||
3840 | spec->init_verbs[spec->num_iverbs++] = vt1708S_volume_init_verbs; | 2770 | spec->init_verbs[spec->num_iverbs++] = vt1708S_init_verbs; |
3841 | if (codec->vendor_id == 0x11064397) | ||
3842 | spec->init_verbs[spec->num_iverbs++] = | ||
3843 | vt1705_uniwill_init_verbs; | ||
3844 | else | ||
3845 | spec->init_verbs[spec->num_iverbs++] = | ||
3846 | vt1708S_uniwill_init_verbs; | ||
3847 | |||
3848 | if (codec->vendor_id == 0x11060440) | ||
3849 | spec->stream_name_analog = "VT1818S Analog"; | ||
3850 | else if (codec->vendor_id == 0x11064397) | ||
3851 | spec->stream_name_analog = "VT1705 Analog"; | ||
3852 | else | ||
3853 | spec->stream_name_analog = "VT1708S Analog"; | ||
3854 | if (codec->vendor_id == 0x11064397) | ||
3855 | spec->stream_analog_playback = &vt1705_pcm_analog_playback; | ||
3856 | else | ||
3857 | spec->stream_analog_playback = &vt1708S_pcm_analog_playback; | ||
3858 | spec->stream_analog_capture = &vt1708S_pcm_analog_capture; | ||
3859 | |||
3860 | if (codec->vendor_id == 0x11060440) | ||
3861 | spec->stream_name_digital = "VT1818S Digital"; | ||
3862 | else if (codec->vendor_id == 0x11064397) | ||
3863 | spec->stream_name_digital = "VT1705 Digital"; | ||
3864 | else | ||
3865 | spec->stream_name_digital = "VT1708S Digital"; | ||
3866 | spec->stream_digital_playback = &vt1708S_pcm_digital_playback; | ||
3867 | |||
3868 | if (!spec->adc_nids && spec->input_mux) { | ||
3869 | spec->adc_nids = vt1708S_adc_nids; | ||
3870 | spec->num_adc_nids = ARRAY_SIZE(vt1708S_adc_nids); | ||
3871 | get_mux_nids(codec); | ||
3872 | override_mic_boost(codec, 0x1a, 0, 3, 40); | ||
3873 | override_mic_boost(codec, 0x1e, 0, 3, 40); | ||
3874 | spec->mixers[spec->num_mixers] = vt1708S_capture_mixer; | ||
3875 | spec->num_mixers++; | ||
3876 | } | ||
3877 | 2771 | ||
3878 | codec->patch_ops = via_patch_ops; | 2772 | codec->patch_ops = via_patch_ops; |
3879 | 2773 | ||
3880 | codec->patch_ops.init = via_auto_init; | ||
3881 | codec->patch_ops.unsol_event = via_unsol_event; | ||
3882 | #ifdef CONFIG_SND_HDA_POWER_SAVE | ||
3883 | spec->loopback.amplist = vt1708S_loopbacks; | ||
3884 | #endif | ||
3885 | |||
3886 | /* correct names for VT1708BCE */ | 2774 | /* correct names for VT1708BCE */ |
3887 | if (get_codec_type(codec) == VT1708BCE) { | 2775 | if (get_codec_type(codec) == VT1708BCE) { |
3888 | kfree(codec->chip_name); | 2776 | kfree(codec->chip_name); |
@@ -3890,13 +2778,6 @@ static int patch_vt1708S(struct hda_codec *codec) | |||
3890 | snprintf(codec->bus->card->mixername, | 2778 | snprintf(codec->bus->card->mixername, |
3891 | sizeof(codec->bus->card->mixername), | 2779 | sizeof(codec->bus->card->mixername), |
3892 | "%s %s", codec->vendor_name, codec->chip_name); | 2780 | "%s %s", codec->vendor_name, codec->chip_name); |
3893 | spec->stream_name_analog = "VT1708BCE Analog"; | ||
3894 | spec->stream_name_digital = "VT1708BCE Digital"; | ||
3895 | } | ||
3896 | /* correct names for VT1818S */ | ||
3897 | if (codec->vendor_id == 0x11060440) { | ||
3898 | spec->stream_name_analog = "VT1818S Analog"; | ||
3899 | spec->stream_name_digital = "VT1818S Digital"; | ||
3900 | } | 2781 | } |
3901 | /* correct names for VT1705 */ | 2782 | /* correct names for VT1705 */ |
3902 | if (codec->vendor_id == 0x11064397) { | 2783 | if (codec->vendor_id == 0x11064397) { |
@@ -3912,55 +2793,7 @@ static int patch_vt1708S(struct hda_codec *codec) | |||
3912 | 2793 | ||
3913 | /* Patch for VT1702 */ | 2794 | /* Patch for VT1702 */ |
3914 | 2795 | ||
3915 | /* capture mixer elements */ | 2796 | static const struct hda_verb vt1702_init_verbs[] = { |
3916 | static const struct snd_kcontrol_new vt1702_capture_mixer[] = { | ||
3917 | HDA_CODEC_VOLUME("Capture Volume", 0x12, 0x0, HDA_INPUT), | ||
3918 | HDA_CODEC_MUTE("Capture Switch", 0x12, 0x0, HDA_INPUT), | ||
3919 | HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x20, 0x0, HDA_INPUT), | ||
3920 | HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x20, 0x0, HDA_INPUT), | ||
3921 | HDA_CODEC_VOLUME("Digital Mic Capture Volume", 0x1F, 0x0, HDA_INPUT), | ||
3922 | HDA_CODEC_MUTE("Digital Mic Capture Switch", 0x1F, 0x0, HDA_INPUT), | ||
3923 | HDA_CODEC_VOLUME("Digital Mic Boost Capture Volume", 0x1E, 0x0, | ||
3924 | HDA_INPUT), | ||
3925 | { | ||
3926 | .iface = SNDRV_CTL_ELEM_IFACE_MIXER, | ||
3927 | /* The multiple "Capture Source" controls confuse alsamixer | ||
3928 | * So call somewhat different.. | ||
3929 | */ | ||
3930 | /* .name = "Capture Source", */ | ||
3931 | .name = "Input Source", | ||
3932 | .count = 1, | ||
3933 | .info = via_mux_enum_info, | ||
3934 | .get = via_mux_enum_get, | ||
3935 | .put = via_mux_enum_put, | ||
3936 | }, | ||
3937 | { } /* end */ | ||
3938 | }; | ||
3939 | |||
3940 | static const struct hda_verb vt1702_volume_init_verbs[] = { | ||
3941 | /* | ||
3942 | * Unmute ADC0-1 and set the default input to mic-in | ||
3943 | */ | ||
3944 | {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, | ||
3945 | {0x1F, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, | ||
3946 | {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, | ||
3947 | |||
3948 | |||
3949 | /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback | ||
3950 | * mixer widget | ||
3951 | */ | ||
3952 | /* Amp Indices: Mic1 = 1, Line = 1, Mic2 = 3 */ | ||
3953 | {0x1A, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, | ||
3954 | {0x1A, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, | ||
3955 | {0x1A, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)}, | ||
3956 | {0x1A, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)}, | ||
3957 | {0x1A, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, | ||
3958 | |||
3959 | /* Setup default input of PW4 to MW0 */ | ||
3960 | {0x17, AC_VERB_SET_CONNECT_SEL, 0x1}, | ||
3961 | /* PW6 PW7 Output enable */ | ||
3962 | {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40}, | ||
3963 | {0x1C, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40}, | ||
3964 | /* mixer enable */ | 2797 | /* mixer enable */ |
3965 | {0x1, 0xF88, 0x3}, | 2798 | {0x1, 0xF88, 0x3}, |
3966 | /* GPIO 0~2 */ | 2799 | /* GPIO 0~2 */ |
@@ -3968,202 +2801,6 @@ static const struct hda_verb vt1702_volume_init_verbs[] = { | |||
3968 | { } | 2801 | { } |
3969 | }; | 2802 | }; |
3970 | 2803 | ||
3971 | static const struct hda_verb vt1702_uniwill_init_verbs[] = { | ||
3972 | {0x17, AC_VERB_SET_UNSOLICITED_ENABLE, | ||
3973 | AC_USRSP_EN | VIA_HP_EVENT | VIA_JACK_EVENT}, | ||
3974 | {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT}, | ||
3975 | {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT}, | ||
3976 | {0x16, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT}, | ||
3977 | {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT}, | ||
3978 | { } | ||
3979 | }; | ||
3980 | |||
3981 | static const struct hda_pcm_stream vt1702_pcm_analog_playback = { | ||
3982 | .substreams = 2, | ||
3983 | .channels_min = 2, | ||
3984 | .channels_max = 2, | ||
3985 | .nid = 0x10, /* NID to query formats and rates */ | ||
3986 | .ops = { | ||
3987 | .open = via_playback_pcm_open, | ||
3988 | .prepare = via_playback_multi_pcm_prepare, | ||
3989 | .cleanup = via_playback_multi_pcm_cleanup, | ||
3990 | .close = via_pcm_open_close | ||
3991 | }, | ||
3992 | }; | ||
3993 | |||
3994 | static const struct hda_pcm_stream vt1702_pcm_analog_capture = { | ||
3995 | .substreams = 3, | ||
3996 | .channels_min = 2, | ||
3997 | .channels_max = 2, | ||
3998 | .nid = 0x12, /* NID to query formats and rates */ | ||
3999 | .ops = { | ||
4000 | .open = via_pcm_open_close, | ||
4001 | .prepare = via_capture_pcm_prepare, | ||
4002 | .cleanup = via_capture_pcm_cleanup, | ||
4003 | .close = via_pcm_open_close | ||
4004 | }, | ||
4005 | }; | ||
4006 | |||
4007 | static const struct hda_pcm_stream vt1702_pcm_digital_playback = { | ||
4008 | .substreams = 2, | ||
4009 | .channels_min = 2, | ||
4010 | .channels_max = 2, | ||
4011 | /* NID is set in via_build_pcms */ | ||
4012 | .ops = { | ||
4013 | .open = via_dig_playback_pcm_open, | ||
4014 | .close = via_dig_playback_pcm_close, | ||
4015 | .prepare = via_dig_playback_pcm_prepare, | ||
4016 | .cleanup = via_dig_playback_pcm_cleanup | ||
4017 | }, | ||
4018 | }; | ||
4019 | |||
4020 | /* fill in the dac_nids table from the parsed pin configuration */ | ||
4021 | static int vt1702_auto_fill_dac_nids(struct via_spec *spec, | ||
4022 | const struct auto_pin_cfg *cfg) | ||
4023 | { | ||
4024 | spec->multiout.num_dacs = 1; | ||
4025 | spec->multiout.dac_nids = spec->private_dac_nids; | ||
4026 | |||
4027 | if (cfg->line_out_pins[0]) { | ||
4028 | /* config dac list */ | ||
4029 | spec->private_dac_nids[0] = 0x10; | ||
4030 | } | ||
4031 | |||
4032 | return 0; | ||
4033 | } | ||
4034 | |||
4035 | /* add playback controls from the parsed DAC table */ | ||
4036 | static int vt1702_auto_create_line_out_ctls(struct via_spec *spec, | ||
4037 | const struct auto_pin_cfg *cfg) | ||
4038 | { | ||
4039 | int err; | ||
4040 | |||
4041 | if (!cfg->line_out_pins[0]) | ||
4042 | return -1; | ||
4043 | |||
4044 | /* add control to mixer index 0 */ | ||
4045 | err = via_add_control(spec, VIA_CTL_WIDGET_VOL, | ||
4046 | "Master Front Playback Volume", | ||
4047 | HDA_COMPOSE_AMP_VAL(0x1A, 3, 0, HDA_INPUT)); | ||
4048 | if (err < 0) | ||
4049 | return err; | ||
4050 | err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, | ||
4051 | "Master Front Playback Switch", | ||
4052 | HDA_COMPOSE_AMP_VAL(0x1A, 3, 0, HDA_INPUT)); | ||
4053 | if (err < 0) | ||
4054 | return err; | ||
4055 | |||
4056 | /* Front */ | ||
4057 | err = via_add_control(spec, VIA_CTL_WIDGET_VOL, | ||
4058 | "Front Playback Volume", | ||
4059 | HDA_COMPOSE_AMP_VAL(0x10, 3, 0, HDA_OUTPUT)); | ||
4060 | if (err < 0) | ||
4061 | return err; | ||
4062 | err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, | ||
4063 | "Front Playback Switch", | ||
4064 | HDA_COMPOSE_AMP_VAL(0x16, 3, 0, HDA_OUTPUT)); | ||
4065 | if (err < 0) | ||
4066 | return err; | ||
4067 | |||
4068 | return 0; | ||
4069 | } | ||
4070 | |||
4071 | static int vt1702_auto_create_hp_ctls(struct via_spec *spec, hda_nid_t pin) | ||
4072 | { | ||
4073 | int err, i; | ||
4074 | struct hda_input_mux *imux; | ||
4075 | static const char * const texts[] = { "ON", "OFF", NULL}; | ||
4076 | if (!pin) | ||
4077 | return 0; | ||
4078 | spec->multiout.hp_nid = 0x1D; | ||
4079 | spec->hp_independent_mode_index = 0; | ||
4080 | |||
4081 | err = via_add_control(spec, VIA_CTL_WIDGET_VOL, | ||
4082 | "Headphone Playback Volume", | ||
4083 | HDA_COMPOSE_AMP_VAL(0x1D, 3, 0, HDA_OUTPUT)); | ||
4084 | if (err < 0) | ||
4085 | return err; | ||
4086 | |||
4087 | err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, | ||
4088 | "Headphone Playback Switch", | ||
4089 | HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT)); | ||
4090 | if (err < 0) | ||
4091 | return err; | ||
4092 | |||
4093 | imux = &spec->private_imux[1]; | ||
4094 | |||
4095 | /* for hp mode select */ | ||
4096 | for (i = 0; texts[i]; i++) | ||
4097 | snd_hda_add_imux_item(imux, texts[i], i, NULL); | ||
4098 | |||
4099 | spec->hp_mux = &spec->private_imux[1]; | ||
4100 | return 0; | ||
4101 | } | ||
4102 | |||
4103 | /* create playback/capture controls for input pins */ | ||
4104 | static int vt1702_auto_create_analog_input_ctls(struct hda_codec *codec, | ||
4105 | const struct auto_pin_cfg *cfg) | ||
4106 | { | ||
4107 | static const hda_nid_t pin_idxs[] = { 0x14, 0x15, 0x18, 0xff }; | ||
4108 | return vt_auto_create_analog_input_ctls(codec, cfg, 0x1a, pin_idxs, | ||
4109 | ARRAY_SIZE(pin_idxs)); | ||
4110 | } | ||
4111 | |||
4112 | static int vt1702_parse_auto_config(struct hda_codec *codec) | ||
4113 | { | ||
4114 | struct via_spec *spec = codec->spec; | ||
4115 | int err; | ||
4116 | |||
4117 | err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, NULL); | ||
4118 | if (err < 0) | ||
4119 | return err; | ||
4120 | err = vt1702_auto_fill_dac_nids(spec, &spec->autocfg); | ||
4121 | if (err < 0) | ||
4122 | return err; | ||
4123 | if (!spec->autocfg.line_outs && !spec->autocfg.hp_pins[0]) | ||
4124 | return 0; /* can't find valid BIOS pin config */ | ||
4125 | |||
4126 | err = vt1702_auto_create_line_out_ctls(spec, &spec->autocfg); | ||
4127 | if (err < 0) | ||
4128 | return err; | ||
4129 | err = vt1702_auto_create_hp_ctls(spec, spec->autocfg.hp_pins[0]); | ||
4130 | if (err < 0) | ||
4131 | return err; | ||
4132 | /* limit AA path volume to 0 dB */ | ||
4133 | snd_hda_override_amp_caps(codec, 0x1A, HDA_INPUT, | ||
4134 | (0x17 << AC_AMPCAP_OFFSET_SHIFT) | | ||
4135 | (0x17 << AC_AMPCAP_NUM_STEPS_SHIFT) | | ||
4136 | (0x5 << AC_AMPCAP_STEP_SIZE_SHIFT) | | ||
4137 | (1 << AC_AMPCAP_MUTE_SHIFT)); | ||
4138 | err = vt1702_auto_create_analog_input_ctls(codec, &spec->autocfg); | ||
4139 | if (err < 0) | ||
4140 | return err; | ||
4141 | |||
4142 | spec->multiout.max_channels = spec->multiout.num_dacs * 2; | ||
4143 | |||
4144 | fill_dig_outs(codec); | ||
4145 | |||
4146 | if (spec->kctls.list) | ||
4147 | spec->mixers[spec->num_mixers++] = spec->kctls.list; | ||
4148 | |||
4149 | spec->input_mux = &spec->private_imux[0]; | ||
4150 | |||
4151 | if (spec->hp_mux) | ||
4152 | via_hp_build(codec); | ||
4153 | |||
4154 | return 1; | ||
4155 | } | ||
4156 | |||
4157 | #ifdef CONFIG_SND_HDA_POWER_SAVE | ||
4158 | static const struct hda_amp_list vt1702_loopbacks[] = { | ||
4159 | { 0x1A, HDA_INPUT, 1 }, | ||
4160 | { 0x1A, HDA_INPUT, 2 }, | ||
4161 | { 0x1A, HDA_INPUT, 3 }, | ||
4162 | { 0x1A, HDA_INPUT, 4 }, | ||
4163 | { } /* end */ | ||
4164 | }; | ||
4165 | #endif | ||
4166 | |||
4167 | static void set_widgets_power_state_vt1702(struct hda_codec *codec) | 2804 | static void set_widgets_power_state_vt1702(struct hda_codec *codec) |
4168 | { | 2805 | { |
4169 | int imux_is_smixer = | 2806 | int imux_is_smixer = |
@@ -4205,393 +2842,41 @@ static int patch_vt1702(struct hda_codec *codec) | |||
4205 | if (spec == NULL) | 2842 | if (spec == NULL) |
4206 | return -ENOMEM; | 2843 | return -ENOMEM; |
4207 | 2844 | ||
2845 | spec->aa_mix_nid = 0x1a; | ||
2846 | |||
2847 | /* limit AA path volume to 0 dB */ | ||
2848 | snd_hda_override_amp_caps(codec, 0x1A, HDA_INPUT, | ||
2849 | (0x17 << AC_AMPCAP_OFFSET_SHIFT) | | ||
2850 | (0x17 << AC_AMPCAP_NUM_STEPS_SHIFT) | | ||
2851 | (0x5 << AC_AMPCAP_STEP_SIZE_SHIFT) | | ||
2852 | (1 << AC_AMPCAP_MUTE_SHIFT)); | ||
2853 | |||
4208 | /* automatic parse from the BIOS config */ | 2854 | /* automatic parse from the BIOS config */ |
4209 | err = vt1702_parse_auto_config(codec); | 2855 | err = via_parse_auto_config(codec); |
4210 | if (err < 0) { | 2856 | if (err < 0) { |
4211 | via_free(codec); | 2857 | via_free(codec); |
4212 | return err; | 2858 | return err; |
4213 | } else if (!err) { | ||
4214 | printk(KERN_INFO "hda_codec: Cannot set up configuration " | ||
4215 | "from BIOS. Using genenic mode...\n"); | ||
4216 | } | 2859 | } |
4217 | 2860 | ||
4218 | spec->init_verbs[spec->num_iverbs++] = vt1702_volume_init_verbs; | 2861 | spec->init_verbs[spec->num_iverbs++] = vt1702_init_verbs; |
4219 | spec->init_verbs[spec->num_iverbs++] = vt1702_uniwill_init_verbs; | ||
4220 | |||
4221 | spec->stream_name_analog = "VT1702 Analog"; | ||
4222 | spec->stream_analog_playback = &vt1702_pcm_analog_playback; | ||
4223 | spec->stream_analog_capture = &vt1702_pcm_analog_capture; | ||
4224 | |||
4225 | spec->stream_name_digital = "VT1702 Digital"; | ||
4226 | spec->stream_digital_playback = &vt1702_pcm_digital_playback; | ||
4227 | |||
4228 | if (!spec->adc_nids && spec->input_mux) { | ||
4229 | spec->adc_nids = vt1702_adc_nids; | ||
4230 | spec->num_adc_nids = ARRAY_SIZE(vt1702_adc_nids); | ||
4231 | get_mux_nids(codec); | ||
4232 | spec->mixers[spec->num_mixers] = vt1702_capture_mixer; | ||
4233 | spec->num_mixers++; | ||
4234 | } | ||
4235 | 2862 | ||
4236 | codec->patch_ops = via_patch_ops; | 2863 | codec->patch_ops = via_patch_ops; |
4237 | 2864 | ||
4238 | codec->patch_ops.init = via_auto_init; | ||
4239 | codec->patch_ops.unsol_event = via_unsol_event; | ||
4240 | #ifdef CONFIG_SND_HDA_POWER_SAVE | ||
4241 | spec->loopback.amplist = vt1702_loopbacks; | ||
4242 | #endif | ||
4243 | |||
4244 | spec->set_widgets_power_state = set_widgets_power_state_vt1702; | 2865 | spec->set_widgets_power_state = set_widgets_power_state_vt1702; |
4245 | return 0; | 2866 | return 0; |
4246 | } | 2867 | } |
4247 | 2868 | ||
4248 | /* Patch for VT1718S */ | 2869 | /* Patch for VT1718S */ |
4249 | 2870 | ||
4250 | /* capture mixer elements */ | 2871 | static const struct hda_verb vt1718S_init_verbs[] = { |
4251 | static const struct snd_kcontrol_new vt1718S_capture_mixer[] = { | ||
4252 | HDA_CODEC_VOLUME("Capture Volume", 0x10, 0x0, HDA_INPUT), | ||
4253 | HDA_CODEC_MUTE("Capture Switch", 0x10, 0x0, HDA_INPUT), | ||
4254 | HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x11, 0x0, HDA_INPUT), | ||
4255 | HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x11, 0x0, HDA_INPUT), | ||
4256 | HDA_CODEC_VOLUME("Mic Boost Capture Volume", 0x2b, 0x0, HDA_INPUT), | ||
4257 | HDA_CODEC_VOLUME("Front Mic Boost Capture Volume", 0x29, 0x0, | ||
4258 | HDA_INPUT), | ||
4259 | { | ||
4260 | .iface = SNDRV_CTL_ELEM_IFACE_MIXER, | ||
4261 | /* The multiple "Capture Source" controls confuse alsamixer | ||
4262 | * So call somewhat different.. | ||
4263 | */ | ||
4264 | .name = "Input Source", | ||
4265 | .count = 2, | ||
4266 | .info = via_mux_enum_info, | ||
4267 | .get = via_mux_enum_get, | ||
4268 | .put = via_mux_enum_put, | ||
4269 | }, | ||
4270 | { } /* end */ | ||
4271 | }; | ||
4272 | |||
4273 | static const struct hda_verb vt1718S_volume_init_verbs[] = { | ||
4274 | /* | ||
4275 | * Unmute ADC0-1 and set the default input to mic-in | ||
4276 | */ | ||
4277 | {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, | ||
4278 | {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, | ||
4279 | |||
4280 | /* Enable MW0 adjust Gain 5 */ | 2872 | /* Enable MW0 adjust Gain 5 */ |
4281 | {0x1, 0xfb2, 0x10}, | 2873 | {0x1, 0xfb2, 0x10}, |
4282 | /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback | ||
4283 | * mixer widget | ||
4284 | */ | ||
4285 | /* Amp Indices: CD = 1, Mic1 = 2, Line = 3, Mic2 = 4 */ | ||
4286 | {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, | ||
4287 | {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, | ||
4288 | {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, | ||
4289 | {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, | ||
4290 | {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(5)}, | ||
4291 | /* PW9 PW10 Output enable */ | ||
4292 | {0x2d, AC_VERB_SET_PIN_WIDGET_CONTROL, AC_PINCTL_OUT_EN}, | ||
4293 | {0x2e, AC_VERB_SET_PIN_WIDGET_CONTROL, AC_PINCTL_OUT_EN}, | ||
4294 | /* PW11 Input enable */ | ||
4295 | {0x2f, AC_VERB_SET_PIN_WIDGET_CONTROL, AC_PINCTL_IN_EN}, | ||
4296 | /* Enable Boost Volume backdoor */ | 2874 | /* Enable Boost Volume backdoor */ |
4297 | {0x1, 0xf88, 0x8}, | 2875 | {0x1, 0xf88, 0x8}, |
4298 | /* MW0/1/2/3/4: un-mute index 0 (AOWx), mute index 1 (MW9) */ | ||
4299 | {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, | ||
4300 | {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, | ||
4301 | {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, | ||
4302 | {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, | ||
4303 | {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, | ||
4304 | {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, | ||
4305 | {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, | ||
4306 | {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, | ||
4307 | {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, | ||
4308 | {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, | ||
4309 | /* set MUX1 = 2 (AOW4), MUX2 = 1 (AOW3) */ | ||
4310 | {0x34, AC_VERB_SET_CONNECT_SEL, 0x2}, | ||
4311 | {0x35, AC_VERB_SET_CONNECT_SEL, 0x1}, | ||
4312 | { } | ||
4313 | }; | ||
4314 | |||
4315 | 2876 | ||
4316 | static const struct hda_verb vt1718S_uniwill_init_verbs[] = { | ||
4317 | {0x28, AC_VERB_SET_UNSOLICITED_ENABLE, | ||
4318 | AC_USRSP_EN | VIA_HP_EVENT | VIA_JACK_EVENT}, | ||
4319 | {0x24, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT}, | ||
4320 | {0x25, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT}, | ||
4321 | {0x26, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT}, | ||
4322 | {0x27, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT}, | ||
4323 | {0x29, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT}, | ||
4324 | {0x2a, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT}, | ||
4325 | {0x2b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT}, | ||
4326 | { } | 2877 | { } |
4327 | }; | 2878 | }; |
4328 | 2879 | ||
4329 | static const struct hda_pcm_stream vt1718S_pcm_analog_playback = { | ||
4330 | .substreams = 2, | ||
4331 | .channels_min = 2, | ||
4332 | .channels_max = 10, | ||
4333 | .nid = 0x8, /* NID to query formats and rates */ | ||
4334 | .ops = { | ||
4335 | .open = via_playback_pcm_open, | ||
4336 | .prepare = via_playback_multi_pcm_prepare, | ||
4337 | .cleanup = via_playback_multi_pcm_cleanup, | ||
4338 | .close = via_pcm_open_close, | ||
4339 | }, | ||
4340 | }; | ||
4341 | |||
4342 | static const struct hda_pcm_stream vt1718S_pcm_analog_capture = { | ||
4343 | .substreams = 2, | ||
4344 | .channels_min = 2, | ||
4345 | .channels_max = 2, | ||
4346 | .nid = 0x10, /* NID to query formats and rates */ | ||
4347 | .ops = { | ||
4348 | .open = via_pcm_open_close, | ||
4349 | .prepare = via_capture_pcm_prepare, | ||
4350 | .cleanup = via_capture_pcm_cleanup, | ||
4351 | .close = via_pcm_open_close, | ||
4352 | }, | ||
4353 | }; | ||
4354 | |||
4355 | static const struct hda_pcm_stream vt1718S_pcm_digital_playback = { | ||
4356 | .substreams = 2, | ||
4357 | .channels_min = 2, | ||
4358 | .channels_max = 2, | ||
4359 | /* NID is set in via_build_pcms */ | ||
4360 | .ops = { | ||
4361 | .open = via_dig_playback_pcm_open, | ||
4362 | .close = via_dig_playback_pcm_close, | ||
4363 | .prepare = via_dig_playback_pcm_prepare, | ||
4364 | .cleanup = via_dig_playback_pcm_cleanup | ||
4365 | }, | ||
4366 | }; | ||
4367 | |||
4368 | static const struct hda_pcm_stream vt1718S_pcm_digital_capture = { | ||
4369 | .substreams = 1, | ||
4370 | .channels_min = 2, | ||
4371 | .channels_max = 2, | ||
4372 | }; | ||
4373 | |||
4374 | /* fill in the dac_nids table from the parsed pin configuration */ | ||
4375 | static int vt1718S_auto_fill_dac_nids(struct via_spec *spec, | ||
4376 | const struct auto_pin_cfg *cfg) | ||
4377 | { | ||
4378 | int i; | ||
4379 | hda_nid_t nid; | ||
4380 | |||
4381 | spec->multiout.num_dacs = cfg->line_outs; | ||
4382 | |||
4383 | spec->multiout.dac_nids = spec->private_dac_nids; | ||
4384 | |||
4385 | for (i = 0; i < 4; i++) { | ||
4386 | nid = cfg->line_out_pins[i]; | ||
4387 | if (nid) { | ||
4388 | /* config dac list */ | ||
4389 | switch (i) { | ||
4390 | case AUTO_SEQ_FRONT: | ||
4391 | spec->private_dac_nids[i] = 0x8; | ||
4392 | break; | ||
4393 | case AUTO_SEQ_CENLFE: | ||
4394 | spec->private_dac_nids[i] = 0xa; | ||
4395 | break; | ||
4396 | case AUTO_SEQ_SURROUND: | ||
4397 | spec->private_dac_nids[i] = 0x9; | ||
4398 | break; | ||
4399 | case AUTO_SEQ_SIDE: | ||
4400 | spec->private_dac_nids[i] = 0xb; | ||
4401 | break; | ||
4402 | } | ||
4403 | } | ||
4404 | } | ||
4405 | |||
4406 | return 0; | ||
4407 | } | ||
4408 | |||
4409 | /* add playback controls from the parsed DAC table */ | ||
4410 | static int vt1718S_auto_create_multi_out_ctls(struct via_spec *spec, | ||
4411 | const struct auto_pin_cfg *cfg) | ||
4412 | { | ||
4413 | char name[32]; | ||
4414 | static const char * const chname[4] = { | ||
4415 | "Front", "Surround", "C/LFE", "Side" | ||
4416 | }; | ||
4417 | hda_nid_t nid_vols[] = {0x8, 0x9, 0xa, 0xb}; | ||
4418 | hda_nid_t nid_mutes[] = {0x24, 0x25, 0x26, 0x27}; | ||
4419 | hda_nid_t nid, nid_vol, nid_mute = 0; | ||
4420 | int i, err; | ||
4421 | |||
4422 | for (i = 0; i <= AUTO_SEQ_SIDE; i++) { | ||
4423 | nid = cfg->line_out_pins[i]; | ||
4424 | |||
4425 | if (!nid) | ||
4426 | continue; | ||
4427 | nid_vol = nid_vols[i]; | ||
4428 | nid_mute = nid_mutes[i]; | ||
4429 | |||
4430 | if (i == AUTO_SEQ_CENLFE) { | ||
4431 | /* Center/LFE */ | ||
4432 | err = via_add_control(spec, VIA_CTL_WIDGET_VOL, | ||
4433 | "Center Playback Volume", | ||
4434 | HDA_COMPOSE_AMP_VAL(nid_vol, 1, 0, | ||
4435 | HDA_OUTPUT)); | ||
4436 | if (err < 0) | ||
4437 | return err; | ||
4438 | err = via_add_control(spec, VIA_CTL_WIDGET_VOL, | ||
4439 | "LFE Playback Volume", | ||
4440 | HDA_COMPOSE_AMP_VAL(nid_vol, 2, 0, | ||
4441 | HDA_OUTPUT)); | ||
4442 | if (err < 0) | ||
4443 | return err; | ||
4444 | err = via_add_control( | ||
4445 | spec, VIA_CTL_WIDGET_MUTE, | ||
4446 | "Center Playback Switch", | ||
4447 | HDA_COMPOSE_AMP_VAL(nid_mute, 1, 0, | ||
4448 | HDA_OUTPUT)); | ||
4449 | if (err < 0) | ||
4450 | return err; | ||
4451 | err = via_add_control( | ||
4452 | spec, VIA_CTL_WIDGET_MUTE, | ||
4453 | "LFE Playback Switch", | ||
4454 | HDA_COMPOSE_AMP_VAL(nid_mute, 2, 0, | ||
4455 | HDA_OUTPUT)); | ||
4456 | if (err < 0) | ||
4457 | return err; | ||
4458 | } else if (i == AUTO_SEQ_FRONT) { | ||
4459 | /* add control to mixer index 0 */ | ||
4460 | err = via_add_control(spec, VIA_CTL_WIDGET_VOL, | ||
4461 | "Master Front Playback Volume", | ||
4462 | HDA_COMPOSE_AMP_VAL(0x21, 3, 5, | ||
4463 | HDA_INPUT)); | ||
4464 | if (err < 0) | ||
4465 | return err; | ||
4466 | err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, | ||
4467 | "Master Front Playback Switch", | ||
4468 | HDA_COMPOSE_AMP_VAL(0x21, 3, 5, | ||
4469 | HDA_INPUT)); | ||
4470 | if (err < 0) | ||
4471 | return err; | ||
4472 | /* Front */ | ||
4473 | sprintf(name, "%s Playback Volume", chname[i]); | ||
4474 | err = via_add_control( | ||
4475 | spec, VIA_CTL_WIDGET_VOL, name, | ||
4476 | HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, HDA_OUTPUT)); | ||
4477 | if (err < 0) | ||
4478 | return err; | ||
4479 | sprintf(name, "%s Playback Switch", chname[i]); | ||
4480 | err = via_add_control( | ||
4481 | spec, VIA_CTL_WIDGET_MUTE, name, | ||
4482 | HDA_COMPOSE_AMP_VAL(nid_mute, 3, 0, | ||
4483 | HDA_OUTPUT)); | ||
4484 | if (err < 0) | ||
4485 | return err; | ||
4486 | } else { | ||
4487 | sprintf(name, "%s Playback Volume", chname[i]); | ||
4488 | err = via_add_control( | ||
4489 | spec, VIA_CTL_WIDGET_VOL, name, | ||
4490 | HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, HDA_OUTPUT)); | ||
4491 | if (err < 0) | ||
4492 | return err; | ||
4493 | sprintf(name, "%s Playback Switch", chname[i]); | ||
4494 | err = via_add_control( | ||
4495 | spec, VIA_CTL_WIDGET_MUTE, name, | ||
4496 | HDA_COMPOSE_AMP_VAL(nid_mute, 3, 0, | ||
4497 | HDA_OUTPUT)); | ||
4498 | if (err < 0) | ||
4499 | return err; | ||
4500 | } | ||
4501 | } | ||
4502 | return 0; | ||
4503 | } | ||
4504 | |||
4505 | static int vt1718S_auto_create_hp_ctls(struct via_spec *spec, hda_nid_t pin) | ||
4506 | { | ||
4507 | int err; | ||
4508 | |||
4509 | if (!pin) | ||
4510 | return 0; | ||
4511 | |||
4512 | spec->multiout.hp_nid = 0xc; /* AOW4 */ | ||
4513 | spec->hp_independent_mode_index = 1; | ||
4514 | |||
4515 | err = via_add_control(spec, VIA_CTL_WIDGET_VOL, | ||
4516 | "Headphone Playback Volume", | ||
4517 | HDA_COMPOSE_AMP_VAL(0xc, 3, 0, HDA_OUTPUT)); | ||
4518 | if (err < 0) | ||
4519 | return err; | ||
4520 | |||
4521 | err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, | ||
4522 | "Headphone Playback Switch", | ||
4523 | HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT)); | ||
4524 | if (err < 0) | ||
4525 | return err; | ||
4526 | |||
4527 | create_hp_imux(spec); | ||
4528 | return 0; | ||
4529 | } | ||
4530 | |||
4531 | /* create playback/capture controls for input pins */ | ||
4532 | static int vt1718S_auto_create_analog_input_ctls(struct hda_codec *codec, | ||
4533 | const struct auto_pin_cfg *cfg) | ||
4534 | { | ||
4535 | static const hda_nid_t pin_idxs[] = { 0x2c, 0x2b, 0x2a, 0x29, 0, 0xff }; | ||
4536 | return vt_auto_create_analog_input_ctls(codec, cfg, 0x21, pin_idxs, | ||
4537 | ARRAY_SIZE(pin_idxs)); | ||
4538 | } | ||
4539 | |||
4540 | static int vt1718S_parse_auto_config(struct hda_codec *codec) | ||
4541 | { | ||
4542 | struct via_spec *spec = codec->spec; | ||
4543 | int err; | ||
4544 | |||
4545 | err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, NULL); | ||
4546 | |||
4547 | if (err < 0) | ||
4548 | return err; | ||
4549 | err = vt1718S_auto_fill_dac_nids(spec, &spec->autocfg); | ||
4550 | if (err < 0) | ||
4551 | return err; | ||
4552 | if (!spec->autocfg.line_outs && !spec->autocfg.hp_pins[0]) | ||
4553 | return 0; /* can't find valid BIOS pin config */ | ||
4554 | |||
4555 | err = vt1718S_auto_create_multi_out_ctls(spec, &spec->autocfg); | ||
4556 | if (err < 0) | ||
4557 | return err; | ||
4558 | err = vt1718S_auto_create_hp_ctls(spec, spec->autocfg.hp_pins[0]); | ||
4559 | if (err < 0) | ||
4560 | return err; | ||
4561 | err = vt1718S_auto_create_analog_input_ctls(codec, &spec->autocfg); | ||
4562 | if (err < 0) | ||
4563 | return err; | ||
4564 | |||
4565 | spec->multiout.max_channels = spec->multiout.num_dacs * 2; | ||
4566 | |||
4567 | fill_dig_outs(codec); | ||
4568 | |||
4569 | if (spec->autocfg.dig_in_pin && codec->vendor_id == 0x11060428) | ||
4570 | spec->dig_in_nid = 0x13; | ||
4571 | |||
4572 | if (spec->kctls.list) | ||
4573 | spec->mixers[spec->num_mixers++] = spec->kctls.list; | ||
4574 | |||
4575 | spec->input_mux = &spec->private_imux[0]; | ||
4576 | |||
4577 | if (spec->hp_mux) | ||
4578 | via_hp_build(codec); | ||
4579 | |||
4580 | via_smart51_build(spec); | ||
4581 | |||
4582 | return 1; | ||
4583 | } | ||
4584 | |||
4585 | #ifdef CONFIG_SND_HDA_POWER_SAVE | ||
4586 | static const struct hda_amp_list vt1718S_loopbacks[] = { | ||
4587 | { 0x21, HDA_INPUT, 1 }, | ||
4588 | { 0x21, HDA_INPUT, 2 }, | ||
4589 | { 0x21, HDA_INPUT, 3 }, | ||
4590 | { 0x21, HDA_INPUT, 4 }, | ||
4591 | { } /* end */ | ||
4592 | }; | ||
4593 | #endif | ||
4594 | |||
4595 | static void set_widgets_power_state_vt1718S(struct hda_codec *codec) | 2880 | static void set_widgets_power_state_vt1718S(struct hda_codec *codec) |
4596 | { | 2881 | { |
4597 | struct via_spec *spec = codec->spec; | 2882 | struct via_spec *spec = codec->spec; |
@@ -4668,57 +2953,21 @@ static int patch_vt1718S(struct hda_codec *codec) | |||
4668 | if (spec == NULL) | 2953 | if (spec == NULL) |
4669 | return -ENOMEM; | 2954 | return -ENOMEM; |
4670 | 2955 | ||
2956 | spec->aa_mix_nid = 0x21; | ||
2957 | override_mic_boost(codec, 0x2b, 0, 3, 40); | ||
2958 | override_mic_boost(codec, 0x29, 0, 3, 40); | ||
2959 | |||
4671 | /* automatic parse from the BIOS config */ | 2960 | /* automatic parse from the BIOS config */ |
4672 | err = vt1718S_parse_auto_config(codec); | 2961 | err = via_parse_auto_config(codec); |
4673 | if (err < 0) { | 2962 | if (err < 0) { |
4674 | via_free(codec); | 2963 | via_free(codec); |
4675 | return err; | 2964 | return err; |
4676 | } else if (!err) { | ||
4677 | printk(KERN_INFO "hda_codec: Cannot set up configuration " | ||
4678 | "from BIOS. Using genenic mode...\n"); | ||
4679 | } | 2965 | } |
4680 | 2966 | ||
4681 | spec->init_verbs[spec->num_iverbs++] = vt1718S_volume_init_verbs; | 2967 | spec->init_verbs[spec->num_iverbs++] = vt1718S_init_verbs; |
4682 | spec->init_verbs[spec->num_iverbs++] = vt1718S_uniwill_init_verbs; | ||
4683 | |||
4684 | if (codec->vendor_id == 0x11060441) | ||
4685 | spec->stream_name_analog = "VT2020 Analog"; | ||
4686 | else if (codec->vendor_id == 0x11064441) | ||
4687 | spec->stream_name_analog = "VT1828S Analog"; | ||
4688 | else | ||
4689 | spec->stream_name_analog = "VT1718S Analog"; | ||
4690 | spec->stream_analog_playback = &vt1718S_pcm_analog_playback; | ||
4691 | spec->stream_analog_capture = &vt1718S_pcm_analog_capture; | ||
4692 | |||
4693 | if (codec->vendor_id == 0x11060441) | ||
4694 | spec->stream_name_digital = "VT2020 Digital"; | ||
4695 | else if (codec->vendor_id == 0x11064441) | ||
4696 | spec->stream_name_digital = "VT1828S Digital"; | ||
4697 | else | ||
4698 | spec->stream_name_digital = "VT1718S Digital"; | ||
4699 | spec->stream_digital_playback = &vt1718S_pcm_digital_playback; | ||
4700 | if (codec->vendor_id == 0x11060428 || codec->vendor_id == 0x11060441) | ||
4701 | spec->stream_digital_capture = &vt1718S_pcm_digital_capture; | ||
4702 | |||
4703 | if (!spec->adc_nids && spec->input_mux) { | ||
4704 | spec->adc_nids = vt1718S_adc_nids; | ||
4705 | spec->num_adc_nids = ARRAY_SIZE(vt1718S_adc_nids); | ||
4706 | get_mux_nids(codec); | ||
4707 | override_mic_boost(codec, 0x2b, 0, 3, 40); | ||
4708 | override_mic_boost(codec, 0x29, 0, 3, 40); | ||
4709 | spec->mixers[spec->num_mixers] = vt1718S_capture_mixer; | ||
4710 | spec->num_mixers++; | ||
4711 | } | ||
4712 | 2968 | ||
4713 | codec->patch_ops = via_patch_ops; | 2969 | codec->patch_ops = via_patch_ops; |
4714 | 2970 | ||
4715 | codec->patch_ops.init = via_auto_init; | ||
4716 | codec->patch_ops.unsol_event = via_unsol_event; | ||
4717 | |||
4718 | #ifdef CONFIG_SND_HDA_POWER_SAVE | ||
4719 | spec->loopback.amplist = vt1718S_loopbacks; | ||
4720 | #endif | ||
4721 | |||
4722 | spec->set_widgets_power_state = set_widgets_power_state_vt1718S; | 2971 | spec->set_widgets_power_state = set_widgets_power_state_vt1718S; |
4723 | 2972 | ||
4724 | return 0; | 2973 | return 0; |
@@ -4764,26 +3013,6 @@ static int vt1716s_dmic_put(struct snd_kcontrol *kcontrol, | |||
4764 | return 1; | 3013 | return 1; |
4765 | } | 3014 | } |
4766 | 3015 | ||
4767 | /* capture mixer elements */ | ||
4768 | static const struct snd_kcontrol_new vt1716S_capture_mixer[] = { | ||
4769 | HDA_CODEC_VOLUME("Capture Volume", 0x13, 0x0, HDA_INPUT), | ||
4770 | HDA_CODEC_MUTE("Capture Switch", 0x13, 0x0, HDA_INPUT), | ||
4771 | HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x14, 0x0, HDA_INPUT), | ||
4772 | HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x14, 0x0, HDA_INPUT), | ||
4773 | HDA_CODEC_VOLUME("Mic Boost Capture Volume", 0x1A, 0x0, HDA_INPUT), | ||
4774 | HDA_CODEC_VOLUME("Front Mic Boost Capture Volume", 0x1E, 0x0, | ||
4775 | HDA_INPUT), | ||
4776 | { | ||
4777 | .iface = SNDRV_CTL_ELEM_IFACE_MIXER, | ||
4778 | .name = "Input Source", | ||
4779 | .count = 1, | ||
4780 | .info = via_mux_enum_info, | ||
4781 | .get = via_mux_enum_get, | ||
4782 | .put = via_mux_enum_put, | ||
4783 | }, | ||
4784 | { } /* end */ | ||
4785 | }; | ||
4786 | |||
4787 | static const struct snd_kcontrol_new vt1716s_dmic_mixer[] = { | 3016 | static const struct snd_kcontrol_new vt1716s_dmic_mixer[] = { |
4788 | HDA_CODEC_VOLUME("Digital Mic Capture Volume", 0x22, 0x0, HDA_INPUT), | 3017 | HDA_CODEC_VOLUME("Digital Mic Capture Volume", 0x22, 0x0, HDA_INPUT), |
4789 | { | 3018 | { |
@@ -4805,45 +3034,7 @@ static const struct snd_kcontrol_new vt1716S_mono_out_mixer[] = { | |||
4805 | { } /* end */ | 3034 | { } /* end */ |
4806 | }; | 3035 | }; |
4807 | 3036 | ||
4808 | static const struct hda_verb vt1716S_volume_init_verbs[] = { | 3037 | static const struct hda_verb vt1716S_init_verbs[] = { |
4809 | /* | ||
4810 | * Unmute ADC0-1 and set the default input to mic-in | ||
4811 | */ | ||
4812 | {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, | ||
4813 | {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, | ||
4814 | |||
4815 | |||
4816 | /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback | ||
4817 | * mixer widget | ||
4818 | */ | ||
4819 | /* Amp Indices: CD = 1, Mic1 = 2, Line = 3, Mic2 = 4 */ | ||
4820 | {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, | ||
4821 | {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, | ||
4822 | {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, | ||
4823 | {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, | ||
4824 | {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, | ||
4825 | |||
4826 | /* MUX Indices: Stereo Mixer = 5 */ | ||
4827 | {0x17, AC_VERB_SET_CONNECT_SEL, 0x5}, | ||
4828 | |||
4829 | /* Setup default input of PW4 to MW0 */ | ||
4830 | {0x1d, AC_VERB_SET_CONNECT_SEL, 0x0}, | ||
4831 | |||
4832 | /* Setup default input of SW1 as MW0 */ | ||
4833 | {0x18, AC_VERB_SET_CONNECT_SEL, 0x1}, | ||
4834 | |||
4835 | /* Setup default input of SW4 as AOW0 */ | ||
4836 | {0x28, AC_VERB_SET_CONNECT_SEL, 0x1}, | ||
4837 | |||
4838 | /* PW9 PW10 Output enable */ | ||
4839 | {0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40}, | ||
4840 | {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40}, | ||
4841 | |||
4842 | /* Unmute SW1, PW12 */ | ||
4843 | {0x29, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, | ||
4844 | {0x2a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, | ||
4845 | /* PW12 Output enable */ | ||
4846 | {0x2a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40}, | ||
4847 | /* Enable Boost Volume backdoor */ | 3038 | /* Enable Boost Volume backdoor */ |
4848 | {0x1, 0xf8a, 0x80}, | 3039 | {0x1, 0xf8a, 0x80}, |
4849 | /* don't bybass mixer */ | 3040 | /* don't bybass mixer */ |
@@ -4853,272 +3044,6 @@ static const struct hda_verb vt1716S_volume_init_verbs[] = { | |||
4853 | { } | 3044 | { } |
4854 | }; | 3045 | }; |
4855 | 3046 | ||
4856 | |||
4857 | static const struct hda_verb vt1716S_uniwill_init_verbs[] = { | ||
4858 | {0x1d, AC_VERB_SET_UNSOLICITED_ENABLE, | ||
4859 | AC_USRSP_EN | VIA_HP_EVENT | VIA_JACK_EVENT}, | ||
4860 | {0x19, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT}, | ||
4861 | {0x1a, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT}, | ||
4862 | {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT}, | ||
4863 | {0x1c, AC_VERB_SET_UNSOLICITED_ENABLE, | ||
4864 | AC_USRSP_EN | VIA_MONO_EVENT | VIA_JACK_EVENT}, | ||
4865 | {0x1e, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT}, | ||
4866 | {0x23, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT}, | ||
4867 | { } | ||
4868 | }; | ||
4869 | |||
4870 | static const struct hda_pcm_stream vt1716S_pcm_analog_playback = { | ||
4871 | .substreams = 2, | ||
4872 | .channels_min = 2, | ||
4873 | .channels_max = 6, | ||
4874 | .nid = 0x10, /* NID to query formats and rates */ | ||
4875 | .ops = { | ||
4876 | .open = via_playback_pcm_open, | ||
4877 | .prepare = via_playback_multi_pcm_prepare, | ||
4878 | .cleanup = via_playback_multi_pcm_cleanup, | ||
4879 | .close = via_pcm_open_close, | ||
4880 | }, | ||
4881 | }; | ||
4882 | |||
4883 | static const struct hda_pcm_stream vt1716S_pcm_analog_capture = { | ||
4884 | .substreams = 2, | ||
4885 | .channels_min = 2, | ||
4886 | .channels_max = 2, | ||
4887 | .nid = 0x13, /* NID to query formats and rates */ | ||
4888 | .ops = { | ||
4889 | .open = via_pcm_open_close, | ||
4890 | .prepare = via_capture_pcm_prepare, | ||
4891 | .cleanup = via_capture_pcm_cleanup, | ||
4892 | .close = via_pcm_open_close, | ||
4893 | }, | ||
4894 | }; | ||
4895 | |||
4896 | static const struct hda_pcm_stream vt1716S_pcm_digital_playback = { | ||
4897 | .substreams = 2, | ||
4898 | .channels_min = 2, | ||
4899 | .channels_max = 2, | ||
4900 | /* NID is set in via_build_pcms */ | ||
4901 | .ops = { | ||
4902 | .open = via_dig_playback_pcm_open, | ||
4903 | .close = via_dig_playback_pcm_close, | ||
4904 | .prepare = via_dig_playback_pcm_prepare, | ||
4905 | .cleanup = via_dig_playback_pcm_cleanup | ||
4906 | }, | ||
4907 | }; | ||
4908 | |||
4909 | /* fill in the dac_nids table from the parsed pin configuration */ | ||
4910 | static int vt1716S_auto_fill_dac_nids(struct via_spec *spec, | ||
4911 | const struct auto_pin_cfg *cfg) | ||
4912 | { int i; | ||
4913 | hda_nid_t nid; | ||
4914 | |||
4915 | spec->multiout.num_dacs = cfg->line_outs; | ||
4916 | |||
4917 | spec->multiout.dac_nids = spec->private_dac_nids; | ||
4918 | |||
4919 | for (i = 0; i < 3; i++) { | ||
4920 | nid = cfg->line_out_pins[i]; | ||
4921 | if (nid) { | ||
4922 | /* config dac list */ | ||
4923 | switch (i) { | ||
4924 | case AUTO_SEQ_FRONT: | ||
4925 | spec->private_dac_nids[i] = 0x10; | ||
4926 | break; | ||
4927 | case AUTO_SEQ_CENLFE: | ||
4928 | spec->private_dac_nids[i] = 0x25; | ||
4929 | break; | ||
4930 | case AUTO_SEQ_SURROUND: | ||
4931 | spec->private_dac_nids[i] = 0x11; | ||
4932 | break; | ||
4933 | } | ||
4934 | } | ||
4935 | } | ||
4936 | |||
4937 | return 0; | ||
4938 | } | ||
4939 | |||
4940 | /* add playback controls from the parsed DAC table */ | ||
4941 | static int vt1716S_auto_create_multi_out_ctls(struct via_spec *spec, | ||
4942 | const struct auto_pin_cfg *cfg) | ||
4943 | { | ||
4944 | char name[32]; | ||
4945 | static const char * const chname[3] = { | ||
4946 | "Front", "Surround", "C/LFE" | ||
4947 | }; | ||
4948 | hda_nid_t nid_vols[] = {0x10, 0x11, 0x25}; | ||
4949 | hda_nid_t nid_mutes[] = {0x1C, 0x18, 0x27}; | ||
4950 | hda_nid_t nid, nid_vol, nid_mute; | ||
4951 | int i, err; | ||
4952 | |||
4953 | for (i = 0; i <= AUTO_SEQ_CENLFE; i++) { | ||
4954 | nid = cfg->line_out_pins[i]; | ||
4955 | |||
4956 | if (!nid) | ||
4957 | continue; | ||
4958 | |||
4959 | nid_vol = nid_vols[i]; | ||
4960 | nid_mute = nid_mutes[i]; | ||
4961 | |||
4962 | if (i == AUTO_SEQ_CENLFE) { | ||
4963 | err = via_add_control( | ||
4964 | spec, VIA_CTL_WIDGET_VOL, | ||
4965 | "Center Playback Volume", | ||
4966 | HDA_COMPOSE_AMP_VAL(nid_vol, 1, 0, HDA_OUTPUT)); | ||
4967 | if (err < 0) | ||
4968 | return err; | ||
4969 | err = via_add_control( | ||
4970 | spec, VIA_CTL_WIDGET_VOL, | ||
4971 | "LFE Playback Volume", | ||
4972 | HDA_COMPOSE_AMP_VAL(nid_vol, 2, 0, HDA_OUTPUT)); | ||
4973 | if (err < 0) | ||
4974 | return err; | ||
4975 | err = via_add_control( | ||
4976 | spec, VIA_CTL_WIDGET_MUTE, | ||
4977 | "Center Playback Switch", | ||
4978 | HDA_COMPOSE_AMP_VAL(nid_mute, 1, 0, | ||
4979 | HDA_OUTPUT)); | ||
4980 | if (err < 0) | ||
4981 | return err; | ||
4982 | err = via_add_control( | ||
4983 | spec, VIA_CTL_WIDGET_MUTE, | ||
4984 | "LFE Playback Switch", | ||
4985 | HDA_COMPOSE_AMP_VAL(nid_mute, 2, 0, | ||
4986 | HDA_OUTPUT)); | ||
4987 | if (err < 0) | ||
4988 | return err; | ||
4989 | } else if (i == AUTO_SEQ_FRONT) { | ||
4990 | |||
4991 | err = via_add_control( | ||
4992 | spec, VIA_CTL_WIDGET_VOL, | ||
4993 | "Master Front Playback Volume", | ||
4994 | HDA_COMPOSE_AMP_VAL(0x16, 3, 0, HDA_INPUT)); | ||
4995 | if (err < 0) | ||
4996 | return err; | ||
4997 | err = via_add_control( | ||
4998 | spec, VIA_CTL_WIDGET_MUTE, | ||
4999 | "Master Front Playback Switch", | ||
5000 | HDA_COMPOSE_AMP_VAL(0x16, 3, 0, HDA_INPUT)); | ||
5001 | if (err < 0) | ||
5002 | return err; | ||
5003 | |||
5004 | sprintf(name, "%s Playback Volume", chname[i]); | ||
5005 | err = via_add_control( | ||
5006 | spec, VIA_CTL_WIDGET_VOL, name, | ||
5007 | HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, HDA_OUTPUT)); | ||
5008 | if (err < 0) | ||
5009 | return err; | ||
5010 | sprintf(name, "%s Playback Switch", chname[i]); | ||
5011 | err = via_add_control( | ||
5012 | spec, VIA_CTL_WIDGET_MUTE, name, | ||
5013 | HDA_COMPOSE_AMP_VAL(nid_mute, 3, 0, | ||
5014 | HDA_OUTPUT)); | ||
5015 | if (err < 0) | ||
5016 | return err; | ||
5017 | } else { | ||
5018 | sprintf(name, "%s Playback Volume", chname[i]); | ||
5019 | err = via_add_control( | ||
5020 | spec, VIA_CTL_WIDGET_VOL, name, | ||
5021 | HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, HDA_OUTPUT)); | ||
5022 | if (err < 0) | ||
5023 | return err; | ||
5024 | sprintf(name, "%s Playback Switch", chname[i]); | ||
5025 | err = via_add_control( | ||
5026 | spec, VIA_CTL_WIDGET_MUTE, name, | ||
5027 | HDA_COMPOSE_AMP_VAL(nid_mute, 3, 0, | ||
5028 | HDA_OUTPUT)); | ||
5029 | if (err < 0) | ||
5030 | return err; | ||
5031 | } | ||
5032 | } | ||
5033 | return 0; | ||
5034 | } | ||
5035 | |||
5036 | static int vt1716S_auto_create_hp_ctls(struct via_spec *spec, hda_nid_t pin) | ||
5037 | { | ||
5038 | int err; | ||
5039 | |||
5040 | if (!pin) | ||
5041 | return 0; | ||
5042 | |||
5043 | spec->multiout.hp_nid = 0x25; /* AOW3 */ | ||
5044 | spec->hp_independent_mode_index = 1; | ||
5045 | |||
5046 | err = via_add_control(spec, VIA_CTL_WIDGET_VOL, | ||
5047 | "Headphone Playback Volume", | ||
5048 | HDA_COMPOSE_AMP_VAL(0x25, 3, 0, HDA_OUTPUT)); | ||
5049 | if (err < 0) | ||
5050 | return err; | ||
5051 | |||
5052 | err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, | ||
5053 | "Headphone Playback Switch", | ||
5054 | HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT)); | ||
5055 | if (err < 0) | ||
5056 | return err; | ||
5057 | |||
5058 | create_hp_imux(spec); | ||
5059 | return 0; | ||
5060 | } | ||
5061 | |||
5062 | /* create playback/capture controls for input pins */ | ||
5063 | static int vt1716S_auto_create_analog_input_ctls(struct hda_codec *codec, | ||
5064 | const struct auto_pin_cfg *cfg) | ||
5065 | { | ||
5066 | static const hda_nid_t pin_idxs[] = { 0x1f, 0x1a, 0x1b, 0x1e, 0, 0xff }; | ||
5067 | return vt_auto_create_analog_input_ctls(codec, cfg, 0x16, pin_idxs, | ||
5068 | ARRAY_SIZE(pin_idxs)); | ||
5069 | } | ||
5070 | |||
5071 | static int vt1716S_parse_auto_config(struct hda_codec *codec) | ||
5072 | { | ||
5073 | struct via_spec *spec = codec->spec; | ||
5074 | int err; | ||
5075 | |||
5076 | err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, NULL); | ||
5077 | if (err < 0) | ||
5078 | return err; | ||
5079 | err = vt1716S_auto_fill_dac_nids(spec, &spec->autocfg); | ||
5080 | if (err < 0) | ||
5081 | return err; | ||
5082 | if (!spec->autocfg.line_outs && !spec->autocfg.hp_pins[0]) | ||
5083 | return 0; /* can't find valid BIOS pin config */ | ||
5084 | |||
5085 | err = vt1716S_auto_create_multi_out_ctls(spec, &spec->autocfg); | ||
5086 | if (err < 0) | ||
5087 | return err; | ||
5088 | err = vt1716S_auto_create_hp_ctls(spec, spec->autocfg.hp_pins[0]); | ||
5089 | if (err < 0) | ||
5090 | return err; | ||
5091 | err = vt1716S_auto_create_analog_input_ctls(codec, &spec->autocfg); | ||
5092 | if (err < 0) | ||
5093 | return err; | ||
5094 | |||
5095 | spec->multiout.max_channels = spec->multiout.num_dacs * 2; | ||
5096 | |||
5097 | fill_dig_outs(codec); | ||
5098 | |||
5099 | if (spec->kctls.list) | ||
5100 | spec->mixers[spec->num_mixers++] = spec->kctls.list; | ||
5101 | |||
5102 | spec->input_mux = &spec->private_imux[0]; | ||
5103 | |||
5104 | if (spec->hp_mux) | ||
5105 | via_hp_build(codec); | ||
5106 | |||
5107 | via_smart51_build(spec); | ||
5108 | |||
5109 | return 1; | ||
5110 | } | ||
5111 | |||
5112 | #ifdef CONFIG_SND_HDA_POWER_SAVE | ||
5113 | static const struct hda_amp_list vt1716S_loopbacks[] = { | ||
5114 | { 0x16, HDA_INPUT, 1 }, | ||
5115 | { 0x16, HDA_INPUT, 2 }, | ||
5116 | { 0x16, HDA_INPUT, 3 }, | ||
5117 | { 0x16, HDA_INPUT, 4 }, | ||
5118 | { } /* end */ | ||
5119 | }; | ||
5120 | #endif | ||
5121 | |||
5122 | static void set_widgets_power_state_vt1716S(struct hda_codec *codec) | 3047 | static void set_widgets_power_state_vt1716S(struct hda_codec *codec) |
5123 | { | 3048 | { |
5124 | struct via_spec *spec = codec->spec; | 3049 | struct via_spec *spec = codec->spec; |
@@ -5222,35 +3147,18 @@ static int patch_vt1716S(struct hda_codec *codec) | |||
5222 | if (spec == NULL) | 3147 | if (spec == NULL) |
5223 | return -ENOMEM; | 3148 | return -ENOMEM; |
5224 | 3149 | ||
3150 | spec->aa_mix_nid = 0x16; | ||
3151 | override_mic_boost(codec, 0x1a, 0, 3, 40); | ||
3152 | override_mic_boost(codec, 0x1e, 0, 3, 40); | ||
3153 | |||
5225 | /* automatic parse from the BIOS config */ | 3154 | /* automatic parse from the BIOS config */ |
5226 | err = vt1716S_parse_auto_config(codec); | 3155 | err = via_parse_auto_config(codec); |
5227 | if (err < 0) { | 3156 | if (err < 0) { |
5228 | via_free(codec); | 3157 | via_free(codec); |
5229 | return err; | 3158 | return err; |
5230 | } else if (!err) { | ||
5231 | printk(KERN_INFO "hda_codec: Cannot set up configuration " | ||
5232 | "from BIOS. Using genenic mode...\n"); | ||
5233 | } | 3159 | } |
5234 | 3160 | ||
5235 | spec->init_verbs[spec->num_iverbs++] = vt1716S_volume_init_verbs; | 3161 | spec->init_verbs[spec->num_iverbs++] = vt1716S_init_verbs; |
5236 | spec->init_verbs[spec->num_iverbs++] = vt1716S_uniwill_init_verbs; | ||
5237 | |||
5238 | spec->stream_name_analog = "VT1716S Analog"; | ||
5239 | spec->stream_analog_playback = &vt1716S_pcm_analog_playback; | ||
5240 | spec->stream_analog_capture = &vt1716S_pcm_analog_capture; | ||
5241 | |||
5242 | spec->stream_name_digital = "VT1716S Digital"; | ||
5243 | spec->stream_digital_playback = &vt1716S_pcm_digital_playback; | ||
5244 | |||
5245 | if (!spec->adc_nids && spec->input_mux) { | ||
5246 | spec->adc_nids = vt1716S_adc_nids; | ||
5247 | spec->num_adc_nids = ARRAY_SIZE(vt1716S_adc_nids); | ||
5248 | get_mux_nids(codec); | ||
5249 | override_mic_boost(codec, 0x1a, 0, 3, 40); | ||
5250 | override_mic_boost(codec, 0x1e, 0, 3, 40); | ||
5251 | spec->mixers[spec->num_mixers] = vt1716S_capture_mixer; | ||
5252 | spec->num_mixers++; | ||
5253 | } | ||
5254 | 3162 | ||
5255 | spec->mixers[spec->num_mixers] = vt1716s_dmic_mixer; | 3163 | spec->mixers[spec->num_mixers] = vt1716s_dmic_mixer; |
5256 | spec->num_mixers++; | 3164 | spec->num_mixers++; |
@@ -5259,354 +3167,32 @@ static int patch_vt1716S(struct hda_codec *codec) | |||
5259 | 3167 | ||
5260 | codec->patch_ops = via_patch_ops; | 3168 | codec->patch_ops = via_patch_ops; |
5261 | 3169 | ||
5262 | codec->patch_ops.init = via_auto_init; | ||
5263 | codec->patch_ops.unsol_event = via_unsol_event; | ||
5264 | |||
5265 | #ifdef CONFIG_SND_HDA_POWER_SAVE | ||
5266 | spec->loopback.amplist = vt1716S_loopbacks; | ||
5267 | #endif | ||
5268 | |||
5269 | spec->set_widgets_power_state = set_widgets_power_state_vt1716S; | 3170 | spec->set_widgets_power_state = set_widgets_power_state_vt1716S; |
5270 | return 0; | 3171 | return 0; |
5271 | } | 3172 | } |
5272 | 3173 | ||
5273 | /* for vt2002P */ | 3174 | /* for vt2002P */ |
5274 | 3175 | ||
5275 | /* capture mixer elements */ | 3176 | static const struct hda_verb vt2002P_init_verbs[] = { |
5276 | static const struct snd_kcontrol_new vt2002P_capture_mixer[] = { | ||
5277 | HDA_CODEC_VOLUME("Capture Volume", 0x10, 0x0, HDA_INPUT), | ||
5278 | HDA_CODEC_MUTE("Capture Switch", 0x10, 0x0, HDA_INPUT), | ||
5279 | HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x11, 0x0, HDA_INPUT), | ||
5280 | HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x11, 0x0, HDA_INPUT), | ||
5281 | HDA_CODEC_VOLUME("Mic Boost Capture Volume", 0x2b, 0x0, HDA_INPUT), | ||
5282 | HDA_CODEC_VOLUME("Front Mic Boost Capture Volume", 0x29, 0x0, | ||
5283 | HDA_INPUT), | ||
5284 | { | ||
5285 | .iface = SNDRV_CTL_ELEM_IFACE_MIXER, | ||
5286 | /* The multiple "Capture Source" controls confuse alsamixer | ||
5287 | * So call somewhat different.. | ||
5288 | */ | ||
5289 | /* .name = "Capture Source", */ | ||
5290 | .name = "Input Source", | ||
5291 | .count = 2, | ||
5292 | .info = via_mux_enum_info, | ||
5293 | .get = via_mux_enum_get, | ||
5294 | .put = via_mux_enum_put, | ||
5295 | }, | ||
5296 | { } /* end */ | ||
5297 | }; | ||
5298 | |||
5299 | static const struct hda_verb vt2002P_volume_init_verbs[] = { | ||
5300 | /* Class-D speaker related verbs */ | 3177 | /* Class-D speaker related verbs */ |
5301 | {0x1, 0xfe0, 0x4}, | 3178 | {0x1, 0xfe0, 0x4}, |
5302 | {0x1, 0xfe9, 0x80}, | 3179 | {0x1, 0xfe9, 0x80}, |
5303 | {0x1, 0xfe2, 0x22}, | 3180 | {0x1, 0xfe2, 0x22}, |
5304 | /* | ||
5305 | * Unmute ADC0-1 and set the default input to mic-in | ||
5306 | */ | ||
5307 | {0x8, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, | ||
5308 | {0x9, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, | ||
5309 | |||
5310 | |||
5311 | /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback | ||
5312 | * mixer widget | ||
5313 | */ | ||
5314 | /* Amp Indices: CD = 1, Mic1 = 2, Line = 3, Mic2 = 4 */ | ||
5315 | {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, | ||
5316 | {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, | ||
5317 | {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, | ||
5318 | {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, | ||
5319 | {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, | ||
5320 | |||
5321 | /* MUX Indices: Mic = 0 */ | ||
5322 | {0x1e, AC_VERB_SET_CONNECT_SEL, 0}, | ||
5323 | {0x1f, AC_VERB_SET_CONNECT_SEL, 0}, | ||
5324 | |||
5325 | /* PW9 Output enable */ | ||
5326 | {0x2d, AC_VERB_SET_PIN_WIDGET_CONTROL, AC_PINCTL_OUT_EN}, | ||
5327 | |||
5328 | /* Enable Boost Volume backdoor */ | 3181 | /* Enable Boost Volume backdoor */ |
5329 | {0x1, 0xfb9, 0x24}, | 3182 | {0x1, 0xfb9, 0x24}, |
5330 | |||
5331 | /* MW0/1/4/8: un-mute index 0 (MUXx), un-mute index 1 (MW9) */ | ||
5332 | {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, | ||
5333 | {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, | ||
5334 | {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, | ||
5335 | {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, | ||
5336 | {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, | ||
5337 | {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, | ||
5338 | {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, | ||
5339 | {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, | ||
5340 | |||
5341 | /* set MUX0/1/4/8 = 0 (AOW0) */ | ||
5342 | {0x34, AC_VERB_SET_CONNECT_SEL, 0}, | ||
5343 | {0x35, AC_VERB_SET_CONNECT_SEL, 0}, | ||
5344 | {0x37, AC_VERB_SET_CONNECT_SEL, 0}, | ||
5345 | {0x3b, AC_VERB_SET_CONNECT_SEL, 0}, | ||
5346 | |||
5347 | /* set PW0 index=0 (MW0) */ | ||
5348 | {0x24, AC_VERB_SET_CONNECT_SEL, 0}, | ||
5349 | |||
5350 | /* Enable AOW0 to MW9 */ | 3183 | /* Enable AOW0 to MW9 */ |
5351 | {0x1, 0xfb8, 0x88}, | 3184 | {0x1, 0xfb8, 0x88}, |
5352 | { } | 3185 | { } |
5353 | }; | 3186 | }; |
5354 | static const struct hda_verb vt1802_volume_init_verbs[] = { | ||
5355 | /* | ||
5356 | * Unmute ADC0-1 and set the default input to mic-in | ||
5357 | */ | ||
5358 | {0x8, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, | ||
5359 | {0x9, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, | ||
5360 | |||
5361 | |||
5362 | /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback | ||
5363 | * mixer widget | ||
5364 | */ | ||
5365 | /* Amp Indices: CD = 1, Mic1 = 2, Line = 3, Mic2 = 4 */ | ||
5366 | {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, | ||
5367 | {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, | ||
5368 | {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, | ||
5369 | {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, | ||
5370 | {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, | ||
5371 | |||
5372 | /* MUX Indices: Mic = 0 */ | ||
5373 | {0x1e, AC_VERB_SET_CONNECT_SEL, 0}, | ||
5374 | {0x1f, AC_VERB_SET_CONNECT_SEL, 0}, | ||
5375 | |||
5376 | /* PW9 Output enable */ | ||
5377 | {0x2d, AC_VERB_SET_PIN_WIDGET_CONTROL, AC_PINCTL_OUT_EN}, | ||
5378 | 3187 | ||
3188 | static const struct hda_verb vt1802_init_verbs[] = { | ||
5379 | /* Enable Boost Volume backdoor */ | 3189 | /* Enable Boost Volume backdoor */ |
5380 | {0x1, 0xfb9, 0x24}, | 3190 | {0x1, 0xfb9, 0x24}, |
5381 | |||
5382 | /* MW0/1/4/8: un-mute index 0 (MUXx), un-mute index 1 (MW9) */ | ||
5383 | {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, | ||
5384 | {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, | ||
5385 | {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, | ||
5386 | {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, | ||
5387 | {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, | ||
5388 | {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, | ||
5389 | {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, | ||
5390 | {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, | ||
5391 | |||
5392 | /* set MUX0/1/4/8 = 0 (AOW0) */ | ||
5393 | {0x34, AC_VERB_SET_CONNECT_SEL, 0}, | ||
5394 | {0x35, AC_VERB_SET_CONNECT_SEL, 0}, | ||
5395 | {0x38, AC_VERB_SET_CONNECT_SEL, 0}, | ||
5396 | {0x3c, AC_VERB_SET_CONNECT_SEL, 0}, | ||
5397 | |||
5398 | /* set PW0 index=0 (MW0) */ | ||
5399 | {0x24, AC_VERB_SET_CONNECT_SEL, 0}, | ||
5400 | |||
5401 | /* Enable AOW0 to MW9 */ | 3191 | /* Enable AOW0 to MW9 */ |
5402 | {0x1, 0xfb8, 0x88}, | 3192 | {0x1, 0xfb8, 0x88}, |
5403 | { } | 3193 | { } |
5404 | }; | 3194 | }; |
5405 | 3195 | ||
5406 | |||
5407 | static const struct hda_verb vt2002P_uniwill_init_verbs[] = { | ||
5408 | {0x25, AC_VERB_SET_UNSOLICITED_ENABLE, | ||
5409 | AC_USRSP_EN | VIA_JACK_EVENT | VIA_BIND_HP_EVENT}, | ||
5410 | {0x26, AC_VERB_SET_UNSOLICITED_ENABLE, | ||
5411 | AC_USRSP_EN | VIA_JACK_EVENT | VIA_BIND_HP_EVENT}, | ||
5412 | {0x29, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT}, | ||
5413 | {0x2a, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT}, | ||
5414 | {0x2b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT}, | ||
5415 | { } | ||
5416 | }; | ||
5417 | static const struct hda_verb vt1802_uniwill_init_verbs[] = { | ||
5418 | {0x25, AC_VERB_SET_UNSOLICITED_ENABLE, | ||
5419 | AC_USRSP_EN | VIA_JACK_EVENT | VIA_BIND_HP_EVENT}, | ||
5420 | {0x28, AC_VERB_SET_UNSOLICITED_ENABLE, | ||
5421 | AC_USRSP_EN | VIA_JACK_EVENT | VIA_BIND_HP_EVENT}, | ||
5422 | {0x29, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT}, | ||
5423 | {0x2a, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT}, | ||
5424 | {0x2b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT}, | ||
5425 | { } | ||
5426 | }; | ||
5427 | |||
5428 | static const struct hda_pcm_stream vt2002P_pcm_analog_playback = { | ||
5429 | .substreams = 2, | ||
5430 | .channels_min = 2, | ||
5431 | .channels_max = 2, | ||
5432 | .nid = 0x8, /* NID to query formats and rates */ | ||
5433 | .ops = { | ||
5434 | .open = via_playback_pcm_open, | ||
5435 | .prepare = via_playback_multi_pcm_prepare, | ||
5436 | .cleanup = via_playback_multi_pcm_cleanup, | ||
5437 | .close = via_pcm_open_close, | ||
5438 | }, | ||
5439 | }; | ||
5440 | |||
5441 | static const struct hda_pcm_stream vt2002P_pcm_analog_capture = { | ||
5442 | .substreams = 2, | ||
5443 | .channels_min = 2, | ||
5444 | .channels_max = 2, | ||
5445 | .nid = 0x10, /* NID to query formats and rates */ | ||
5446 | .ops = { | ||
5447 | .open = via_pcm_open_close, | ||
5448 | .prepare = via_capture_pcm_prepare, | ||
5449 | .cleanup = via_capture_pcm_cleanup, | ||
5450 | .close = via_pcm_open_close, | ||
5451 | }, | ||
5452 | }; | ||
5453 | |||
5454 | static const struct hda_pcm_stream vt2002P_pcm_digital_playback = { | ||
5455 | .substreams = 1, | ||
5456 | .channels_min = 2, | ||
5457 | .channels_max = 2, | ||
5458 | /* NID is set in via_build_pcms */ | ||
5459 | .ops = { | ||
5460 | .open = via_dig_playback_pcm_open, | ||
5461 | .close = via_dig_playback_pcm_close, | ||
5462 | .prepare = via_dig_playback_pcm_prepare, | ||
5463 | .cleanup = via_dig_playback_pcm_cleanup | ||
5464 | }, | ||
5465 | }; | ||
5466 | |||
5467 | /* fill in the dac_nids table from the parsed pin configuration */ | ||
5468 | static int vt2002P_auto_fill_dac_nids(struct via_spec *spec, | ||
5469 | const struct auto_pin_cfg *cfg) | ||
5470 | { | ||
5471 | spec->multiout.num_dacs = 1; | ||
5472 | spec->multiout.dac_nids = spec->private_dac_nids; | ||
5473 | if (cfg->line_out_pins[0]) | ||
5474 | spec->private_dac_nids[0] = 0x8; | ||
5475 | return 0; | ||
5476 | } | ||
5477 | |||
5478 | /* add playback controls from the parsed DAC table */ | ||
5479 | static int vt2002P_auto_create_multi_out_ctls(struct via_spec *spec, | ||
5480 | const struct auto_pin_cfg *cfg) | ||
5481 | { | ||
5482 | int err; | ||
5483 | hda_nid_t sw_nid; | ||
5484 | |||
5485 | if (!cfg->line_out_pins[0]) | ||
5486 | return -1; | ||
5487 | |||
5488 | if (spec->codec_type == VT1802) | ||
5489 | sw_nid = 0x28; | ||
5490 | else | ||
5491 | sw_nid = 0x26; | ||
5492 | |||
5493 | /* Line-Out: PortE */ | ||
5494 | err = via_add_control(spec, VIA_CTL_WIDGET_VOL, | ||
5495 | "Master Front Playback Volume", | ||
5496 | HDA_COMPOSE_AMP_VAL(0x8, 3, 0, HDA_OUTPUT)); | ||
5497 | if (err < 0) | ||
5498 | return err; | ||
5499 | err = via_add_control(spec, VIA_CTL_WIDGET_BIND_PIN_MUTE, | ||
5500 | "Master Front Playback Switch", | ||
5501 | HDA_COMPOSE_AMP_VAL(sw_nid, 3, 0, HDA_OUTPUT)); | ||
5502 | if (err < 0) | ||
5503 | return err; | ||
5504 | |||
5505 | return 0; | ||
5506 | } | ||
5507 | |||
5508 | static int vt2002P_auto_create_hp_ctls(struct via_spec *spec, hda_nid_t pin) | ||
5509 | { | ||
5510 | int err; | ||
5511 | |||
5512 | if (!pin) | ||
5513 | return 0; | ||
5514 | |||
5515 | spec->multiout.hp_nid = 0x9; | ||
5516 | spec->hp_independent_mode_index = 1; | ||
5517 | |||
5518 | err = via_add_control(spec, VIA_CTL_WIDGET_VOL, | ||
5519 | "Headphone Playback Volume", | ||
5520 | HDA_COMPOSE_AMP_VAL( | ||
5521 | spec->multiout.hp_nid, 3, 0, HDA_OUTPUT)); | ||
5522 | if (err < 0) | ||
5523 | return err; | ||
5524 | |||
5525 | err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, | ||
5526 | "Headphone Playback Switch", | ||
5527 | HDA_COMPOSE_AMP_VAL(0x25, 3, 0, HDA_OUTPUT)); | ||
5528 | if (err < 0) | ||
5529 | return err; | ||
5530 | |||
5531 | create_hp_imux(spec); | ||
5532 | return 0; | ||
5533 | } | ||
5534 | |||
5535 | /* create playback/capture controls for input pins */ | ||
5536 | static int vt2002P_auto_create_analog_input_ctls(struct hda_codec *codec, | ||
5537 | const struct auto_pin_cfg *cfg) | ||
5538 | { | ||
5539 | struct via_spec *spec = codec->spec; | ||
5540 | struct hda_input_mux *imux = &spec->private_imux[0]; | ||
5541 | static const hda_nid_t pin_idxs[] = { 0x2b, 0x2a, 0x29, 0xff }; | ||
5542 | int err; | ||
5543 | |||
5544 | err = vt_auto_create_analog_input_ctls(codec, cfg, 0x21, pin_idxs, | ||
5545 | ARRAY_SIZE(pin_idxs)); | ||
5546 | if (err < 0) | ||
5547 | return err; | ||
5548 | /* build volume/mute control of loopback */ | ||
5549 | err = via_new_analog_input(spec, "Stereo Mixer", 0, 3, 0x21); | ||
5550 | if (err < 0) | ||
5551 | return err; | ||
5552 | |||
5553 | /* for digital mic select */ | ||
5554 | snd_hda_add_imux_item(imux, "Digital Mic", 4, NULL); | ||
5555 | |||
5556 | return 0; | ||
5557 | } | ||
5558 | |||
5559 | static int vt2002P_parse_auto_config(struct hda_codec *codec) | ||
5560 | { | ||
5561 | struct via_spec *spec = codec->spec; | ||
5562 | int err; | ||
5563 | |||
5564 | |||
5565 | err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, NULL); | ||
5566 | if (err < 0) | ||
5567 | return err; | ||
5568 | |||
5569 | err = vt2002P_auto_fill_dac_nids(spec, &spec->autocfg); | ||
5570 | if (err < 0) | ||
5571 | return err; | ||
5572 | |||
5573 | if (!spec->autocfg.line_outs && !spec->autocfg.hp_pins[0]) | ||
5574 | return 0; /* can't find valid BIOS pin config */ | ||
5575 | |||
5576 | err = vt2002P_auto_create_multi_out_ctls(spec, &spec->autocfg); | ||
5577 | if (err < 0) | ||
5578 | return err; | ||
5579 | err = vt2002P_auto_create_hp_ctls(spec, spec->autocfg.hp_pins[0]); | ||
5580 | if (err < 0) | ||
5581 | return err; | ||
5582 | err = vt2002P_auto_create_analog_input_ctls(codec, &spec->autocfg); | ||
5583 | if (err < 0) | ||
5584 | return err; | ||
5585 | |||
5586 | spec->multiout.max_channels = spec->multiout.num_dacs * 2; | ||
5587 | |||
5588 | fill_dig_outs(codec); | ||
5589 | |||
5590 | if (spec->kctls.list) | ||
5591 | spec->mixers[spec->num_mixers++] = spec->kctls.list; | ||
5592 | |||
5593 | spec->input_mux = &spec->private_imux[0]; | ||
5594 | |||
5595 | if (spec->hp_mux) | ||
5596 | via_hp_build(codec); | ||
5597 | |||
5598 | return 1; | ||
5599 | } | ||
5600 | |||
5601 | #ifdef CONFIG_SND_HDA_POWER_SAVE | ||
5602 | static const struct hda_amp_list vt2002P_loopbacks[] = { | ||
5603 | { 0x21, HDA_INPUT, 0 }, | ||
5604 | { 0x21, HDA_INPUT, 1 }, | ||
5605 | { 0x21, HDA_INPUT, 2 }, | ||
5606 | { } /* end */ | ||
5607 | }; | ||
5608 | #endif | ||
5609 | |||
5610 | static void set_widgets_power_state_vt2002P(struct hda_codec *codec) | 3196 | static void set_widgets_power_state_vt2002P(struct hda_codec *codec) |
5611 | { | 3197 | { |
5612 | struct via_spec *spec = codec->spec; | 3198 | struct via_spec *spec = codec->spec; |
@@ -5729,334 +3315,38 @@ static int patch_vt2002P(struct hda_codec *codec) | |||
5729 | if (spec == NULL) | 3315 | if (spec == NULL) |
5730 | return -ENOMEM; | 3316 | return -ENOMEM; |
5731 | 3317 | ||
3318 | spec->aa_mix_nid = 0x21; | ||
3319 | override_mic_boost(codec, 0x2b, 0, 3, 40); | ||
3320 | override_mic_boost(codec, 0x29, 0, 3, 40); | ||
3321 | |||
5732 | /* automatic parse from the BIOS config */ | 3322 | /* automatic parse from the BIOS config */ |
5733 | err = vt2002P_parse_auto_config(codec); | 3323 | err = via_parse_auto_config(codec); |
5734 | if (err < 0) { | 3324 | if (err < 0) { |
5735 | via_free(codec); | 3325 | via_free(codec); |
5736 | return err; | 3326 | return err; |
5737 | } else if (!err) { | ||
5738 | printk(KERN_INFO "hda_codec: Cannot set up configuration " | ||
5739 | "from BIOS. Using genenic mode...\n"); | ||
5740 | } | 3327 | } |
5741 | 3328 | ||
5742 | if (spec->codec_type == VT1802) | 3329 | if (spec->codec_type == VT1802) |
5743 | spec->init_verbs[spec->num_iverbs++] = | 3330 | spec->init_verbs[spec->num_iverbs++] = vt1802_init_verbs; |
5744 | vt1802_volume_init_verbs; | ||
5745 | else | 3331 | else |
5746 | spec->init_verbs[spec->num_iverbs++] = | 3332 | spec->init_verbs[spec->num_iverbs++] = vt2002P_init_verbs; |
5747 | vt2002P_volume_init_verbs; | ||
5748 | |||
5749 | if (spec->codec_type == VT1802) | ||
5750 | spec->init_verbs[spec->num_iverbs++] = | ||
5751 | vt1802_uniwill_init_verbs; | ||
5752 | else | ||
5753 | spec->init_verbs[spec->num_iverbs++] = | ||
5754 | vt2002P_uniwill_init_verbs; | ||
5755 | |||
5756 | if (spec->codec_type == VT1802) | ||
5757 | spec->stream_name_analog = "VT1802 Analog"; | ||
5758 | else | ||
5759 | spec->stream_name_analog = "VT2002P Analog"; | ||
5760 | spec->stream_analog_playback = &vt2002P_pcm_analog_playback; | ||
5761 | spec->stream_analog_capture = &vt2002P_pcm_analog_capture; | ||
5762 | |||
5763 | if (spec->codec_type == VT1802) | ||
5764 | spec->stream_name_digital = "VT1802 Digital"; | ||
5765 | else | ||
5766 | spec->stream_name_digital = "VT2002P Digital"; | ||
5767 | spec->stream_digital_playback = &vt2002P_pcm_digital_playback; | ||
5768 | |||
5769 | if (!spec->adc_nids && spec->input_mux) { | ||
5770 | spec->adc_nids = vt2002P_adc_nids; | ||
5771 | spec->num_adc_nids = ARRAY_SIZE(vt2002P_adc_nids); | ||
5772 | get_mux_nids(codec); | ||
5773 | override_mic_boost(codec, 0x2b, 0, 3, 40); | ||
5774 | override_mic_boost(codec, 0x29, 0, 3, 40); | ||
5775 | spec->mixers[spec->num_mixers] = vt2002P_capture_mixer; | ||
5776 | spec->num_mixers++; | ||
5777 | } | ||
5778 | 3333 | ||
5779 | codec->patch_ops = via_patch_ops; | 3334 | codec->patch_ops = via_patch_ops; |
5780 | 3335 | ||
5781 | codec->patch_ops.init = via_auto_init; | ||
5782 | codec->patch_ops.unsol_event = via_unsol_event; | ||
5783 | |||
5784 | #ifdef CONFIG_SND_HDA_POWER_SAVE | ||
5785 | spec->loopback.amplist = vt2002P_loopbacks; | ||
5786 | #endif | ||
5787 | |||
5788 | spec->set_widgets_power_state = set_widgets_power_state_vt2002P; | 3336 | spec->set_widgets_power_state = set_widgets_power_state_vt2002P; |
5789 | return 0; | 3337 | return 0; |
5790 | } | 3338 | } |
5791 | 3339 | ||
5792 | /* for vt1812 */ | 3340 | /* for vt1812 */ |
5793 | 3341 | ||
5794 | /* capture mixer elements */ | 3342 | static const struct hda_verb vt1812_init_verbs[] = { |
5795 | static const struct snd_kcontrol_new vt1812_capture_mixer[] = { | ||
5796 | HDA_CODEC_VOLUME("Capture Volume", 0x10, 0x0, HDA_INPUT), | ||
5797 | HDA_CODEC_MUTE("Capture Switch", 0x10, 0x0, HDA_INPUT), | ||
5798 | HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x11, 0x0, HDA_INPUT), | ||
5799 | HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x11, 0x0, HDA_INPUT), | ||
5800 | HDA_CODEC_MUTE("Mic Boost Capture Volume", 0x2b, 0x0, HDA_INPUT), | ||
5801 | HDA_CODEC_MUTE("Front Mic Boost Capture Volume", 0x29, 0x0, | ||
5802 | HDA_INPUT), | ||
5803 | { | ||
5804 | .iface = SNDRV_CTL_ELEM_IFACE_MIXER, | ||
5805 | /* The multiple "Capture Source" controls confuse alsamixer | ||
5806 | * So call somewhat different.. | ||
5807 | */ | ||
5808 | .name = "Input Source", | ||
5809 | .count = 2, | ||
5810 | .info = via_mux_enum_info, | ||
5811 | .get = via_mux_enum_get, | ||
5812 | .put = via_mux_enum_put, | ||
5813 | }, | ||
5814 | { } /* end */ | ||
5815 | }; | ||
5816 | |||
5817 | static const struct hda_verb vt1812_volume_init_verbs[] = { | ||
5818 | /* | ||
5819 | * Unmute ADC0-1 and set the default input to mic-in | ||
5820 | */ | ||
5821 | {0x8, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, | ||
5822 | {0x9, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, | ||
5823 | |||
5824 | |||
5825 | /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback | ||
5826 | * mixer widget | ||
5827 | */ | ||
5828 | /* Amp Indices: CD = 1, Mic1 = 2, Line = 3, Mic2 = 4 */ | ||
5829 | {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, | ||
5830 | {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, | ||
5831 | {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, | ||
5832 | {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, | ||
5833 | {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, | ||
5834 | |||
5835 | /* MUX Indices: Mic = 0 */ | ||
5836 | {0x1e, AC_VERB_SET_CONNECT_SEL, 0}, | ||
5837 | {0x1f, AC_VERB_SET_CONNECT_SEL, 0}, | ||
5838 | |||
5839 | /* PW9 Output enable */ | ||
5840 | {0x2d, AC_VERB_SET_PIN_WIDGET_CONTROL, AC_PINCTL_OUT_EN}, | ||
5841 | |||
5842 | /* Enable Boost Volume backdoor */ | 3343 | /* Enable Boost Volume backdoor */ |
5843 | {0x1, 0xfb9, 0x24}, | 3344 | {0x1, 0xfb9, 0x24}, |
5844 | |||
5845 | /* MW0/1/4/13/15: un-mute index 0 (MUXx), un-mute index 1 (MW9) */ | ||
5846 | {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, | ||
5847 | {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, | ||
5848 | {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, | ||
5849 | {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, | ||
5850 | {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, | ||
5851 | {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, | ||
5852 | {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, | ||
5853 | {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, | ||
5854 | {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, | ||
5855 | {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, | ||
5856 | |||
5857 | /* set MUX0/1/4/13/15 = 0 (AOW0) */ | ||
5858 | {0x34, AC_VERB_SET_CONNECT_SEL, 0}, | ||
5859 | {0x35, AC_VERB_SET_CONNECT_SEL, 0}, | ||
5860 | {0x38, AC_VERB_SET_CONNECT_SEL, 0}, | ||
5861 | {0x3c, AC_VERB_SET_CONNECT_SEL, 0}, | ||
5862 | {0x3d, AC_VERB_SET_CONNECT_SEL, 0}, | ||
5863 | |||
5864 | /* Enable AOW0 to MW9 */ | 3345 | /* Enable AOW0 to MW9 */ |
5865 | {0x1, 0xfb8, 0xa8}, | 3346 | {0x1, 0xfb8, 0xa8}, |
5866 | { } | 3347 | { } |
5867 | }; | 3348 | }; |
5868 | 3349 | ||
5869 | |||
5870 | static const struct hda_verb vt1812_uniwill_init_verbs[] = { | ||
5871 | {0x33, AC_VERB_SET_UNSOLICITED_ENABLE, | ||
5872 | AC_USRSP_EN | VIA_JACK_EVENT | VIA_BIND_HP_EVENT}, | ||
5873 | {0x25, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT }, | ||
5874 | {0x28, AC_VERB_SET_UNSOLICITED_ENABLE, | ||
5875 | AC_USRSP_EN | VIA_JACK_EVENT | VIA_BIND_HP_EVENT}, | ||
5876 | {0x29, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT}, | ||
5877 | {0x2a, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT}, | ||
5878 | {0x2b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT}, | ||
5879 | { } | ||
5880 | }; | ||
5881 | |||
5882 | static const struct hda_pcm_stream vt1812_pcm_analog_playback = { | ||
5883 | .substreams = 2, | ||
5884 | .channels_min = 2, | ||
5885 | .channels_max = 2, | ||
5886 | .nid = 0x8, /* NID to query formats and rates */ | ||
5887 | .ops = { | ||
5888 | .open = via_playback_pcm_open, | ||
5889 | .prepare = via_playback_multi_pcm_prepare, | ||
5890 | .cleanup = via_playback_multi_pcm_cleanup, | ||
5891 | .close = via_pcm_open_close, | ||
5892 | }, | ||
5893 | }; | ||
5894 | |||
5895 | static const struct hda_pcm_stream vt1812_pcm_analog_capture = { | ||
5896 | .substreams = 2, | ||
5897 | .channels_min = 2, | ||
5898 | .channels_max = 2, | ||
5899 | .nid = 0x10, /* NID to query formats and rates */ | ||
5900 | .ops = { | ||
5901 | .open = via_pcm_open_close, | ||
5902 | .prepare = via_capture_pcm_prepare, | ||
5903 | .cleanup = via_capture_pcm_cleanup, | ||
5904 | .close = via_pcm_open_close, | ||
5905 | }, | ||
5906 | }; | ||
5907 | |||
5908 | static const struct hda_pcm_stream vt1812_pcm_digital_playback = { | ||
5909 | .substreams = 1, | ||
5910 | .channels_min = 2, | ||
5911 | .channels_max = 2, | ||
5912 | /* NID is set in via_build_pcms */ | ||
5913 | .ops = { | ||
5914 | .open = via_dig_playback_pcm_open, | ||
5915 | .close = via_dig_playback_pcm_close, | ||
5916 | .prepare = via_dig_playback_pcm_prepare, | ||
5917 | .cleanup = via_dig_playback_pcm_cleanup | ||
5918 | }, | ||
5919 | }; | ||
5920 | /* fill in the dac_nids table from the parsed pin configuration */ | ||
5921 | static int vt1812_auto_fill_dac_nids(struct via_spec *spec, | ||
5922 | const struct auto_pin_cfg *cfg) | ||
5923 | { | ||
5924 | spec->multiout.num_dacs = 1; | ||
5925 | spec->multiout.dac_nids = spec->private_dac_nids; | ||
5926 | if (cfg->line_out_pins[0]) | ||
5927 | spec->private_dac_nids[0] = 0x8; | ||
5928 | return 0; | ||
5929 | } | ||
5930 | |||
5931 | |||
5932 | /* add playback controls from the parsed DAC table */ | ||
5933 | static int vt1812_auto_create_multi_out_ctls(struct via_spec *spec, | ||
5934 | const struct auto_pin_cfg *cfg) | ||
5935 | { | ||
5936 | int err; | ||
5937 | |||
5938 | if (!cfg->line_out_pins[0]) | ||
5939 | return -1; | ||
5940 | |||
5941 | /* Line-Out: PortE */ | ||
5942 | err = via_add_control(spec, VIA_CTL_WIDGET_VOL, | ||
5943 | "Front Playback Volume", | ||
5944 | HDA_COMPOSE_AMP_VAL(0x8, 3, 0, HDA_OUTPUT)); | ||
5945 | if (err < 0) | ||
5946 | return err; | ||
5947 | err = via_add_control(spec, VIA_CTL_WIDGET_BIND_PIN_MUTE, | ||
5948 | "Front Playback Switch", | ||
5949 | HDA_COMPOSE_AMP_VAL(0x28, 3, 0, HDA_OUTPUT)); | ||
5950 | if (err < 0) | ||
5951 | return err; | ||
5952 | |||
5953 | return 0; | ||
5954 | } | ||
5955 | |||
5956 | static int vt1812_auto_create_hp_ctls(struct via_spec *spec, hda_nid_t pin) | ||
5957 | { | ||
5958 | int err; | ||
5959 | |||
5960 | if (!pin) | ||
5961 | return 0; | ||
5962 | |||
5963 | spec->multiout.hp_nid = 0x9; | ||
5964 | spec->hp_independent_mode_index = 1; | ||
5965 | |||
5966 | |||
5967 | err = via_add_control(spec, VIA_CTL_WIDGET_VOL, | ||
5968 | "Headphone Playback Volume", | ||
5969 | HDA_COMPOSE_AMP_VAL( | ||
5970 | spec->multiout.hp_nid, 3, 0, HDA_OUTPUT)); | ||
5971 | if (err < 0) | ||
5972 | return err; | ||
5973 | |||
5974 | err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, | ||
5975 | "Headphone Playback Switch", | ||
5976 | HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT)); | ||
5977 | if (err < 0) | ||
5978 | return err; | ||
5979 | |||
5980 | create_hp_imux(spec); | ||
5981 | return 0; | ||
5982 | } | ||
5983 | |||
5984 | /* create playback/capture controls for input pins */ | ||
5985 | static int vt1812_auto_create_analog_input_ctls(struct hda_codec *codec, | ||
5986 | const struct auto_pin_cfg *cfg) | ||
5987 | { | ||
5988 | struct via_spec *spec = codec->spec; | ||
5989 | struct hda_input_mux *imux = &spec->private_imux[0]; | ||
5990 | static const hda_nid_t pin_idxs[] = { 0x2b, 0x2a, 0x29, 0, 0, 0xff }; | ||
5991 | int err; | ||
5992 | |||
5993 | err = vt_auto_create_analog_input_ctls(codec, cfg, 0x21, pin_idxs, | ||
5994 | ARRAY_SIZE(pin_idxs)); | ||
5995 | if (err < 0) | ||
5996 | return err; | ||
5997 | |||
5998 | /* build volume/mute control of loopback */ | ||
5999 | err = via_new_analog_input(spec, "Stereo Mixer", 0, 5, 0x21); | ||
6000 | if (err < 0) | ||
6001 | return err; | ||
6002 | |||
6003 | /* for digital mic select */ | ||
6004 | snd_hda_add_imux_item(imux, "Digital Mic", 6, NULL); | ||
6005 | |||
6006 | return 0; | ||
6007 | } | ||
6008 | |||
6009 | static int vt1812_parse_auto_config(struct hda_codec *codec) | ||
6010 | { | ||
6011 | struct via_spec *spec = codec->spec; | ||
6012 | int err; | ||
6013 | |||
6014 | |||
6015 | err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, NULL); | ||
6016 | if (err < 0) | ||
6017 | return err; | ||
6018 | fill_dig_outs(codec); | ||
6019 | err = vt1812_auto_fill_dac_nids(spec, &spec->autocfg); | ||
6020 | if (err < 0) | ||
6021 | return err; | ||
6022 | |||
6023 | if (!spec->autocfg.line_outs && !spec->autocfg.hp_outs) | ||
6024 | return 0; /* can't find valid BIOS pin config */ | ||
6025 | |||
6026 | err = vt1812_auto_create_multi_out_ctls(spec, &spec->autocfg); | ||
6027 | if (err < 0) | ||
6028 | return err; | ||
6029 | err = vt1812_auto_create_hp_ctls(spec, spec->autocfg.hp_pins[0]); | ||
6030 | if (err < 0) | ||
6031 | return err; | ||
6032 | err = vt1812_auto_create_analog_input_ctls(codec, &spec->autocfg); | ||
6033 | if (err < 0) | ||
6034 | return err; | ||
6035 | |||
6036 | spec->multiout.max_channels = spec->multiout.num_dacs * 2; | ||
6037 | |||
6038 | fill_dig_outs(codec); | ||
6039 | |||
6040 | if (spec->kctls.list) | ||
6041 | spec->mixers[spec->num_mixers++] = spec->kctls.list; | ||
6042 | |||
6043 | spec->input_mux = &spec->private_imux[0]; | ||
6044 | |||
6045 | if (spec->hp_mux) | ||
6046 | via_hp_build(codec); | ||
6047 | |||
6048 | return 1; | ||
6049 | } | ||
6050 | |||
6051 | #ifdef CONFIG_SND_HDA_POWER_SAVE | ||
6052 | static const struct hda_amp_list vt1812_loopbacks[] = { | ||
6053 | { 0x21, HDA_INPUT, 0 }, | ||
6054 | { 0x21, HDA_INPUT, 1 }, | ||
6055 | { 0x21, HDA_INPUT, 2 }, | ||
6056 | { } /* end */ | ||
6057 | }; | ||
6058 | #endif | ||
6059 | |||
6060 | static void set_widgets_power_state_vt1812(struct hda_codec *codec) | 3350 | static void set_widgets_power_state_vt1812(struct hda_codec *codec) |
6061 | { | 3351 | { |
6062 | struct via_spec *spec = codec->spec; | 3352 | struct via_spec *spec = codec->spec; |
@@ -6160,47 +3450,21 @@ static int patch_vt1812(struct hda_codec *codec) | |||
6160 | if (spec == NULL) | 3450 | if (spec == NULL) |
6161 | return -ENOMEM; | 3451 | return -ENOMEM; |
6162 | 3452 | ||
3453 | spec->aa_mix_nid = 0x21; | ||
3454 | override_mic_boost(codec, 0x2b, 0, 3, 40); | ||
3455 | override_mic_boost(codec, 0x29, 0, 3, 40); | ||
3456 | |||
6163 | /* automatic parse from the BIOS config */ | 3457 | /* automatic parse from the BIOS config */ |
6164 | err = vt1812_parse_auto_config(codec); | 3458 | err = via_parse_auto_config(codec); |
6165 | if (err < 0) { | 3459 | if (err < 0) { |
6166 | via_free(codec); | 3460 | via_free(codec); |
6167 | return err; | 3461 | return err; |
6168 | } else if (!err) { | ||
6169 | printk(KERN_INFO "hda_codec: Cannot set up configuration " | ||
6170 | "from BIOS. Using genenic mode...\n"); | ||
6171 | } | 3462 | } |
6172 | 3463 | ||
6173 | 3464 | spec->init_verbs[spec->num_iverbs++] = vt1812_init_verbs; | |
6174 | spec->init_verbs[spec->num_iverbs++] = vt1812_volume_init_verbs; | ||
6175 | spec->init_verbs[spec->num_iverbs++] = vt1812_uniwill_init_verbs; | ||
6176 | |||
6177 | spec->stream_name_analog = "VT1812 Analog"; | ||
6178 | spec->stream_analog_playback = &vt1812_pcm_analog_playback; | ||
6179 | spec->stream_analog_capture = &vt1812_pcm_analog_capture; | ||
6180 | |||
6181 | spec->stream_name_digital = "VT1812 Digital"; | ||
6182 | spec->stream_digital_playback = &vt1812_pcm_digital_playback; | ||
6183 | |||
6184 | |||
6185 | if (!spec->adc_nids && spec->input_mux) { | ||
6186 | spec->adc_nids = vt1812_adc_nids; | ||
6187 | spec->num_adc_nids = ARRAY_SIZE(vt1812_adc_nids); | ||
6188 | get_mux_nids(codec); | ||
6189 | override_mic_boost(codec, 0x2b, 0, 3, 40); | ||
6190 | override_mic_boost(codec, 0x29, 0, 3, 40); | ||
6191 | spec->mixers[spec->num_mixers] = vt1812_capture_mixer; | ||
6192 | spec->num_mixers++; | ||
6193 | } | ||
6194 | 3465 | ||
6195 | codec->patch_ops = via_patch_ops; | 3466 | codec->patch_ops = via_patch_ops; |
6196 | 3467 | ||
6197 | codec->patch_ops.init = via_auto_init; | ||
6198 | codec->patch_ops.unsol_event = via_unsol_event; | ||
6199 | |||
6200 | #ifdef CONFIG_SND_HDA_POWER_SAVE | ||
6201 | spec->loopback.amplist = vt1812_loopbacks; | ||
6202 | #endif | ||
6203 | |||
6204 | spec->set_widgets_power_state = set_widgets_power_state_vt1812; | 3468 | spec->set_widgets_power_state = set_widgets_power_state_vt1812; |
6205 | return 0; | 3469 | return 0; |
6206 | } | 3470 | } |
@@ -6214,37 +3478,37 @@ static const struct hda_codec_preset snd_hda_preset_via[] = { | |||
6214 | { .id = 0x1106170a, .name = "VT1708", .patch = patch_vt1708}, | 3478 | { .id = 0x1106170a, .name = "VT1708", .patch = patch_vt1708}, |
6215 | { .id = 0x1106170b, .name = "VT1708", .patch = patch_vt1708}, | 3479 | { .id = 0x1106170b, .name = "VT1708", .patch = patch_vt1708}, |
6216 | { .id = 0x1106e710, .name = "VT1709 10-Ch", | 3480 | { .id = 0x1106e710, .name = "VT1709 10-Ch", |
6217 | .patch = patch_vt1709_10ch}, | 3481 | .patch = patch_vt1709}, |
6218 | { .id = 0x1106e711, .name = "VT1709 10-Ch", | 3482 | { .id = 0x1106e711, .name = "VT1709 10-Ch", |
6219 | .patch = patch_vt1709_10ch}, | 3483 | .patch = patch_vt1709}, |
6220 | { .id = 0x1106e712, .name = "VT1709 10-Ch", | 3484 | { .id = 0x1106e712, .name = "VT1709 10-Ch", |
6221 | .patch = patch_vt1709_10ch}, | 3485 | .patch = patch_vt1709}, |
6222 | { .id = 0x1106e713, .name = "VT1709 10-Ch", | 3486 | { .id = 0x1106e713, .name = "VT1709 10-Ch", |
6223 | .patch = patch_vt1709_10ch}, | 3487 | .patch = patch_vt1709}, |
6224 | { .id = 0x1106e714, .name = "VT1709 6-Ch", | 3488 | { .id = 0x1106e714, .name = "VT1709 6-Ch", |
6225 | .patch = patch_vt1709_6ch}, | 3489 | .patch = patch_vt1709}, |
6226 | { .id = 0x1106e715, .name = "VT1709 6-Ch", | 3490 | { .id = 0x1106e715, .name = "VT1709 6-Ch", |
6227 | .patch = patch_vt1709_6ch}, | 3491 | .patch = patch_vt1709}, |
6228 | { .id = 0x1106e716, .name = "VT1709 6-Ch", | 3492 | { .id = 0x1106e716, .name = "VT1709 6-Ch", |
6229 | .patch = patch_vt1709_6ch}, | 3493 | .patch = patch_vt1709}, |
6230 | { .id = 0x1106e717, .name = "VT1709 6-Ch", | 3494 | { .id = 0x1106e717, .name = "VT1709 6-Ch", |
6231 | .patch = patch_vt1709_6ch}, | 3495 | .patch = patch_vt1709}, |
6232 | { .id = 0x1106e720, .name = "VT1708B 8-Ch", | 3496 | { .id = 0x1106e720, .name = "VT1708B 8-Ch", |
6233 | .patch = patch_vt1708B_8ch}, | 3497 | .patch = patch_vt1708B}, |
6234 | { .id = 0x1106e721, .name = "VT1708B 8-Ch", | 3498 | { .id = 0x1106e721, .name = "VT1708B 8-Ch", |
6235 | .patch = patch_vt1708B_8ch}, | 3499 | .patch = patch_vt1708B}, |
6236 | { .id = 0x1106e722, .name = "VT1708B 8-Ch", | 3500 | { .id = 0x1106e722, .name = "VT1708B 8-Ch", |
6237 | .patch = patch_vt1708B_8ch}, | 3501 | .patch = patch_vt1708B}, |
6238 | { .id = 0x1106e723, .name = "VT1708B 8-Ch", | 3502 | { .id = 0x1106e723, .name = "VT1708B 8-Ch", |
6239 | .patch = patch_vt1708B_8ch}, | 3503 | .patch = patch_vt1708B}, |
6240 | { .id = 0x1106e724, .name = "VT1708B 4-Ch", | 3504 | { .id = 0x1106e724, .name = "VT1708B 4-Ch", |
6241 | .patch = patch_vt1708B_4ch}, | 3505 | .patch = patch_vt1708B}, |
6242 | { .id = 0x1106e725, .name = "VT1708B 4-Ch", | 3506 | { .id = 0x1106e725, .name = "VT1708B 4-Ch", |
6243 | .patch = patch_vt1708B_4ch}, | 3507 | .patch = patch_vt1708B}, |
6244 | { .id = 0x1106e726, .name = "VT1708B 4-Ch", | 3508 | { .id = 0x1106e726, .name = "VT1708B 4-Ch", |
6245 | .patch = patch_vt1708B_4ch}, | 3509 | .patch = patch_vt1708B}, |
6246 | { .id = 0x1106e727, .name = "VT1708B 4-Ch", | 3510 | { .id = 0x1106e727, .name = "VT1708B 4-Ch", |
6247 | .patch = patch_vt1708B_4ch}, | 3511 | .patch = patch_vt1708B}, |
6248 | { .id = 0x11060397, .name = "VT1708S", | 3512 | { .id = 0x11060397, .name = "VT1708S", |
6249 | .patch = patch_vt1708S}, | 3513 | .patch = patch_vt1708S}, |
6250 | { .id = 0x11061397, .name = "VT1708S", | 3514 | { .id = 0x11061397, .name = "VT1708S", |