b17c67b14d59a6b7777f5b37dd23b8155a65e885
[muen/linux.git] / sound / drivers / vx / vx_mixer.c
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  */
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  */
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  */
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
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  */
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  */
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  */
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
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  */
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  */
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  */
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  */
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  */
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  */
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
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
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  */
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
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
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  */
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
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
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  */
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
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
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
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
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
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
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
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
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  */
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
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
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
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
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
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
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
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
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                 if ((err = snd_ctl_add(card, snd_ctl_new1(&temp, chip))) < 0)
914                         return err;
915         }
916
917         /* PCM volumes, switches, monitoring */
918         for (i = 0; i < chip->hw->num_outs; i++) {
919                 int val = i * 2;
920                 temp = vx_control_audio_gain;
921                 temp.index = i;
922                 temp.name = "PCM Playback Volume";
923                 temp.private_value = val;
924                 if ((err = snd_ctl_add(card, snd_ctl_new1(&temp, chip))) < 0)
925                         return err;
926                 temp = vx_control_output_switch;
927                 temp.index = i;
928                 temp.private_value = val;
929                 if ((err = snd_ctl_add(card, snd_ctl_new1(&temp, chip))) < 0)
930                         return err;
931                 temp = vx_control_monitor_gain;
932                 temp.index = i;
933                 temp.private_value = val;
934                 if ((err = snd_ctl_add(card, snd_ctl_new1(&temp, chip))) < 0)
935                         return err;
936                 temp = vx_control_monitor_switch;
937                 temp.index = i;
938                 temp.private_value = val;
939                 if ((err = snd_ctl_add(card, snd_ctl_new1(&temp, chip))) < 0)
940                         return err;
941         }
942         for (i = 0; i < chip->hw->num_outs; i++) {
943                 temp = vx_control_audio_gain;
944                 temp.index = i;
945                 temp.name = "PCM Capture Volume";
946                 temp.private_value = (i * 2) | (1 << 8);
947                 if ((err = snd_ctl_add(card, snd_ctl_new1(&temp, chip))) < 0)
948                         return err;
949         }
950
951         /* Audio source */
952         if ((err = snd_ctl_add(card, snd_ctl_new1(&vx_control_audio_src, chip))) < 0)
953                 return err;
954         /* clock mode */
955         if ((err = snd_ctl_add(card, snd_ctl_new1(&vx_control_clock_mode, chip))) < 0)
956                 return err;
957         /* IEC958 controls */
958         if ((err = snd_ctl_add(card, snd_ctl_new1(&vx_control_iec958_mask, chip))) < 0)
959                 return err;
960         if ((err = snd_ctl_add(card, snd_ctl_new1(&vx_control_iec958, chip))) < 0)
961                 return err;
962         /* VU, peak, saturation meters */
963         for (c = 0; c < 2; c++) {
964                 static char *dir[2] = { "Output", "Input" };
965                 for (i = 0; i < chip->hw->num_ins; i++) {
966                         int val = (i * 2) | (c << 8);
967                         if (c == 1) {
968                                 temp = vx_control_saturation;
969                                 temp.index = i;
970                                 temp.private_value = val;
971                                 if ((err = snd_ctl_add(card, snd_ctl_new1(&temp, chip))) < 0)
972                                         return err;
973                         }
974                         sprintf(name, "%s VU Meter", dir[c]);
975                         temp = vx_control_vu_meter;
976                         temp.index = i;
977                         temp.name = name;
978                         temp.private_value = val;
979                         if ((err = snd_ctl_add(card, snd_ctl_new1(&temp, chip))) < 0)
980                                 return err;
981                         sprintf(name, "%s Peak Meter", dir[c]);
982                         temp = vx_control_peak_meter;
983                         temp.index = i;
984                         temp.name = name;
985                         temp.private_value = val;
986                         if ((err = snd_ctl_add(card, snd_ctl_new1(&temp, chip))) < 0)
987                                 return err;
988                 }
989         }
990         vx_reset_audio_levels(chip);
991         return 0;
992 }