xref: /linux/sound/drivers/vx/vx_mixer.c (revision 762f99f4f3cb41a775b5157dd761217beba65873)
1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3  * Driver for Digigram VX soundcards
4  *
5  * Common mixer part
6  *
7  * Copyright (c) 2002 by Takashi Iwai <tiwai@suse.de>
8  */
9 
10 #include <sound/core.h>
11 #include <sound/control.h>
12 #include <sound/tlv.h>
13 #include <sound/vx_core.h>
14 #include "vx_cmd.h"
15 
16 
17 /*
18  * write a codec data (24bit)
19  */
vx_write_codec_reg(struct vx_core * chip,int codec,unsigned int data)20 static void vx_write_codec_reg(struct vx_core *chip, int codec, unsigned int data)
21 {
22 	if (snd_BUG_ON(!chip->ops->write_codec))
23 		return;
24 
25 	if (chip->chip_status & VX_STAT_IS_STALE)
26 		return;
27 
28 	mutex_lock(&chip->lock);
29 	chip->ops->write_codec(chip, codec, data);
30 	mutex_unlock(&chip->lock);
31 }
32 
33 /*
34  * Data type used to access the Codec
35  */
36 union vx_codec_data {
37 	u32 l;
38 #ifdef SNDRV_BIG_ENDIAN
39 	struct w {
40 		u16 h;
41 		u16 l;
42 	} w;
43 	struct b {
44 		u8 hh;
45 		u8 mh;
46 		u8 ml;
47 		u8 ll;
48 	} b;
49 #else /* LITTLE_ENDIAN */
50 	struct w {
51 		u16 l;
52 		u16 h;
53 	} w;
54 	struct b {
55 		u8 ll;
56 		u8 ml;
57 		u8 mh;
58 		u8 hh;
59 	} b;
60 #endif
61 };
62 
63 #define SET_CDC_DATA_SEL(di,s)          ((di).b.mh = (u8) (s))
64 #define SET_CDC_DATA_REG(di,r)          ((di).b.ml = (u8) (r))
65 #define SET_CDC_DATA_VAL(di,d)          ((di).b.ll = (u8) (d))
66 #define SET_CDC_DATA_INIT(di)           ((di).l = 0L, SET_CDC_DATA_SEL(di,XX_CODEC_SELECTOR))
67 
68 /*
69  * set up codec register and write the value
70  * @codec: the codec id, 0 or 1
71  * @reg: register index
72  * @val: data value
73  */
vx_set_codec_reg(struct vx_core * chip,int codec,int reg,int val)74 static void vx_set_codec_reg(struct vx_core *chip, int codec, int reg, int val)
75 {
76 	union vx_codec_data data;
77 	/* DAC control register */
78 	SET_CDC_DATA_INIT(data);
79 	SET_CDC_DATA_REG(data, reg);
80 	SET_CDC_DATA_VAL(data, val);
81 	vx_write_codec_reg(chip, codec, data.l);
82 }
83 
84 
85 /*
86  * vx_set_analog_output_level - set the output attenuation level
87  * @codec: the output codec, 0 or 1.  (1 for VXP440 only)
88  * @left: left output level, 0 = mute
89  * @right: right output level
90  */
vx_set_analog_output_level(struct vx_core * chip,int codec,int left,int right)91 static void vx_set_analog_output_level(struct vx_core *chip, int codec, int left, int right)
92 {
93 	left  = chip->hw->output_level_max - left;
94 	right = chip->hw->output_level_max - right;
95 
96 	if (chip->ops->akm_write) {
97 		chip->ops->akm_write(chip, XX_CODEC_LEVEL_LEFT_REGISTER, left);
98 		chip->ops->akm_write(chip, XX_CODEC_LEVEL_RIGHT_REGISTER, right);
99 	} else {
100 		/* convert to attenuation level: 0 = 0dB (max), 0xe3 = -113.5 dB (min) */
101 		vx_set_codec_reg(chip, codec, XX_CODEC_LEVEL_LEFT_REGISTER, left);
102 		vx_set_codec_reg(chip, codec, XX_CODEC_LEVEL_RIGHT_REGISTER, right);
103 	}
104 }
105 
106 
107 /*
108  * vx_toggle_dac_mute -  mute/unmute DAC
109  * @mute: 0 = unmute, 1 = mute
110  */
111 
112 #define DAC_ATTEN_MIN	0x08
113 #define DAC_ATTEN_MAX	0x38
114 
vx_toggle_dac_mute(struct vx_core * chip,int mute)115 void vx_toggle_dac_mute(struct vx_core *chip, int mute)
116 {
117 	unsigned int i;
118 	for (i = 0; i < chip->hw->num_codecs; i++) {
119 		if (chip->ops->akm_write)
120 			chip->ops->akm_write(chip, XX_CODEC_DAC_CONTROL_REGISTER, mute); /* XXX */
121 		else
122 			vx_set_codec_reg(chip, i, XX_CODEC_DAC_CONTROL_REGISTER,
123 					 mute ? DAC_ATTEN_MAX : DAC_ATTEN_MIN);
124 	}
125 }
126 
127 /*
128  * vx_reset_codec - reset and initialize the codecs
129  */
vx_reset_codec(struct vx_core * chip,int cold_reset)130 void vx_reset_codec(struct vx_core *chip, int cold_reset)
131 {
132 	unsigned int i;
133 	int port = chip->type >= VX_TYPE_VXPOCKET ? 0x75 : 0x65;
134 
135 	chip->ops->reset_codec(chip);
136 
137 	/* AKM codecs should be initialized in reset_codec callback */
138 	if (! chip->ops->akm_write) {
139 		/* initialize old codecs */
140 		for (i = 0; i < chip->hw->num_codecs; i++) {
141 			/* DAC control register (change level when zero crossing + mute) */
142 			vx_set_codec_reg(chip, i, XX_CODEC_DAC_CONTROL_REGISTER, DAC_ATTEN_MAX);
143 			/* ADC control register */
144 			vx_set_codec_reg(chip, i, XX_CODEC_ADC_CONTROL_REGISTER, 0x00);
145 			/* Port mode register */
146 			vx_set_codec_reg(chip, i, XX_CODEC_PORT_MODE_REGISTER, port);
147 			/* Clock control register */
148 			vx_set_codec_reg(chip, i, XX_CODEC_CLOCK_CONTROL_REGISTER, 0x00);
149 		}
150 	}
151 
152 	/* mute analog output */
153 	for (i = 0; i < chip->hw->num_codecs; i++) {
154 		chip->output_level[i][0] = 0;
155 		chip->output_level[i][1] = 0;
156 		vx_set_analog_output_level(chip, i, 0, 0);
157 	}
158 }
159 
160 /*
161  * change the audio input source
162  * @src: the target source (VX_AUDIO_SRC_XXX)
163  */
vx_change_audio_source(struct vx_core * chip,int src)164 static void vx_change_audio_source(struct vx_core *chip, int src)
165 {
166 	if (chip->chip_status & VX_STAT_IS_STALE)
167 		return;
168 
169 	mutex_lock(&chip->lock);
170 	chip->ops->change_audio_source(chip, src);
171 	mutex_unlock(&chip->lock);
172 }
173 
174 
175 /*
176  * change the audio source if necessary and possible
177  * returns 1 if the source is actually changed.
178  */
vx_sync_audio_source(struct vx_core * chip)179 int vx_sync_audio_source(struct vx_core *chip)
180 {
181 	if (chip->audio_source_target == chip->audio_source ||
182 	    chip->pcm_running)
183 		return 0;
184 	vx_change_audio_source(chip, chip->audio_source_target);
185 	chip->audio_source = chip->audio_source_target;
186 	return 1;
187 }
188 
189 
190 /*
191  * audio level, mute, monitoring
192  */
193 struct vx_audio_level {
194 	unsigned int has_level: 1;
195 	unsigned int has_monitor_level: 1;
196 	unsigned int has_mute: 1;
197 	unsigned int has_monitor_mute: 1;
198 	unsigned int mute;
199 	unsigned int monitor_mute;
200 	short level;
201 	short monitor_level;
202 };
203 
vx_adjust_audio_level(struct vx_core * chip,int audio,int capture,struct vx_audio_level * info)204 static int vx_adjust_audio_level(struct vx_core *chip, int audio, int capture,
205 				 struct vx_audio_level *info)
206 {
207 	struct vx_rmh rmh;
208 
209 	if (chip->chip_status & VX_STAT_IS_STALE)
210 		return -EBUSY;
211 
212         vx_init_rmh(&rmh, CMD_AUDIO_LEVEL_ADJUST);
213 	if (capture)
214 		rmh.Cmd[0] |= COMMAND_RECORD_MASK;
215 	/* Add Audio IO mask */
216 	rmh.Cmd[1] = 1 << audio;
217 	rmh.Cmd[2] = 0;
218 	if (info->has_level) {
219 		rmh.Cmd[0] |=  VALID_AUDIO_IO_DIGITAL_LEVEL;
220 		rmh.Cmd[2] |= info->level;
221         }
222 	if (info->has_monitor_level) {
223 		rmh.Cmd[0] |=  VALID_AUDIO_IO_MONITORING_LEVEL;
224 		rmh.Cmd[2] |= ((unsigned int)info->monitor_level << 10);
225         }
226 	if (info->has_mute) {
227 		rmh.Cmd[0] |= VALID_AUDIO_IO_MUTE_LEVEL;
228 		if (info->mute)
229 			rmh.Cmd[2] |= AUDIO_IO_HAS_MUTE_LEVEL;
230 	}
231 	if (info->has_monitor_mute) {
232 		/* validate flag for M2 at least to unmute it */
233 		rmh.Cmd[0] |=  VALID_AUDIO_IO_MUTE_MONITORING_1 | VALID_AUDIO_IO_MUTE_MONITORING_2;
234 		if (info->monitor_mute)
235 			rmh.Cmd[2] |= AUDIO_IO_HAS_MUTE_MONITORING_1;
236 	}
237 
238 	return vx_send_msg(chip, &rmh);
239 }
240 
241 
242 #if 0 // not used
243 static int vx_read_audio_level(struct vx_core *chip, int audio, int capture,
244 			       struct vx_audio_level *info)
245 {
246 	int err;
247 	struct vx_rmh rmh;
248 
249 	memset(info, 0, sizeof(*info));
250         vx_init_rmh(&rmh, CMD_GET_AUDIO_LEVELS);
251 	if (capture)
252 		rmh.Cmd[0] |= COMMAND_RECORD_MASK;
253 	/* Add Audio IO mask */
254 	rmh.Cmd[1] = 1 << audio;
255 	err = vx_send_msg(chip, &rmh);
256 	if (err < 0)
257 		return err;
258 	info.level = rmh.Stat[0] & MASK_DSP_WORD_LEVEL;
259 	info.monitor_level = (rmh.Stat[0] >> 10) & MASK_DSP_WORD_LEVEL;
260 	info.mute = (rmh.Stat[i] & AUDIO_IO_HAS_MUTE_LEVEL) ? 1 : 0;
261 	info.monitor_mute = (rmh.Stat[i] & AUDIO_IO_HAS_MUTE_MONITORING_1) ? 1 : 0;
262 	return 0;
263 }
264 #endif // not used
265 
266 /*
267  * set the monitoring level and mute state of the given audio
268  * no more static, because must be called from vx_pcm to demute monitoring
269  */
vx_set_monitor_level(struct vx_core * chip,int audio,int level,int active)270 int vx_set_monitor_level(struct vx_core *chip, int audio, int level, int active)
271 {
272 	struct vx_audio_level info;
273 
274 	memset(&info, 0, sizeof(info));
275 	info.has_monitor_level = 1;
276 	info.monitor_level = level;
277 	info.has_monitor_mute = 1;
278 	info.monitor_mute = !active;
279 	chip->audio_monitor[audio] = level;
280 	chip->audio_monitor_active[audio] = active;
281 	return vx_adjust_audio_level(chip, audio, 0, &info); /* playback only */
282 }
283 
284 
285 /*
286  * set the mute status of the given audio
287  */
vx_set_audio_switch(struct vx_core * chip,int audio,int active)288 static int vx_set_audio_switch(struct vx_core *chip, int audio, int active)
289 {
290 	struct vx_audio_level info;
291 
292 	memset(&info, 0, sizeof(info));
293 	info.has_mute = 1;
294 	info.mute = !active;
295 	chip->audio_active[audio] = active;
296 	return vx_adjust_audio_level(chip, audio, 0, &info); /* playback only */
297 }
298 
299 /*
300  * set the mute status of the given audio
301  */
vx_set_audio_gain(struct vx_core * chip,int audio,int capture,int level)302 static int vx_set_audio_gain(struct vx_core *chip, int audio, int capture, int level)
303 {
304 	struct vx_audio_level info;
305 
306 	memset(&info, 0, sizeof(info));
307 	info.has_level = 1;
308 	info.level = level;
309 	chip->audio_gain[capture][audio] = level;
310 	return vx_adjust_audio_level(chip, audio, capture, &info);
311 }
312 
313 /*
314  * reset all audio levels
315  */
vx_reset_audio_levels(struct vx_core * chip)316 static void vx_reset_audio_levels(struct vx_core *chip)
317 {
318 	unsigned int i, c;
319 	struct vx_audio_level info;
320 
321 	memset(chip->audio_gain, 0, sizeof(chip->audio_gain));
322 	memset(chip->audio_active, 0, sizeof(chip->audio_active));
323 	memset(chip->audio_monitor, 0, sizeof(chip->audio_monitor));
324 	memset(chip->audio_monitor_active, 0, sizeof(chip->audio_monitor_active));
325 
326 	for (c = 0; c < 2; c++) {
327 		for (i = 0; i < chip->hw->num_ins * 2; i++) {
328 			memset(&info, 0, sizeof(info));
329 			if (c == 0) {
330 				info.has_monitor_level = 1;
331 				info.has_mute = 1;
332 				info.has_monitor_mute = 1;
333 			}
334 			info.has_level = 1;
335 			info.level = CVAL_0DB; /* default: 0dB */
336 			vx_adjust_audio_level(chip, i, c, &info);
337 			chip->audio_gain[c][i] = CVAL_0DB;
338 			chip->audio_monitor[i] = CVAL_0DB;
339 		}
340 	}
341 }
342 
343 
344 /*
345  * VU, peak meter record
346  */
347 
348 #define VU_METER_CHANNELS	2
349 
350 struct vx_vu_meter {
351 	int saturated;
352 	int vu_level;
353 	int peak_level;
354 };
355 
356 /*
357  * get the VU and peak meter values
358  * @audio: the audio index
359  * @capture: 0 = playback, 1 = capture operation
360  * @info: the array of vx_vu_meter records (size = 2).
361  */
vx_get_audio_vu_meter(struct vx_core * chip,int audio,int capture,struct vx_vu_meter * info)362 static int vx_get_audio_vu_meter(struct vx_core *chip, int audio, int capture, struct vx_vu_meter *info)
363 {
364 	struct vx_rmh rmh;
365 	int i, err;
366 
367 	if (chip->chip_status & VX_STAT_IS_STALE)
368 		return -EBUSY;
369 
370 	vx_init_rmh(&rmh, CMD_AUDIO_VU_PIC_METER);
371 	rmh.LgStat += 2 * VU_METER_CHANNELS;
372 	if (capture)
373 		rmh.Cmd[0] |= COMMAND_RECORD_MASK;
374 
375         /* Add Audio IO mask */
376 	rmh.Cmd[1] = 0;
377 	for (i = 0; i < VU_METER_CHANNELS; i++)
378 		rmh.Cmd[1] |= 1 << (audio + i);
379 	err = vx_send_msg(chip, &rmh);
380 	if (err < 0)
381 		return err;
382 	/* Read response */
383 	for (i = 0; i < 2 * VU_METER_CHANNELS; i +=2) {
384 		info->saturated = (rmh.Stat[0] & (1 << (audio + i))) ? 1 : 0;
385 		info->vu_level = rmh.Stat[i + 1];
386 		info->peak_level = rmh.Stat[i + 2];
387 		info++;
388 	}
389 	return 0;
390 }
391 
392 
393 /*
394  * control API entries
395  */
396 
397 /*
398  * output level control
399  */
vx_output_level_info(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_info * uinfo)400 static int vx_output_level_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
401 {
402 	struct vx_core *chip = snd_kcontrol_chip(kcontrol);
403 	uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
404 	uinfo->count = 2;
405 	uinfo->value.integer.min = 0;
406 	uinfo->value.integer.max = chip->hw->output_level_max;
407 	return 0;
408 }
409 
vx_output_level_get(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)410 static int vx_output_level_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
411 {
412 	struct vx_core *chip = snd_kcontrol_chip(kcontrol);
413 	int codec = kcontrol->id.index;
414 	mutex_lock(&chip->mixer_mutex);
415 	ucontrol->value.integer.value[0] = chip->output_level[codec][0];
416 	ucontrol->value.integer.value[1] = chip->output_level[codec][1];
417 	mutex_unlock(&chip->mixer_mutex);
418 	return 0;
419 }
420 
vx_output_level_put(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)421 static int vx_output_level_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
422 {
423 	struct vx_core *chip = snd_kcontrol_chip(kcontrol);
424 	int codec = kcontrol->id.index;
425 	unsigned int val[2], vmax;
426 
427 	vmax = chip->hw->output_level_max;
428 	val[0] = ucontrol->value.integer.value[0];
429 	val[1] = ucontrol->value.integer.value[1];
430 	if (val[0] > vmax || val[1] > vmax)
431 		return -EINVAL;
432 	mutex_lock(&chip->mixer_mutex);
433 	if (val[0] != chip->output_level[codec][0] ||
434 	    val[1] != chip->output_level[codec][1]) {
435 		vx_set_analog_output_level(chip, codec, val[0], val[1]);
436 		chip->output_level[codec][0] = val[0];
437 		chip->output_level[codec][1] = val[1];
438 		mutex_unlock(&chip->mixer_mutex);
439 		return 1;
440 	}
441 	mutex_unlock(&chip->mixer_mutex);
442 	return 0;
443 }
444 
445 static const struct snd_kcontrol_new vx_control_output_level = {
446 	.iface =	SNDRV_CTL_ELEM_IFACE_MIXER,
447 	.access =	(SNDRV_CTL_ELEM_ACCESS_READWRITE |
448 			 SNDRV_CTL_ELEM_ACCESS_TLV_READ),
449 	.name =		"Master Playback Volume",
450 	.info =		vx_output_level_info,
451 	.get =		vx_output_level_get,
452 	.put =		vx_output_level_put,
453 	/* tlv will be filled later */
454 };
455 
456 /*
457  * audio source select
458  */
vx_audio_src_info(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_info * uinfo)459 static int vx_audio_src_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
460 {
461 	static const char * const texts_mic[3] = {
462 		"Digital", "Line", "Mic"
463 	};
464 	static const char * const texts_vx2[2] = {
465 		"Digital", "Analog"
466 	};
467 	struct vx_core *chip = snd_kcontrol_chip(kcontrol);
468 
469 	if (chip->type >= VX_TYPE_VXPOCKET)
470 		return snd_ctl_enum_info(uinfo, 1, 3, texts_mic);
471 	else
472 		return snd_ctl_enum_info(uinfo, 1, 2, texts_vx2);
473 }
474 
vx_audio_src_get(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)475 static int vx_audio_src_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
476 {
477 	struct vx_core *chip = snd_kcontrol_chip(kcontrol);
478 	ucontrol->value.enumerated.item[0] = chip->audio_source_target;
479 	return 0;
480 }
481 
vx_audio_src_put(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)482 static int vx_audio_src_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
483 {
484 	struct vx_core *chip = snd_kcontrol_chip(kcontrol);
485 
486 	if (chip->type >= VX_TYPE_VXPOCKET) {
487 		if (ucontrol->value.enumerated.item[0] > 2)
488 			return -EINVAL;
489 	} else {
490 		if (ucontrol->value.enumerated.item[0] > 1)
491 			return -EINVAL;
492 	}
493 	mutex_lock(&chip->mixer_mutex);
494 	if (chip->audio_source_target != ucontrol->value.enumerated.item[0]) {
495 		chip->audio_source_target = ucontrol->value.enumerated.item[0];
496 		vx_sync_audio_source(chip);
497 		mutex_unlock(&chip->mixer_mutex);
498 		return 1;
499 	}
500 	mutex_unlock(&chip->mixer_mutex);
501 	return 0;
502 }
503 
504 static const struct snd_kcontrol_new vx_control_audio_src = {
505 	.iface =	SNDRV_CTL_ELEM_IFACE_MIXER,
506 	.name =		"Capture Source",
507 	.info =		vx_audio_src_info,
508 	.get =		vx_audio_src_get,
509 	.put =		vx_audio_src_put,
510 };
511 
512 /*
513  * clock mode selection
514  */
vx_clock_mode_info(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_info * uinfo)515 static int vx_clock_mode_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
516 {
517 	static const char * const texts[3] = {
518 		"Auto", "Internal", "External"
519 	};
520 
521 	return snd_ctl_enum_info(uinfo, 1, 3, texts);
522 }
523 
vx_clock_mode_get(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)524 static int vx_clock_mode_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
525 {
526 	struct vx_core *chip = snd_kcontrol_chip(kcontrol);
527 	ucontrol->value.enumerated.item[0] = chip->clock_mode;
528 	return 0;
529 }
530 
vx_clock_mode_put(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)531 static int vx_clock_mode_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
532 {
533 	struct vx_core *chip = snd_kcontrol_chip(kcontrol);
534 
535 	if (ucontrol->value.enumerated.item[0] > 2)
536 		return -EINVAL;
537 	mutex_lock(&chip->mixer_mutex);
538 	if (chip->clock_mode != ucontrol->value.enumerated.item[0]) {
539 		chip->clock_mode = ucontrol->value.enumerated.item[0];
540 		vx_set_clock(chip, chip->freq);
541 		mutex_unlock(&chip->mixer_mutex);
542 		return 1;
543 	}
544 	mutex_unlock(&chip->mixer_mutex);
545 	return 0;
546 }
547 
548 static const struct snd_kcontrol_new vx_control_clock_mode = {
549 	.iface =	SNDRV_CTL_ELEM_IFACE_MIXER,
550 	.name =		"Clock Mode",
551 	.info =		vx_clock_mode_info,
552 	.get =		vx_clock_mode_get,
553 	.put =		vx_clock_mode_put,
554 };
555 
556 /*
557  * Audio Gain
558  */
vx_audio_gain_info(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_info * uinfo)559 static int vx_audio_gain_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
560 {
561 	uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
562 	uinfo->count = 2;
563 	uinfo->value.integer.min = 0;
564 	uinfo->value.integer.max = CVAL_MAX;
565 	return 0;
566 }
567 
vx_audio_gain_get(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)568 static int vx_audio_gain_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
569 {
570 	struct vx_core *chip = snd_kcontrol_chip(kcontrol);
571 	int audio = kcontrol->private_value & 0xff;
572 	int capture = (kcontrol->private_value >> 8) & 1;
573 
574 	mutex_lock(&chip->mixer_mutex);
575 	ucontrol->value.integer.value[0] = chip->audio_gain[capture][audio];
576 	ucontrol->value.integer.value[1] = chip->audio_gain[capture][audio+1];
577 	mutex_unlock(&chip->mixer_mutex);
578 	return 0;
579 }
580 
vx_audio_gain_put(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)581 static int vx_audio_gain_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
582 {
583 	struct vx_core *chip = snd_kcontrol_chip(kcontrol);
584 	int audio = kcontrol->private_value & 0xff;
585 	int capture = (kcontrol->private_value >> 8) & 1;
586 	unsigned int val[2];
587 
588 	val[0] = ucontrol->value.integer.value[0];
589 	val[1] = ucontrol->value.integer.value[1];
590 	if (val[0] > CVAL_MAX || val[1] > CVAL_MAX)
591 		return -EINVAL;
592 	mutex_lock(&chip->mixer_mutex);
593 	if (val[0] != chip->audio_gain[capture][audio] ||
594 	    val[1] != chip->audio_gain[capture][audio+1]) {
595 		vx_set_audio_gain(chip, audio, capture, val[0]);
596 		vx_set_audio_gain(chip, audio+1, capture, val[1]);
597 		mutex_unlock(&chip->mixer_mutex);
598 		return 1;
599 	}
600 	mutex_unlock(&chip->mixer_mutex);
601 	return 0;
602 }
603 
vx_audio_monitor_get(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)604 static int vx_audio_monitor_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
605 {
606 	struct vx_core *chip = snd_kcontrol_chip(kcontrol);
607 	int audio = kcontrol->private_value & 0xff;
608 
609 	mutex_lock(&chip->mixer_mutex);
610 	ucontrol->value.integer.value[0] = chip->audio_monitor[audio];
611 	ucontrol->value.integer.value[1] = chip->audio_monitor[audio+1];
612 	mutex_unlock(&chip->mixer_mutex);
613 	return 0;
614 }
615 
vx_audio_monitor_put(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)616 static int vx_audio_monitor_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
617 {
618 	struct vx_core *chip = snd_kcontrol_chip(kcontrol);
619 	int audio = kcontrol->private_value & 0xff;
620 	unsigned int val[2];
621 
622 	val[0] = ucontrol->value.integer.value[0];
623 	val[1] = ucontrol->value.integer.value[1];
624 	if (val[0] > CVAL_MAX || val[1] > CVAL_MAX)
625 		return -EINVAL;
626 
627 	mutex_lock(&chip->mixer_mutex);
628 	if (val[0] != chip->audio_monitor[audio] ||
629 	    val[1] != chip->audio_monitor[audio+1]) {
630 		vx_set_monitor_level(chip, audio, val[0],
631 				     chip->audio_monitor_active[audio]);
632 		vx_set_monitor_level(chip, audio+1, val[1],
633 				     chip->audio_monitor_active[audio+1]);
634 		mutex_unlock(&chip->mixer_mutex);
635 		return 1;
636 	}
637 	mutex_unlock(&chip->mixer_mutex);
638 	return 0;
639 }
640 
641 #define vx_audio_sw_info	snd_ctl_boolean_stereo_info
642 
vx_audio_sw_get(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)643 static int vx_audio_sw_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
644 {
645 	struct vx_core *chip = snd_kcontrol_chip(kcontrol);
646 	int audio = kcontrol->private_value & 0xff;
647 
648 	mutex_lock(&chip->mixer_mutex);
649 	ucontrol->value.integer.value[0] = chip->audio_active[audio];
650 	ucontrol->value.integer.value[1] = chip->audio_active[audio+1];
651 	mutex_unlock(&chip->mixer_mutex);
652 	return 0;
653 }
654 
vx_audio_sw_put(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)655 static int vx_audio_sw_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
656 {
657 	struct vx_core *chip = snd_kcontrol_chip(kcontrol);
658 	int audio = kcontrol->private_value & 0xff;
659 
660 	mutex_lock(&chip->mixer_mutex);
661 	if (ucontrol->value.integer.value[0] != chip->audio_active[audio] ||
662 	    ucontrol->value.integer.value[1] != chip->audio_active[audio+1]) {
663 		vx_set_audio_switch(chip, audio,
664 				    !!ucontrol->value.integer.value[0]);
665 		vx_set_audio_switch(chip, audio+1,
666 				    !!ucontrol->value.integer.value[1]);
667 		mutex_unlock(&chip->mixer_mutex);
668 		return 1;
669 	}
670 	mutex_unlock(&chip->mixer_mutex);
671 	return 0;
672 }
673 
vx_monitor_sw_get(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)674 static int vx_monitor_sw_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
675 {
676 	struct vx_core *chip = snd_kcontrol_chip(kcontrol);
677 	int audio = kcontrol->private_value & 0xff;
678 
679 	mutex_lock(&chip->mixer_mutex);
680 	ucontrol->value.integer.value[0] = chip->audio_monitor_active[audio];
681 	ucontrol->value.integer.value[1] = chip->audio_monitor_active[audio+1];
682 	mutex_unlock(&chip->mixer_mutex);
683 	return 0;
684 }
685 
vx_monitor_sw_put(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)686 static int vx_monitor_sw_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
687 {
688 	struct vx_core *chip = snd_kcontrol_chip(kcontrol);
689 	int audio = kcontrol->private_value & 0xff;
690 
691 	mutex_lock(&chip->mixer_mutex);
692 	if (ucontrol->value.integer.value[0] != chip->audio_monitor_active[audio] ||
693 	    ucontrol->value.integer.value[1] != chip->audio_monitor_active[audio+1]) {
694 		vx_set_monitor_level(chip, audio, chip->audio_monitor[audio],
695 				     !!ucontrol->value.integer.value[0]);
696 		vx_set_monitor_level(chip, audio+1, chip->audio_monitor[audio+1],
697 				     !!ucontrol->value.integer.value[1]);
698 		mutex_unlock(&chip->mixer_mutex);
699 		return 1;
700 	}
701 	mutex_unlock(&chip->mixer_mutex);
702 	return 0;
703 }
704 
705 static const DECLARE_TLV_DB_SCALE(db_scale_audio_gain, -10975, 25, 0);
706 
707 static const struct snd_kcontrol_new vx_control_audio_gain = {
708 	.iface =	SNDRV_CTL_ELEM_IFACE_MIXER,
709 	.access =	(SNDRV_CTL_ELEM_ACCESS_READWRITE |
710 			 SNDRV_CTL_ELEM_ACCESS_TLV_READ),
711 	/* name will be filled later */
712 	.info =         vx_audio_gain_info,
713 	.get =          vx_audio_gain_get,
714 	.put =          vx_audio_gain_put,
715 	.tlv = { .p = db_scale_audio_gain },
716 };
717 static const struct snd_kcontrol_new vx_control_output_switch = {
718 	.iface =	SNDRV_CTL_ELEM_IFACE_MIXER,
719 	.name =         "PCM Playback Switch",
720 	.info =         vx_audio_sw_info,
721 	.get =          vx_audio_sw_get,
722 	.put =          vx_audio_sw_put
723 };
724 static const struct snd_kcontrol_new vx_control_monitor_gain = {
725 	.iface =	SNDRV_CTL_ELEM_IFACE_MIXER,
726 	.name =         "Monitoring Volume",
727 	.access =	(SNDRV_CTL_ELEM_ACCESS_READWRITE |
728 			 SNDRV_CTL_ELEM_ACCESS_TLV_READ),
729 	.info =         vx_audio_gain_info,	/* shared */
730 	.get =          vx_audio_monitor_get,
731 	.put =          vx_audio_monitor_put,
732 	.tlv = { .p = db_scale_audio_gain },
733 };
734 static const struct snd_kcontrol_new vx_control_monitor_switch = {
735 	.iface =	SNDRV_CTL_ELEM_IFACE_MIXER,
736 	.name =         "Monitoring Switch",
737 	.info =         vx_audio_sw_info,	/* shared */
738 	.get =          vx_monitor_sw_get,
739 	.put =          vx_monitor_sw_put
740 };
741 
742 
743 /*
744  * IEC958 status bits
745  */
vx_iec958_info(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_info * uinfo)746 static int vx_iec958_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
747 {
748 	uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958;
749 	uinfo->count = 1;
750 	return 0;
751 }
752 
vx_iec958_get(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)753 static int vx_iec958_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
754 {
755 	struct vx_core *chip = snd_kcontrol_chip(kcontrol);
756 
757 	mutex_lock(&chip->mixer_mutex);
758 	ucontrol->value.iec958.status[0] = (chip->uer_bits >> 0) & 0xff;
759 	ucontrol->value.iec958.status[1] = (chip->uer_bits >> 8) & 0xff;
760 	ucontrol->value.iec958.status[2] = (chip->uer_bits >> 16) & 0xff;
761 	ucontrol->value.iec958.status[3] = (chip->uer_bits >> 24) & 0xff;
762 	mutex_unlock(&chip->mixer_mutex);
763         return 0;
764 }
765 
vx_iec958_mask_get(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)766 static int vx_iec958_mask_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
767 {
768 	ucontrol->value.iec958.status[0] = 0xff;
769 	ucontrol->value.iec958.status[1] = 0xff;
770 	ucontrol->value.iec958.status[2] = 0xff;
771 	ucontrol->value.iec958.status[3] = 0xff;
772         return 0;
773 }
774 
vx_iec958_put(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)775 static int vx_iec958_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
776 {
777 	struct vx_core *chip = snd_kcontrol_chip(kcontrol);
778 	unsigned int val;
779 
780 	val = (ucontrol->value.iec958.status[0] << 0) |
781 	      (ucontrol->value.iec958.status[1] << 8) |
782 	      (ucontrol->value.iec958.status[2] << 16) |
783 	      (ucontrol->value.iec958.status[3] << 24);
784 	mutex_lock(&chip->mixer_mutex);
785 	if (chip->uer_bits != val) {
786 		chip->uer_bits = val;
787 		vx_set_iec958_status(chip, val);
788 		mutex_unlock(&chip->mixer_mutex);
789 		return 1;
790 	}
791 	mutex_unlock(&chip->mixer_mutex);
792 	return 0;
793 }
794 
795 static const struct snd_kcontrol_new vx_control_iec958_mask = {
796 	.access =	SNDRV_CTL_ELEM_ACCESS_READ,
797 	.iface =	SNDRV_CTL_ELEM_IFACE_PCM,
798 	.name =		SNDRV_CTL_NAME_IEC958("",PLAYBACK,MASK),
799 	.info =		vx_iec958_info,	/* shared */
800 	.get =		vx_iec958_mask_get,
801 };
802 
803 static const struct snd_kcontrol_new vx_control_iec958 = {
804 	.iface =	SNDRV_CTL_ELEM_IFACE_PCM,
805 	.name =         SNDRV_CTL_NAME_IEC958("",PLAYBACK,DEFAULT),
806 	.info =         vx_iec958_info,
807 	.get =          vx_iec958_get,
808 	.put =          vx_iec958_put
809 };
810 
811 
812 /*
813  * VU meter
814  */
815 
816 #define METER_MAX	0xff
817 #define METER_SHIFT	16
818 
vx_vu_meter_info(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_info * uinfo)819 static int vx_vu_meter_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
820 {
821 	uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
822 	uinfo->count = 2;
823 	uinfo->value.integer.min = 0;
824 	uinfo->value.integer.max = METER_MAX;
825 	return 0;
826 }
827 
vx_vu_meter_get(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)828 static int vx_vu_meter_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
829 {
830 	struct vx_core *chip = snd_kcontrol_chip(kcontrol);
831 	struct vx_vu_meter meter[2];
832 	int audio = kcontrol->private_value & 0xff;
833 	int capture = (kcontrol->private_value >> 8) & 1;
834 
835 	vx_get_audio_vu_meter(chip, audio, capture, meter);
836 	ucontrol->value.integer.value[0] = meter[0].vu_level >> METER_SHIFT;
837 	ucontrol->value.integer.value[1] = meter[1].vu_level >> METER_SHIFT;
838 	return 0;
839 }
840 
vx_peak_meter_get(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)841 static int vx_peak_meter_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
842 {
843 	struct vx_core *chip = snd_kcontrol_chip(kcontrol);
844 	struct vx_vu_meter meter[2];
845 	int audio = kcontrol->private_value & 0xff;
846 	int capture = (kcontrol->private_value >> 8) & 1;
847 
848 	vx_get_audio_vu_meter(chip, audio, capture, meter);
849 	ucontrol->value.integer.value[0] = meter[0].peak_level >> METER_SHIFT;
850 	ucontrol->value.integer.value[1] = meter[1].peak_level >> METER_SHIFT;
851 	return 0;
852 }
853 
854 #define vx_saturation_info	snd_ctl_boolean_stereo_info
855 
vx_saturation_get(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)856 static int vx_saturation_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
857 {
858 	struct vx_core *chip = snd_kcontrol_chip(kcontrol);
859 	struct vx_vu_meter meter[2];
860 	int audio = kcontrol->private_value & 0xff;
861 
862 	vx_get_audio_vu_meter(chip, audio, 1, meter); /* capture only */
863 	ucontrol->value.integer.value[0] = meter[0].saturated;
864 	ucontrol->value.integer.value[1] = meter[1].saturated;
865 	return 0;
866 }
867 
868 static const struct snd_kcontrol_new vx_control_vu_meter = {
869 	.iface =	SNDRV_CTL_ELEM_IFACE_MIXER,
870 	.access =	SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE,
871 	/* name will be filled later */
872 	.info =		vx_vu_meter_info,
873 	.get =		vx_vu_meter_get,
874 };
875 
876 static const struct snd_kcontrol_new vx_control_peak_meter = {
877 	.iface =	SNDRV_CTL_ELEM_IFACE_MIXER,
878 	.access =	SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE,
879 	/* name will be filled later */
880 	.info =		vx_vu_meter_info,	/* shared */
881 	.get =		vx_peak_meter_get,
882 };
883 
884 static const struct snd_kcontrol_new vx_control_saturation = {
885 	.iface =	SNDRV_CTL_ELEM_IFACE_MIXER,
886 	.name =		"Input Saturation",
887 	.access =	SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE,
888 	.info =		vx_saturation_info,
889 	.get =		vx_saturation_get,
890 };
891 
892 
893 
894 /*
895  *
896  */
897 
snd_vx_mixer_new(struct vx_core * chip)898 int snd_vx_mixer_new(struct vx_core *chip)
899 {
900 	unsigned int i, c;
901 	int err;
902 	struct snd_kcontrol_new temp;
903 	struct snd_card *card = chip->card;
904 	char name[32];
905 
906 	strcpy(card->mixername, card->driver);
907 
908 	/* output level controls */
909 	for (i = 0; i < chip->hw->num_outs; i++) {
910 		temp = vx_control_output_level;
911 		temp.index = i;
912 		temp.tlv.p = chip->hw->output_level_db_scale;
913 		err = snd_ctl_add(card, snd_ctl_new1(&temp, chip));
914 		if (err < 0)
915 			return err;
916 	}
917 
918 	/* PCM volumes, switches, monitoring */
919 	for (i = 0; i < chip->hw->num_outs; i++) {
920 		int val = i * 2;
921 		temp = vx_control_audio_gain;
922 		temp.index = i;
923 		temp.name = "PCM Playback Volume";
924 		temp.private_value = val;
925 		err = snd_ctl_add(card, snd_ctl_new1(&temp, chip));
926 		if (err < 0)
927 			return err;
928 		temp = vx_control_output_switch;
929 		temp.index = i;
930 		temp.private_value = val;
931 		err = snd_ctl_add(card, snd_ctl_new1(&temp, chip));
932 		if (err < 0)
933 			return err;
934 		temp = vx_control_monitor_gain;
935 		temp.index = i;
936 		temp.private_value = val;
937 		err = snd_ctl_add(card, snd_ctl_new1(&temp, chip));
938 		if (err < 0)
939 			return err;
940 		temp = vx_control_monitor_switch;
941 		temp.index = i;
942 		temp.private_value = val;
943 		err = snd_ctl_add(card, snd_ctl_new1(&temp, chip));
944 		if (err < 0)
945 			return err;
946 	}
947 	for (i = 0; i < chip->hw->num_outs; i++) {
948 		temp = vx_control_audio_gain;
949 		temp.index = i;
950 		temp.name = "PCM Capture Volume";
951 		temp.private_value = (i * 2) | (1 << 8);
952 		err = snd_ctl_add(card, snd_ctl_new1(&temp, chip));
953 		if (err < 0)
954 			return err;
955 	}
956 
957 	/* Audio source */
958 	err = snd_ctl_add(card, snd_ctl_new1(&vx_control_audio_src, chip));
959 	if (err < 0)
960 		return err;
961 	/* clock mode */
962 	err = snd_ctl_add(card, snd_ctl_new1(&vx_control_clock_mode, chip));
963 	if (err < 0)
964 		return err;
965 	/* IEC958 controls */
966 	err = snd_ctl_add(card, snd_ctl_new1(&vx_control_iec958_mask, chip));
967 	if (err < 0)
968 		return err;
969 	err = snd_ctl_add(card, snd_ctl_new1(&vx_control_iec958, chip));
970 	if (err < 0)
971 		return err;
972 	/* VU, peak, saturation meters */
973 	for (c = 0; c < 2; c++) {
974 		static const char * const dir[2] = { "Output", "Input" };
975 		for (i = 0; i < chip->hw->num_ins; i++) {
976 			int val = (i * 2) | (c << 8);
977 			if (c == 1) {
978 				temp = vx_control_saturation;
979 				temp.index = i;
980 				temp.private_value = val;
981 				err = snd_ctl_add(card, snd_ctl_new1(&temp, chip));
982 				if (err < 0)
983 					return err;
984 			}
985 			sprintf(name, "%s VU Meter", dir[c]);
986 			temp = vx_control_vu_meter;
987 			temp.index = i;
988 			temp.name = name;
989 			temp.private_value = val;
990 			err = snd_ctl_add(card, snd_ctl_new1(&temp, chip));
991 			if (err < 0)
992 				return err;
993 			sprintf(name, "%s Peak Meter", dir[c]);
994 			temp = vx_control_peak_meter;
995 			temp.index = i;
996 			temp.name = name;
997 			temp.private_value = val;
998 			err = snd_ctl_add(card, snd_ctl_new1(&temp, chip));
999 			if (err < 0)
1000 				return err;
1001 		}
1002 	}
1003 	vx_reset_audio_levels(chip);
1004 	return 0;
1005 }
1006