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