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