2 * Driver for Digigram VX soundcards
6 * Copyright (c) 2002 by Takashi Iwai <tiwai@suse.de>
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.
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.
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
23 #include <sound/core.h>
24 #include <sound/control.h>
25 #include <sound/tlv.h>
26 #include <sound/vx_core.h>
31 * write a codec data (24bit)
33 static void vx_write_codec_reg(struct vx_core
*chip
, int codec
, unsigned int data
)
35 if (snd_BUG_ON(!chip
->ops
->write_codec
))
38 if (chip
->chip_status
& VX_STAT_IS_STALE
)
41 mutex_lock(&chip
->lock
);
42 chip
->ops
->write_codec(chip
, codec
, data
);
43 mutex_unlock(&chip
->lock
);
47 * Data type used to access the Codec
51 #ifdef SNDRV_BIG_ENDIAN
62 #else /* LITTLE_ENDIAN */
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))
82 * set up codec register and write the value
83 * @codec: the codec id, 0 or 1
84 * @reg: register index
87 static void vx_set_codec_reg(struct vx_core
*chip
, int codec
, int reg
, int val
)
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
);
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
104 static void vx_set_analog_output_level(struct vx_core
*chip
, int codec
, int left
, int right
)
106 left
= chip
->hw
->output_level_max
- left
;
107 right
= chip
->hw
->output_level_max
- right
;
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
);
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
);
121 * vx_toggle_dac_mute - mute/unmute DAC
122 * @mute: 0 = unmute, 1 = mute
125 #define DAC_ATTEN_MIN 0x08
126 #define DAC_ATTEN_MAX 0x38
128 void vx_toggle_dac_mute(struct vx_core
*chip
, int mute
)
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 */
135 vx_set_codec_reg(chip
, i
, XX_CODEC_DAC_CONTROL_REGISTER
,
136 mute
? DAC_ATTEN_MAX
: DAC_ATTEN_MIN
);
141 * vx_reset_codec - reset and initialize the codecs
143 void vx_reset_codec(struct vx_core
*chip
, int cold_reset
)
146 int port
= chip
->type
>= VX_TYPE_VXPOCKET
? 0x75 : 0x65;
148 chip
->ops
->reset_codec(chip
);
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);
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);
174 * change the audio input source
175 * @src: the target source (VX_AUDIO_SRC_XXX)
177 static void vx_change_audio_source(struct vx_core
*chip
, int src
)
179 if (chip
->chip_status
& VX_STAT_IS_STALE
)
182 mutex_lock(&chip
->lock
);
183 chip
->ops
->change_audio_source(chip
, src
);
184 mutex_unlock(&chip
->lock
);
189 * change the audio source if necessary and possible
190 * returns 1 if the source is actually changed.
192 int vx_sync_audio_source(struct vx_core
*chip
)
194 if (chip
->audio_source_target
== chip
->audio_source
||
197 vx_change_audio_source(chip
, chip
->audio_source_target
);
198 chip
->audio_source
= chip
->audio_source_target
;
204 * audio level, mute, monitoring
206 struct 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;
212 unsigned int monitor_mute
;
217 static int vx_adjust_audio_level(struct vx_core
*chip
, int audio
, int capture
,
218 struct vx_audio_level
*info
)
222 if (chip
->chip_status
& VX_STAT_IS_STALE
)
225 vx_init_rmh(&rmh
, CMD_AUDIO_LEVEL_ADJUST
);
227 rmh
.Cmd
[0] |= COMMAND_RECORD_MASK
;
228 /* Add Audio IO mask */
229 rmh
.Cmd
[1] = 1 << audio
;
231 if (info
->has_level
) {
232 rmh
.Cmd
[0] |= VALID_AUDIO_IO_DIGITAL_LEVEL
;
233 rmh
.Cmd
[2] |= info
->level
;
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);
239 if (info
->has_mute
) {
240 rmh
.Cmd
[0] |= VALID_AUDIO_IO_MUTE_LEVEL
;
242 rmh
.Cmd
[2] |= AUDIO_IO_HAS_MUTE_LEVEL
;
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
;
251 return vx_send_msg(chip
, &rmh
);
256 static int vx_read_audio_level(struct vx_core
*chip
, int audio
, int capture
,
257 struct vx_audio_level
*info
)
262 memset(info
, 0, sizeof(*info
));
263 vx_init_rmh(&rmh
, CMD_GET_AUDIO_LEVELS
);
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
);
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;
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
283 int vx_set_monitor_level(struct vx_core
*chip
, int audio
, int level
, int active
)
285 struct vx_audio_level info
;
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 */
299 * set the mute status of the given audio
301 static int vx_set_audio_switch(struct vx_core
*chip
, int audio
, int active
)
303 struct vx_audio_level info
;
305 memset(&info
, 0, sizeof(info
));
308 chip
->audio_active
[audio
] = active
;
309 return vx_adjust_audio_level(chip
, audio
, 0, &info
); /* playback only */
313 * set the mute status of the given audio
315 static int vx_set_audio_gain(struct vx_core
*chip
, int audio
, int capture
, int level
)
317 struct vx_audio_level info
;
319 memset(&info
, 0, sizeof(info
));
322 chip
->audio_gain
[capture
][audio
] = level
;
323 return vx_adjust_audio_level(chip
, audio
, capture
, &info
);
327 * reset all audio levels
329 static void vx_reset_audio_levels(struct vx_core
*chip
)
332 struct vx_audio_level info
;
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
));
339 for (c
= 0; c
< 2; c
++) {
340 for (i
= 0; i
< chip
->hw
->num_ins
* 2; i
++) {
341 memset(&info
, 0, sizeof(info
));
343 info
.has_monitor_level
= 1;
345 info
.has_monitor_mute
= 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
;
358 * VU, peak meter record
361 #define VU_METER_CHANNELS 2
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).
375 static int vx_get_audio_vu_meter(struct vx_core
*chip
, int audio
, int capture
, struct vx_vu_meter
*info
)
380 if (chip
->chip_status
& VX_STAT_IS_STALE
)
383 vx_init_rmh(&rmh
, CMD_AUDIO_VU_PIC_METER
);
384 rmh
.LgStat
+= 2 * VU_METER_CHANNELS
;
386 rmh
.Cmd
[0] |= COMMAND_RECORD_MASK
;
388 /* Add Audio IO mask */
390 for (i
= 0; i
< VU_METER_CHANNELS
; i
++)
391 rmh
.Cmd
[1] |= 1 << (audio
+ i
);
392 err
= vx_send_msg(chip
, &rmh
);
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];
407 * control API entries
411 * output level control
413 static int vx_output_level_info(struct snd_kcontrol
*kcontrol
, struct snd_ctl_elem_info
*uinfo
)
415 struct vx_core
*chip
= snd_kcontrol_chip(kcontrol
);
416 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_INTEGER
;
418 uinfo
->value
.integer
.min
= 0;
419 uinfo
->value
.integer
.max
= chip
->hw
->output_level_max
;
423 static int vx_output_level_get(struct snd_kcontrol
*kcontrol
, struct snd_ctl_elem_value
*ucontrol
)
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
);
434 static int vx_output_level_put(struct snd_kcontrol
*kcontrol
, struct snd_ctl_elem_value
*ucontrol
)
436 struct vx_core
*chip
= snd_kcontrol_chip(kcontrol
);
437 int codec
= kcontrol
->id
.index
;
438 unsigned int val
[2], vmax
;
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
)
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
);
454 mutex_unlock(&chip
->mixer_mutex
);
458 static const 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 */
470 * audio source select
472 static int vx_audio_src_info(struct snd_kcontrol
*kcontrol
, struct snd_ctl_elem_info
*uinfo
)
474 static const char * const texts_mic
[3] = {
475 "Digital", "Line", "Mic"
477 static const char * const texts_vx2
[2] = {
480 struct vx_core
*chip
= snd_kcontrol_chip(kcontrol
);
482 if (chip
->type
>= VX_TYPE_VXPOCKET
)
483 return snd_ctl_enum_info(uinfo
, 1, 3, texts_mic
);
485 return snd_ctl_enum_info(uinfo
, 1, 2, texts_vx2
);
488 static int vx_audio_src_get(struct snd_kcontrol
*kcontrol
, struct snd_ctl_elem_value
*ucontrol
)
490 struct vx_core
*chip
= snd_kcontrol_chip(kcontrol
);
491 ucontrol
->value
.enumerated
.item
[0] = chip
->audio_source_target
;
495 static int vx_audio_src_put(struct snd_kcontrol
*kcontrol
, struct snd_ctl_elem_value
*ucontrol
)
497 struct vx_core
*chip
= snd_kcontrol_chip(kcontrol
);
499 if (chip
->type
>= VX_TYPE_VXPOCKET
) {
500 if (ucontrol
->value
.enumerated
.item
[0] > 2)
503 if (ucontrol
->value
.enumerated
.item
[0] > 1)
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
);
513 mutex_unlock(&chip
->mixer_mutex
);
517 static const 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
,
526 * clock mode selection
528 static int vx_clock_mode_info(struct snd_kcontrol
*kcontrol
, struct snd_ctl_elem_info
*uinfo
)
530 static const char * const texts
[3] = {
531 "Auto", "Internal", "External"
534 return snd_ctl_enum_info(uinfo
, 1, 3, texts
);
537 static int vx_clock_mode_get(struct snd_kcontrol
*kcontrol
, struct snd_ctl_elem_value
*ucontrol
)
539 struct vx_core
*chip
= snd_kcontrol_chip(kcontrol
);
540 ucontrol
->value
.enumerated
.item
[0] = chip
->clock_mode
;
544 static int vx_clock_mode_put(struct snd_kcontrol
*kcontrol
, struct snd_ctl_elem_value
*ucontrol
)
546 struct vx_core
*chip
= snd_kcontrol_chip(kcontrol
);
548 if (ucontrol
->value
.enumerated
.item
[0] > 2)
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
);
557 mutex_unlock(&chip
->mixer_mutex
);
561 static const 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
,
572 static int vx_audio_gain_info(struct snd_kcontrol
*kcontrol
, struct snd_ctl_elem_info
*uinfo
)
574 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_INTEGER
;
576 uinfo
->value
.integer
.min
= 0;
577 uinfo
->value
.integer
.max
= CVAL_MAX
;
581 static int vx_audio_gain_get(struct snd_kcontrol
*kcontrol
, struct snd_ctl_elem_value
*ucontrol
)
583 struct vx_core
*chip
= snd_kcontrol_chip(kcontrol
);
584 int audio
= kcontrol
->private_value
& 0xff;
585 int capture
= (kcontrol
->private_value
>> 8) & 1;
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
);
594 static int vx_audio_gain_put(struct snd_kcontrol
*kcontrol
, struct snd_ctl_elem_value
*ucontrol
)
596 struct vx_core
*chip
= snd_kcontrol_chip(kcontrol
);
597 int audio
= kcontrol
->private_value
& 0xff;
598 int capture
= (kcontrol
->private_value
>> 8) & 1;
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
)
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
);
613 mutex_unlock(&chip
->mixer_mutex
);
617 static int vx_audio_monitor_get(struct snd_kcontrol
*kcontrol
, struct snd_ctl_elem_value
*ucontrol
)
619 struct vx_core
*chip
= snd_kcontrol_chip(kcontrol
);
620 int audio
= kcontrol
->private_value
& 0xff;
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
);
629 static int vx_audio_monitor_put(struct snd_kcontrol
*kcontrol
, struct snd_ctl_elem_value
*ucontrol
)
631 struct vx_core
*chip
= snd_kcontrol_chip(kcontrol
);
632 int audio
= kcontrol
->private_value
& 0xff;
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
)
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
);
650 mutex_unlock(&chip
->mixer_mutex
);
654 #define vx_audio_sw_info snd_ctl_boolean_stereo_info
656 static int vx_audio_sw_get(struct snd_kcontrol
*kcontrol
, struct snd_ctl_elem_value
*ucontrol
)
658 struct vx_core
*chip
= snd_kcontrol_chip(kcontrol
);
659 int audio
= kcontrol
->private_value
& 0xff;
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
);
668 static int vx_audio_sw_put(struct snd_kcontrol
*kcontrol
, struct snd_ctl_elem_value
*ucontrol
)
670 struct vx_core
*chip
= snd_kcontrol_chip(kcontrol
);
671 int audio
= kcontrol
->private_value
& 0xff;
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
);
683 mutex_unlock(&chip
->mixer_mutex
);
687 static int vx_monitor_sw_get(struct snd_kcontrol
*kcontrol
, struct snd_ctl_elem_value
*ucontrol
)
689 struct vx_core
*chip
= snd_kcontrol_chip(kcontrol
);
690 int audio
= kcontrol
->private_value
& 0xff;
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
);
699 static int vx_monitor_sw_put(struct snd_kcontrol
*kcontrol
, struct snd_ctl_elem_value
*ucontrol
)
701 struct vx_core
*chip
= snd_kcontrol_chip(kcontrol
);
702 int audio
= kcontrol
->private_value
& 0xff;
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
);
714 mutex_unlock(&chip
->mixer_mutex
);
718 static const DECLARE_TLV_DB_SCALE(db_scale_audio_gain
, -10975, 25, 0);
720 static const 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
},
730 static const 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
737 static const 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
},
747 static const 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
759 static int vx_iec958_info(struct snd_kcontrol
*kcontrol
, struct snd_ctl_elem_info
*uinfo
)
761 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_IEC958
;
766 static int vx_iec958_get(struct snd_kcontrol
*kcontrol
, struct snd_ctl_elem_value
*ucontrol
)
768 struct vx_core
*chip
= snd_kcontrol_chip(kcontrol
);
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
);
779 static int vx_iec958_mask_get(struct snd_kcontrol
*kcontrol
, struct snd_ctl_elem_value
*ucontrol
)
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;
788 static int vx_iec958_put(struct snd_kcontrol
*kcontrol
, struct snd_ctl_elem_value
*ucontrol
)
790 struct vx_core
*chip
= snd_kcontrol_chip(kcontrol
);
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
);
804 mutex_unlock(&chip
->mixer_mutex
);
808 static const 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
,
816 static const 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
,
829 #define METER_MAX 0xff
830 #define METER_SHIFT 16
832 static int vx_vu_meter_info(struct snd_kcontrol
*kcontrol
, struct snd_ctl_elem_info
*uinfo
)
834 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_INTEGER
;
836 uinfo
->value
.integer
.min
= 0;
837 uinfo
->value
.integer
.max
= METER_MAX
;
841 static int vx_vu_meter_get(struct snd_kcontrol
*kcontrol
, struct snd_ctl_elem_value
*ucontrol
)
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;
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
;
854 static int vx_peak_meter_get(struct snd_kcontrol
*kcontrol
, struct snd_ctl_elem_value
*ucontrol
)
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;
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
;
867 #define vx_saturation_info snd_ctl_boolean_stereo_info
869 static int vx_saturation_get(struct snd_kcontrol
*kcontrol
, struct snd_ctl_elem_value
*ucontrol
)
871 struct vx_core
*chip
= snd_kcontrol_chip(kcontrol
);
872 struct vx_vu_meter meter
[2];
873 int audio
= kcontrol
->private_value
& 0xff;
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
;
881 static const 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
,
889 static const 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
,
897 static const 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
,
911 int snd_vx_mixer_new(struct vx_core
*chip
)
915 struct snd_kcontrol_new temp
;
916 struct snd_card
*card
= chip
->card
;
919 strcpy(card
->mixername
, card
->driver
);
921 /* output level controls */
922 for (i
= 0; i
< chip
->hw
->num_outs
; i
++) {
923 temp
= vx_control_output_level
;
925 temp
.tlv
.p
= chip
->hw
->output_level_db_scale
;
926 if ((err
= snd_ctl_add(card
, snd_ctl_new1(&temp
, chip
))) < 0)
930 /* PCM volumes, switches, monitoring */
931 for (i
= 0; i
< chip
->hw
->num_outs
; i
++) {
933 temp
= vx_control_audio_gain
;
935 temp
.name
= "PCM Playback Volume";
936 temp
.private_value
= val
;
937 if ((err
= snd_ctl_add(card
, snd_ctl_new1(&temp
, chip
))) < 0)
939 temp
= vx_control_output_switch
;
941 temp
.private_value
= val
;
942 if ((err
= snd_ctl_add(card
, snd_ctl_new1(&temp
, chip
))) < 0)
944 temp
= vx_control_monitor_gain
;
946 temp
.private_value
= val
;
947 if ((err
= snd_ctl_add(card
, snd_ctl_new1(&temp
, chip
))) < 0)
949 temp
= vx_control_monitor_switch
;
951 temp
.private_value
= val
;
952 if ((err
= snd_ctl_add(card
, snd_ctl_new1(&temp
, chip
))) < 0)
955 for (i
= 0; i
< chip
->hw
->num_outs
; i
++) {
956 temp
= vx_control_audio_gain
;
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)
965 if ((err
= snd_ctl_add(card
, snd_ctl_new1(&vx_control_audio_src
, chip
))) < 0)
968 if ((err
= snd_ctl_add(card
, snd_ctl_new1(&vx_control_clock_mode
, chip
))) < 0)
970 /* IEC958 controls */
971 if ((err
= snd_ctl_add(card
, snd_ctl_new1(&vx_control_iec958_mask
, chip
))) < 0)
973 if ((err
= snd_ctl_add(card
, snd_ctl_new1(&vx_control_iec958
, chip
))) < 0)
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);
981 temp
= vx_control_saturation
;
983 temp
.private_value
= val
;
984 if ((err
= snd_ctl_add(card
, snd_ctl_new1(&temp
, chip
))) < 0)
987 sprintf(name
, "%s VU Meter", dir
[c
]);
988 temp
= vx_control_vu_meter
;
991 temp
.private_value
= val
;
992 if ((err
= snd_ctl_add(card
, snd_ctl_new1(&temp
, chip
))) < 0)
994 sprintf(name
, "%s Peak Meter", dir
[c
]);
995 temp
= vx_control_peak_meter
;
998 temp
.private_value
= val
;
999 if ((err
= snd_ctl_add(card
, snd_ctl_new1(&temp
, chip
))) < 0)
1003 vx_reset_audio_levels(chip
);