1 // SPDX-License-Identifier: GPL-2.0-or-later
3 * Tascam US-16x08 ALSA driver
5 * Copyright (c) 2016 by Detlef Urban (onkel@paraair.de)
8 #include <linux/slab.h>
10 #include <linux/usb/audio-v2.h>
12 #include <sound/core.h>
13 #include <sound/control.h>
19 #include "mixer_us16x08.h"
21 /* USB control message templates */
22 static const char route_msg[] = {
25 0x03, /* input from master (0x02) or input from computer bus (0x03) */
28 0x01, /* input index (0x01/0x02 eq. left/right) or bus (0x01-0x08) */
36 0x01, /* output index (0x01-0x08) */
45 static const char mix_init_msg1[] = {
46 0x71, 0x01, 0x00, 0x00
49 static const char mix_init_msg2[] = {
50 0x62, 0x02, 0x00, 0x61, 0x02, 0x04, 0xb1, 0x01, 0x00, 0x00
53 static const char mix_msg_in[] = {
54 /* default message head, equal to all mixers */
55 0x61, 0x02, 0x04, 0x62, 0x02, 0x01,
56 0x81, /* 0x06: Controller ID */
58 0x00, /* 0x08: Value of common mixer */
63 static const char mix_msg_out[] = {
64 /* default message head, equal to all mixers */
65 0x61, 0x02, 0x02, 0x62, 0x02, 0x01,
66 0x81, /* 0x06: Controller ID */
68 0x00, /* 0x08: Value of common mixer */
73 static const char bypass_msg_out[] = {
76 0x01, /* on/off flag */
81 static const char bus_msg_out[] = {
84 0x01, /* on/off flag */
89 static const char comp_msg[] = {
90 /* default message head, equal to all mixers */
91 0x61, 0x02, 0x04, 0x62, 0x02, 0x01,
94 0xf0, /* 0x08: Threshold db (8) (e0 ... 00) (+-0dB -- -32dB) x-32 */
97 0x0a, /* 0x0b: Ratio (0a,0b,0d,0f,11,14,19,1e,23,28,32,3c,50,a0,ff) */
100 0x02, /* 0x0e: Attack (0x02 ... 0xc0) (2ms ... 200ms) */
103 0x01, /* 0x11: Release (0x01 ... 0x64) (10ms ... 1000ms) x*10 */
106 0x03, /* 0x14: gain (0 ... 20) (0dB .. 20dB) */
112 0x01, /* 0x1a: main Comp switch (0 ... 1) (off ... on)) */
117 static const char eqs_msq[] = {
118 /* default message head, equal to all mixers */
119 0x61, 0x02, 0x04, 0x62, 0x02, 0x01,
120 0x51, /* 0x06: Controller ID */
122 0x04, /* 0x08: EQ set num (0x01..0x04) (LOW, LOWMID, HIGHMID, HIGH)) */
125 0x0c, /* 0x0b: value dB (0 ... 12) (-12db .. +12db) x-6 */
128 0x0f, /* 0x0e: value freq (32-47) (1.7kHz..18kHz) */
131 0x02, /* 0x11: band width (0-6) (Q16-Q0.25) 2^x/4 (EQ xxMID only) */
134 0x01, /* 0x14: main EQ switch (0 ... 1) (off ... on)) */
139 /* compressor ratio map */
140 static const char ratio_map[] = {
141 0x0a, 0x0b, 0x0d, 0x0f, 0x11, 0x14, 0x19, 0x1e,
142 0x23, 0x28, 0x32, 0x3c, 0x50, 0xa0, 0xff
145 /* route enumeration names */
146 static const char *const route_names[] = {
147 "Master Left", "Master Right", "Output 1", "Output 2", "Output 3",
148 "Output 4", "Output 5", "Output 6", "Output 7", "Output 8",
151 static int snd_us16x08_recv_urb(struct snd_usb_audio *chip,
152 unsigned char *buf, int size)
155 mutex_lock(&chip->mutex);
156 snd_usb_ctl_msg(chip->dev,
157 usb_rcvctrlpipe(chip->dev, 0),
158 SND_US16X08_URB_METER_REQUEST,
159 SND_US16X08_URB_METER_REQUESTTYPE, 0, 0, buf, size);
160 mutex_unlock(&chip->mutex);
164 /* wrapper function to send prepared URB buffer to usb device. Return an error
165 * code if something went wrong
167 static int snd_us16x08_send_urb(struct snd_usb_audio *chip, char *buf, int size)
169 return snd_usb_ctl_msg(chip->dev, usb_sndctrlpipe(chip->dev, 0),
170 SND_US16X08_URB_REQUEST, SND_US16X08_URB_REQUESTTYPE,
174 static int snd_us16x08_route_info(struct snd_kcontrol *kcontrol,
175 struct snd_ctl_elem_info *uinfo)
177 return snd_ctl_enum_info(uinfo, 1, 10, route_names);
180 static int snd_us16x08_route_get(struct snd_kcontrol *kcontrol,
181 struct snd_ctl_elem_value *ucontrol)
183 struct usb_mixer_elem_info *elem = kcontrol->private_data;
184 int index = ucontrol->id.index;
186 /* route has no bias */
187 ucontrol->value.enumerated.item[0] = elem->cache_val[index];
192 static int snd_us16x08_route_put(struct snd_kcontrol *kcontrol,
193 struct snd_ctl_elem_value *ucontrol)
195 struct usb_mixer_elem_info *elem = kcontrol->private_data;
196 struct snd_usb_audio *chip = elem->head.mixer->chip;
197 int index = ucontrol->id.index;
198 char buf[sizeof(route_msg)];
199 int val, val_org, err;
201 /* get the new value (no bias for routes) */
202 val = ucontrol->value.enumerated.item[0];
205 if (val < 0 || val > 9)
208 /* prepare the message buffer from template */
209 memcpy(buf, route_msg, sizeof(route_msg));
212 /* input comes from a master channel */
216 /* input comes from a computer channel */
221 /* place new route selection in URB message */
222 buf[5] = (unsigned char) (val_org & 0x0f) + 1;
223 /* place route selector in URB message */
226 err = snd_us16x08_send_urb(chip, buf, sizeof(route_msg));
229 elem->cached |= 1 << index;
230 elem->cache_val[index] = val;
232 usb_audio_dbg(chip, "Failed to set routing, err:%d\n", err);
235 return err > 0 ? 1 : 0;
238 static int snd_us16x08_master_info(struct snd_kcontrol *kcontrol,
239 struct snd_ctl_elem_info *uinfo)
242 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
243 uinfo->value.integer.max = SND_US16X08_KCMAX(kcontrol);
244 uinfo->value.integer.min = SND_US16X08_KCMIN(kcontrol);
245 uinfo->value.integer.step = SND_US16X08_KCSTEP(kcontrol);
249 static int snd_us16x08_master_get(struct snd_kcontrol *kcontrol,
250 struct snd_ctl_elem_value *ucontrol)
252 struct usb_mixer_elem_info *elem = kcontrol->private_data;
253 int index = ucontrol->id.index;
255 ucontrol->value.integer.value[0] = elem->cache_val[index];
260 static int snd_us16x08_master_put(struct snd_kcontrol *kcontrol,
261 struct snd_ctl_elem_value *ucontrol)
263 struct usb_mixer_elem_info *elem = kcontrol->private_data;
264 struct snd_usb_audio *chip = elem->head.mixer->chip;
265 char buf[sizeof(mix_msg_out)];
267 int index = ucontrol->id.index;
269 /* new control value incl. bias*/
270 val = ucontrol->value.integer.value[0];
273 if (val < SND_US16X08_KCMIN(kcontrol)
274 || val > SND_US16X08_KCMAX(kcontrol))
277 /* prepare the message buffer from template */
278 memcpy(buf, mix_msg_out, sizeof(mix_msg_out));
280 buf[8] = val - SND_US16X08_KCBIAS(kcontrol);
281 buf[6] = elem->head.id;
283 /* place channel selector in URB message */
285 err = snd_us16x08_send_urb(chip, buf, sizeof(mix_msg_out));
288 elem->cached |= 1 << index;
289 elem->cache_val[index] = val;
291 usb_audio_dbg(chip, "Failed to set master, err:%d\n", err);
294 return err > 0 ? 1 : 0;
297 static int snd_us16x08_bus_put(struct snd_kcontrol *kcontrol,
298 struct snd_ctl_elem_value *ucontrol)
300 struct usb_mixer_elem_info *elem = kcontrol->private_data;
301 struct snd_usb_audio *chip = elem->head.mixer->chip;
302 char buf[sizeof(mix_msg_out)];
305 val = ucontrol->value.integer.value[0];
307 /* prepare the message buffer from template */
308 switch (elem->head.id) {
309 case SND_US16X08_ID_BYPASS:
310 memcpy(buf, bypass_msg_out, sizeof(bypass_msg_out));
312 err = snd_us16x08_send_urb(chip, buf, sizeof(bypass_msg_out));
314 case SND_US16X08_ID_BUSS_OUT:
315 memcpy(buf, bus_msg_out, sizeof(bus_msg_out));
317 err = snd_us16x08_send_urb(chip, buf, sizeof(bus_msg_out));
319 case SND_US16X08_ID_MUTE:
320 memcpy(buf, mix_msg_out, sizeof(mix_msg_out));
322 buf[6] = elem->head.id;
324 err = snd_us16x08_send_urb(chip, buf, sizeof(mix_msg_out));
330 elem->cache_val[0] = val;
332 usb_audio_dbg(chip, "Failed to set bus parameter, err:%d\n", err);
335 return err > 0 ? 1 : 0;
338 static int snd_us16x08_bus_get(struct snd_kcontrol *kcontrol,
339 struct snd_ctl_elem_value *ucontrol)
341 struct usb_mixer_elem_info *elem = kcontrol->private_data;
343 switch (elem->head.id) {
344 case SND_US16X08_ID_BUSS_OUT:
345 ucontrol->value.integer.value[0] = elem->cache_val[0];
347 case SND_US16X08_ID_BYPASS:
348 ucontrol->value.integer.value[0] = elem->cache_val[0];
350 case SND_US16X08_ID_MUTE:
351 ucontrol->value.integer.value[0] = elem->cache_val[0];
358 /* gets a current mixer value from common store */
359 static int snd_us16x08_channel_get(struct snd_kcontrol *kcontrol,
360 struct snd_ctl_elem_value *ucontrol)
362 struct usb_mixer_elem_info *elem = kcontrol->private_data;
363 int index = ucontrol->id.index;
365 ucontrol->value.integer.value[0] = elem->cache_val[index];
370 static int snd_us16x08_channel_put(struct snd_kcontrol *kcontrol,
371 struct snd_ctl_elem_value *ucontrol)
373 struct usb_mixer_elem_info *elem = kcontrol->private_data;
374 struct snd_usb_audio *chip = elem->head.mixer->chip;
375 char buf[sizeof(mix_msg_in)];
377 int index = ucontrol->id.index;
379 val = ucontrol->value.integer.value[0];
382 if (val < SND_US16X08_KCMIN(kcontrol)
383 || val > SND_US16X08_KCMAX(kcontrol))
386 /* prepare URB message from template */
387 memcpy(buf, mix_msg_in, sizeof(mix_msg_in));
389 /* add the bias to the new value */
390 buf[8] = val - SND_US16X08_KCBIAS(kcontrol);
391 buf[6] = elem->head.id;
394 err = snd_us16x08_send_urb(chip, buf, sizeof(mix_msg_in));
397 elem->cached |= 1 << index;
398 elem->cache_val[index] = val;
400 usb_audio_dbg(chip, "Failed to set channel, err:%d\n", err);
403 return err > 0 ? 1 : 0;
406 static int snd_us16x08_mix_info(struct snd_kcontrol *kcontrol,
407 struct snd_ctl_elem_info *uinfo)
410 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
411 uinfo->value.integer.max = SND_US16X08_KCMAX(kcontrol);
412 uinfo->value.integer.min = SND_US16X08_KCMIN(kcontrol);
413 uinfo->value.integer.step = SND_US16X08_KCSTEP(kcontrol);
417 static int snd_us16x08_comp_get(struct snd_kcontrol *kcontrol,
418 struct snd_ctl_elem_value *ucontrol)
420 struct usb_mixer_elem_info *elem = kcontrol->private_data;
421 struct snd_us16x08_comp_store *store = elem->private_data;
422 int index = ucontrol->id.index;
423 int val_idx = COMP_STORE_IDX(elem->head.id);
425 ucontrol->value.integer.value[0] = store->val[val_idx][index];
430 static int snd_us16x08_comp_put(struct snd_kcontrol *kcontrol,
431 struct snd_ctl_elem_value *ucontrol)
433 struct usb_mixer_elem_info *elem = kcontrol->private_data;
434 struct snd_usb_audio *chip = elem->head.mixer->chip;
435 struct snd_us16x08_comp_store *store = elem->private_data;
436 int index = ucontrol->id.index;
437 char buf[sizeof(comp_msg)];
441 val = ucontrol->value.integer.value[0];
444 if (val < SND_US16X08_KCMIN(kcontrol)
445 || val > SND_US16X08_KCMAX(kcontrol))
448 /* new control value incl. bias*/
449 val_idx = elem->head.id - SND_US16X08_ID_COMP_BASE;
451 store->val[val_idx][index] = ucontrol->value.integer.value[0];
453 /* prepare compressor URB message from template */
454 memcpy(buf, comp_msg, sizeof(comp_msg));
456 /* place comp values in message buffer watch bias! */
458 COMP_STORE_IDX(SND_US16X08_ID_COMP_THRESHOLD)][index]
459 - SND_US16X08_COMP_THRESHOLD_BIAS;
460 buf[11] = ratio_map[store->val[
461 COMP_STORE_IDX(SND_US16X08_ID_COMP_RATIO)][index]];
462 buf[14] = store->val[COMP_STORE_IDX(SND_US16X08_ID_COMP_ATTACK)][index]
463 + SND_US16X08_COMP_ATTACK_BIAS;
464 buf[17] = store->val[COMP_STORE_IDX(SND_US16X08_ID_COMP_RELEASE)][index]
465 + SND_US16X08_COMP_RELEASE_BIAS;
466 buf[20] = store->val[COMP_STORE_IDX(SND_US16X08_ID_COMP_GAIN)][index];
467 buf[26] = store->val[COMP_STORE_IDX(SND_US16X08_ID_COMP_SWITCH)][index];
469 /* place channel selector in message buffer */
472 err = snd_us16x08_send_urb(chip, buf, sizeof(comp_msg));
475 elem->cached |= 1 << index;
476 elem->cache_val[index] = val;
478 usb_audio_dbg(chip, "Failed to set compressor, err:%d\n", err);
484 static int snd_us16x08_eqswitch_get(struct snd_kcontrol *kcontrol,
485 struct snd_ctl_elem_value *ucontrol)
488 struct usb_mixer_elem_info *elem = kcontrol->private_data;
489 struct snd_us16x08_eq_store *store = elem->private_data;
490 int index = ucontrol->id.index;
492 /* get low switch from cache is enough, cause all bands are together */
493 val = store->val[EQ_STORE_BAND_IDX(elem->head.id)]
494 [EQ_STORE_PARAM_IDX(elem->head.id)][index];
495 ucontrol->value.integer.value[0] = val;
500 static int snd_us16x08_eqswitch_put(struct snd_kcontrol *kcontrol,
501 struct snd_ctl_elem_value *ucontrol)
503 struct usb_mixer_elem_info *elem = kcontrol->private_data;
504 struct snd_usb_audio *chip = elem->head.mixer->chip;
505 struct snd_us16x08_eq_store *store = elem->private_data;
506 int index = ucontrol->id.index;
507 char buf[sizeof(eqs_msq)];
511 /* new control value incl. bias*/
512 val = ucontrol->value.integer.value[0] + SND_US16X08_KCBIAS(kcontrol);
514 /* prepare URB message from EQ template */
515 memcpy(buf, eqs_msq, sizeof(eqs_msq));
517 /* place channel index in URB message */
519 for (b_idx = 0; b_idx < SND_US16X08_ID_EQ_BAND_COUNT; b_idx++) {
520 /* all four EQ bands have to be enabled/disabled in once */
522 buf[17] = store->val[b_idx][2][index];
523 buf[14] = store->val[b_idx][1][index];
524 buf[11] = store->val[b_idx][0][index];
526 err = snd_us16x08_send_urb(chip, buf, sizeof(eqs_msq));
529 store->val[b_idx][3][index] = val;
534 elem->cached |= 1 << index;
535 elem->cache_val[index] = val;
537 usb_audio_dbg(chip, "Failed to set eq switch, err:%d\n", err);
543 static int snd_us16x08_eq_get(struct snd_kcontrol *kcontrol,
544 struct snd_ctl_elem_value *ucontrol)
547 struct usb_mixer_elem_info *elem = kcontrol->private_data;
548 struct snd_us16x08_eq_store *store = elem->private_data;
549 int index = ucontrol->id.index;
550 int b_idx = EQ_STORE_BAND_IDX(elem->head.id) - 1;
551 int p_idx = EQ_STORE_PARAM_IDX(elem->head.id);
553 val = store->val[b_idx][p_idx][index];
555 ucontrol->value.integer.value[0] = val;
560 static int snd_us16x08_eq_put(struct snd_kcontrol *kcontrol,
561 struct snd_ctl_elem_value *ucontrol)
563 struct usb_mixer_elem_info *elem = kcontrol->private_data;
564 struct snd_usb_audio *chip = elem->head.mixer->chip;
565 struct snd_us16x08_eq_store *store = elem->private_data;
566 int index = ucontrol->id.index;
567 char buf[sizeof(eqs_msq)];
569 int b_idx = EQ_STORE_BAND_IDX(elem->head.id) - 1;
570 int p_idx = EQ_STORE_PARAM_IDX(elem->head.id);
572 val = ucontrol->value.integer.value[0];
575 if (val < SND_US16X08_KCMIN(kcontrol)
576 || val > SND_US16X08_KCMAX(kcontrol))
579 /* copy URB buffer from EQ template */
580 memcpy(buf, eqs_msq, sizeof(eqs_msq));
582 store->val[b_idx][p_idx][index] = val;
583 buf[20] = store->val[b_idx][3][index];
584 buf[17] = store->val[b_idx][2][index];
585 buf[14] = store->val[b_idx][1][index];
586 buf[11] = store->val[b_idx][0][index];
588 /* place channel index in URB buffer */
591 /* place EQ band in URB buffer */
594 err = snd_us16x08_send_urb(chip, buf, sizeof(eqs_msq));
597 /* store new value in EQ band cache */
598 elem->cached |= 1 << index;
599 elem->cache_val[index] = val;
601 usb_audio_dbg(chip, "Failed to set eq param, err:%d\n", err);
607 static int snd_us16x08_meter_info(struct snd_kcontrol *kcontrol,
608 struct snd_ctl_elem_info *uinfo)
611 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
612 uinfo->value.integer.max = 0x7FFF;
613 uinfo->value.integer.min = 0;
618 /* calculate compressor index for reduction level request */
619 static int snd_get_meter_comp_index(struct snd_us16x08_meter_store *store)
623 /* any channel active */
624 if (store->comp_active_index) {
625 /* check for stereo link */
626 if (store->comp_active_index & 0x20) {
627 /* reset comp_index to left channel*/
628 if (store->comp_index -
629 store->comp_active_index > 1)
631 store->comp_active_index;
633 ret = store->comp_index++ & 0x1F;
636 ret = store->comp_active_index;
639 /* skip channels with no compressor active */
640 while (!store->comp_store->val[
641 COMP_STORE_IDX(SND_US16X08_ID_COMP_SWITCH)]
642 [store->comp_index - 1]
643 && store->comp_index <= SND_US16X08_MAX_CHANNELS) {
646 ret = store->comp_index++;
647 if (store->comp_index > SND_US16X08_MAX_CHANNELS)
648 store->comp_index = 1;
653 /* retrieve the meter level values from URB message */
654 static void get_meter_levels_from_urb(int s,
655 struct snd_us16x08_meter_store *store,
658 int val = MUC2(meter_urb, s) + (MUC3(meter_urb, s) << 8);
660 if (MUA0(meter_urb, s) == 0x61 && MUA1(meter_urb, s) == 0x02 &&
661 MUA2(meter_urb, s) == 0x04 && MUB0(meter_urb, s) == 0x62) {
662 if (MUC0(meter_urb, s) == 0x72)
663 store->meter_level[MUB2(meter_urb, s) - 1] = val;
664 if (MUC0(meter_urb, s) == 0xb2)
665 store->comp_level[MUB2(meter_urb, s) - 1] = val;
667 if (MUA0(meter_urb, s) == 0x61 && MUA1(meter_urb, s) == 0x02 &&
668 MUA2(meter_urb, s) == 0x02 && MUB0(meter_urb, s) == 0x62)
669 store->master_level[MUB2(meter_urb, s) - 1] = val;
672 /* Function to retrieve current meter values from the device.
674 * The device needs to be polled for meter values with an initial
675 * requests. It will return with a sequence of different meter value
676 * packages. The first request (case 0:) initiate this meter response sequence.
677 * After the third response, an additional request can be placed,
678 * to retrieve compressor reduction level value for given channel. This round
679 * trip channel selector will skip all inactive compressors.
680 * A mixer can interrupt this round-trip by selecting one ore two (stereo-link)
683 static int snd_us16x08_meter_get(struct snd_kcontrol *kcontrol,
684 struct snd_ctl_elem_value *ucontrol)
687 struct usb_mixer_elem_info *elem = kcontrol->private_data;
688 struct snd_usb_audio *chip = elem->head.mixer->chip;
689 struct snd_us16x08_meter_store *store = elem->private_data;
692 switch (kcontrol->private_value) {
694 char tmp[sizeof(mix_init_msg1)];
696 memcpy(tmp, mix_init_msg1, sizeof(mix_init_msg1));
697 snd_us16x08_send_urb(chip, tmp, 4);
698 snd_us16x08_recv_urb(chip, meter_urb,
700 kcontrol->private_value++;
704 snd_us16x08_recv_urb(chip, meter_urb,
706 kcontrol->private_value++;
709 snd_us16x08_recv_urb(chip, meter_urb,
711 kcontrol->private_value++;
714 char tmp[sizeof(mix_init_msg2)];
716 memcpy(tmp, mix_init_msg2, sizeof(mix_init_msg2));
717 tmp[2] = snd_get_meter_comp_index(store);
718 snd_us16x08_send_urb(chip, tmp, 10);
719 snd_us16x08_recv_urb(chip, meter_urb,
721 kcontrol->private_value = 0;
726 for (set = 0; set < 6; set++)
727 get_meter_levels_from_urb(set, store, meter_urb);
729 for (i = 0; i < SND_US16X08_MAX_CHANNELS; i++) {
730 ucontrol->value.integer.value[i] =
731 store ? store->meter_level[i] : 0;
734 ucontrol->value.integer.value[i++] = store ? store->master_level[0] : 0;
735 ucontrol->value.integer.value[i++] = store ? store->master_level[1] : 0;
737 for (i = 2; i < SND_US16X08_MAX_CHANNELS + 2; i++)
738 ucontrol->value.integer.value[i + SND_US16X08_MAX_CHANNELS] =
739 store ? store->comp_level[i - 2] : 0;
744 static int snd_us16x08_meter_put(struct snd_kcontrol *kcontrol,
745 struct snd_ctl_elem_value *ucontrol)
747 struct usb_mixer_elem_info *elem = kcontrol->private_data;
748 struct snd_us16x08_meter_store *store = elem->private_data;
751 val = ucontrol->value.integer.value[0];
754 if (val < 0 || val >= SND_US16X08_MAX_CHANNELS)
757 store->comp_active_index = val;
758 store->comp_index = val;
763 static const struct snd_kcontrol_new snd_us16x08_ch_boolean_ctl = {
764 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
765 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
767 .info = snd_us16x08_switch_info,
768 .get = snd_us16x08_channel_get,
769 .put = snd_us16x08_channel_put,
770 .private_value = SND_US16X08_KCSET(SND_US16X08_NO_BIAS, 1, 0, 1)
773 static const struct snd_kcontrol_new snd_us16x08_ch_int_ctl = {
774 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
775 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
777 .info = snd_us16x08_mix_info,
778 .get = snd_us16x08_channel_get,
779 .put = snd_us16x08_channel_put,
780 .private_value = SND_US16X08_KCSET(SND_US16X08_FADER_BIAS, 1, 0, 133)
783 static const struct snd_kcontrol_new snd_us16x08_pan_int_ctl = {
784 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
785 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
787 .info = snd_us16x08_mix_info,
788 .get = snd_us16x08_channel_get,
789 .put = snd_us16x08_channel_put,
790 .private_value = SND_US16X08_KCSET(SND_US16X08_FADER_BIAS, 1, 0, 255)
793 static const struct snd_kcontrol_new snd_us16x08_master_ctl = {
794 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
795 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
797 .info = snd_us16x08_master_info,
798 .get = snd_us16x08_master_get,
799 .put = snd_us16x08_master_put,
800 .private_value = SND_US16X08_KCSET(SND_US16X08_FADER_BIAS, 1, 0, 133)
803 static const struct snd_kcontrol_new snd_us16x08_route_ctl = {
804 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
805 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
807 .info = snd_us16x08_route_info,
808 .get = snd_us16x08_route_get,
809 .put = snd_us16x08_route_put,
810 .private_value = SND_US16X08_KCSET(SND_US16X08_NO_BIAS, 1, 0, 9)
813 static const struct snd_kcontrol_new snd_us16x08_bus_ctl = {
814 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
815 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
817 .info = snd_us16x08_switch_info,
818 .get = snd_us16x08_bus_get,
819 .put = snd_us16x08_bus_put,
820 .private_value = SND_US16X08_KCSET(SND_US16X08_NO_BIAS, 1, 0, 1)
823 static const struct snd_kcontrol_new snd_us16x08_compswitch_ctl = {
824 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
825 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
827 .info = snd_us16x08_switch_info,
828 .get = snd_us16x08_comp_get,
829 .put = snd_us16x08_comp_put,
830 .private_value = SND_US16X08_KCSET(SND_US16X08_NO_BIAS, 1, 0, 1)
833 static const struct snd_kcontrol_new snd_us16x08_comp_threshold_ctl = {
834 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
835 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
837 .info = snd_us16x08_mix_info,
838 .get = snd_us16x08_comp_get,
839 .put = snd_us16x08_comp_put,
840 .private_value = SND_US16X08_KCSET(SND_US16X08_COMP_THRESHOLD_BIAS, 1,
844 static const struct snd_kcontrol_new snd_us16x08_comp_ratio_ctl = {
845 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
846 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
848 .info = snd_us16x08_mix_info,
849 .get = snd_us16x08_comp_get,
850 .put = snd_us16x08_comp_put,
851 .private_value = SND_US16X08_KCSET(SND_US16X08_NO_BIAS, 1, 0,
852 sizeof(ratio_map) - 1), /*max*/
855 static const struct snd_kcontrol_new snd_us16x08_comp_gain_ctl = {
856 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
857 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
859 .info = snd_us16x08_mix_info,
860 .get = snd_us16x08_comp_get,
861 .put = snd_us16x08_comp_put,
862 .private_value = SND_US16X08_KCSET(SND_US16X08_NO_BIAS, 1, 0, 0x14)
865 static const struct snd_kcontrol_new snd_us16x08_comp_attack_ctl = {
866 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
867 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
869 .info = snd_us16x08_mix_info,
870 .get = snd_us16x08_comp_get,
871 .put = snd_us16x08_comp_put,
873 SND_US16X08_KCSET(SND_US16X08_COMP_ATTACK_BIAS, 1, 0, 0xc6),
876 static const struct snd_kcontrol_new snd_us16x08_comp_release_ctl = {
877 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
878 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
880 .info = snd_us16x08_mix_info,
881 .get = snd_us16x08_comp_get,
882 .put = snd_us16x08_comp_put,
884 SND_US16X08_KCSET(SND_US16X08_COMP_RELEASE_BIAS, 1, 0, 0x63),
887 static const struct snd_kcontrol_new snd_us16x08_eq_gain_ctl = {
888 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
889 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
891 .info = snd_us16x08_mix_info,
892 .get = snd_us16x08_eq_get,
893 .put = snd_us16x08_eq_put,
894 .private_value = SND_US16X08_KCSET(SND_US16X08_NO_BIAS, 1, 0, 24),
897 static const struct snd_kcontrol_new snd_us16x08_eq_low_freq_ctl = {
898 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
899 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
901 .info = snd_us16x08_mix_info,
902 .get = snd_us16x08_eq_get,
903 .put = snd_us16x08_eq_put,
904 .private_value = SND_US16X08_KCSET(SND_US16X08_NO_BIAS, 1, 0, 0x1F),
907 static const struct snd_kcontrol_new snd_us16x08_eq_mid_freq_ctl = {
908 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
909 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
911 .info = snd_us16x08_mix_info,
912 .get = snd_us16x08_eq_get,
913 .put = snd_us16x08_eq_put,
914 .private_value = SND_US16X08_KCSET(SND_US16X08_NO_BIAS, 1, 0, 0x3F)
917 static const struct snd_kcontrol_new snd_us16x08_eq_mid_width_ctl = {
918 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
919 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
921 .info = snd_us16x08_mix_info,
922 .get = snd_us16x08_eq_get,
923 .put = snd_us16x08_eq_put,
924 .private_value = SND_US16X08_KCSET(SND_US16X08_NO_BIAS, 1, 0, 0x06)
927 static const struct snd_kcontrol_new snd_us16x08_eq_high_freq_ctl = {
928 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
929 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
931 .info = snd_us16x08_mix_info,
932 .get = snd_us16x08_eq_get,
933 .put = snd_us16x08_eq_put,
935 SND_US16X08_KCSET(SND_US16X08_EQ_HIGHFREQ_BIAS, 1, 0, 0x1F)
938 static const struct snd_kcontrol_new snd_us16x08_eq_switch_ctl = {
939 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
940 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
942 .info = snd_us16x08_switch_info,
943 .get = snd_us16x08_eqswitch_get,
944 .put = snd_us16x08_eqswitch_put,
945 .private_value = SND_US16X08_KCSET(SND_US16X08_NO_BIAS, 1, 0, 1)
948 static const struct snd_kcontrol_new snd_us16x08_meter_ctl = {
949 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
950 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
952 .info = snd_us16x08_meter_info,
953 .get = snd_us16x08_meter_get,
954 .put = snd_us16x08_meter_put
957 /* control store preparation */
959 /* setup compressor store and assign default value */
960 static struct snd_us16x08_comp_store *snd_us16x08_create_comp_store(void)
963 struct snd_us16x08_comp_store *tmp;
965 tmp = kmalloc(sizeof(*tmp), GFP_KERNEL);
969 for (i = 0; i < SND_US16X08_MAX_CHANNELS; i++) {
970 tmp->val[COMP_STORE_IDX(SND_US16X08_ID_COMP_THRESHOLD)][i]
972 tmp->val[COMP_STORE_IDX(SND_US16X08_ID_COMP_RATIO)][i] = 0x00;
973 tmp->val[COMP_STORE_IDX(SND_US16X08_ID_COMP_GAIN)][i] = 0x00;
974 tmp->val[COMP_STORE_IDX(SND_US16X08_ID_COMP_SWITCH)][i] = 0x00;
975 tmp->val[COMP_STORE_IDX(SND_US16X08_ID_COMP_ATTACK)][i] = 0x00;
976 tmp->val[COMP_STORE_IDX(SND_US16X08_ID_COMP_RELEASE)][i] = 0x00;
981 /* setup EQ store and assign default values */
982 static struct snd_us16x08_eq_store *snd_us16x08_create_eq_store(void)
985 struct snd_us16x08_eq_store *tmp;
987 tmp = kmalloc(sizeof(*tmp), GFP_KERNEL);
991 for (i = 0; i < SND_US16X08_MAX_CHANNELS; i++) {
992 for (b_idx = 0; b_idx < SND_US16X08_ID_EQ_BAND_COUNT; b_idx++) {
993 tmp->val[b_idx][0][i] = 0x0c;
994 tmp->val[b_idx][3][i] = 0x00;
997 tmp->val[b_idx][1][i] = 0x05;
998 tmp->val[b_idx][2][i] = 0xff;
1000 case 1: /* EQ Mid low */
1001 tmp->val[b_idx][1][i] = 0x0e;
1002 tmp->val[b_idx][2][i] = 0x02;
1004 case 2: /* EQ Mid High */
1005 tmp->val[b_idx][1][i] = 0x1b;
1006 tmp->val[b_idx][2][i] = 0x02;
1008 case 3: /* EQ High */
1009 tmp->val[b_idx][1][i] = 0x2f
1010 - SND_US16X08_EQ_HIGHFREQ_BIAS;
1011 tmp->val[b_idx][2][i] = 0xff;
1019 static struct snd_us16x08_meter_store *snd_us16x08_create_meter_store(void)
1021 struct snd_us16x08_meter_store *tmp;
1023 tmp = kzalloc(sizeof(*tmp), GFP_KERNEL);
1026 tmp->comp_index = 1;
1027 tmp->comp_active_index = 0;
1031 /* release elem->private_free as well; called only once for each *_store */
1032 static void elem_private_free(struct snd_kcontrol *kctl)
1034 struct usb_mixer_elem_info *elem = kctl->private_data;
1037 kfree(elem->private_data);
1039 kctl->private_data = NULL;
1042 static int add_new_ctl(struct usb_mixer_interface *mixer,
1043 const struct snd_kcontrol_new *ncontrol,
1044 int index, int val_type, int channels,
1045 const char *name, void *opt,
1046 bool do_private_free,
1047 struct usb_mixer_elem_info **elem_ret)
1049 struct snd_kcontrol *kctl;
1050 struct usb_mixer_elem_info *elem;
1053 usb_audio_dbg(mixer->chip, "us16x08 add mixer %s\n", name);
1055 elem = kzalloc(sizeof(*elem), GFP_KERNEL);
1059 elem->head.mixer = mixer;
1060 elem->head.resume = NULL;
1063 elem->head.id = index;
1064 elem->val_type = val_type;
1065 elem->channels = channels;
1066 elem->private_data = opt;
1068 kctl = snd_ctl_new1(ncontrol, elem);
1074 if (do_private_free)
1075 kctl->private_free = elem_private_free;
1077 kctl->private_free = snd_usb_mixer_elem_free;
1079 strscpy(kctl->id.name, name, sizeof(kctl->id.name));
1081 err = snd_usb_mixer_add_control(&elem->head, kctl);
1091 /* table of EQ controls */
1092 static const struct snd_us16x08_control_params eq_controls[] = {
1094 .kcontrol_new = &snd_us16x08_eq_switch_ctl,
1095 .control_id = SND_US16X08_ID_EQENABLE,
1096 .type = USB_MIXER_BOOLEAN,
1098 .name = "EQ Switch",
1101 .kcontrol_new = &snd_us16x08_eq_gain_ctl,
1102 .control_id = SND_US16X08_ID_EQLOWLEVEL,
1103 .type = USB_MIXER_U8,
1105 .name = "EQ Low Volume",
1108 .kcontrol_new = &snd_us16x08_eq_low_freq_ctl,
1109 .control_id = SND_US16X08_ID_EQLOWFREQ,
1110 .type = USB_MIXER_U8,
1112 .name = "EQ Low Frequency",
1114 { /* EQ mid low gain */
1115 .kcontrol_new = &snd_us16x08_eq_gain_ctl,
1116 .control_id = SND_US16X08_ID_EQLOWMIDLEVEL,
1117 .type = USB_MIXER_U8,
1119 .name = "EQ MidLow Volume",
1121 { /* EQ mid low freq */
1122 .kcontrol_new = &snd_us16x08_eq_mid_freq_ctl,
1123 .control_id = SND_US16X08_ID_EQLOWMIDFREQ,
1124 .type = USB_MIXER_U8,
1126 .name = "EQ MidLow Frequency",
1128 { /* EQ mid low Q */
1129 .kcontrol_new = &snd_us16x08_eq_mid_width_ctl,
1130 .control_id = SND_US16X08_ID_EQLOWMIDWIDTH,
1131 .type = USB_MIXER_U8,
1133 .name = "EQ MidLow Q",
1135 { /* EQ mid high gain */
1136 .kcontrol_new = &snd_us16x08_eq_gain_ctl,
1137 .control_id = SND_US16X08_ID_EQHIGHMIDLEVEL,
1138 .type = USB_MIXER_U8,
1140 .name = "EQ MidHigh Volume",
1142 { /* EQ mid high freq */
1143 .kcontrol_new = &snd_us16x08_eq_mid_freq_ctl,
1144 .control_id = SND_US16X08_ID_EQHIGHMIDFREQ,
1145 .type = USB_MIXER_U8,
1147 .name = "EQ MidHigh Frequency",
1149 { /* EQ mid high Q */
1150 .kcontrol_new = &snd_us16x08_eq_mid_width_ctl,
1151 .control_id = SND_US16X08_ID_EQHIGHMIDWIDTH,
1152 .type = USB_MIXER_U8,
1154 .name = "EQ MidHigh Q",
1156 { /* EQ high gain */
1157 .kcontrol_new = &snd_us16x08_eq_gain_ctl,
1158 .control_id = SND_US16X08_ID_EQHIGHLEVEL,
1159 .type = USB_MIXER_U8,
1161 .name = "EQ High Volume",
1164 .kcontrol_new = &snd_us16x08_eq_high_freq_ctl,
1165 .control_id = SND_US16X08_ID_EQHIGHFREQ,
1166 .type = USB_MIXER_U8,
1168 .name = "EQ High Frequency",
1172 /* table of compressor controls */
1173 static const struct snd_us16x08_control_params comp_controls[] = {
1175 .kcontrol_new = &snd_us16x08_compswitch_ctl,
1176 .control_id = SND_US16X08_ID_COMP_SWITCH,
1177 .type = USB_MIXER_BOOLEAN,
1179 .name = "Compressor Switch",
1181 { /* Comp threshold */
1182 .kcontrol_new = &snd_us16x08_comp_threshold_ctl,
1183 .control_id = SND_US16X08_ID_COMP_THRESHOLD,
1184 .type = USB_MIXER_U8,
1186 .name = "Compressor Threshold Volume",
1189 .kcontrol_new = &snd_us16x08_comp_ratio_ctl,
1190 .control_id = SND_US16X08_ID_COMP_RATIO,
1191 .type = USB_MIXER_U8,
1193 .name = "Compressor Ratio",
1196 .kcontrol_new = &snd_us16x08_comp_attack_ctl,
1197 .control_id = SND_US16X08_ID_COMP_ATTACK,
1198 .type = USB_MIXER_U8,
1200 .name = "Compressor Attack",
1202 { /* Comp release */
1203 .kcontrol_new = &snd_us16x08_comp_release_ctl,
1204 .control_id = SND_US16X08_ID_COMP_RELEASE,
1205 .type = USB_MIXER_U8,
1207 .name = "Compressor Release",
1210 .kcontrol_new = &snd_us16x08_comp_gain_ctl,
1211 .control_id = SND_US16X08_ID_COMP_GAIN,
1212 .type = USB_MIXER_U8,
1214 .name = "Compressor Volume",
1218 /* table of channel controls */
1219 static const struct snd_us16x08_control_params channel_controls[] = {
1221 .kcontrol_new = &snd_us16x08_ch_boolean_ctl,
1222 .control_id = SND_US16X08_ID_PHASE,
1223 .type = USB_MIXER_BOOLEAN,
1225 .name = "Phase Switch",
1229 .kcontrol_new = &snd_us16x08_ch_int_ctl,
1230 .control_id = SND_US16X08_ID_FADER,
1231 .type = USB_MIXER_U8,
1233 .name = "Line Volume",
1237 .kcontrol_new = &snd_us16x08_ch_boolean_ctl,
1238 .control_id = SND_US16X08_ID_MUTE,
1239 .type = USB_MIXER_BOOLEAN,
1241 .name = "Mute Switch",
1245 .kcontrol_new = &snd_us16x08_pan_int_ctl,
1246 .control_id = SND_US16X08_ID_PAN,
1247 .type = USB_MIXER_U16,
1249 .name = "Pan Left-Right Volume",
1254 /* table of master controls */
1255 static const struct snd_us16x08_control_params master_controls[] = {
1257 .kcontrol_new = &snd_us16x08_master_ctl,
1258 .control_id = SND_US16X08_ID_FADER,
1259 .type = USB_MIXER_U8,
1261 .name = "Master Volume",
1265 .kcontrol_new = &snd_us16x08_bus_ctl,
1266 .control_id = SND_US16X08_ID_BYPASS,
1267 .type = USB_MIXER_BOOLEAN,
1269 .name = "DSP Bypass Switch",
1273 .kcontrol_new = &snd_us16x08_bus_ctl,
1274 .control_id = SND_US16X08_ID_BUSS_OUT,
1275 .type = USB_MIXER_BOOLEAN,
1277 .name = "Buss Out Switch",
1281 .kcontrol_new = &snd_us16x08_bus_ctl,
1282 .control_id = SND_US16X08_ID_MUTE,
1283 .type = USB_MIXER_BOOLEAN,
1285 .name = "Master Mute Switch",
1291 int snd_us16x08_controls_create(struct usb_mixer_interface *mixer)
1295 struct usb_mixer_elem_info *elem;
1296 struct snd_us16x08_comp_store *comp_store;
1297 struct snd_us16x08_meter_store *meter_store;
1298 struct snd_us16x08_eq_store *eq_store;
1300 /* just check for non-MIDI interface */
1301 if (mixer->hostif->desc.bInterfaceNumber == 3) {
1303 /* add routing control */
1304 err = add_new_ctl(mixer, &snd_us16x08_route_ctl,
1305 SND_US16X08_ID_ROUTE, USB_MIXER_U8, 8, "Line Out Route",
1306 NULL, false, &elem);
1308 usb_audio_dbg(mixer->chip,
1309 "Failed to create route control, err:%d\n",
1313 for (i = 0; i < 8; i++)
1314 elem->cache_val[i] = i < 2 ? i : i + 2;
1315 elem->cached = 0xff;
1317 /* create compressor mixer elements */
1318 comp_store = snd_us16x08_create_comp_store();
1322 /* add master controls */
1323 for (i = 0; i < ARRAY_SIZE(master_controls); i++) {
1325 err = add_new_ctl(mixer,
1326 master_controls[i].kcontrol_new,
1327 master_controls[i].control_id,
1328 master_controls[i].type,
1329 master_controls[i].num_channels,
1330 master_controls[i].name,
1332 i == 0, /* release comp_store only once */
1336 elem->cache_val[0] = master_controls[i].default_val;
1340 /* add channel controls */
1341 for (i = 0; i < ARRAY_SIZE(channel_controls); i++) {
1343 err = add_new_ctl(mixer,
1344 channel_controls[i].kcontrol_new,
1345 channel_controls[i].control_id,
1346 channel_controls[i].type,
1347 channel_controls[i].num_channels,
1348 channel_controls[i].name,
1353 for (j = 0; j < SND_US16X08_MAX_CHANNELS; j++) {
1354 elem->cache_val[j] =
1355 channel_controls[i].default_val;
1357 elem->cached = 0xffff;
1360 /* create eq store */
1361 eq_store = snd_us16x08_create_eq_store();
1365 /* add EQ controls */
1366 for (i = 0; i < ARRAY_SIZE(eq_controls); i++) {
1368 err = add_new_ctl(mixer,
1369 eq_controls[i].kcontrol_new,
1370 eq_controls[i].control_id,
1371 eq_controls[i].type,
1372 eq_controls[i].num_channels,
1373 eq_controls[i].name,
1375 i == 0, /* release eq_store only once */
1381 /* add compressor controls */
1382 for (i = 0; i < ARRAY_SIZE(comp_controls); i++) {
1384 err = add_new_ctl(mixer,
1385 comp_controls[i].kcontrol_new,
1386 comp_controls[i].control_id,
1387 comp_controls[i].type,
1388 comp_controls[i].num_channels,
1389 comp_controls[i].name,
1396 /* create meters store */
1397 meter_store = snd_us16x08_create_meter_store();
1401 /* meter function 'get' must access to compressor store
1402 * so place a reference here
1404 meter_store->comp_store = comp_store;
1405 err = add_new_ctl(mixer, &snd_us16x08_meter_ctl,
1406 SND_US16X08_ID_METER, USB_MIXER_U16, 0, "Level Meter",
1407 meter_store, true, NULL);